Slic3r::GUI::GLGizmoAssembly Class Reference

#include </home/runner/work/OrcaSlicer/OrcaSlicer/src/slic3r/GUI/Gizmos/GLGizmoAssembly.hpp>

Inheritance diagram for Slic3r::GUI::GLGizmoAssembly:

Collaboration diagram for Slic3r::GUI::GLGizmoAssembly:

Public Types
enum class	EGrabberExtension {   None = 0 , PosX = 1 << 0 , NegX = 1 << 1 , PosY = 1 << 2 ,   NegY = 1 << 3 , PosZ = 1 << 4 , NegZ = 1 << 5 }
enum	EState { Off , On , Num_States }

Public Member Functions
	GLGizmoAssembly (GLCanvas3D &parent, const std::string &icon_filename, unsigned int sprite_id)
bool	wants_enter_leave_snapshots () const override
	Apply rotation on select plane.
std::string	get_gizmo_entering_text () const override
std::string	get_gizmo_leaving_text () const override
bool	on_mouse (const wxMouseEvent &mouse_event) override
	Apply rotation on select plane.
void	data_changed (bool is_serializing) override
	Is called when data (Selection) is changed.
virtual bool	gizmo_event (SLAGizmoEventType action, const Vec2d &mouse_position, bool shift_down, bool alt_down, bool control_down)
bool	init ()
void	load (cereal::BinaryInputArchive &ar)
void	save (cereal::BinaryOutputArchive &ar) const
std::string	get_name (bool include_shortcut=true) const
EState	get_state () const
void	set_state (EState state)
std::optional< Shortcut >	shortcut () const
const std::string &	get_icon_filename () const
void	set_icon_filename (const std::string &filename)
bool	is_activable () const
bool	is_selectable () const
CommonGizmosDataID	get_requirements () const
virtual std::string	get_action_snapshot_name () const
void	set_common_data_pool (CommonGizmosDataPool *ptr)
virtual bool	apply_clipping_plane ()
unsigned int	get_sprite_id () const
int	get_hover_id () const
void	set_hover_id (int id)
bool	is_dragging () const
bool	update_items_state ()
void	render ()
void	render_input_window (float x, float y, float bottom_limit)
virtual void	on_change_color_mode (bool is_dark)
virtual std::string	get_tooltip () const
	Mouse tooltip text.
int	get_count ()
std::string	get_gizmo_name ()
void	register_raycasters_for_picking ()
void	unregister_raycasters_for_picking ()
virtual bool	is_in_editing_mode () const
virtual bool	is_selection_rectangle_dragging () const

Static Public Member Functions
static void	update_render_colors ()
static void	load_render_colors ()

Static Public Attributes
static const unsigned int	BASE_ID = 255 * 255 * 254
static const unsigned int	GRABBER_ELEMENTS_MAX_COUNT = 7
static float	INV_ZOOM = 1.0f
static ColorRGBA	DEFAULT_BASE_COLOR = { 0.625f, 0.625f, 0.625f, 1.0f }
static ColorRGBA	DEFAULT_DRAG_COLOR = { 1.0f, 1.0f, 1.0f, 1.0f }
static ColorRGBA	DEFAULT_HIGHLIGHT_COLOR = {1.0f, 0.38f, 0.0f, 1.0f}
static std::array< ColorRGBA, 3 >	AXES_COLOR
static std::array< ColorRGBA, 3 >	AXES_HOVER_COLOR
static ColorRGBA	CONSTRAINED_COLOR = {0.5f, 0.5f, 0.5f, 1.0f}
static ColorRGBA	FLATTEN_COLOR = {0.96f, 0.93f, 0.93f, 0.5f}
static ColorRGBA	FLATTEN_HOVER_COLOR = {1.0f, 1.0f, 1.0f, 0.75f}
static ColorRGBA	GRABBER_NORMAL_COL = {1.0f, 1.0f, 1.0f, 1.0f}
static ColorRGBA	GRABBER_HOVER_COL = {0.863f, 0.125f, 0.063f, 1.0f}
static ColorRGBA	GRABBER_UNIFORM_COL = {0, 1.0, 1.0, 1.0f}
static ColorRGBA	GRABBER_UNIFORM_HOVER_COL = {0, 0.7, 0.7, 1.0f}

Protected Types
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 , PointSelection }
using	PickRaycaster = SceneRaycasterItem

Protected Member Functions
bool	on_init () override
std::string	on_get_name () const override
bool	on_is_activable () const override
virtual void	on_render_input_window (float x, float y, float bottom_limit) override
void	render_input_window_warning (bool same_model_object) override
bool	render_assembly_mode_combo (double label_width, float item_width)
void	switch_to_mode (AssemblyMode new_mode)
void	init_circle_glmodel (GripperType gripper_type, const Measure::SurfaceFeature &feature, CircleGLModel &circle_gl_model, float inv_zoom)
void	init_plane_glmodel (GripperType gripper_type, const Measure::SurfaceFeature &feature, PlaneGLModel &plane_gl_model)
void	update_if_needed ()
void	disable_scene_raycasters ()
void	restore_scene_raycasters_state ()
void	render_dimensioning ()
void	render_dimensioning_if_scene_reused ()
bool	render_follows_cursor () const override
void	on_render () override
void	on_set_state () override
void	show_selection_ui ()
void	show_distance_xyz_ui ()
void	show_face_face_assembly_common ()
void	show_face_face_assembly_senior ()
void	init_render_input_window ()
void	remove_selected_sphere_raycaster (int id)
void	update_measurement_result ()
void	reset_all_pick ()
void	reset_gripper_pick (GripperType id, bool is_all=false)
void	register_single_mesh_pick ()
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)
void	set_to_parallel (bool same_model_object, bool take_shot=true, bool is_anti_parallel=false)
void	set_to_reverse_rotation (bool same_model_object, int feature_index)
void	set_to_around_center_of_faces (bool same_model_object, float rotate_degree)
void	set_to_center_coincidence (bool same_model_object)
void	set_parallel_distance (bool same_model_object, float dist)
bool	is_pick_meet_assembly_mode (const SelectedFeatures::Item &item)
bool	render_combo (const std::string &label, const std::vector< std::string > &lines, int &selection_idx, float label_width, float item_width)
void	render_cross_mark (const Vec3f &target, bool is_single=false)
virtual void	on_load (cereal::BinaryInputArchive &ar)
virtual void	on_save (cereal::BinaryOutputArchive &ar) const
virtual void	on_set_hover_id ()
virtual bool	on_is_selectable () const
virtual CommonGizmosDataID	on_get_requirements () const
virtual void	on_enable_grabber (unsigned int id)
virtual void	on_disable_grabber (unsigned int id)
virtual void	on_start_dragging ()
virtual void	on_stop_dragging ()
virtual void	on_dragging (const UpdateData &data)
bool	GizmoImguiBegin (const std::string &name, int flags)
void	GizmoImguiEnd ()
void	GizmoImguiSetNextWIndowPos (float &x, float y, int flag, float pivot_x=0.0f, float pivot_y=0.0f)
void	GizmoImguiSetNextWIndowPos (float &x, float y, float w, float h, int flag, float pivot_x=0.0f, float pivot_y=0.0f)
void	register_grabbers_for_picking ()
void	unregister_grabbers_for_picking ()
virtual void	on_register_raycasters_for_picking ()
virtual void	on_unregister_raycasters_for_picking ()
void	render_grabbers (const BoundingBoxf3 &box) const
void	render_grabbers (float size) const
void	render_grabbers (size_t first, size_t last, float size, bool force_hover) const
std::string	format (float value, unsigned int decimals) const
void	set_dirty ()
bool	use_grabbers (const wxMouseEvent &mouse_event)
	function which Set up m_dragging and call functions on_start_dragging / on_dragging / on_stop_dragging
void	do_stop_dragging (bool perform_mouse_cleanup)

Protected Attributes
EMode	m_mode { EMode::FeatureSelection }
Measure::MeasurementResult	m_measurement_result
Measure::AssemblyAction	m_assembly_action
std::map< GLVolume *, std::shared_ptr< Measure::Measuring > >	m_mesh_measure_map
std::shared_ptr< Measure::Measuring >	m_curr_measuring {nullptr}
PickingModel	m_sphere
PickingModel	m_cylinder
CircleGLModel	m_curr_circle
CircleGLModel	m_feature_circle_first
CircleGLModel	m_feature_circle_second
PlaneGLModel	m_curr_plane
PlaneGLModel	m_feature_plane_first
PlaneGLModel	m_feature_plane_second
Dimensioning	m_dimensioning
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
unsigned int	m_last_active_item_imgui {0}
Vec3d	m_buffered_distance
Vec3d	m_distance
double	m_buffered_parallel_distance {0}
double	m_buffered_around_center {0}
std::optional< Measure::SurfaceFeature >	m_curr_feature
std::optional< Vec3d >	m_curr_point_on_feature_position
float	m_last_inv_zoom { 0.0f }
std::optional< Measure::SurfaceFeature >	m_last_circle_feature
int	m_last_plane_idx { -1 }
bool	m_mouse_left_down { false }
bool	m_mouse_left_down_mesh_deal {false}
KeyAutoRepeatFilter	m_shift_kar_filter
SelectedFeatures	m_selected_features
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}
bool	m_rendered_this_frame { false }
std::vector< std::pair< wxString, wxString > >	m_shortcuts
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
bool	m_same_model_object
unsigned int	m_current_active_imgui_id
GLCanvas3D &	m_parent
int	m_group_id
EState	m_state
std::optional< Shortcut >	m_shortcut
std::string	m_icon_filename
unsigned int	m_sprite_id
int	m_hover_id { -1 }
bool	m_dragging { false }
std::vector< Grabber >	m_grabbers
ImGuiWrapper *	m_imgui
bool	m_first_input_window_render { true }
CommonGizmosDataPool *	m_c { nullptr }
bool	m_is_dark_mode = false
float	last_input_window_width = 0

Private Attributes
bool	m_dirty { false }
int	count = 0

Detailed Description

Member Typedef Documentation

PickRaycaster

using Slic3r::GUI::GLGizmoMeasure::PickRaycaster = SceneRaycasterItem

protectedinherited

Member Enumeration Documentation

EGrabberExtension

enum class Slic3r::GUI::GLGizmoBase::EGrabberExtension

stronginherited

Enumerator
None
PosX
NegX
PosY
NegY
PosZ
NegZ

    {
        None = 0,
        PosX = 1 << 0,
        NegX = 1 << 1,
        PosY = 1 << 2,
        NegY = 1 << 3,
        PosZ = 1 << 4,
        NegZ = 1 << 5,
    };

EMode

enum class Slic3r::GUI::GLGizmoMeasure::EMode : unsigned char

strongprotectedinherited

Enumerator
FeatureSelection
PointSelection

    {
        FeatureSelection,
        PointSelection
    };

EState

enum Slic3r::GUI::GLGizmoBase::EState

inherited

Enumerator
Off
On
Num_States

    {
        Off,
        On,
        Num_States
    };

GripperType

enum Slic3r::GUI::GLGizmoMeasure::GripperType

protectedinherited

Enumerator
UNDEFINE
POINT
EDGE
CIRCLE
CIRCLE_1
CIRCLE_2
PLANE
PLANE_1
PLANE_2
SPHERE_1
SPHERE_2

                   {
        UNDEFINE,
        POINT,
        EDGE,
        CIRCLE,
        CIRCLE_1,
        CIRCLE_2,
        PLANE,
        PLANE_1,
        PLANE_2,
        SPHERE_1,
        SPHERE_2,
    };

Constructor & Destructor Documentation

GLGizmoAssembly()

Slic3r::GUI::GLGizmoAssembly::GLGizmoAssembly	(	GLCanvas3D &	parent,
		const std::string &	icon_filename,
		unsigned int	sprite_id )

                                                                                                           :
    GLGizmoMeasure(parent, icon_filename, sprite_id)
{
    m_measure_mode       = EMeasureMode::ONLY_ASSEMBLY;
}

References Slic3r::GUI::GLGizmoMeasure::GLGizmoMeasure(), Slic3r::GUI::GLGizmoMeasure::m_measure_mode, and Slic3r::GUI::ONLY_ASSEMBLY.

Here is the call graph for this function:

Member Function Documentation

apply_clipping_plane()

virtual bool Slic3r::GUI::GLGizmoBase::apply_clipping_plane ( )

inlinevirtualinherited

{ return true; }

Referenced by Slic3r::GUI::GLCanvas3D::_render_objects(), and Slic3r::GUI::GLCanvas3D::get_raycaster_clipping_plane().

Here is the caller graph for this function:

center_on_feature_type_as_string()

std::string Slic3r::GUI::GLGizmoMeasure::center_on_feature_type_as_string ( Measure::SurfaceFeatureType type )

protectedinherited

{
    std::string ret;
    switch (type) {
    case Measure::SurfaceFeatureType::Edge:   { ret = _u8L("Center of edge"); break; }
    case Measure::SurfaceFeatureType::Circle: { ret = _u8L("Center of circle"); break; }
    default: { assert(false); break; }
    }
    return ret;
}

References _u8L, Slic3r::Measure::Circle, and Slic3r::Measure::Edge.

Referenced by show_selection_ui().

Here is the caller graph for this function:

data_changed()

void Slic3r::GUI::GLGizmoMeasure::data_changed ( bool is_serializing )

overridevirtualinherited

Is called when data (Selection) is changed.

Reimplemented from Slic3r::GUI::GLGizmoBase.

{
    wxBusyCursor wait;
 
    if (m_pending_scale > 0) {
        update_if_needed();
        register_single_mesh_pick();
        update_measurement_result();
        m_pending_scale --;
    }
    else {
        m_parent.toggle_selected_volume_visibility(true);
        reset_all_pick();
        update_if_needed();
        register_single_mesh_pick();
        reset_all_feature();
    }
    m_last_inv_zoom  = 0.0f;
    m_last_plane_idx = -1;
    m_editing_distance                = false;
    m_is_editing_distance_first_frame = true;
}

References m_editing_distance, m_is_editing_distance_first_frame, m_last_inv_zoom, m_last_plane_idx, Slic3r::GUI::GLGizmoBase::m_parent, m_pending_scale, register_single_mesh_pick(), reset_all_feature(), reset_all_pick(), update_if_needed(), and update_measurement_result().

Here is the call graph for this function:

disable_scene_raycasters()

void Slic3r::GUI::GLGizmoMeasure::disable_scene_raycasters ( )

protectedinherited

{
    for(auto iter:m_gripper_id_raycast_map)
    {
        iter.second->set_active(false);
    }
}

References m_gripper_id_raycast_map.

Referenced by gizmo_event().

Here is the caller graph for this function:

do_stop_dragging()

void Slic3r::GUI::GLGizmoBase::do_stop_dragging ( bool perform_mouse_cleanup )

protectedinherited

{
    for (auto& grabber : m_grabbers) grabber.dragging = false;
    m_dragging = false;
 
    // NOTE: This should be part of GLCanvas3D
    // Reset hover_id when leave window
    if (perform_mouse_cleanup) m_parent.mouse_up_cleanup();
 
    on_stop_dragging();
 
    // There is prediction that after draggign, data are changed
    // Data are updated twice also by canvas3D::reload_scene.
    // Should be fixed.
    m_parent.get_gizmos_manager().update_data();
 
    wxGetApp().obj_manipul()->set_dirty();
 
    // Let the plater know that the dragging finished, so a delayed
    // refresh of the scene with the background processing data should
    // be performed.
    m_parent.post_event(SimpleEvent(EVT_GLCANVAS_MOUSE_DRAGGING_FINISHED));
    // updates camera target constraints
    m_parent.refresh_camera_scene_box();
}

References m_dragging, m_grabbers, m_parent, and on_stop_dragging().

Referenced by use_grabbers().

Here is the call graph for this function:

Here is the caller graph for this function:

format()

std::string Slic3r::GUI::GLGizmoBase::format ( float value, unsigned int decimals ) const

protectedinherited

{
    return Slic3r::string_printf("%.*f", decimals, value);
}

References Slic3r::string_printf().

Referenced by Slic3r::GUI::GLGizmoCut3D::get_tooltip(), Slic3r::GUI::GLGizmoMove3D::get_tooltip(), Slic3r::GUI::GLGizmoRotate::get_tooltip(), Slic3r::GUI::GLGizmoScale3D::get_tooltip(), Slic3r::GUI::GLGizmoEmboss::init_font_name_texture(), Slic3r::GUI::GLGizmoSimplify::on_render_input_window(), Slic3r::GUI::GLGizmoCut3D::render_angle_input(), Slic3r::GUI::GLGizmoCut3D::render_slider_input(), Slic3r::GUI::GLGizmoCut3D::render_slider_two_input(), Slic3r::GUI::GLGizmoCut3D::render_snap_specific_input(), Slic3r::GUI::GLGizmoEmboss::rev_input(), Slic3r::GUI::GLGizmoEmboss::rev_input_mm(), Slic3r::GUI::GLGizmoEmboss::rev_slider(), Slic3r::GUI::GLGizmoEmboss::rev_slider(), and Slic3r::GUI::GLGizmoEmboss::rev_slider().

Here is the call graph for this function:

Here is the caller graph for this function:

format_double()

std::string Slic3r::GUI::GLGizmoMeasure::format_double ( double value )

protectedinherited

{
    char buf[1024];
    sprintf(buf, "%.3f", value);
    return std::string(buf);
}

Referenced by render_dimensioning(), show_distance_xyz_ui(), and show_selection_ui().

Here is the caller graph for this function:

format_vec3()

std::string Slic3r::GUI::GLGizmoMeasure::format_vec3 ( const Vec3d & v )

protectedinherited

{
    char buf[1024];
    sprintf(buf, "X: %.3f, Y: %.3f, Z: %.3f", v.x(), v.y(), v.z());
    return std::string(buf);
}

Referenced by show_distance_xyz_ui().

Here is the caller graph for this function:

get_action_snapshot_name()

std::string Slic3r::GUI::GLGizmoBase::get_action_snapshot_name ( ) const

virtualinherited

Reimplemented in Slic3r::GUI::GLGizmoCut3D, Slic3r::GUI::GLGizmoEmboss, Slic3r::GUI::GLGizmoFdmSupports, Slic3r::GUI::GLGizmoFuzzySkin, Slic3r::GUI::GLGizmoMmuSegmentation, Slic3r::GUI::GLGizmoSeam, Slic3r::GUI::GLGizmoSVG, and Slic3r::GUI::GLGizmoTextureDisplacement.

{
    return "Gizmo action";
}

Referenced by Slic3r::GUI::Plater::priv::take_snapshot().

Here is the caller graph for this function:

get_count()

int Slic3r::GUI::GLGizmoBase::get_count ( )

inlineinherited

{ return ++count; }

References count.

get_feature_offset()

Vec3d Slic3r::GUI::GLGizmoMeasure::get_feature_offset ( const Measure::SurfaceFeature & feature )

protectedinherited

{
    Vec3d ret;
    switch (feature.get_type())
    {
    case Measure::SurfaceFeatureType::Circle:
    {
        const auto [center, radius, normal] = feature.get_circle();
        ret = center;
        break;
    }
    case Measure::SurfaceFeatureType::Edge:
    {
        // Only polygon edges store an extra point (the polygon centre); plain edges have none.
        const std::optional<Vec3d> extra = feature.get_extra_point();
        if (extra.has_value())
            ret = *extra;
        else {
            const auto [pt1, pt2] = feature.get_edge();
            ret = 0.5 * (pt1 + pt2);
        }
        break;
    }
    case Measure::SurfaceFeatureType::Point:
    {
        ret = feature.get_point();
        break;
    }
    default: { assert(false); }
    }
    return ret;
}

References Slic3r::center(), Slic3r::Measure::Circle, Slic3r::Measure::Edge, Slic3r::Measure::SurfaceFeature::get_circle(), Slic3r::Measure::SurfaceFeature::get_edge(), Slic3r::Measure::SurfaceFeature::get_extra_point(), Slic3r::Measure::SurfaceFeature::get_point(), Slic3r::Measure::SurfaceFeature::get_type(), Slic3r::normal(), and Slic3r::Measure::Point.

Referenced by on_mouse(), and on_render().

Here is the call graph for this function:

Here is the caller graph for this function:

get_gizmo_entering_text()

std::string Slic3r::GUI::GLGizmoAssembly::get_gizmo_entering_text ( ) const

inlineoverridevirtual

Reimplemented from Slic3r::GUI::GLGizmoBase.

{ return _u8L("Entering Assembly gizmo"); }

References _u8L.

get_gizmo_leaving_text()

std::string Slic3r::GUI::GLGizmoAssembly::get_gizmo_leaving_text ( ) const

inlineoverridevirtual

Reimplemented from Slic3r::GUI::GLGizmoBase.

{ return _u8L("Leaving Assembly gizmo"); }

References _u8L.

get_gizmo_name()

std::string Slic3r::GUI::GLGizmoBase::get_gizmo_name ( )

inlineinherited

{ return on_get_name(); }

References on_get_name().

Here is the call graph for this function:

get_hover_id()

int Slic3r::GUI::GLGizmoBase::get_hover_id ( ) const

inlineinherited

{ return m_hover_id; }

References m_hover_id.

Referenced by Slic3r::GUI::GLCanvas3D::_scene_cache_key(), Slic3r::GUI::GLGizmosManager::grabber_contains_mouse(), Slic3r::GUI::GLGizmoBrimEars::on_mouse(), Slic3r::GUI::GLGizmoCut3D::on_mouse(), Slic3r::GUI::GLGizmoMeshBoolean::on_mouse(), and Slic3r::GUI::GLGizmoPainterBase::on_mouse().

Here is the caller graph for this function:

get_icon_filename()

const std::string & Slic3r::GUI::GLGizmoBase::get_icon_filename ( ) const

inlineinherited

{ return m_icon_filename; }

References m_icon_filename.

get_measuring_of_mesh()

Measure::Measuring * Slic3r::GUI::GLGizmoMeasure::get_measuring_of_mesh ( GLVolume * v, Transform3d & tran )

protectedinherited

{
    for (auto glvolume:m_hit_order_volumes) {
        if (glvolume == v) {
            tran = m_mesh_raycaster_map[glvolume]->get_transform();
            return m_mesh_measure_map[glvolume].get();
        }
    }
    return nullptr;
}

References m_hit_order_volumes, m_mesh_measure_map, and m_mesh_raycaster_map.

Referenced by update_feature_by_tran().

Here is the caller graph for this function:

get_name()

std::string Slic3r::GUI::GLGizmoBase::get_name ( bool include_shortcut = true ) const

inherited

{
    const std::string name = on_get_name();
    return include_shortcut && m_shortcut.has_value() ? wxGetApp().shortcuts().with_key(name, *m_shortcut) : name;
}

References m_shortcut, and on_get_name().

Referenced by Slic3r::GUI::GLGizmoAssembly::on_render_input_window(), Slic3r::GUI::GLGizmoBrimEars::on_render_input_window(), Slic3r::GUI::GLGizmoCut3D::on_render_input_window(), Slic3r::GUI::GLGizmoEmboss::on_render_input_window(), Slic3r::GUI::GLGizmoFdmSupports::on_render_input_window(), Slic3r::GUI::GLGizmoFuzzySkin::on_render_input_window(), Slic3r::GUI::GLGizmoMeasure::on_render_input_window(), Slic3r::GUI::GLGizmoMmuSegmentation::on_render_input_window(), Slic3r::GUI::GLGizmoSeam::on_render_input_window(), Slic3r::GUI::GLGizmoTextureDisplacement::on_render_input_window(), and Slic3r::GUI::GLGizmosManager::update_hover_state().

Here is the call graph for this function:

Here is the caller graph for this function:

get_requirements()

CommonGizmosDataID Slic3r::GUI::GLGizmoBase::get_requirements ( ) const

inlineinherited

{ return on_get_requirements(); }

References on_get_requirements().

Here is the call graph for this function:

get_sprite_id()

unsigned int Slic3r::GUI::GLGizmoBase::get_sprite_id ( ) const

inlineinherited

{ return m_sprite_id; }

References m_sprite_id.

Referenced by Slic3r::GUI::GLGizmosManager::do_render_overlay().

Here is the caller graph for this function:

get_state()

EState Slic3r::GUI::GLGizmoBase::get_state ( ) const

inlineinherited

{ return m_state; }

References m_state.

Referenced by Slic3r::GUI::GLGizmosManager::activate_gizmo(), Slic3r::GUI::GLGizmoFdmSupports::on_set_state(), Slic3r::GUI::GLGizmoMmuSegmentation::on_set_state(), Slic3r::GUI::GLGizmoMove3D::on_set_state(), Slic3r::GUI::GLGizmoRotate3D::on_set_state(), Slic3r::GUI::GLGizmoScale3D::on_set_state(), Slic3r::GUI::GLGizmoSeam::on_set_state(), and Slic3r::GUI::GLGizmoFlatten::set_flattening_data().

Here is the caller graph for this function:

get_tooltip()

virtual std::string Slic3r::GUI::GLGizmoBase::get_tooltip ( ) const

inlinevirtualinherited

Mouse tooltip text.

Returns

Text to be visible in mouse tooltip

Reimplemented in Slic3r::GUI::GLGizmoCut3D, Slic3r::GUI::GLGizmoMove3D, Slic3r::GUI::GLGizmoRotate3D, Slic3r::GUI::GLGizmoRotate, and Slic3r::GUI::GLGizmoScale3D.

{ return ""; }

Referenced by Slic3r::GUI::GLGizmosManager::get_tooltip().

Here is the caller graph for this function:

gizmo_event()

bool Slic3r::GUI::GLGizmoMeasure::gizmo_event ( SLAGizmoEventType action, const Vec2d & mouse_position, bool shift_down, bool alt_down, bool control_down )

virtualinherited

{
    if (action == SLAGizmoEventType::ShiftDown) {
        if (m_shift_kar_filter.is_first()) {
            m_mode = EMode::PointSelection;
            disable_scene_raycasters();
        }
        m_shift_kar_filter.increase_count();
    }
    else if (action == SLAGizmoEventType::ShiftUp) {
        m_shift_kar_filter.reset_count();
        m_mode = EMode::FeatureSelection;
        restore_scene_raycasters_state();
    }
    else if (action == SLAGizmoEventType::Delete) {
        reset_all_feature();
        m_parent.request_extra_frame();
    }
    else if (action == SLAGizmoEventType::Escape) {
        if (!m_selected_features.first.feature.has_value()) {
            update_measurement_result();
            return false;
        }
        else {
            if (m_selected_features.second.feature.has_value()) {
                reset_feature2();
            }
            else {
                reset_feature1();
            }
        }
    }
    return true;
}

References Slic3r::GUI::Delete, disable_scene_raycasters(), Slic3r::GUI::Escape, FeatureSelection, m_mode, Slic3r::GUI::GLGizmoBase::m_parent, m_selected_features, m_shift_kar_filter, PointSelection, reset_all_feature(), reset_feature1(), reset_feature2(), restore_scene_raycasters_state(), Slic3r::GUI::ShiftDown, Slic3r::GUI::ShiftUp, and update_measurement_result().

Referenced by Slic3r::GUI::GLGizmosManager::gizmo_event().

Here is the call graph for this function:

Here is the caller graph for this function:

GizmoImguiBegin()

bool Slic3r::GUI::GLGizmoBase::GizmoImguiBegin ( const std::string & name, int flags )

protectedinherited

{
    return m_imgui->begin(name, flags);
}

References m_imgui.

Referenced by Slic3r::GUI::GLGizmoAssembly::on_render_input_window(), Slic3r::GUI::GLGizmoBrimEars::on_render_input_window(), Slic3r::GUI::GLGizmoCut3D::on_render_input_window(), Slic3r::GUI::GLGizmoEmboss::on_render_input_window(), Slic3r::GUI::GLGizmoFdmSupports::on_render_input_window(), Slic3r::GUI::GLGizmoFuzzySkin::on_render_input_window(), Slic3r::GUI::GLGizmoMeasure::on_render_input_window(), Slic3r::GUI::GLGizmoMeshBoolean::on_render_input_window(), Slic3r::GUI::GLGizmoMmuSegmentation::on_render_input_window(), Slic3r::GUI::GLGizmoSeam::on_render_input_window(), Slic3r::GUI::GLGizmoSVG::on_render_input_window(), and Slic3r::GUI::GLGizmoTextureDisplacement::on_render_input_window().

Here is the caller graph for this function:

GizmoImguiEnd()

void Slic3r::GUI::GLGizmoBase::GizmoImguiEnd ( )

protectedinherited

{
    last_input_window_width = ImGui::GetWindowWidth();
    m_imgui->end();
}

References last_input_window_width, and m_imgui.

Referenced by Slic3r::GUI::GLGizmoAssembly::on_render_input_window(), Slic3r::GUI::GLGizmoBrimEars::on_render_input_window(), Slic3r::GUI::GLGizmoCut3D::on_render_input_window(), Slic3r::GUI::GLGizmoEmboss::on_render_input_window(), Slic3r::GUI::GLGizmoFdmSupports::on_render_input_window(), Slic3r::GUI::GLGizmoFuzzySkin::on_render_input_window(), Slic3r::GUI::GLGizmoMeasure::on_render_input_window(), Slic3r::GUI::GLGizmoMeshBoolean::on_render_input_window(), Slic3r::GUI::GLGizmoMmuSegmentation::on_render_input_window(), Slic3r::GUI::GLGizmoSeam::on_render_input_window(), and Slic3r::GUI::GLGizmoSVG::on_render_input_window().

Here is the caller graph for this function:

GizmoImguiSetNextWIndowPos() [1/2]

void Slic3r::GUI::GLGizmoBase::GizmoImguiSetNextWIndowPos ( float & x, float y, float w, float h, int flag, float pivot_x = 0.0f, float pivot_y = 0.0f )

protectedinherited

{
    if (abs(w) > 0.01f) {
        if (x + w > m_parent.get_canvas_size().get_width()) {
            if (w > m_parent.get_canvas_size().get_width()) {
                x = 0;
            } else {
                x = m_parent.get_canvas_size().get_width() - w;
            }
        }
    }
 
    m_imgui->set_next_window_pos(x, y, flag, pivot_x, pivot_y);
}

References m_imgui, and m_parent.

GizmoImguiSetNextWIndowPos() [2/2]

void Slic3r::GUI::GLGizmoBase::GizmoImguiSetNextWIndowPos ( float & x, float y, int flag, float pivot_x = 0.0f, float pivot_y = 0.0f )

protectedinherited

{
    GizmoImguiSetNextWIndowPos(x, y, last_input_window_width, 0, flag, pivot_x, pivot_y);
}

References GizmoImguiSetNextWIndowPos(), and last_input_window_width.

Referenced by GizmoImguiSetNextWIndowPos(), Slic3r::GUI::GLGizmoAssembly::on_render_input_window(), Slic3r::GUI::GLGizmoBrimEars::on_render_input_window(), Slic3r::GUI::GLGizmoCut3D::on_render_input_window(), Slic3r::GUI::GLGizmoEmboss::on_render_input_window(), Slic3r::GUI::GLGizmoFdmSupports::on_render_input_window(), Slic3r::GUI::GLGizmoFuzzySkin::on_render_input_window(), Slic3r::GUI::GLGizmoMeasure::on_render_input_window(), Slic3r::GUI::GLGizmoMeshBoolean::on_render_input_window(), Slic3r::GUI::GLGizmoMmuSegmentation::on_render_input_window(), Slic3r::GUI::GLGizmoSeam::on_render_input_window(), Slic3r::GUI::GLGizmoSVG::on_render_input_window(), and Slic3r::GUI::GLGizmoTextureDisplacement::on_render_input_window().

Here is the call graph for this function:

Here is the caller graph for this function:

init()

bool Slic3r::GUI::GLGizmoBase::init ( )

inlineinherited

{ return on_init(); }

References on_init().

Here is the call graph for this function:

init_circle_glmodel()

void Slic3r::GUI::GLGizmoMeasure::init_circle_glmodel ( GripperType gripper_type, const Measure::SurfaceFeature & feature, CircleGLModel & circle_gl_model, float inv_zoom )

protectedinherited

{
    const auto [center, radius, normal] = feature.get_circle();
    auto cur_feature =const_cast<Measure::SurfaceFeature *>(&feature);
    if (circle_gl_model.inv_zoom != inv_zoom) {
        if (circle_gl_model.last_circle_feature) {
            const auto [last_center, last_radius, last_normal] = circle_gl_model.last_circle_feature->get_circle();
            float eps    = 1e-2;
            if ((last_center - center).norm() < eps && (last_normal - normal).norm() < eps && abs(last_radius - radius) < eps){
                return;
            }
        }
        reset_gripper_pick(gripper_type);
        circle_gl_model.circle.reset();
        GLModel::Geometry circle_geometry = init_torus_data(64, 16, center.cast<float>(), float(radius), 5.0f * inv_zoom, normal.cast<float>(), Transform3f::Identity());
        circle_gl_model.circle.mesh_raycaster = std::make_unique<MeshRaycaster>(std::make_shared<const TriangleMesh>(circle_geometry.get_as_indexed_triangle_set()));
        circle_gl_model.circle.model.init_from(std::move(circle_geometry));
        if (circle_gl_model.circle.model.is_initialized()) {
            m_gripper_id_raycast_map[gripper_type] = std::make_shared<PickRaycaster>(CIRCLE_ID, *m_curr_circle.circle.mesh_raycaster);
        }
        circle_gl_model.last_circle_feature = cur_feature;
        circle_gl_model.inv_zoom            = inv_zoom;
    }
}

References Slic3r::center(), Slic3r::GUI::GLGizmoMeasure::CircleGLModel::circle, Slic3r::GUI::CIRCLE_ID, Slic3r::GUI::GLModel::Geometry::get_as_indexed_triangle_set(), Slic3r::Measure::SurfaceFeature::get_circle(), Slic3r::GUI::GLModel::init_from(), Slic3r::GUI::init_torus_data(), Slic3r::GUI::GLGizmoMeasure::CircleGLModel::inv_zoom, Slic3r::GUI::GLModel::is_initialized(), Slic3r::GUI::GLGizmoMeasure::CircleGLModel::last_circle_feature, m_curr_circle, m_gripper_id_raycast_map, Slic3r::GUI::PickingModel::mesh_raycaster, Slic3r::GUI::PickingModel::model, Slic3r::normal(), Slic3r::GUI::PickingModel::reset(), and reset_gripper_pick().

Referenced by on_render().

Here is the call graph for this function:

Here is the caller graph for this function:

init_plane_glmodel()

void Slic3r::GUI::GLGizmoMeasure::init_plane_glmodel ( GripperType gripper_type, const Measure::SurfaceFeature & feature, PlaneGLModel & plane_gl_model )

protectedinherited

{
    if (!feature.volume) { return; }
    Selection&  selection = m_parent.get_selection();
    auto volume = static_cast<GLVolume *>(feature.volume);
    const ModelObject* obj      = selection.get_model()->objects[volume->object_idx()];
    const ModelVolume* vol      = obj->volumes[volume->volume_idx()];
    auto               mesh = vol->mesh_ptr();
    const auto &[idx, normal, pt] = feature.get_plane();
    if (plane_gl_model.plane_idx != idx) {
        plane_gl_model.plane.reset();
    }
    if (!plane_gl_model.plane.model.is_initialized()) {
        plane_gl_model.plane_idx    = idx;
        reset_gripper_pick(gripper_type);
        GLModel::Geometry init_data = init_plane_data(mesh->its, *feature.plane_indices, MEASURE_PLNE_NORMAL_OFFSET);
        plane_gl_model.plane.mesh_raycaster = std::make_unique<MeshRaycaster>(std::make_shared<const TriangleMesh>(init_data.get_as_indexed_triangle_set()));
        plane_gl_model.plane.model.init_from(std::move(init_data));
        if (plane_gl_model.plane.model.is_initialized()) {
            m_gripper_id_raycast_map[gripper_type] = std::make_shared<PickRaycaster>(PLANE_ID, *plane_gl_model.plane.mesh_raycaster, feature.world_tran);
        }
    }
}

References Slic3r::GUI::GLModel::Geometry::get_as_indexed_triangle_set(), Slic3r::GUI::Selection::get_model(), Slic3r::Measure::SurfaceFeature::get_plane(), Slic3r::GUI::GLModel::init_from(), Slic3r::GUI::init_plane_data(), Slic3r::GUI::GLModel::is_initialized(), m_gripper_id_raycast_map, Slic3r::GUI::GLGizmoBase::m_parent, Slic3r::GUI::MEASURE_PLNE_NORMAL_OFFSET, Slic3r::ModelVolume::mesh_ptr(), Slic3r::GUI::PickingModel::mesh_raycaster, Slic3r::GUI::PickingModel::model, Slic3r::normal(), Slic3r::Model::objects, Slic3r::GUI::GLGizmoMeasure::PlaneGLModel::plane, Slic3r::GUI::PLANE_ID, Slic3r::GUI::GLGizmoMeasure::PlaneGLModel::plane_idx, Slic3r::Measure::SurfaceFeature::plane_indices, Slic3r::GUI::PickingModel::reset(), reset_gripper_pick(), Slic3r::Measure::SurfaceFeature::volume, Slic3r::ModelObject::volumes, and Slic3r::Measure::SurfaceFeature::world_tran.

Referenced by on_render().

Here is the call graph for this function:

Here is the caller graph for this function:

init_render_input_window()

void Slic3r::GUI::GLGizmoMeasure::init_render_input_window ( )

protectedinherited

{
    m_use_inches        = wxGetApp().app_config->get_bool("use_inches");
    m_units             = " " + (m_use_inches ? _u8L_CONTEXT("in", "inches") : _u8L("mm"));
    m_space_size        = ImGui::CalcTextSize("  ").x * 2;
    m_input_size_max    = ImGui::CalcTextSize("-100.00").x * 1.2;
    m_same_model_object = is_two_volume_in_same_model_object();
}

References _u8L, _u8L_CONTEXT, is_two_volume_in_same_model_object(), m_input_size_max, m_same_model_object, m_space_size, m_units, and m_use_inches.

Referenced by Slic3r::GUI::GLGizmoAssembly::on_render_input_window(), and on_render_input_window().

Here is the call graph for this function:

Here is the caller graph for this function:

is_activable()

bool Slic3r::GUI::GLGizmoBase::is_activable ( ) const

inlineinherited

{ return on_is_activable(); }

References on_is_activable().

Referenced by Slic3r::GUI::GLGizmosManager::activate_gizmo(), Slic3r::GUI::GLGizmosManager::do_render_overlay(), Slic3r::GUI::GLGizmoEmboss::init_create(), and Slic3r::GUI::GLGizmosManager::update_hover_state().

Here is the call graph for this function:

Here is the caller graph for this function:

is_dragging()

bool Slic3r::GUI::GLGizmoBase::is_dragging ( ) const

inlineinherited

{ return m_dragging; }

References m_dragging.

Referenced by Slic3r::GUI::GLGizmoCut3D::gizmo_event(), Slic3r::GUI::GLGizmoEmboss::on_mouse_for_translate(), and Slic3r::GUI::GLGizmoSVG::on_mouse_for_translate().

Here is the caller graph for this function:

is_feature_with_center()

bool Slic3r::GUI::GLGizmoMeasure::is_feature_with_center ( const Measure::SurfaceFeature & feature )

protectedinherited

{
    const Measure::SurfaceFeatureType type = feature.get_type();
    return (type == Measure::SurfaceFeatureType::Circle || (type == Measure::SurfaceFeatureType::Edge && feature.get_extra_point().has_value()));
}

References Slic3r::Measure::Circle, Slic3r::Measure::Edge, Slic3r::Measure::SurfaceFeature::get_extra_point(), and Slic3r::Measure::SurfaceFeature::get_type().

Referenced by on_mouse(), and on_render().

Here is the call graph for this function:

Here is the caller graph for this function:

is_in_editing_mode()

virtual bool Slic3r::GUI::GLGizmoBase::is_in_editing_mode ( ) const

inlinevirtualinherited

Reimplemented in Slic3r::GUI::GLGizmoCut3D.

{ return false; }

Referenced by Slic3r::GUI::GLGizmosManager::on_key().

Here is the caller graph for this function:

is_pick_meet_assembly_mode()

bool Slic3r::GUI::GLGizmoMeasure::is_pick_meet_assembly_mode ( const SelectedFeatures::Item & item )

protectedinherited

                                                                                {
    if (m_measure_mode == EMeasureMode::ONLY_ASSEMBLY) {
        if (m_assembly_mode == AssemblyMode::FACE_FACE && item.feature->get_type() == Measure::SurfaceFeatureType::Plane) {
            return true;
        }
        if (m_assembly_mode == AssemblyMode::POINT_POINT &&
            (item.feature->get_type() == Measure::SurfaceFeatureType::Point||
                item.feature->get_type() == Measure::SurfaceFeatureType::Circle)) {
            return true;
        }
        return false;
    }
    else {
        return true;
    }
}

References Slic3r::Measure::Circle, Slic3r::GUI::FACE_FACE, Slic3r::GUI::GLGizmoMeasure::SelectedFeatures::Item::feature, m_assembly_mode, m_measure_mode, Slic3r::GUI::ONLY_ASSEMBLY, Slic3r::Measure::Plane, Slic3r::Measure::Point, and Slic3r::GUI::POINT_POINT.

Referenced by on_mouse().

Here is the caller graph for this function:

is_selectable()

bool Slic3r::GUI::GLGizmoBase::is_selectable ( ) const

inlineinherited

{ return on_is_selectable(); }

References on_is_selectable().

Here is the call graph for this function:

is_selection_rectangle_dragging()

virtual bool Slic3r::GUI::GLGizmoBase::is_selection_rectangle_dragging ( ) const

inlinevirtualinherited

Reimplemented in Slic3r::GUI::GLGizmoBrimEars, and Slic3r::GUI::GLGizmoCut3D.

{ return false; }

is_two_volume_in_same_model_object()

bool Slic3r::GUI::GLGizmoMeasure::is_two_volume_in_same_model_object ( )

protectedinherited

{
    if (m_hit_different_volumes.size() == 2) {
        if (m_hit_different_volumes[0]->composite_id.object_id == m_hit_different_volumes[1]->composite_id.object_id) {
            return true;
        }
    }
    return false;
}

References m_hit_different_volumes.

Referenced by init_render_input_window().

Here is the caller graph for this function:

load()

void Slic3r::GUI::GLGizmoBase::load ( cereal::BinaryInputArchive & ar )

inlineinherited

{ m_state = On; on_load(ar); }

References m_state, On, and on_load().

Here is the call graph for this function:

load_render_colors()

void Slic3r::GUI::GLGizmoBase::load_render_colors ( )

staticinherited

{
    RenderColor::colors[RenderCol_Grabber_X]           = ImGuiWrapper::to_ImVec4(GLGizmoBase::AXES_COLOR[0]);
    RenderColor::colors[RenderCol_Grabber_Y]           = ImGuiWrapper::to_ImVec4(GLGizmoBase::AXES_COLOR[1]);
    RenderColor::colors[RenderCol_Grabber_Z]           = ImGuiWrapper::to_ImVec4(GLGizmoBase::AXES_COLOR[2]);
    RenderColor::colors[RenderCol_Flatten_Plane]       = ImGuiWrapper::to_ImVec4(GLGizmoBase::FLATTEN_COLOR);
    RenderColor::colors[RenderCol_Flatten_Plane_Hover] = ImGuiWrapper::to_ImVec4(GLGizmoBase::FLATTEN_HOVER_COLOR);
}

References AXES_COLOR, Slic3r::RenderColor::colors, FLATTEN_COLOR, FLATTEN_HOVER_COLOR, RenderCol_Flatten_Plane, RenderCol_Flatten_Plane_Hover, RenderCol_Grabber_X, RenderCol_Grabber_Y, RenderCol_Grabber_Z, and Slic3r::GUI::ImGuiWrapper::to_ImVec4().

Referenced by Slic3r::GUI::GLCanvas3D::init().

Here is the call graph for this function:

Here is the caller graph for this function:

on_change_color_mode()

virtual void Slic3r::GUI::GLGizmoBase::on_change_color_mode ( bool is_dark )

inlinevirtualinherited

{  m_is_dark_mode = is_dark; }

References is_dark(), and m_is_dark_mode.

Here is the call graph for this function:

on_disable_grabber()

virtual void Slic3r::GUI::GLGizmoBase::on_disable_grabber ( unsigned int id )

inlineprotectedvirtualinherited

Reimplemented in Slic3r::GUI::GLGizmoEmboss, Slic3r::GUI::GLGizmoRotate3D, and Slic3r::GUI::GLGizmoSVG.

{}

on_dragging()

virtual void Slic3r::GUI::GLGizmoBase::on_dragging ( const UpdateData & data )

inlineprotectedvirtualinherited

Reimplemented in Slic3r::GUI::GLGizmoBrimEars, Slic3r::GUI::GLGizmoCut3D, Slic3r::GUI::GLGizmoEmboss, Slic3r::GUI::GLGizmoMove3D, Slic3r::GUI::GLGizmoRotate3D, Slic3r::GUI::GLGizmoRotate, Slic3r::GUI::GLGizmoScale3D, and Slic3r::GUI::GLGizmoSVG.

{}

Referenced by use_grabbers().

Here is the caller graph for this function:

on_enable_grabber()

virtual void Slic3r::GUI::GLGizmoBase::on_enable_grabber ( unsigned int id )

inlineprotectedvirtualinherited

Reimplemented in Slic3r::GUI::GLGizmoEmboss, Slic3r::GUI::GLGizmoRotate3D, and Slic3r::GUI::GLGizmoSVG.

{}

on_get_name()

std::string Slic3r::GUI::GLGizmoAssembly::on_get_name ( ) const

overrideprotectedvirtual

Implements Slic3r::GUI::GLGizmoBase.

{
    if (!on_is_activable() && m_state == EState::Off) {
        if (wxGetApp().plater()->canvas3D()->get_canvas_type() == GLCanvas3D::ECanvasType::CanvasAssembleView) {
            return _u8L_CONTEXT("Assemble", "Assembly tool") + ":\n" + _u8L("Please confirm explosion ratio = 1 and select at least two volumes.");
        }
        else {
            return _u8L_CONTEXT("Assemble", "Assembly tool") + ":\n" + _u8L("Please select at least two volumes.");
        }
    } else {
        return _u8L_CONTEXT("Assemble", "Assembly tool");
    }
}

References _u8L, _u8L_CONTEXT, Slic3r::GUI::GLCanvas3D::CanvasAssembleView, Slic3r::GUI::GLGizmoBase::m_state, Slic3r::GUI::GLGizmoBase::Off, on_is_activable(), and Slic3r::GUI::plater().

Here is the call graph for this function:

on_get_requirements()

virtual CommonGizmosDataID Slic3r::GUI::GLGizmoBase::on_get_requirements ( ) const

inlineprotectedvirtualinherited

Reimplemented in Slic3r::GUI::GLGizmoBrimEars, Slic3r::GUI::GLGizmoCut3D, Slic3r::GUI::GLGizmoFlatten, Slic3r::GUI::GLGizmoMeshBoolean, Slic3r::GUI::GLGizmoPainterBase, and Slic3r::GUI::GLGizmoSimplify.

{ return CommonGizmosDataID(0); }

Referenced by get_requirements().

Here is the caller graph for this function:

on_init()

bool Slic3r::GUI::GLGizmoAssembly::on_init ( )

overrideprotectedvirtual

Implements Slic3r::GUI::GLGizmoBase.

{
    GLGizmoMeasure::on_init();
 
    m_shortcut = Shortcut::GizmoAssembly;
    return true;
}

References Slic3r::GUI::GizmoAssembly, Slic3r::GUI::GLGizmoBase::m_shortcut, and Slic3r::GUI::GLGizmoMeasure::on_init().

Here is the call graph for this function:

on_is_activable()

bool Slic3r::GUI::GLGizmoAssembly::on_is_activable ( ) const

overrideprotectedvirtual

Reimplemented from Slic3r::GUI::GLGizmoBase.

{
    const Selection& selection = m_parent.get_selection();
    if (selection.is_wipe_tower()) {
        return false;
    }
    const int    selection_volumes_count = 2;
    if (wxGetApp().plater()->canvas3D()->get_canvas_type() == GLCanvas3D::ECanvasType::CanvasAssembleView) {
        if (abs(m_parent.get_explosion_ratio() - 1.0f) < 1e-2 && selection.volumes_count() >= selection_volumes_count) {
            return true;
        }
        return false;
    } else {
        return selection.volumes_count() >= selection_volumes_count;
    }
}

References Slic3r::GUI::GLCanvas3D::CanvasAssembleView, Slic3r::GUI::Selection::is_wipe_tower(), Slic3r::GUI::GLGizmoBase::m_parent, Slic3r::GUI::plater(), and Slic3r::GUI::Selection::volumes_count().

Referenced by on_get_name().

Here is the call graph for this function:

Here is the caller graph for this function:

on_is_selectable()

virtual bool Slic3r::GUI::GLGizmoBase::on_is_selectable ( ) const

inlineprotectedvirtualinherited

Reimplemented in Slic3r::GUI::GLGizmoCut3D, Slic3r::GUI::GLGizmoMmuSegmentation, Slic3r::GUI::GLGizmoPainterBase, Slic3r::GUI::GLGizmoSimplify, and Slic3r::GUI::GLGizmoSVG.

{ return true; }

Referenced by is_selectable().

Here is the caller graph for this function:

on_load()

virtual void Slic3r::GUI::GLGizmoBase::on_load ( cereal::BinaryInputArchive & ar )

inlineprotectedvirtualinherited

Reimplemented in Slic3r::GUI::GLGizmoBrimEars, Slic3r::GUI::GLGizmoCut3D, Slic3r::GUI::GLGizmoMeshBoolean, and Slic3r::GUI::GLGizmoPainterBase.

{}

Referenced by load().

Here is the caller graph for this function:

on_mouse()

bool Slic3r::GUI::GLGizmoMeasure::on_mouse ( const wxMouseEvent & mouse_event )

overridevirtualinherited

Apply rotation on select plane.

Parameters

mouse_event

Keep information about mouse click

Returns

Return True when use the information otherwise False.

Reimplemented from Slic3r::GUI::GLGizmoBase.

{
    if (mouse_event.Moving()) {
        // only for sure
        m_mouse_left_down = false;
        return false;
    }
    else if (mouse_event.Dragging()) {
        // Enable/Disable panning/rotating the 3D scene
        // Ctrl is pressed or the mouse is not hovering a selected volume
        bool unlock_dragging = mouse_event.CmdDown() || (m_hover_id == -1 && !m_parent.get_selection().contains_volume(m_parent.get_first_hover_volume_idx()));
        // mode is not center selection or mouse is not hovering a center
        unlock_dragging &= !mouse_event.ShiftDown() || (m_hover_id != SEL_SPHERE_1_ID && m_hover_id != SEL_SPHERE_2_ID && m_hover_id != POINT_ID);
        return !unlock_dragging;
    }
    else if (mouse_event.LeftDown()) {
        // let the event pass through to allow panning/rotating the 3D scene
        if (mouse_event.CmdDown())
            return false;
 
        if (m_hover_id != -1) {
            m_mouse_left_down = true;
            m_mouse_left_down_mesh_deal = true;
            auto detect_current_item = [this]() {
                SelectedFeatures::Item item;
                if (m_hover_id == SEL_SPHERE_1_ID) {
                    if (m_selected_features.first.is_center)
                        // mouse is hovering over a selected center
                        item = { true, m_selected_features.first.source, { Measure::SurfaceFeature(get_feature_offset(*m_selected_features.first.source)) } };
                    else if (is_feature_with_center(*m_selected_features.first.feature))
                        // mouse is hovering over a unselected center
                        item = { true, m_selected_features.first.feature, { Measure::SurfaceFeature(get_feature_offset(*m_selected_features.first.feature)) } };
                    else
                        // mouse is hovering over a point
                        item = m_selected_features.first;
                }
                else if (m_hover_id == SEL_SPHERE_2_ID) {
                    if (m_selected_features.second.is_center)
                        // mouse is hovering over a selected center
                        item = { true, m_selected_features.second.source, { Measure::SurfaceFeature(get_feature_offset(*m_selected_features.second.source)) } };
                    else if (is_feature_with_center(*m_selected_features.second.feature))
                        // mouse is hovering over a center
                        item = { true, m_selected_features.second.feature, { Measure::SurfaceFeature(get_feature_offset(*m_selected_features.second.feature)) } };
                    else
                        // mouse is hovering over a point
                        item = m_selected_features.second;
                }
                else {
                    switch (m_mode)
                    {
                    case EMode::FeatureSelection: { item = { false, m_curr_feature, m_curr_feature }; break; }
                    case EMode::PointSelection:   {
                       item = { false, m_curr_feature, Measure::SurfaceFeature(*m_curr_point_on_feature_position)};
                       auto local_pt = m_curr_feature->world_tran.inverse() * (*m_curr_point_on_feature_position);
                       item.feature->origin_surface_feature = std::make_shared<Measure::SurfaceFeature>(local_pt);
                       item.feature->world_tran             = m_curr_feature->world_tran;
                       item.feature->volume                 = m_curr_feature->volume;
                       break; }
                    }
                }
                return item;
            };
 
            auto requires_sphere_raycaster_for_picking = [this](const SelectedFeatures::Item& item) {
                if (m_mode == EMode::PointSelection || item.feature->get_type() == Measure::SurfaceFeatureType::Point)
                    return true;
                else if (m_mode == EMode::FeatureSelection) {
                    if (is_feature_with_center(*item.feature))
                        return true;
                }
                return false;
            };
 
            if (m_selected_features.first.feature.has_value()) {
                reset_feature2_render();
                const SelectedFeatures::Item item = detect_current_item();
                if (!is_pick_meet_assembly_mode(item)) { // assembly deal
                    m_selected_wrong_feature_waring_tip = true;
                    return true;
                }
                m_selected_wrong_feature_waring_tip = false;
                if (m_selected_features.first != item) {
                    bool processed = false;
                    if (item.is_center) {
                        if (item.source == m_selected_features.first.feature) {
                            // switch 1st selection from feature to its center
                            m_selected_features.first = item;
                            processed = true;
                        }
                        else if (item.source == m_selected_features.second.feature) {
                            // switch 2nd selection from feature to its center
                            m_selected_features.second = item;
                            processed = true;
                        }
                    }
                    else if (is_feature_with_center(*item.feature)) {
                      if (m_selected_features.first.is_center && m_selected_features.first.source == item.feature) {
                          // switch 1st selection from center to its feature
                          m_selected_features.first = item;
                          processed = true;
                      }
                      else if (m_selected_features.second.is_center && m_selected_features.second.source == item.feature) {
                          // switch 2nd selection from center to its feature
                          m_selected_features.second = item;
                          processed = true;
                      }
                    }
 
                    if (!processed) {
                        remove_selected_sphere_raycaster(SEL_SPHERE_2_ID);
                        if (m_selected_features.second == item) {
                            // 2nd feature deselection
                            // m_selected_features.second.reset();
                            reset_feature2();
                        }
                        else {
                            // 2nd feature selection
                            m_selected_features.second = item;
                            if (requires_sphere_raycaster_for_picking(item)) {
                                auto pick = std::make_shared<PickRaycaster>(SEL_SPHERE_2_ID, *m_sphere.mesh_raycaster);
                                m_gripper_id_raycast_map[GripperType::SPHERE_2] = pick;
                            }
                        }
                    }
                }
                else {
                    remove_selected_sphere_raycaster(SEL_SPHERE_1_ID);
                    if (m_selected_features.second.feature.has_value()) {
                        // promote 2nd feature to 1st feature
                        reset_feature1();
                        if (requires_sphere_raycaster_for_picking(m_selected_features.first)) {
                            auto pick = std::make_shared<PickRaycaster>(SEL_SPHERE_1_ID, *m_sphere.mesh_raycaster);
                            m_gripper_id_raycast_map[GripperType::SPHERE_1] = pick;
                        }
                    } else {
                        // 1st feature deselection
                        reset_feature1();
                    }
                }
            }
            else {
                // 1st feature selection
                reset_feature1_render();
                const SelectedFeatures::Item item = detect_current_item();
                if (!is_pick_meet_assembly_mode(item)) {//assembly deal
                    m_selected_wrong_feature_waring_tip = true;
                    return true;
                }
                m_selected_wrong_feature_waring_tip = false;
                m_selected_features.first = item;
                if (requires_sphere_raycaster_for_picking(item)) {
                    auto pick = std::make_shared<PickRaycaster>(SEL_SPHERE_1_ID, *m_sphere.mesh_raycaster);
                    m_gripper_id_raycast_map[GripperType::SPHERE_1] = pick;
                }
            }
 
            update_measurement_result();
 
            m_imgui->set_requires_extra_frame();
            return true;
        }
        else
            // if the mouse pointer is on any volume, filter out the event to prevent the user to move it
            // equivalent tp: return (m_parent.get_first_hover_volume_idx() != -1);
            return m_curr_feature.has_value();
 
        // 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;
        }
        if (m_hover_id == -1 && !m_parent.is_mouse_dragging())
            // avoid closing the gizmo if the user clicks outside of any volume
            return true;
    }
    else if (mouse_event.RightDown()) {
        // let the event pass through to allow panning/rotating the 3D scene
        if (mouse_event.CmdDown())
            return false;
    }
    else if (mouse_event.Leaving())
        m_mouse_left_down = false;
 
    return false;
}

References Slic3r::GUI::GLGizmoMeasure::SelectedFeatures::Item::feature, FeatureSelection, get_feature_offset(), Slic3r::GUI::GLGizmoMeasure::SelectedFeatures::Item::is_center, is_feature_with_center(), is_pick_meet_assembly_mode(), m_curr_feature, m_curr_point_on_feature_position, m_gripper_id_raycast_map, Slic3r::GUI::GLGizmoBase::m_hover_id, Slic3r::GUI::GLGizmoBase::m_imgui, m_mode, m_mouse_left_down, m_mouse_left_down_mesh_deal, Slic3r::GUI::GLGizmoBase::m_parent, m_selected_features, m_selected_wrong_feature_waring_tip, m_sphere, Slic3r::Measure::Point, Slic3r::GUI::POINT_ID, PointSelection, remove_selected_sphere_raycaster(), reset_feature1(), reset_feature1_render(), reset_feature2(), reset_feature2_render(), Slic3r::GUI::SEL_SPHERE_1_ID, Slic3r::GUI::SEL_SPHERE_2_ID, Slic3r::GUI::GLGizmoMeasure::SelectedFeatures::Item::source, SPHERE_1, SPHERE_2, update_measurement_result(), and Slic3r::GUI::wxMouseEvent.

Here is the call graph for this function:

on_register_raycasters_for_picking()

virtual void Slic3r::GUI::GLGizmoBase::on_register_raycasters_for_picking ( )

inlineprotectedvirtualinherited

Reimplemented in Slic3r::GUI::GLGizmoBrimEars, Slic3r::GUI::GLGizmoCut3D, Slic3r::GUI::GLGizmoEmboss, Slic3r::GUI::GLGizmoFlatten, Slic3r::GUI::GLGizmoMove3D, Slic3r::GUI::GLGizmoRotate3D, Slic3r::GUI::GLGizmoScale3D, and Slic3r::GUI::GLGizmoSVG.

{}

Referenced by register_raycasters_for_picking().

Here is the caller graph for this function:

on_render()

void Slic3r::GUI::GLGizmoMeasure::on_render ( )

overrideprotectedvirtualinherited

Implements Slic3r::GUI::GLGizmoBase.

{
    m_rendered_this_frame = true;
#if ENABLE_MEASURE_GIZMO_DEBUG
    render_debug_dialog();
#endif // ENABLE_MEASURE_GIZMO_DEBUG
 
    Vec2d mouse_position = m_parent.get_local_mouse_position();
    update_if_needed();
 
    const Camera& camera = wxGetApp().plater()->get_camera();
    const float inv_zoom = (float)camera.get_inv_zoom();
    bool mouse_on_gripper = false;
    bool mouse_on_object =false;
    {
        if (!m_editing_distance) {
            Vec3f  hit                          = Vec3f::Zero();
            double closest_hit_squared_distance = std::numeric_limits<double>::max();
            for (auto item : m_gripper_id_raycast_map) {
 
                auto  world_tran = item.second->get_transform();
                Vec3f normal_on_gripper;
                if (item.second->get_raycaster()->closest_hit(mouse_position, item.second->get_transform(), camera, hit, normal_on_gripper)) {
                    double hit_squared_distance = (camera.get_position() - world_tran * hit.cast<double>()).squaredNorm();
                    if (hit_squared_distance < closest_hit_squared_distance) {
                        closest_hit_squared_distance = hit_squared_distance;
                        if (item.second->get_id() > 0) {
                            m_hover_id       = item.second->get_id();
                            mouse_on_gripper = true;
                        }
                    }
                }
            }
        }
    }
    Vec3d  position_on_model;
    size_t model_facet_idx = -1;
    double closest_hit_distance = std::numeric_limits<double>::max();
    {
        if (!m_editing_distance) {
            for (auto item : m_mesh_raycaster_map) {
                auto   raycaster                    = item.second->get_raycaster();
                auto   world_tran                   = item.second->get_transform();
                Vec3f  normal                       = Vec3f::Zero();
                Vec3f  hit                          = Vec3f::Zero();
                size_t facet                        = 0;
                if (raycaster->unproject_on_mesh(mouse_position, world_tran, camera, hit, normal, nullptr, &facet)) {
                    // Is this hit the closest to the camera so far?
                    double hit_squared_distance = (camera.get_position() - world_tran * hit.cast<double>()).norm();
                    if (hit_squared_distance < closest_hit_distance) {
                        closest_hit_distance = hit_squared_distance;
                        mouse_on_object   = true;
                        model_facet_idx   = facet;
                        position_on_model = hit.cast<double>();
                        m_last_hit_volume = item.first;
                        m_curr_measuring  = m_mesh_measure_map[m_last_hit_volume];
                    }
                }
            }
        }
 
        if (!(mouse_on_gripper || mouse_on_object)) {
            m_hover_id = -1;
            m_last_plane_idx = -1;
            reset_gripper_pick(GripperType::PLANE);
            reset_gripper_pick(GripperType::CIRCLE);
        }
        if (m_mouse_left_down_mesh_deal && m_hover_id >= 0) {
            m_mouse_left_down_mesh_deal = false;
            if (m_selected_features.second.feature.has_value()) {
                if (m_hit_order_volumes.size() == 1) {
                    m_hit_order_volumes.push_back(m_last_hit_volume);
                } else {
                    m_hit_order_volumes[1] = m_last_hit_volume;
                }
                // deal hit_different_volumes
                if (m_hit_different_volumes.size() >= 1) {
                    if (m_last_hit_volume == m_hit_different_volumes[0]) {
                        if (m_hit_different_volumes.size() == 2) {//hit same volume
                            m_hit_different_volumes.erase(m_hit_different_volumes.begin() + 1);
                        }
                    } else  {
                        if (m_hit_different_volumes.size() == 2) {
                            m_hit_different_volumes[1] = m_last_hit_volume;
                        } else {
                            m_hit_different_volumes.push_back(m_last_hit_volume);
                        }
                    }
                }
            }
            else if (m_selected_features.first.feature.has_value()) {
                if (m_hit_order_volumes.size() == 0) {
                    m_hit_order_volumes.push_back(m_last_hit_volume);
                } else {
                    m_hit_order_volumes[0] = m_last_hit_volume;
                }
                //deal hit_different_volumes
                if (m_hit_different_volumes.size() == 0) {
                    m_hit_different_volumes.push_back(m_last_hit_volume);
                }
            }
        }
    }
    //const bool mouse_on_object = m_raycaster->unproject_on_mesh(mouse_position, Transform3d::Identity(), camera, position_on_model, normal_on_model, nullptr, &model_facet_idx);
    const bool is_hovering_on_feature = m_mode == EMode::PointSelection && m_hover_id != -1;
 
    if (m_mode == EMode::FeatureSelection || m_mode == EMode::PointSelection) {
        if (m_hover_id == SEL_SPHERE_1_ID || m_hover_id == SEL_SPHERE_2_ID) {
            // Skip feature detection if hovering on a selected point/center
            //reset_gripper_pick(GripperType::UNDEFINE, true);
            m_curr_feature.reset();
            m_curr_point_on_feature_position.reset();
        }
        else {
            std::optional<Measure::SurfaceFeature> curr_feature = std::nullopt;
            if (m_curr_measuring) {
                curr_feature = wxGetMouseState().LeftIsDown() ? m_curr_feature :
                               mouse_on_object                ? m_curr_measuring->get_feature(model_facet_idx, position_on_model,
                                                                               m_mesh_raycaster_map[m_last_hit_volume]->get_transform(), m_only_select_plane) :
                                                              std::nullopt;
            }
            if (m_measure_mode == EMeasureMode::ONLY_ASSEMBLY && curr_feature.has_value()) {
                if (m_assembly_mode == AssemblyMode::FACE_FACE) {
                    if (curr_feature->get_type() != Measure::SurfaceFeatureType::Plane) {
                        curr_feature.reset();
                    }
                } else if (m_assembly_mode == AssemblyMode::POINT_POINT) {
                    if (!(curr_feature->get_type() == Measure::SurfaceFeatureType::Point ||
                        curr_feature->get_type() == Measure::SurfaceFeatureType::Circle ||
                        (m_mode == EMode::PointSelection && (curr_feature->get_type() == Measure::SurfaceFeatureType::Plane || curr_feature->get_type() == Measure::SurfaceFeatureType::Edge)))) {
                        curr_feature.reset();
                    }
                }
            }
            if (m_curr_feature != curr_feature ||
                (curr_feature.has_value() && curr_feature->get_type() == Measure::SurfaceFeatureType::Circle && (m_curr_feature != curr_feature || m_last_inv_zoom != inv_zoom))) {
                reset_gripper_pick(GripperType::UNDEFINE, true);
 
                m_curr_feature = curr_feature;
                // The selected features are drawn below whether or not one is hovered.
                if (m_curr_feature.has_value()) {
                    m_curr_feature->volume     = m_last_hit_volume;
                    m_curr_feature->world_tran = m_mesh_raycaster_map[m_last_hit_volume]->get_transform();
 
                    switch (m_curr_feature->get_type()) {
                    default: { assert(false); break; }
                    case Measure::SurfaceFeatureType::Point:
                    {
                        m_gripper_id_raycast_map[GripperType::POINT] = std::make_shared<PickRaycaster>(POINT_ID, *m_sphere.mesh_raycaster);
                        break;
                    }
                    case Measure::SurfaceFeatureType::Edge:
                    {
                        m_gripper_id_raycast_map[GripperType::EDGE] = std::make_shared<PickRaycaster>(EDGE_ID, *m_cylinder.mesh_raycaster);
                        break;
                    }
                    case Measure::SurfaceFeatureType::Circle: {
                        m_curr_circle.last_circle_feature = nullptr;
                        m_curr_circle.inv_zoom            = 0;
                        init_circle_glmodel(GripperType::CIRCLE, *m_curr_feature, m_curr_circle,inv_zoom);
                        break;
                    }
                    case Measure::SurfaceFeatureType::Plane: {
                        update_world_plane_features(m_curr_measuring.get(), *m_curr_feature);
                        m_curr_plane.plane_idx = -1;
                        init_plane_glmodel(GripperType::PLANE, *m_curr_feature, m_curr_plane);
                        break;
                    }
                    }
                }
            }
        }
    }
 
    if (m_mode != EMode::PointSelection) {
        m_curr_point_on_feature_position.reset();
    }
    else if (is_hovering_on_feature) {
        auto position_on_feature = [this, &mouse_position](int feature_type_id, const Camera &camera, std::function<Vec3f(const Vec3f &)> callback = nullptr) -> Vec3d {
            auto it = m_gripper_id_raycast_map.find((GripperType) feature_type_id); // m_raycasters.find(feature_type_id);
            if (it != m_gripper_id_raycast_map.end() && it->second != nullptr) {
                Vec3f p;
                Vec3f n;
                const Transform3d& trafo = it->second->get_transform();
                bool res = it->second->get_raycaster()->closest_hit(mouse_position, trafo, camera, p, n);
                if (res) {
                    if (callback)
                        p = callback(p);
                    return trafo * p.cast<double>();
                }
            }
            return Vec3d(DBL_MAX, DBL_MAX, DBL_MAX);
        };
        if (m_curr_feature.has_value()) {
            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:
            {
                const std::optional<Vec3d> extra = m_curr_feature->get_extra_point();
                if (extra.has_value() && m_hover_id == GripperType::POINT)
                    m_curr_point_on_feature_position = *extra;
                else {
                    const Vec3d pos = position_on_feature(GripperType::EDGE, camera, [](const Vec3f &v) { return Vec3f(0.0f, 0.0f, v.z()); });
                    if (!pos.isApprox(Vec3d(DBL_MAX, DBL_MAX, DBL_MAX)))
                        m_curr_point_on_feature_position = pos;
                }
                break;
            }
            case Measure::SurfaceFeatureType::Plane:
            {
                m_curr_point_on_feature_position = position_on_feature(GripperType::PLANE, 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 Vec3d world_pof = position_on_feature(GripperType::CIRCLE, camera, [](const Vec3f &v) { return v; });
                    const Eigen::Hyperplane<double, 3> plane(normal, center);
                    const Transform3d local_to_model_matrix = Geometry::translation_transform(center) * Eigen::Quaternion<double>::FromTwoVectors(Vec3d::UnitZ(), normal);
                    const Vec3d local_proj = local_to_model_matrix.inverse() * plane.projection(world_pof);
                    double angle = std::atan2(local_proj.y(), local_proj.x());
                    if (angle < 0.0)
                        angle += 2.0 * double(M_PI);
 
                    const Vec3d local_pos = radius * Vec3d(std::cos(angle), std::sin(angle), 0.0);
                    m_curr_point_on_feature_position = local_to_model_matrix * local_pos;
                }
                break;
            }
            }
        }
    }
    else {
        m_curr_point_on_feature_position.reset();
    }
 
    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("projection_matrix", camera.get_projection_matrix());
 
    glsafe(::glClear(GL_DEPTH_BUFFER_BIT));
    glsafe(::glEnable(GL_DEPTH_TEST));
    const bool old_cullface = ::glIsEnabled(GL_CULL_FACE);
    glsafe(::glDisable(GL_CULL_FACE));
 
    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 set_emission_uniform = [shader](const ColorRGBA& color, bool hover) {
        shader->set_uniform("emission_factor", /*(color == GLVolume::SELECTED_COLOR) ? 0.0f :*/
            hover ? 0.5f : 0.25f);
    };
 
    auto render_glmodel = [set_matrix_uniforms, set_emission_uniform](PickingModel& model, const ColorRGBA& color, const Transform3d& model_matrix, bool hover) {
        set_matrix_uniforms(model_matrix);
        set_emission_uniform(color, hover);
        model.model.set_color(color);
        model.model.render();
    };
 
    auto render_feature =
        [this, render_glmodel](const Measure::SurfaceFeature& feature, const std::vector<ColorRGBA>& colors,
        float inv_zoom, bool hover, bool update_raycasters_transform,int featura_index = -1) {
            switch (feature.get_type())
            {
            default: { assert(false); break; }
            case Measure::SurfaceFeatureType::Point:
            {
                const Transform3d feature_matrix =  Geometry::translation_transform(feature.get_point()) * Geometry::scale_transform(inv_zoom);
                Geometry::Transformation tran(feature_matrix);
                render_glmodel(m_sphere, colors.front(), tran.get_matrix(), hover);
                if (update_raycasters_transform) {
                    auto it = m_gripper_id_raycast_map.find(GripperType::POINT);
                    if (it != m_gripper_id_raycast_map.end() && it->second != nullptr)
                        it->second->set_transform(feature_matrix);
                }
                break;
            }
            case Measure::SurfaceFeatureType::Circle:
            {
                const auto& [center, radius, normal] = feature.get_circle();
                // render circle
                const Transform3d circle_matrix =  Transform3d::Identity();
                //set_matrix_uniforms(circle_matrix);
                Geometry::Transformation tran(circle_matrix);
                if (featura_index == -1) {
                    init_circle_glmodel(GripperType::CIRCLE, feature, m_curr_circle, inv_zoom);
                    render_glmodel(m_curr_circle.circle, colors.front(), tran.get_matrix(), hover);
                }
                // render plane feature1 or feature2
                if (featura_index == 0) { // feature1
                    init_circle_glmodel(GripperType::CIRCLE_1, feature, m_feature_circle_first, inv_zoom);
                    render_glmodel(m_feature_circle_first.circle, colors.front(), tran.get_matrix(), hover);
                } else if (featura_index == 1) { // feature2
                    init_circle_glmodel(GripperType::CIRCLE_2, feature, m_feature_circle_second, inv_zoom);
                    render_glmodel(m_feature_circle_second.circle, colors.front(), tran.get_matrix(), hover);
                }
                // render center
                if (colors.size() > 1) {
                    const Transform3d center_matrix = Geometry::translation_transform(center) * Geometry::scale_transform(inv_zoom);
                    render_glmodel(m_sphere, colors.back(), center_matrix, hover);
 
                    Geometry::Transformation tran(center_matrix);
                    auto it = m_gripper_id_raycast_map.find(GripperType::POINT);
                    if (it != m_gripper_id_raycast_map.end() && it->second != nullptr)
                        it->second->set_transform(center_matrix);
                }
                break;
            }
            case Measure::SurfaceFeatureType::Edge:
            {
                const auto& [from, to] = feature.get_edge();
                // render edge
                const Transform3d edge_matrix =  Geometry::translation_transform(from) *
                    Eigen::Quaternion<double>::FromTwoVectors(Vec3d::UnitZ(), to - from) *
                    Geometry::scale_transform({ (double)inv_zoom, (double)inv_zoom, (to - from).norm() });
 
                Geometry::Transformation tran(edge_matrix);
                render_glmodel(m_cylinder, colors.front(), tran.get_matrix(), hover);
                if (update_raycasters_transform) {
                    auto it = m_gripper_id_raycast_map.find(GripperType::EDGE);
                    if (it != m_gripper_id_raycast_map.end() && it->second != nullptr){
                        it->second->set_transform(edge_matrix);
                    }
                }
                // render extra point
                if (colors.size() > 1) {
                    const std::optional<Vec3d> extra = feature.get_extra_point();
                    if (extra.has_value()) {
                        const Transform3d point_matrix = Geometry::translation_transform(*extra) * Geometry::scale_transform(inv_zoom);
                        Geometry::Transformation tran(point_matrix);
                        render_glmodel(m_sphere, colors.back(), tran.get_matrix(), hover);
 
                        auto it = m_gripper_id_raycast_map.find(GripperType::POINT);
                        if (it != m_gripper_id_raycast_map.end() && it->second != nullptr) {
                            it->second->set_transform(point_matrix);
                        }
                    }
                }
                break;
            }
            case Measure::SurfaceFeatureType::Plane: {
                if (featura_index == -1) {
                    render_glmodel(m_curr_plane.plane, colors.back(), feature.world_tran, hover);
                    break;
                }
                //render plane feature1 or feature2
                if (featura_index == 0) {//feature1
                    init_plane_glmodel(GripperType::PLANE_1, feature, m_feature_plane_first);
                    render_glmodel(m_feature_plane_first.plane, colors.back(), feature.world_tran, hover);
                } else if (featura_index == 1) {//feature2
                    init_plane_glmodel(GripperType::PLANE_2, feature, m_feature_plane_second);
                    render_glmodel(m_feature_plane_second.plane, colors.back(), feature.world_tran, hover);
                }
                break;
            }
            }
    };
 
    auto hover_selection_color = [this]() {
      return ((m_mode == EMode::PointSelection && !m_selected_features.first.feature.has_value()) ||
              (m_mode != EMode::PointSelection && (!m_selected_features.first.feature.has_value() || *m_curr_feature == *m_selected_features.first.feature))) ?
          SELECTED_1ST_COLOR : SELECTED_2ND_COLOR;
    };
 
    auto hovering_color = [this, hover_selection_color]() {
        return (m_mode == EMode::PointSelection) ? HOVER_COLOR : hover_selection_color();
    };
 
    if (m_curr_feature.has_value()) {
        // render hovered feature
        std::vector<ColorRGBA> colors;
        if (m_selected_features.first.feature.has_value() && *m_curr_feature == *m_selected_features.first.feature) {
            // hovering over the 1st selected feature
            if (m_selected_features.first.is_center)
                // hovering over a center
                colors = { NEUTRAL_COLOR, hovering_color() };
            else if (is_feature_with_center(*m_selected_features.first.feature))
                // hovering over a feature with center
                colors = { hovering_color(), NEUTRAL_COLOR };
            else
                colors = { hovering_color() };
        }
        else if (m_selected_features.second.feature.has_value() && *m_curr_feature == *m_selected_features.second.feature) {
            // hovering over the 2nd selected feature
            if (m_selected_features.second.is_center)
                // hovering over a center
                colors = { NEUTRAL_COLOR, hovering_color() };
            else if (is_feature_with_center(*m_selected_features.second.feature))
                // hovering over a feature with center
                colors = { hovering_color(), NEUTRAL_COLOR };
            else
                colors = { hovering_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::Edge:
            case Measure::SurfaceFeatureType::Circle:
            {
                if (m_selected_features.first.is_center && m_curr_feature == m_selected_features.first.source)
                    colors = { SELECTED_1ST_COLOR, NEUTRAL_COLOR };
                else if (m_selected_features.second.is_center && m_curr_feature == m_selected_features.second.source)
                    colors = { SELECTED_2ND_COLOR, NEUTRAL_COLOR };
                else
                    colors = { hovering_color(), hovering_color() };
                break;
            }
            case Measure::SurfaceFeatureType::Plane:
            {
                colors.emplace_back(hovering_color());
                break;
            }
            }
        }
 
        render_feature(*m_curr_feature, colors, inv_zoom, true, true);
    }
 
    if (m_selected_features.first.feature.has_value() && (!m_curr_feature.has_value() || *m_curr_feature != *m_selected_features.first.feature)) {
        // render 1st selected feature
 
        std::optional<Measure::SurfaceFeature> feature_to_render;
        std::vector<ColorRGBA> colors;
        bool requires_raycaster_update = false;
        if (m_hover_id == SEL_SPHERE_1_ID && (m_selected_features.first.is_center || is_feature_with_center(*m_selected_features.first.feature))) {
            // hovering over a center
            feature_to_render = m_selected_features.first.source;
            colors = { NEUTRAL_COLOR, SELECTED_1ST_COLOR };
            requires_raycaster_update = true;
        }
        else if (is_feature_with_center(*m_selected_features.first.feature)) {
            // hovering over a feature with center
            feature_to_render = m_selected_features.first.feature;
            colors = { SELECTED_1ST_COLOR, NEUTRAL_COLOR };
            requires_raycaster_update = true;
        }
        else {
            feature_to_render = m_selected_features.first.feature;
            colors = { SELECTED_1ST_COLOR };
            requires_raycaster_update = m_selected_features.first.feature->get_type() == Measure::SurfaceFeatureType::Point;
        }
 
        render_feature(*feature_to_render, colors, inv_zoom, m_hover_id == SEL_SPHERE_1_ID, false, 0);
 
        if (requires_raycaster_update) {
            if (m_gripper_id_raycast_map.find(GripperType::SPHERE_1) != m_gripper_id_raycast_map.end()) {
                m_gripper_id_raycast_map[GripperType::SPHERE_1]->set_transform(Geometry::translation_transform(get_feature_offset(*m_selected_features.first.feature)) *
                                                                               Geometry::scale_transform(inv_zoom));
            }
        }
    }
 
    if (m_selected_features.second.feature.has_value() && (!m_curr_feature.has_value() || *m_curr_feature != *m_selected_features.second.feature)) {
        // render 2nd selected feature
 
        std::optional<Measure::SurfaceFeature> feature_to_render;
        std::vector<ColorRGBA> colors;
        bool requires_raycaster_update = false;
        if (m_hover_id == SEL_SPHERE_2_ID && (m_selected_features.second.is_center || is_feature_with_center(*m_selected_features.second.feature))) {
            // hovering over a center
            feature_to_render = m_selected_features.second.source;
            colors = { NEUTRAL_COLOR, SELECTED_2ND_COLOR };
            requires_raycaster_update = true;
        }
        else if (is_feature_with_center(*m_selected_features.second.feature)) {
            // hovering over a feature with center
            feature_to_render = m_selected_features.second.feature;
            colors = { SELECTED_2ND_COLOR, NEUTRAL_COLOR };
            requires_raycaster_update = true;
        }
        else {
            feature_to_render = m_selected_features.second.feature;
            colors = { SELECTED_2ND_COLOR };
            requires_raycaster_update = m_selected_features.second.feature->get_type() == Measure::SurfaceFeatureType::Point;
        }
 
        render_feature(*feature_to_render, colors, inv_zoom, m_hover_id == SEL_SPHERE_2_ID, false, 1);
 
        if (requires_raycaster_update) {
            if (m_gripper_id_raycast_map.find(GripperType::SPHERE_2) != m_gripper_id_raycast_map.end()) {
                m_gripper_id_raycast_map[GripperType::SPHERE_2]->set_transform(Geometry::translation_transform(get_feature_offset(*m_selected_features.second.feature)) *
                                                                               Geometry::scale_transform(inv_zoom));
            }
        }
    }
 
    if (is_hovering_on_feature && m_curr_point_on_feature_position.has_value()) {
        if (m_hover_id != POINT_ID) {
            // render point on feature while SHIFT is pressed
            const Transform3d matrix = Geometry::translation_transform(*m_curr_point_on_feature_position) * Geometry::scale_transform(inv_zoom);
            const ColorRGBA color = hover_selection_color();
 
            Geometry::Transformation tran(matrix);
            render_glmodel(m_sphere, color, tran.get_matrix(), true);
        }
    }
 
    shader->stop_using();
 
    if (old_cullface)
        glsafe(::glEnable(GL_CULL_FACE));
 
    render_dimensioning();
}

References Slic3r::angle(), Slic3r::center(), CIRCLE, Slic3r::Measure::Circle, CIRCLE_1, CIRCLE_2, EDGE, Slic3r::Measure::Edge, Slic3r::GUI::EDGE_ID, Slic3r::GUI::FACE_FACE, FeatureSelection, Slic3r::Measure::SurfaceFeature::get_circle(), Slic3r::Measure::SurfaceFeature::get_edge(), Slic3r::Measure::SurfaceFeature::get_extra_point(), get_feature_offset(), Slic3r::GUI::Camera::get_inv_zoom(), Slic3r::Geometry::Transformation::get_matrix(), Slic3r::Measure::SurfaceFeature::get_point(), Slic3r::GUI::Camera::get_position(), Slic3r::GUI::Camera::get_projection_matrix(), Slic3r::Measure::SurfaceFeature::get_type(), Slic3r::GUI::Camera::get_view_matrix(), GL_CULL_FACE, GL_DEPTH_BUFFER_BIT, GL_DEPTH_TEST, glClear, glDisable, glEnable, glIsEnabled, glsafe, Slic3r::GUI::HOVER_COLOR, init_circle_glmodel(), init_plane_glmodel(), is_feature_with_center(), m_assembly_mode, m_curr_circle, m_curr_feature, m_curr_measuring, m_curr_plane, m_curr_point_on_feature_position, m_cylinder, m_editing_distance, m_feature_circle_first, m_feature_circle_second, m_feature_plane_first, m_feature_plane_second, m_gripper_id_raycast_map, m_hit_different_volumes, m_hit_order_volumes, Slic3r::GUI::GLGizmoBase::m_hover_id, m_last_hit_volume, m_last_inv_zoom, m_last_plane_idx, m_measure_mode, m_mesh_measure_map, m_mesh_raycaster_map, m_mode, m_mouse_left_down_mesh_deal, m_only_select_plane, Slic3r::GUI::GLGizmoBase::m_parent, M_PI, m_rendered_this_frame, m_selected_features, m_sphere, Slic3r::GUI::NEUTRAL_COLOR, Slic3r::normal(), Slic3r::GUI::ONLY_ASSEMBLY, PLANE, Slic3r::Measure::Plane, PLANE_1, PLANE_2, POINT, Slic3r::Measure::Point, Slic3r::GUI::POINT_ID, Slic3r::GUI::POINT_POINT, PointSelection, render_dimensioning(), reset_gripper_pick(), Slic3r::Geometry::scale_transform(), Slic3r::GUI::SEL_SPHERE_1_ID, Slic3r::GUI::SEL_SPHERE_2_ID, Slic3r::GUI::SELECTED_1ST_COLOR, Slic3r::GUI::SELECTED_2ND_COLOR, Slic3r::GLShaderProgram::set_uniform(), SPHERE_1, SPHERE_2, Slic3r::GLShaderProgram::start_using(), Slic3r::GLShaderProgram::stop_using(), Slic3r::Geometry::translation_transform(), UNDEFINE, update_if_needed(), update_world_plane_features(), and Slic3r::Measure::SurfaceFeature::world_tran.

Here is the call graph for this function:

on_render_input_window()

void Slic3r::GUI::GLGizmoAssembly::on_render_input_window ( float x, float y, float bottom_limit )

overrideprotectedvirtual

Reimplemented from Slic3r::GUI::GLGizmoMeasure.

{
    render_dimensioning_if_scene_reused();
    static std::optional<Measure::SurfaceFeature> last_feature;
    static EMode last_mode = EMode::FeatureSelection;
    static SelectedFeatures last_selected_features;
 
    static float last_y = 0.0f;
    static float last_h = 0.0f;
 
    if (m_editing_distance)
        return;
    m_current_active_imgui_id      = ImGui::GetActiveID();
    // adjust window position to avoid overlap the view toolbar
    const float win_h = ImGui::GetWindowHeight();
    y = std::min(y, bottom_limit - win_h);
    GizmoImguiSetNextWIndowPos(x, y, ImGuiCond_Always, 0.0f, 0.0f);
    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;
    }
    // Orca
    ImGuiWrapper::push_toolbar_style(m_parent.get_scale());
    GizmoImguiBegin(get_name(), ImGuiWindowFlags_NoMove | ImGuiWindowFlags_AlwaysAutoResize | ImGuiWindowFlags_NoCollapse | ImGuiWindowFlags_NoTitleBar);
    init_render_input_window();
 
    float moving_size = m_imgui->calc_text_size(_L("(Moving)")).x;
    float combox_content_size = m_imgui->calc_text_size(_L("Point and point assembly")).x*1.1 + ImGui::GetStyle().FramePadding.x * 18.0f;
    float caption_size = moving_size + 2 * m_space_size;
    if (render_assembly_mode_combo(caption_size + 0.5 * m_space_size,  combox_content_size)) {
        ;
    }
    show_selection_ui();
    show_face_face_assembly_common();
 
    ImGui::Separator();
    show_face_face_assembly_senior();
    show_distance_xyz_ui();
 
    ImGui::Separator();
    float f_scale =m_parent.get_gizmos_manager().get_layout_scale();
    ImGui::PushStyleVar(ImGuiStyleVar_FramePadding, ImVec2(6.0f, 4.0f * f_scale));
 
    GLGizmoUtils::render_tooltip_button(m_imgui, m_parent, m_shortcuts, x, y);
 
    ImGui::SameLine();
    GLGizmoUtils::begin_right_aligned_buttons({ _L("Done") });
    if (m_imgui->button(_L("Done"))) {
        m_parent.reset_all_gizmos();
    }
 
    render_input_window_warning(m_same_model_object);
 
    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_last_active_item_imgui = m_current_active_imgui_id;
    
    GizmoImguiEnd();
    // Orca
    ImGui::PopStyleVar(1); // ImGuiStyleVar_FramePadding
    ImGuiWrapper::pop_toolbar_style();
}

References _L, Slic3r::GUI::GLGizmoUtils::begin_right_aligned_buttons(), Slic3r::GUI::GLGizmoMeasure::FeatureSelection, Slic3r::GUI::GLGizmoBase::get_name(), Slic3r::GUI::GLGizmoBase::GizmoImguiBegin(), Slic3r::GUI::GLGizmoBase::GizmoImguiEnd(), Slic3r::GUI::GLGizmoBase::GizmoImguiSetNextWIndowPos(), Slic3r::GUI::GLGizmoMeasure::init_render_input_window(), Slic3r::GUI::GLGizmoMeasure::m_curr_feature, Slic3r::GUI::GLGizmoMeasure::m_current_active_imgui_id, Slic3r::GUI::GLGizmoMeasure::m_editing_distance, Slic3r::GUI::GLGizmoBase::m_imgui, Slic3r::GUI::GLGizmoMeasure::m_last_active_item_imgui, Slic3r::GUI::GLGizmoMeasure::m_mode, Slic3r::GUI::GLGizmoBase::m_parent, Slic3r::GUI::GLGizmoMeasure::m_same_model_object, Slic3r::GUI::GLGizmoMeasure::m_selected_features, Slic3r::GUI::GLGizmoMeasure::m_shortcuts, Slic3r::GUI::GLGizmoMeasure::m_space_size, Slic3r::GUI::ImGuiWrapper::pop_toolbar_style(), Slic3r::GUI::ImGuiWrapper::push_toolbar_style(), render_assembly_mode_combo(), Slic3r::GUI::GLGizmoMeasure::render_dimensioning_if_scene_reused(), render_input_window_warning(), Slic3r::GUI::GLGizmoUtils::render_tooltip_button(), Slic3r::GUI::GLGizmoMeasure::show_distance_xyz_ui(), Slic3r::GUI::GLGizmoMeasure::show_face_face_assembly_common(), Slic3r::GUI::GLGizmoMeasure::show_face_face_assembly_senior(), and Slic3r::GUI::GLGizmoMeasure::show_selection_ui().

Here is the call graph for this function:

on_save()

virtual void Slic3r::GUI::GLGizmoBase::on_save ( cereal::BinaryOutputArchive & ar ) const

inlineprotectedvirtualinherited

Reimplemented in Slic3r::GUI::GLGizmoBrimEars, Slic3r::GUI::GLGizmoCut3D, Slic3r::GUI::GLGizmoMeshBoolean, and Slic3r::GUI::GLGizmoPainterBase.

{}

Referenced by save().

Here is the caller graph for this function:

on_set_hover_id()

virtual void Slic3r::GUI::GLGizmoBase::on_set_hover_id ( )

inlineprotectedvirtualinherited

Reimplemented in Slic3r::GUI::GLGizmoBrimEars, Slic3r::GUI::GLGizmoCut3D, Slic3r::GUI::GLGizmoEmboss, Slic3r::GUI::GLGizmoRotate3D, and Slic3r::GUI::GLGizmoSVG.

{}

Referenced by set_hover_id().

Here is the caller graph for this function:

on_set_state()

void Slic3r::GUI::GLGizmoMeasure::on_set_state ( )

overrideprotectedvirtualinherited

Reimplemented from Slic3r::GUI::GLGizmoBase.

{
    if (m_state == Off) {
        m_parent.toggle_selected_volume_visibility(false);
        m_shift_kar_filter.reset_count();
        m_curr_feature.reset();
        m_curr_point_on_feature_position.reset();
        restore_scene_raycasters_state();
        m_editing_distance = false;
        m_is_editing_distance_first_frame = true;
        std::map<GLVolume *, std::shared_ptr<Measure::Measuring>>().swap(m_mesh_measure_map);
    }
    else {
        m_mode = EMode::FeatureSelection;
        m_hover_id = -1;
        m_show_reset_first_tip = false;
        m_only_select_plane    = false;
        m_distance             = Vec3d::Zero();
    }
}

References FeatureSelection, m_curr_feature, m_curr_point_on_feature_position, m_distance, m_editing_distance, Slic3r::GUI::GLGizmoBase::m_hover_id, m_is_editing_distance_first_frame, m_mesh_measure_map, m_mode, m_only_select_plane, Slic3r::GUI::GLGizmoBase::m_parent, m_shift_kar_filter, m_show_reset_first_tip, Slic3r::GUI::GLGizmoBase::m_state, Slic3r::GUI::GLGizmoBase::Off, and restore_scene_raycasters_state().

Here is the call graph for this function:

on_start_dragging()

virtual void Slic3r::GUI::GLGizmoBase::on_start_dragging ( )

inlineprotectedvirtualinherited

Reimplemented in Slic3r::GUI::GLGizmoBrimEars, Slic3r::GUI::GLGizmoCut3D, Slic3r::GUI::GLGizmoEmboss, Slic3r::GUI::GLGizmoMove3D, Slic3r::GUI::GLGizmoRotate3D, Slic3r::GUI::GLGizmoRotate, Slic3r::GUI::GLGizmoScale3D, and Slic3r::GUI::GLGizmoSVG.

{}

Referenced by use_grabbers().

Here is the caller graph for this function:

on_stop_dragging()

virtual void Slic3r::GUI::GLGizmoBase::on_stop_dragging ( )

inlineprotectedvirtualinherited

Reimplemented in Slic3r::GUI::GLGizmoBrimEars, Slic3r::GUI::GLGizmoCut3D, Slic3r::GUI::GLGizmoEmboss, Slic3r::GUI::GLGizmoMove3D, Slic3r::GUI::GLGizmoRotate3D, Slic3r::GUI::GLGizmoScale3D, and Slic3r::GUI::GLGizmoSVG.

{}

Referenced by do_stop_dragging(), and Slic3r::GUI::GLGizmoRotate::stop_dragging().

Here is the caller graph for this function:

on_unregister_raycasters_for_picking()

virtual void Slic3r::GUI::GLGizmoBase::on_unregister_raycasters_for_picking ( )

inlineprotectedvirtualinherited

Reimplemented in Slic3r::GUI::GLGizmoBrimEars, Slic3r::GUI::GLGizmoCut3D, Slic3r::GUI::GLGizmoEmboss, Slic3r::GUI::GLGizmoFlatten, Slic3r::GUI::GLGizmoMove3D, Slic3r::GUI::GLGizmoRotate3D, Slic3r::GUI::GLGizmoScale3D, and Slic3r::GUI::GLGizmoSVG.

{}

Referenced by unregister_raycasters_for_picking().

Here is the caller graph for this function:

point_on_feature_type_as_string()

std::string Slic3r::GUI::GLGizmoMeasure::point_on_feature_type_as_string ( Measure::SurfaceFeatureType type, int hover_id )

protectedinherited

{
    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 = _u8L("Point on circle"); break; }
    case Measure::SurfaceFeatureType::Plane:  { ret = _u8L("Point on plane"); break; }
    default:                                  { assert(false); break; }
    }
    return ret;
}

References _u8L, Slic3r::Measure::Circle, Slic3r::Measure::Edge, Slic3r::Measure::Plane, and Slic3r::Measure::Point.

Referenced by show_selection_ui().

Here is the caller graph for this function:

register_grabbers_for_picking()

void Slic3r::GUI::GLGizmoBase::register_grabbers_for_picking ( )

protectedinherited

{
    for (size_t i = 0; i < m_grabbers.size(); ++i) {
        m_grabbers[i].register_raycasters_for_picking((m_group_id >= 0) ? m_group_id : i);
    }
}

References m_grabbers, and m_group_id.

Referenced by register_raycasters_for_picking().

Here is the caller graph for this function:

register_raycasters_for_picking()

void Slic3r::GUI::GLGizmoBase::register_raycasters_for_picking ( )

inlineinherited

{ register_grabbers_for_picking(); on_register_raycasters_for_picking(); }

References on_register_raycasters_for_picking(), and register_grabbers_for_picking().

Referenced by Slic3r::GUI::GLGizmosManager::activate_gizmo(), and Slic3r::GUI::GLCanvas3D::reload_scene().

Here is the call graph for this function:

Here is the caller graph for this function:

register_single_mesh_pick()

void Slic3r::GUI::GLGizmoMeasure::register_single_mesh_pick ( )

protectedinherited

{
    Selection&  selection = m_parent.get_selection();
    const Selection::IndicesList &idxs  = selection.get_volume_idxs();
    if (idxs.size() > 0) {
        for (unsigned int idx : idxs) {
            GLVolume *v                = const_cast<GLVolume *>(selection.get_volume(idx));
            auto world_tran            = v->get_instance_transformation() * v->get_volume_transformation();
            if (m_mesh_raycaster_map.find(v) != m_mesh_raycaster_map.end()) {
                m_mesh_raycaster_map[v]->set_transform(world_tran.get_matrix());
            } else {
                const ModelObject*   obj  = selection.get_model()->objects[v->object_idx()];
                const ModelVolume*   vol  = obj->volumes[v->volume_idx()];
                auto                 mesh = vol->mesh_ptr();
                m_mesh_raycaster_map[v] = std::make_shared<PickRaycaster>(-1, *v->mesh_raycaster, world_tran.get_matrix());
                m_mesh_raycaster_map[v]->set_transform(world_tran.get_matrix());
                m_mesh_measure_map[v] = std::make_shared<Measure::Measuring>(mesh->its);
            }
        }
    }
}

References Slic3r::GLVolume::get_instance_transformation(), Slic3r::GUI::Selection::get_model(), Slic3r::GUI::Selection::get_volume(), Slic3r::GUI::Selection::get_volume_idxs(), Slic3r::GLVolume::get_volume_transformation(), m_mesh_measure_map, m_mesh_raycaster_map, Slic3r::GUI::GLGizmoBase::m_parent, Slic3r::ModelVolume::mesh_ptr(), Slic3r::GLVolume::mesh_raycaster, Slic3r::GLVolume::object_idx(), Slic3r::Model::objects, Slic3r::GLVolume::volume_idx(), and Slic3r::ModelObject::volumes.

Referenced by data_changed(), render_dimensioning(), set_distance(), set_parallel_distance(), set_to_around_center_of_faces(), set_to_parallel(), and set_to_reverse_rotation().

Here is the call graph for this function:

Here is the caller graph for this function:

remove_selected_sphere_raycaster()

void Slic3r::GUI::GLGizmoMeasure::remove_selected_sphere_raycaster ( int id )

protectedinherited

{
    reset_gripper_pick(id == SEL_SPHERE_1_ID ? GripperType::SPHERE_1 : GripperType::SPHERE_2);
}

References reset_gripper_pick(), Slic3r::GUI::SEL_SPHERE_1_ID, SPHERE_1, and SPHERE_2.

Referenced by on_mouse(), reset_feature1(), and reset_feature2().

Here is the call graph for this function:

Here is the caller graph for this function:

render()

void Slic3r::GUI::GLGizmoBase::render ( )

inlineinherited

{ on_render(); }

References on_render().

Here is the call graph for this function:

render_assembly_mode_combo()

bool Slic3r::GUI::GLGizmoAssembly::render_assembly_mode_combo ( double label_width, float item_width )

protected

{
    ImGui::AlignTextToFramePadding();
    int                      selection_idx = int(m_assembly_mode);
    std::vector<std::string> modes         = {_u8L("Face and face assembly"), _u8L("Point and point assembly")};
    bool                     is_changed    = false;
 
    ImGuiWrapper::push_combo_style(m_parent.get_scale());
    if (render_combo(_u8L("Mode"), modes, selection_idx, label_width, item_width)) {
        is_changed = true;
        switch_to_mode((AssemblyMode) selection_idx);
    }
    ImGuiWrapper::pop_combo_style();
    return is_changed;
}

References _u8L, Slic3r::GUI::GLGizmoMeasure::m_assembly_mode, Slic3r::GUI::GLGizmoBase::m_parent, Slic3r::GUI::ImGuiWrapper::pop_combo_style(), Slic3r::GUI::ImGuiWrapper::push_combo_style(), Slic3r::GUI::GLGizmoBase::render_combo(), and switch_to_mode().

Referenced by on_render_input_window().

Here is the call graph for this function:

Here is the caller graph for this function:

render_combo()

bool Slic3r::GUI::GLGizmoBase::render_combo ( const std::string & label, const std::vector< std::string > & lines, int & selection_idx, float label_width, float item_width )

protectedinherited

{
    ImGuiWrapper::push_combo_style(m_parent.get_scale());
    ImGui::AlignTextToFramePadding();
    m_imgui->text(label);
    ImGui::SameLine(label_width);
    ImGui::PushItemWidth(item_width);
 
    size_t selection_out = selection_idx;
 
    const char *selected_str = (selection_idx >= 0 && selection_idx < int(lines.size())) ? lines[selection_idx].c_str() : "";
    if (ImGui::BBLBeginCombo(("##" + label).c_str(), selected_str, 0)) {
        for (size_t line_idx = 0; line_idx < lines.size(); ++line_idx) {
            ImGui::PushID(int(line_idx));
            if (ImGui::Selectable("", line_idx == selection_idx)) selection_out = line_idx;
 
            ImGui::SameLine();
            ImGui::Text("%s", lines[line_idx].c_str());
            ImGui::PopID();
        }
 
        ImGui::EndCombo();
    }
 
    bool is_changed = selection_idx != selection_out;
    selection_idx   = selection_out;
 
    //if (is_changed) update_connector_shape();
    ImGuiWrapper::pop_combo_style();
 
    return is_changed;
}

References m_imgui, m_parent, Slic3r::GUI::ImGuiWrapper::pop_combo_style(), and Slic3r::GUI::ImGuiWrapper::push_combo_style().

Referenced by Slic3r::GUI::GLGizmoAssembly::render_assembly_mode_combo(), and Slic3r::GUI::GLGizmoCut3D::render_connectors_input_window().

Here is the call graph for this function:

Here is the caller graph for this function:

render_cross_mark()

void Slic3r::GUI::GLGizmoBase::render_cross_mark ( const Vec3f & target, bool is_single = false )

protectedinherited

{
    const float half_length = 4.0f;
 
    // ORCA: OpenGL Core Profile
#if !SLIC3R_OPENGL_ES
    if (!OpenGLManager::get_gl_info().is_core_profile())
        glsafe(::glLineWidth(2.0f));
#endif // !SLIC3R_OPENGL_ES
 
    auto render_line = [](const Vec3f& p1, const Vec3f& p2, const ColorRGBA& color) {
        GLModel::Geometry init_data;
        init_data.format = {GLModel::Geometry::EPrimitiveType::Lines, GLModel::Geometry::EVertexLayout::P3};
        init_data.color  = color;
        init_data.reserve_vertices(2);
        init_data.reserve_indices(2);
 
        // vertices
        init_data.add_vertex(p1);
        init_data.add_vertex(p2);
 
        // indices
        init_data.add_line(0, 1);
 
        GLModel model;
        model.init_from(std::move(init_data));
        model.render();
    };
 
    // draw line for x axis
    if (!is_single) {
        render_line(
            {target(0) - half_length, target(1), target(2)}, 
            {target(0) + half_length, target(1), target(2)},
            ColorRGBA::X()); // ORCA match axis colors
    }
    else {
        render_line(
            {target(0), target(1), target(2)}, 
            {target(0) + half_length, target(1), target(2)},
            ColorRGBA::X()); // ORCA match axis colors
    }
    // draw line for y axis
    if (!is_single) {
        render_line(
            {target(0), target(1) - half_length, target(2)}, 
            {target(0), target(1) + half_length, target(2)},
            ColorRGBA::Y()); // ORCA match axis colors
    } else {
        render_line(
            {target(0), target(1), target(2)}, 
            {target(0), target(1) + half_length, target(2)},
            ColorRGBA::Y()); // ORCA match axis colors
    }
    // draw line for z axis
    if (!is_single) {
        render_line(
            {target(0), target(1), target(2) - half_length}, 
            {target(0), target(1), target(2) + half_length},
            ColorRGBA::Z()); // ORCA match axis colors
    } else {
        render_line(
            {target(0), target(1), target(2)}, 
            {target(0), target(1), target(2) + half_length},
            ColorRGBA::Z()); // ORCA match axis colors
    }
}

References Slic3r::GUI::GLModel::Geometry::add_line(), Slic3r::GUI::GLModel::Geometry::add_vertex(), Slic3r::GUI::GLModel::Geometry::color, Slic3r::GUI::GLModel::Geometry::format, Slic3r::GUI::OpenGLManager::get_gl_info(), glLineWidth, glsafe, Slic3r::GUI::GLModel::init_from(), Slic3r::GUI::GLModel::Geometry::Lines, Slic3r::GUI::GLModel::Geometry::P3, Slic3r::GUI::GLModel::render(), Slic3r::GUI::GLModel::Geometry::reserve_indices(), Slic3r::GUI::GLModel::Geometry::reserve_vertices(), Slic3r::ColorRGBA::X(), Slic3r::ColorRGBA::Y(), and Slic3r::ColorRGBA::Z().

Referenced by Slic3r::GUI::GLGizmoMove3D::on_render().

Here is the call graph for this function:

Here is the caller graph for this function:

render_dimensioning()

void Slic3r::GUI::GLGizmoMeasure::render_dimensioning ( )

protectedinherited

{
    static SelectedFeatures last_selected_features;
 
    if (!m_selected_features.first.feature.has_value())
        return;
 
    if (!m_selected_features.second.feature.has_value() && m_selected_features.first.feature->get_type() != Measure::SurfaceFeatureType::Circle)
        return;
 
    GLShaderProgram* shader = wxGetApp().get_shader("flat");
    if (shader == nullptr)
        return;
 
    auto point_point = [this, &shader](const Vec3d &v1, const Vec3d &v2, float distance, const ColorRGBA &color, bool show_label = true, bool show_first_tri = true) {
        if ((v2 - v1).squaredNorm() < 0.000001 || abs(distance) < 0.001f)
            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<int, 4>& viewport = camera.get_viewport();
 
        // screen coordinates
        const Vec2d v1ss = TransformHelper::world_to_ss(v1, projection_view_matrix, viewport);
        const Vec2d v2ss = TransformHelper::world_to_ss(v2, 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<double>::FromTwoVectors(Vec3d::UnitX(), Vec3d(v12ss.x(), v12ss.y(), 0.0));
        const auto q21ss = Eigen::Quaternion<double>::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 = TransformHelper::ndc_to_ss_matrix_inverse(viewport);
 
#if !SLIC3R_OPENGL_ES
        if (OpenGLManager::get_gl_info().is_core_profile()) {
#endif // !SLIC3R_OPENGL_ES
            shader->stop_using();
 
#if SLIC3R_OPENGL_ES
            shader = wxGetApp().get_shader("dashed_lines");
#else
             shader = wxGetApp().get_shader("dashed_thick_lines");
#endif // SLIC3R_OPENGL_ES
            if (shader == nullptr)
                return;
 
            shader->start_using();
            shader->set_uniform("projection_matrix", Transform3d::Identity());
            shader->set_uniform("viewport_size", Vec2d(double(viewport[2]), double(viewport[3])));
            shader->set_uniform("width", 1.0f);
            shader->set_uniform("gap_size", 0.0f);
#if !SLIC3R_OPENGL_ES
        }
        else
             glsafe(::glLineWidth(2.0f));
#endif // !SLIC3R_OPENGL_ES
 
        // 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.set_color(color);
        m_dimensioning.line.render();
 
#if !SLIC3R_OPENGL_ES
        if (OpenGLManager::get_gl_info().is_core_profile()) {
#endif // !SLIC3R_OPENGL_ES
            shader->stop_using();
 
            shader = wxGetApp().get_shader("flat");
            if (shader == nullptr)
                return;
 
            shader->start_using();
#if !SLIC3R_OPENGL_ES
        }
        else
            glsafe(::glLineWidth(1.0f));
#endif // !SLIC3R_OPENGL_ES
 
        // arrow 1
        if (show_first_tri) {
            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();
 
        const bool use_inches = wxGetApp().app_config->get_bool("use_inches");
        const double curr_value = use_inches ? GizmoObjectManipulation::mm_to_in * distance : distance;
        const std::string curr_value_str = format_double(curr_value);
        const std::string units = use_inches ? _u8L_CONTEXT("in", "inches") : _u8L("mm");
        const float value_str_width = 20.0f + ImGui::CalcTextSize(curr_value_str.c_str()).x;
        static double edit_value = 0.0;
 
        ImGuiWrapper::push_common_window_style(m_parent.get_scale());
        const Vec2d label_position = 0.5 * (v1ss + v2ss);
        m_imgui->set_next_window_pos(label_position.x(), viewport[3] - label_position.y(), ImGuiCond_Always, 0.0f, 1.0f);
        m_imgui->set_next_window_bg_alpha(0.0f);
 
        if (!m_editing_distance && show_label) {
            ImGui::PushStyleVar(ImGuiStyleVar_WindowBorderSize, 0.0f);
            ImGui::PushStyleVar(ImGuiStyleVar_WindowRounding, 0.0f);
            ImGui::PushStyleVar(ImGuiStyleVar_WindowPadding, { 1.0f, 1.0f });
            m_imgui->begin(std::string("distance"), ImGuiWindowFlags_AlwaysAutoResize | ImGuiWindowFlags_NoDecoration);
            ImGui::BringWindowToDisplayFront(ImGui::GetCurrentWindow());
            ImGui::AlignTextToFramePadding();
            ImDrawList* draw_list = ImGui::GetWindowDrawList();
            const ImVec2 pos = ImGui::GetCursorScreenPos();
            const std::string txt = curr_value_str + " " + units;
            ImVec2 txt_size = ImGui::CalcTextSize(txt.c_str());
            const ImGuiStyle& style = ImGui::GetStyle();
            draw_list->AddRectFilled({pos.x - style.FramePadding.x, pos.y + style.FramePadding.y},
                                     {pos.x + txt_size.x + 2.0f * style.FramePadding.x, pos.y + txt_size.y + 2.0f * style.FramePadding.y},
                                     ImGuiWrapper::to_ImU32({1.0f, 1.0f, 1.0f, 0.5f}));
            ImGui::SetCursorScreenPos({ pos.x + style.FramePadding.x, pos.y });
            m_imgui->text(txt);
            if (m_hit_different_volumes.size() < 2 && wxGetApp().plater()->canvas3D()->get_canvas_type() == GLCanvas3D::ECanvasType::CanvasView3D) {
                ImGui::SameLine();
                if (m_imgui->image_button(ImGui::SliderFloatEditBtnIcon, _L("Edit to scale"))) {
                    m_editing_distance = true;
                    edit_value         = curr_value;
                    m_imgui->requires_extra_frame();
                }
            }
            m_imgui->end();
            ImGui::PopStyleVar(3);
        }
 
        if (m_editing_distance && !ImGui::IsPopupOpen("distance_popup"))
            ImGui::OpenPopup("distance_popup");
 
        ImGui::PushStyleVar(ImGuiStyleVar_WindowBorderSize, 0.0f);
        ImGui::PushStyleVar(ImGuiStyleVar_WindowRounding, 0.0f);
        ImGui::PushStyleVar(ImGuiStyleVar_WindowPadding, { 1.0f, 1.0f });
        ImGui::PushStyleVar(ImGuiStyleVar_ItemSpacing, { 4.0f, 0.0f });
        if (show_label && ImGui::BeginPopupModal("distance_popup", nullptr, ImGuiWindowFlags_AlwaysAutoResize | ImGuiWindowFlags_NoDecoration)) {
            auto perform_scale = [this](double new_value, double old_value,bool scale_single_volume) {
                if (new_value == old_value || new_value <= 0.0)
                    return;
 
                const double ratio = new_value / old_value;
                wxGetApp().plater()->take_snapshot(_u8L_CONTEXT("Scale", "Verb"), UndoRedo::SnapshotType::GizmoAction);
                // apply scale
                TransformationType type;
                type.set_world();
                type.set_relative();
                type.set_joint();
 
                // scale selection
                Selection& selection = m_parent.get_selection();
                selection.setup_cache();
                if (scale_single_volume && m_hit_different_volumes.size()==1) {
                    //todo//update_single_mesh_pick(m_hit_different_volumes[0])
                } else {
                    selection.scale(ratio * Vec3d::Ones(), type);
                    wxGetApp().plater()->canvas3D()->do_scale(""); // avoid storing another snapshot
                    register_single_mesh_pick();
                }
                wxGetApp().obj_manipul()->set_dirty();
                // scale dimensioning
                update_feature_by_tran(*m_selected_features.first.feature);
                if (m_selected_features.second.feature.has_value())
                    update_feature_by_tran(*m_selected_features.second.feature);
                // update measure on next call to data_changed()
                m_pending_scale = 1;
 
            };
            auto action_exit = [this]() {
                m_editing_distance = false;
                m_is_editing_distance_first_frame = true;
                ImGui::CloseCurrentPopup();
            };
            auto action_scale = [perform_scale, action_exit](double new_value, double old_value, bool scale_single_volume) {
                perform_scale(new_value, old_value, scale_single_volume);
                action_exit();
            };
 
            m_imgui->disable_background_fadeout_animation();
            ImGui::PushItemWidth(value_str_width);
            if (ImGui::InputDouble("##distance", &edit_value, 0.0f, 0.0f, "%.3f")) {
            }
 
            // trick to auto-select text in the input widgets on 1st frame
            if (m_is_editing_distance_first_frame) {
                ImGui::SetKeyboardFocusHere(0);
                m_is_editing_distance_first_frame = false;
                m_imgui->set_requires_extra_frame();
            }
 
            // handle keys input
            if (ImGui::IsKeyPressedMap(ImGuiKey_Enter) || ImGui::IsKeyPressedMap(ImGuiKey_KeyPadEnter))
                action_scale(edit_value, curr_value, false);
            else if (ImGui::IsKeyPressedMap(ImGuiKey_Escape))
                action_exit();
 
            ImGui::SameLine();
            ImGuiWrapper::push_confirm_button_style();
            //if (m_imgui->button(_L_CONTEXT(L_CONTEXT("Scale part", "Verb"), "Verb")))
                //action_scale(edit_value, curr_value, true);
            //ImGui::SameLine();
            if (m_imgui->button(_L_CONTEXT(L_CONTEXT("Scale all", "Verb"), "Verb")))
                action_scale(edit_value, curr_value, false);
            ImGuiWrapper::pop_confirm_button_style();
            ImGui::SameLine();
            ImGuiWrapper::push_cancel_button_style();
            if (m_imgui->button(_L("Cancel")))
                action_exit();
            ImGuiWrapper::pop_cancel_button_style();
            ImGui::EndPopup();
        }
        ImGui::PopStyleVar(4);
        ImGuiWrapper::pop_common_window_style();
    };
 
    auto point_edge = [this, shader](const Measure::SurfaceFeature& f1, const Measure::SurfaceFeature& f2) {
        assert(f1.get_type() == Measure::SurfaceFeatureType::Point && f2.get_type() == Measure::SurfaceFeatureType::Edge);
        std::pair<Vec3d, Vec3d> e = f2.get_edge();
        const Vec3d v_proj = m_measurement_result.distance_infinite->to;
        const Vec3d e1e2 = e.second - e.first;
        const Vec3d v_proje1 = v_proj - e.first;
        const bool on_e1_side = v_proje1.dot(e1e2) < -EPSILON;
        const bool on_e2_side = !on_e1_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<int, 4>& viewport = camera.get_viewport();
            const Transform3d ss_to_ndc_matrix = TransformHelper::ndc_to_ss_matrix_inverse(viewport);
 
            const Vec2d v_projss = TransformHelper::world_to_ss(v_proj, 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 = TransformHelper::world_to_ss(p, 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<double>::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.set_color(ColorRGBA::LIGHT_GRAY());
                    m_dimensioning.line.render();
                }
            };
 
            render_extension(on_e1_side ? e.first : e.second);
        }
    };
 
    auto arc_edge_edge = [this, &shader](const Measure::SurfaceFeature& f1, const Measure::SurfaceFeature& f2, double radius = 0.0) {
        assert(f1.get_type() == Measure::SurfaceFeatureType::Edge && f2.get_type() == Measure::SurfaceFeatureType::Edge);
        if (!m_measurement_result.angle.has_value())
            return;
 
        const double angle = m_measurement_result.angle->angle;
        const Vec3d  center = m_measurement_result.angle->center;
        const std::pair<Vec3d, Vec3d> e1 = m_measurement_result.angle->e1;
        const std::pair<Vec3d, Vec3d> e2 = m_measurement_result.angle->e2;
        const double calc_radius = m_measurement_result.angle->radius;
        const bool   coplanar = m_measurement_result.angle->coplanar;
 
        if (std::abs(angle) < EPSILON || std::abs(calc_radius) < EPSILON)
            return;
 
        const double draw_radius = (radius > 0.0) ? radius : calc_radius;
 
        const Vec3d e1_unit = Measure::edge_direction(e1);
        const Vec3d e2_unit = Measure::edge_direction(e2);
 
        const unsigned int resolution = std::max<unsigned int>(2, 64 * angle / double(PI));
        const double step = angle / double(resolution);
        const Vec3d normal = e1_unit.cross(e2_unit).normalized();
 
        if (!m_dimensioning.arc.is_initialized()) {
            GLModel::Geometry init_data;
            init_data.format = { GLModel::Geometry::EPrimitiveType::LineStrip, GLModel::Geometry::EVertexLayout::P3 };
            init_data.color  = ColorRGBA::WHITE();
            init_data.reserve_vertices(resolution + 1);
            init_data.reserve_indices(resolution + 1);
 
            // vertices + indices
            for (unsigned int i = 0; i <= resolution; ++i) {
                const double a = step * double(i);
                const Vec3d  v = draw_radius * (Eigen::Quaternion<double>(Eigen::AngleAxisd(a, normal)) * e1_unit);
                init_data.add_vertex((Vec3f) v.cast<float>());
                init_data.add_index(i);
            }
 
            m_dimensioning.arc.init_from(std::move(init_data));
        }
 
        const Camera& camera = wxGetApp().plater()->get_camera();
#if !SLIC3R_OPENGL_ES
        if (OpenGLManager::get_gl_info().is_core_profile()) {
#endif // !SLIC3R_OPENGL_ES
            shader->stop_using();
 
#if SLIC3R_OPENGL_ES
            shader = wxGetApp().get_shader("dashed_lines");
#else
            shader = wxGetApp().get_shader("dashed_thick_lines");
#endif // SLIC3R_OPENGL_ES
            if (shader == nullptr)
                return;
 
            shader->start_using();
            shader->set_uniform("projection_matrix", Transform3d::Identity());
            const std::array<int, 4>& viewport = camera.get_viewport();
            shader->set_uniform("viewport_size", Vec2d(double(viewport[2]), double(viewport[3])));
            shader->set_uniform("width", 1.0f);
            shader->set_uniform("gap_size", 0.0f);
#if !SLIC3R_OPENGL_ES
        }
        else
            glsafe(::glLineWidth(2.0f));
#endif // !SLIC3R_OPENGL_ES
 
        // arc
        shader->set_uniform("projection_matrix", camera.get_projection_matrix());
        shader->set_uniform("view_model_matrix", camera.get_view_matrix() * Geometry::translation_transform(center));
        m_dimensioning.arc.render();
 
#if !SLIC3R_OPENGL_ES
        if (OpenGLManager::get_gl_info().is_core_profile()) {
#endif // !SLIC3R_OPENGL_ES
            shader->stop_using();
 
            shader = wxGetApp().get_shader("flat");
            if (shader == nullptr)
                return;
 
            shader->start_using();
#if !SLIC3R_OPENGL_ES
        }
        else
            glsafe(::glLineWidth(1.0f));
#endif // !SLIC3R_OPENGL_ES
 
        // arrows
        auto render_arrow = [this, shader, &camera, &normal, &center, &e1_unit, draw_radius, step, resolution](unsigned int endpoint_id) {
            const double angle = (endpoint_id == 1) ? 0.0 : step * double(resolution);
            const Vec3d position_model = Geometry::translation_transform(center) * (draw_radius * (Eigen::Quaternion<double>(Eigen::AngleAxisd(angle, normal)) * e1_unit));
            const Vec3d direction_model = (endpoint_id == 1) ? -normal.cross(position_model - center).normalized() : normal.cross(position_model - center).normalized();
            const auto qz = Eigen::Quaternion<double>::FromTwoVectors(Vec3d::UnitZ(), (endpoint_id == 1) ? normal : -normal);
            const auto qx = Eigen::Quaternion<double>::FromTwoVectors(qz * Vec3d::UnitX(), direction_model);
            const Transform3d view_model_matrix = camera.get_view_matrix() * Geometry::translation_transform(position_model) *
                qx * qz * Geometry::scale_transform(camera.get_inv_zoom());
            shader->set_uniform("view_model_matrix", view_model_matrix);
            m_dimensioning.triangle.render();
        };
 
        glsafe(::glDisable(GL_CULL_FACE));
        render_arrow(1);
        render_arrow(2);
        glsafe(::glEnable(GL_CULL_FACE));
 
        // edge 1 extension
        const Vec3d e11e12 = e1.second - e1.first;
        const Vec3d e11center = center - e1.first;
        const double e11center_len = e11center.norm();
 
        if (e11center_len > EPSILON && e11center.dot(e11e12) < 0.0) {
            shader->set_uniform("view_model_matrix", camera.get_view_matrix() * Geometry::translation_transform(center) *
                Eigen::Quaternion<double>::FromTwoVectors(Vec3d::UnitX(), Measure::edge_direction(e1.first, e1.second)) *
                Geometry::scale_transform({ e11center_len, 1.0f, 1.0f }));
            m_dimensioning.line.set_color(ColorRGBA::LIGHT_GRAY());
            m_dimensioning.line.render();
        }
 
        // edge 2 extension
        const Vec3d e21center = center - e2.first;
        const double e21center_len = e21center.norm();
        if (e21center_len > EPSILON) {
            shader->set_uniform("view_model_matrix", camera.get_view_matrix() * Geometry::translation_transform(center) *
                Eigen::Quaternion<double>::FromTwoVectors(Vec3d::UnitX(), Measure::edge_direction(e2.first, e2.second)) *
                Geometry::scale_transform({ (coplanar && radius > 0.0) ? e21center_len : draw_radius, 1.0f, 1.0f }));
            m_dimensioning.line.set_color(ColorRGBA::LIGHT_GRAY());
            m_dimensioning.line.render();
        }
 
        // label
        // label world coordinates
        const Vec3d label_position_world = Geometry::translation_transform(center) * (draw_radius * (Eigen::Quaternion<double>(Eigen::AngleAxisd(step * 0.5 * double(resolution), normal)) * e1_unit));
 
        // label screen coordinates
        const std::array<int, 4>& viewport = camera.get_viewport();
        const Vec2d label_position_ss = TransformHelper::world_to_ss(label_position_world,
            camera.get_projection_matrix().matrix() * camera.get_view_matrix().matrix(), viewport);
 
        ImGuiWrapper::push_common_window_style(m_parent.get_scale());
        m_imgui->set_next_window_pos(label_position_ss.x(), viewport[3] - label_position_ss.y(), ImGuiCond_Always, 0.0f, 1.0f);
        m_imgui->set_next_window_bg_alpha(0.0f);
        ImGui::PushStyleVar(ImGuiStyleVar_WindowBorderSize, 0.0f);
        m_imgui->begin(wxString("##angle"), ImGuiWindowFlags_NoMouseInputs | ImGuiWindowFlags_AlwaysAutoResize | ImGuiWindowFlags_NoDecoration | ImGuiWindowFlags_NoMove);
        ImGui::BringWindowToDisplayFront(ImGui::GetCurrentWindow());
        ImGui::AlignTextToFramePadding();
        ImDrawList* draw_list = ImGui::GetWindowDrawList();
        const ImVec2 pos = ImGui::GetCursorScreenPos();
        const std::string txt = format_double(Geometry::rad2deg(angle)) + "°";
        ImVec2 txt_size = ImGui::CalcTextSize(txt.c_str());
        const ImGuiStyle& style = ImGui::GetStyle();
        ColorRGBA         color{1.0f, 1.0f, 1.0f, 0.5f};
        draw_list->AddRectFilled({ pos.x - style.FramePadding.x, pos.y + style.FramePadding.y }, { pos.x + txt_size.x + 2.0f * style.FramePadding.x,
            pos.y + txt_size.y + 2.0f * style.FramePadding.y}, ImGuiWrapper::to_ImU32(color));
        ImGui::SetCursorScreenPos({ pos.x + style.FramePadding.x, pos.y });
        m_imgui->text(txt);
        m_imgui->end();
        ImGui::PopStyleVar();
        ImGuiWrapper::pop_common_window_style();
    };
 
    auto arc_edge_plane = [this, arc_edge_edge](const Measure::SurfaceFeature& f1, const Measure::SurfaceFeature& f2) {
        assert(f1.get_type() == Measure::SurfaceFeatureType::Edge && f2.get_type() == Measure::SurfaceFeatureType::Plane);
        if (!m_measurement_result.angle.has_value())
            return;
 
        const std::pair<Vec3d, Vec3d> e1 = m_measurement_result.angle->e1;
        const std::pair<Vec3d, Vec3d> e2 = m_measurement_result.angle->e2;
        const double calc_radius = m_measurement_result.angle->radius;
 
        if (calc_radius == 0.0)
            return;
 
        arc_edge_edge(Measure::SurfaceFeature(Measure::SurfaceFeatureType::Edge, e1.first, e1.second),
            Measure::SurfaceFeature(Measure::SurfaceFeatureType::Edge, e2.first, e2.second), calc_radius);
    };
 
    auto arc_plane_plane = [this, arc_edge_edge](const Measure::SurfaceFeature& f1, const Measure::SurfaceFeature& f2) {
        assert(f1.get_type() == Measure::SurfaceFeatureType::Plane && f2.get_type() == Measure::SurfaceFeatureType::Plane);
        if (!m_measurement_result.angle.has_value())
            return;
 
        const std::pair<Vec3d, Vec3d> e1 = m_measurement_result.angle->e1;
        const std::pair<Vec3d, Vec3d> e2 = m_measurement_result.angle->e2;
        const double calc_radius = m_measurement_result.angle->radius;
 
        if (calc_radius == 0.0)
            return;
 
        arc_edge_edge(Measure::SurfaceFeature(Measure::SurfaceFeatureType::Edge, e1.first, e1.second),
            Measure::SurfaceFeature(Measure::SurfaceFeatureType::Edge, e2.first, e2.second), calc_radius);
    };
 
    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));
    }
 
    if (last_selected_features != m_selected_features)
        m_dimensioning.arc.reset();
 
    glsafe(::glDisable(GL_DEPTH_TEST));
 
    const bool has_distance = m_measurement_result.has_distance_data();
 
    const Measure::SurfaceFeature* f1 = &(*m_selected_features.first.feature);
    const Measure::SurfaceFeature* f2 = nullptr;
    std::unique_ptr<Measure::SurfaceFeature> temp_feature;
    if (m_selected_features.second.feature.has_value())
        f2 = &(*m_selected_features.second.feature);
    else {
        assert(m_selected_features.first.feature->get_type() == Measure::SurfaceFeatureType::Circle);
        temp_feature = std::make_unique<Measure::SurfaceFeature>(std::get<0>(m_selected_features.first.feature->get_circle()));
        f2 = temp_feature.get();
    }
 
    if (!m_selected_features.second.feature.has_value() && m_selected_features.first.feature->get_type() != Measure::SurfaceFeatureType::Circle)
        return;
 
    Measure::SurfaceFeatureType ft1 = f1->get_type();
    Measure::SurfaceFeatureType ft2 = f2->get_type();
 
    // Order features by type so following conditions are simple.
    if (ft1 > ft2) {
        std::swap(ft1, ft2);
        std::swap(f1, f2);
    }
 
    // If there is an angle to show, draw the arc:
    if (ft1 == Measure::SurfaceFeatureType::Edge && ft2 == Measure::SurfaceFeatureType::Edge)
        arc_edge_edge(*f1, *f2);
    else if (ft1 == Measure::SurfaceFeatureType::Edge && ft2 == Measure::SurfaceFeatureType::Plane)
        arc_edge_plane(*f1, *f2);
    else if (ft1 == Measure::SurfaceFeatureType::Plane && ft2 == Measure::SurfaceFeatureType::Plane)
        arc_plane_plane(*f1, *f2);
 
    if (has_distance){
        // Where needed, draw the extension of the edge to where the dist is measured:
        if (ft1 == Measure::SurfaceFeatureType::Point && ft2 == Measure::SurfaceFeatureType::Edge)
            point_edge(*f1, *f2);
 
        // Render the arrow between the points that the backend passed:
        const Measure::DistAndPoints& dap = m_measurement_result.distance_infinite.has_value()
            ? *m_measurement_result.distance_infinite
            : *m_measurement_result.distance_strict;
        if (m_selected_features.second.feature.has_value() &&
            !(m_measure_mode == EMeasureMode::ONLY_ASSEMBLY && m_assembly_mode == AssemblyMode::FACE_FACE)) {
            auto x_to = dap.from;
            x_to[0]   = dap.to[0];
            point_point(dap.from, x_to, x_to[0] - dap.from[0], ColorRGBA::RED(), false, false);
            auto y_to = x_to;
            y_to[1]   = dap.to[1];
            point_point(x_to, y_to, y_to[1] - x_to[1], ColorRGBA::GREEN(), false, false);
            point_point(y_to, dap.to, dap.to[2] - y_to[2], ColorRGBA::BLUE(), false, false);
        }
 
        point_point(dap.from, dap.to, dap.dist, ColorRGBA::WHITE());
    }
 
    glsafe(::glEnable(GL_DEPTH_TEST));
 
    shader->stop_using();
}

References _L, _L_CONTEXT, _u8L, _u8L_CONTEXT, Slic3r::GUI::GLModel::Geometry::add_index(), Slic3r::GUI::GLModel::Geometry::add_line(), Slic3r::GUI::GLModel::Geometry::add_triangle(), Slic3r::GUI::GLModel::Geometry::add_vertex(), Slic3r::angle(), Slic3r::ColorRGBA::BLUE(), Slic3r::GUI::GLCanvas3D::CanvasView3D, Slic3r::center(), Slic3r::Measure::Circle, Slic3r::GUI::GLModel::Geometry::color, Slic3r::Measure::DistAndPoints::dist, Slic3r::Measure::Edge, Slic3r::Measure::edge_direction(), EPSILON, Slic3r::GUI::FACE_FACE, Slic3r::GUI::GLModel::Geometry::format, format_double(), Slic3r::Measure::DistAndPoints::from, Slic3r::GUI::OpenGLManager::get_gl_info(), Slic3r::GUI::Camera::get_inv_zoom(), Slic3r::GUI::Camera::get_projection_matrix(), Slic3r::Measure::SurfaceFeature::get_type(), Slic3r::GUI::Camera::get_view_matrix(), Slic3r::GUI::Camera::get_viewport(), Slic3r::UndoRedo::GizmoAction, GL_CULL_FACE, GL_DEPTH_TEST, glDisable, glEnable, glLineWidth, glsafe, Slic3r::ColorRGBA::GREEN(), L_CONTEXT, Slic3r::ColorRGBA::LIGHT_GRAY(), Slic3r::GUI::GLModel::Geometry::Lines, Slic3r::GUI::GLModel::Geometry::LineStrip, m_assembly_mode, m_dimensioning, m_editing_distance, m_hit_different_volumes, Slic3r::GUI::GLGizmoBase::m_imgui, m_is_editing_distance_first_frame, m_measure_mode, m_measurement_result, Slic3r::GUI::GLGizmoBase::m_parent, m_pending_scale, m_selected_features, Slic3r::GUI::GizmoObjectManipulation::mm_to_in, Slic3r::GUI::TransformHelper::ndc_to_ss_matrix_inverse(), Slic3r::normal(), Slic3r::GUI::ONLY_ASSEMBLY, Slic3r::GUI::GLModel::Geometry::P3, PI, Slic3r::Measure::Plane, Slic3r::GUI::plater(), Slic3r::Measure::Point, Slic3r::GUI::ImGuiWrapper::pop_cancel_button_style(), Slic3r::GUI::ImGuiWrapper::pop_common_window_style(), Slic3r::GUI::ImGuiWrapper::pop_confirm_button_style(), Slic3r::GUI::ImGuiWrapper::push_cancel_button_style(), Slic3r::GUI::ImGuiWrapper::push_common_window_style(), Slic3r::GUI::ImGuiWrapper::push_confirm_button_style(), Slic3r::Geometry::rad2deg(), Slic3r::ColorRGBA::RED(), register_single_mesh_pick(), Slic3r::GUI::GLModel::Geometry::reserve_indices(), Slic3r::GUI::GLModel::Geometry::reserve_vertices(), Slic3r::resolution(), Slic3r::GUI::Selection::scale(), Slic3r::Geometry::scale_transform(), Slic3r::GUI::TransformationType::set_joint(), Slic3r::GUI::TransformationType::set_relative(), Slic3r::GLShaderProgram::set_uniform(), Slic3r::GUI::TransformationType::set_world(), Slic3r::GUI::Selection::setup_cache(), Slic3r::GLShaderProgram::start_using(), Slic3r::GLShaderProgram::stop_using(), style, Slic3r::Measure::DistAndPoints::to, Slic3r::GUI::ImGuiWrapper::to_ImU32(), Slic3r::Geometry::translation_transform(), Slic3r::GUI::TRIANGLE_BASE, Slic3r::GUI::TRIANGLE_HEIGHT, Slic3r::GUI::GLModel::Geometry::Triangles, update_feature_by_tran(), Slic3r::ColorRGBA::WHITE(), and Slic3r::GUI::TransformHelper::world_to_ss().

Referenced by on_render(), and render_dimensioning_if_scene_reused().

Here is the call graph for this function:

Here is the caller graph for this function:

render_dimensioning_if_scene_reused()

void Slic3r::GUI::GLGizmoMeasure::render_dimensioning_if_scene_reused ( )

protectedinherited

{
    // The labels are ImGui and live one frame; the lines drawn with them land under the cached
    // scene, which is drawn after the overlay is built.
    if (!m_rendered_this_frame)
        render_dimensioning();
    m_rendered_this_frame = false;
}

References m_rendered_this_frame, and render_dimensioning().

Referenced by Slic3r::GUI::GLGizmoAssembly::on_render_input_window(), and on_render_input_window().

Here is the call graph for this function:

Here is the caller graph for this function:

render_follows_cursor()

bool Slic3r::GUI::GLGizmoMeasure::render_follows_cursor ( ) const

overrideprotectedvirtualinherited

Reimplemented from Slic3r::GUI::GLGizmoBase.

{
    // The two raycasts on_render() starts with, without their side effects.
    if (m_editing_distance)
        return false;
 
    const Vec2d mouse_position = m_parent.get_local_mouse_position();
    const Camera& camera = wxGetApp().plater()->get_camera();
    Vec3f hit = Vec3f::Zero();
    Vec3f normal = Vec3f::Zero();
    for (const auto& item : m_gripper_id_raycast_map) {
        if (item.second->get_id() > 0 && item.second->get_raycaster()->closest_hit(mouse_position, item.second->get_transform(), camera, hit, normal))
            return true;
    }
    for (const auto& item : m_mesh_raycaster_map) {
        if (item.second->get_raycaster()->unproject_on_mesh(mouse_position, item.second->get_transform(), camera, hit, normal))
            return true;
    }
    return false;
}

References m_editing_distance, m_gripper_id_raycast_map, m_mesh_raycaster_map, Slic3r::GUI::GLGizmoBase::m_parent, and Slic3r::normal().

Here is the call graph for this function:

render_grabbers() [1/3]

void Slic3r::GUI::GLGizmoBase::render_grabbers ( const BoundingBoxf3 & box ) const

protectedinherited

{
#if ENABLE_FIXED_GRABBER
    render_grabbers((float)(GLGizmoBase::Grabber::FixedGrabberSize));
#else
    render_grabbers((float)((box.size().x() + box.size().y() + box.size().z()) / 3.0));
#endif
}

References Slic3r::GUI::GLGizmoBase::Grabber::FixedGrabberSize, render_grabbers(), and Slic3r::BoundingBox3Base< PointType >::size().

Referenced by Slic3r::GUI::GLGizmoMove3D::on_render(), Slic3r::GUI::GLGizmoScale3D::on_render(), Slic3r::GUI::GLGizmoRotate::render_grabber(), render_grabbers(), and render_grabbers().

Here is the call graph for this function:

Here is the caller graph for this function:

render_grabbers() [2/3]

void Slic3r::GUI::GLGizmoBase::render_grabbers ( float size ) const

protectedinherited

{
    render_grabbers(0, m_grabbers.size() - 1, size, false);
}

References m_grabbers, and render_grabbers().

Here is the call graph for this function:

render_grabbers() [3/3]

void Slic3r::GUI::GLGizmoBase::render_grabbers ( size_t first, size_t last, float size, bool force_hover ) const

protectedinherited

{
    GLShaderProgram* shader = wxGetApp().get_shader("gouraud_light");
    if (shader == nullptr)
        return;
    shader->start_using();
    shader->set_uniform("emission_factor", 0.1f);
    glsafe(::glDisable(GL_CULL_FACE));
    for (size_t i = first; i <= last; ++i) {
        if (m_grabbers[i].enabled)
            m_grabbers[i].render(force_hover ? true : m_hover_id == (int)i, size);
    }
    glsafe(::glEnable(GL_CULL_FACE));
    shader->stop_using();
}

References GL_CULL_FACE, glDisable, glEnable, glsafe, m_grabbers, m_hover_id, Slic3r::GLShaderProgram::set_uniform(), Slic3r::GLShaderProgram::start_using(), and Slic3r::GLShaderProgram::stop_using().

Here is the call graph for this function:

render_input_window()

void Slic3r::GUI::GLGizmoBase::render_input_window ( float x, float y, float bottom_limit )

inherited

{
    on_render_input_window(x, y, bottom_limit);
    if (m_first_input_window_render) {
        // imgui windows that don't have an initial size needs to be processed once to get one
        // and are not rendered in the first frame
        // so, we forces to render another frame the first time the imgui window is shown
        // https://github.com/ocornut/imgui/issues/2949
        m_parent.set_as_dirty();
        m_parent.request_extra_frame();
        m_first_input_window_render = false;
    }
}

References m_first_input_window_render, m_parent, and on_render_input_window().

Here is the call graph for this function:

render_input_window_warning()

void Slic3r::GUI::GLGizmoAssembly::render_input_window_warning ( bool same_model_object )

overrideprotectedvirtual

Reimplemented from Slic3r::GUI::GLGizmoMeasure.

{
    const bool same_mesh_warning        = m_hit_different_volumes.size() == 1;
    const bool wrong_feature_warning    = m_selected_wrong_feature_waring_tip;
    const bool not_assembled_warning    = m_hit_different_volumes.size() == 2 && same_model_object == false &&
                                        wxGetApp().plater()->canvas3D()->get_canvas_type() == GLCanvas3D::ECanvasType::CanvasView3D;
 
    if (same_mesh_warning || not_assembled_warning || wrong_feature_warning) {
        ImGui::Separator();
    }
 
    if (same_mesh_warning) {
        m_imgui->warning_text(_L("Warning: please select two different meshes."));
    }
    if (wrong_feature_warning) {
        if (m_assembly_mode == AssemblyMode::FACE_FACE) {
            m_imgui->warning_text(_L("Warning: please select Plane's feature."));
        } else if (m_assembly_mode == AssemblyMode::POINT_POINT) {
            m_imgui->warning_text(_L("Warning: please select Point's or Circle's feature."));
        }
    }
    if (not_assembled_warning) {
        m_imgui->warning_text(
            _L("Warning") + ": " +
            _L("It is recommended to assemble objects first,\nbecause they are restricted to the bed \nand only parts can be lifted.")
        );
    }
}

References _L, Slic3r::GUI::GLCanvas3D::CanvasView3D, Slic3r::GUI::FACE_FACE, Slic3r::GUI::GLGizmoMeasure::m_assembly_mode, Slic3r::GUI::GLGizmoMeasure::m_hit_different_volumes, Slic3r::GUI::GLGizmoBase::m_imgui, Slic3r::GUI::GLGizmoMeasure::m_selected_wrong_feature_waring_tip, and Slic3r::GUI::POINT_POINT.

Referenced by on_render_input_window().

Here is the caller graph for this function:

reset_all_feature()

void Slic3r::GUI::GLGizmoMeasure::reset_all_feature ( )

protectedinherited

                                        {
     reset_feature2();
     reset_feature1();
     m_show_reset_first_tip = false;
     m_hit_different_volumes.clear();
     m_hit_order_volumes.clear();
     m_last_hit_volume = nullptr;
 }

References m_hit_different_volumes, m_hit_order_volumes, m_last_hit_volume, m_show_reset_first_tip, reset_feature1(), and reset_feature2().

Referenced by data_changed(), gizmo_event(), and Slic3r::GUI::GLGizmoAssembly::switch_to_mode().

Here is the call graph for this function:

Here is the caller graph for this function:

reset_all_pick()

void Slic3r::GUI::GLGizmoMeasure::reset_all_pick ( )

protectedinherited

{
   std::map<GLVolume*, std::shared_ptr<PickRaycaster>>().swap(m_mesh_raycaster_map);
   reset_gripper_pick(GripperType::UNDEFINE,true);
}

References m_mesh_raycaster_map, reset_gripper_pick(), and UNDEFINE.

Referenced by data_changed().

Here is the call graph for this function:

Here is the caller graph for this function:

reset_feature1()

void Slic3r::GUI::GLGizmoMeasure::reset_feature1 ( )

protectedinherited

{
     m_selected_wrong_feature_waring_tip = false;
     reset_feature1_render();
     if (m_selected_features.second.feature.has_value()) {
         if (m_hit_different_volumes.size() == 2) {
             m_hit_different_volumes[0] = m_hit_different_volumes[1];
         }
         if (m_hit_order_volumes.size() == 2) {
             m_hit_order_volumes[0] = m_hit_order_volumes[1];
         }
         m_selected_features.first = m_selected_features.second;
         reset_feature2();
         m_show_reset_first_tip = true;
     } else {
         remove_selected_sphere_raycaster(SEL_SPHERE_1_ID);
         m_selected_features.first.feature.reset();
         m_show_reset_first_tip = false;
         if (m_hit_different_volumes.size() == 1) {
             m_hit_different_volumes.clear();
         }
         if (m_hit_order_volumes.size() == 1) {
             m_hit_order_volumes.clear();
         }
         reset_gripper_pick(GripperType::PLANE_1);
         reset_gripper_pick(GripperType::CIRCLE_1);
         reset_gripper_pick(GripperType::SPHERE_1);
     }
     update_measurement_result();
 }

References CIRCLE_1, m_hit_different_volumes, m_hit_order_volumes, m_selected_features, m_selected_wrong_feature_waring_tip, m_show_reset_first_tip, PLANE_1, remove_selected_sphere_raycaster(), reset_feature1_render(), reset_feature2(), reset_gripper_pick(), Slic3r::GUI::SEL_SPHERE_1_ID, SPHERE_1, and update_measurement_result().

Referenced by gizmo_event(), on_mouse(), reset_all_feature(), and show_selection_ui().

Here is the call graph for this function:

Here is the caller graph for this function:

reset_feature1_render()

void Slic3r::GUI::GLGizmoMeasure::reset_feature1_render ( )

protectedinherited

{
    if (m_feature_plane_first.plane.model.is_initialized()) {
        m_feature_plane_first.plane.model.reset();
        m_feature_plane_first.plane_idx = -1;
    }
    if (m_feature_circle_first.circle.model.is_initialized()) {
        m_feature_circle_first.circle.model.reset();
        m_feature_circle_first.last_circle_feature = nullptr;
        m_feature_circle_first.inv_zoom            = 0;
    }
}

References m_feature_circle_first, and m_feature_plane_first.

Referenced by on_mouse(), and reset_feature1().

Here is the caller graph for this function:

reset_feature2()

void Slic3r::GUI::GLGizmoMeasure::reset_feature2 ( )

protectedinherited

{
     reset_feature2_render();
     if (m_hit_different_volumes.size() == 2) {
         m_hit_different_volumes.erase(m_hit_different_volumes.begin() + 1);
     }
     if (m_hit_order_volumes.size() == 2) {
         m_hit_order_volumes.erase(m_hit_order_volumes.begin() + 1);
     }
     remove_selected_sphere_raycaster(SEL_SPHERE_2_ID);
     m_selected_features.second.reset();
     m_show_reset_first_tip = false;
     m_selected_wrong_feature_waring_tip = false;
     reset_gripper_pick(GripperType::PLANE_2);
     reset_gripper_pick(GripperType::CIRCLE_2);
     reset_gripper_pick(GripperType::SPHERE_2);
 
     update_measurement_result();
}

References CIRCLE_2, m_hit_different_volumes, m_hit_order_volumes, m_selected_features, m_selected_wrong_feature_waring_tip, m_show_reset_first_tip, PLANE_2, remove_selected_sphere_raycaster(), reset_feature2_render(), reset_gripper_pick(), Slic3r::GUI::SEL_SPHERE_2_ID, SPHERE_2, and update_measurement_result().

Referenced by gizmo_event(), on_mouse(), reset_all_feature(), reset_feature1(), and show_selection_ui().

Here is the call graph for this function:

Here is the caller graph for this function:

reset_feature2_render()

void Slic3r::GUI::GLGizmoMeasure::reset_feature2_render ( )

protectedinherited

{
    if (m_feature_plane_second.plane.model.is_initialized()) {
        m_feature_plane_second.plane.model.reset();
        m_feature_plane_second.plane_idx = -1;
    }
    if (m_feature_circle_second.circle.model.is_initialized()) {
        m_feature_circle_second.circle.model.reset();
        m_feature_circle_second.last_circle_feature = nullptr;
        m_feature_circle_second.inv_zoom            = 0;
    }
}

References m_feature_circle_second, and m_feature_plane_second.

Referenced by on_mouse(), and reset_feature2().

Here is the caller graph for this function:

reset_gripper_pick()

void Slic3r::GUI::GLGizmoMeasure::reset_gripper_pick ( GripperType id, bool is_all = false )

protectedinherited

{
    if (m_gripper_id_raycast_map.find(id) != m_gripper_id_raycast_map.end()) {
        m_gripper_id_raycast_map[id].reset();
        m_gripper_id_raycast_map.erase(id);
    }
    if (id == GripperType ::UNDEFINE && is_all) {
        reset_gripper_pick(GripperType::POINT);
        reset_gripper_pick(GripperType::EDGE);
        reset_gripper_pick(GripperType::PLANE);
        reset_gripper_pick(GripperType::PLANE_1);
        reset_gripper_pick(GripperType::PLANE_2);
        reset_gripper_pick(GripperType::CIRCLE);
        reset_gripper_pick(GripperType::CIRCLE_1);
        reset_gripper_pick(GripperType::CIRCLE_2);
    }
}

References CIRCLE, CIRCLE_1, CIRCLE_2, EDGE, m_gripper_id_raycast_map, PLANE, PLANE_1, PLANE_2, POINT, and reset_gripper_pick().

Referenced by init_circle_glmodel(), init_plane_glmodel(), on_render(), remove_selected_sphere_raycaster(), reset_all_pick(), reset_feature1(), reset_feature2(), and reset_gripper_pick().

Here is the call graph for this function:

Here is the caller graph for this function:

restore_scene_raycasters_state()

void Slic3r::GUI::GLGizmoMeasure::restore_scene_raycasters_state ( )

protectedinherited

{
    for(auto iter:m_gripper_id_raycast_map)
    {
        iter.second->set_active(true);
    }
}

References m_gripper_id_raycast_map.

Referenced by gizmo_event(), and on_set_state().

Here is the caller graph for this function:

save()

void Slic3r::GUI::GLGizmoBase::save ( cereal::BinaryOutputArchive & ar ) const

inlineinherited

{ on_save(ar); }

References on_save().

Here is the call graph for this function:

set_common_data_pool()

void Slic3r::GUI::GLGizmoBase::set_common_data_pool ( CommonGizmosDataPool * ptr )

inlineinherited

{ m_c = ptr; }

References m_c.

set_dirty()

void Slic3r::GUI::GLGizmoBase::set_dirty ( )

protectedinherited

                            {
    m_dirty = true;
}

References m_dirty.

Referenced by Slic3r::GUI::GLGizmoCut3D::process_cut_line(), and Slic3r::GUI::GLGizmoSimplify::request_rerender().

Here is the caller graph for this function:

set_distance()

void Slic3r::GUI::GLGizmoMeasure::set_distance ( bool same_model_object, const Vec3d & displacement, bool take_shot = true )

protectedinherited

{
    if (m_hit_different_volumes.size() == 2 && displacement.norm() > 0.0f) {
        auto v         = m_hit_different_volumes[1];
        auto selection = const_cast<Selection *>(&m_parent.get_selection());
        selection->setup_cache();
        if (take_shot) {
            wxGetApp().plater()->take_snapshot("MoveInMeasure", UndoRedo::SnapshotType::GizmoAction); // avoid storing another snapshot
        }
        selection->set_mode(same_model_object ? Selection::Volume : Selection::Instance);
        m_pending_scale ++;
        if (same_model_object == false) {
            Vec3d object_displacement = v->get_instance_transformation().get_matrix_no_offset().inverse() * displacement;
            v->set_instance_transformation(v->get_instance_transformation().get_matrix() * Geometry::translation_transform(object_displacement));
        } else {
            Geometry::Transformation tran(v->world_matrix());
            Vec3d                     local_displacement = tran.get_matrix_no_offset().inverse() * displacement;
            v->set_volume_transformation(v->get_volume_transformation().get_matrix() * Geometry::translation_transform(local_displacement));
        }
        wxGetApp().plater()->canvas3D()->do_move("");
        register_single_mesh_pick();
        if (same_model_object ) {
            update_feature_by_tran(*m_selected_features.first.feature);
        }
        update_feature_by_tran(*m_selected_features.second.feature);
    }
}

References Slic3r::Geometry::Transformation::get_matrix_no_offset(), Slic3r::UndoRedo::GizmoAction, Slic3r::GUI::Selection::Instance, m_hit_different_volumes, Slic3r::GUI::GLGizmoBase::m_parent, m_pending_scale, m_selected_features, register_single_mesh_pick(), Slic3r::GUI::Selection::setup_cache(), Slic3r::Geometry::translation_transform(), update_feature_by_tran(), and Slic3r::GUI::Selection::Volume.

Referenced by set_to_center_coincidence(), and show_distance_xyz_ui().

Here is the call graph for this function:

Here is the caller graph for this function:

set_hover_id()

void Slic3r::GUI::GLGizmoBase::set_hover_id ( int id )

inherited

{
    // do not change hover id during dragging
    assert(!m_dragging);
 
    // allow empty grabbers when not using grabbers but use hover_id - flatten, rotate
//    if (!m_grabbers.empty() && id >= (int) m_grabbers.size())
//        return;
    
    m_hover_id = id;
    on_set_hover_id();    
}

References m_dragging, m_hover_id, and on_set_hover_id().

Referenced by Slic3r::GUI::GLGizmoRotate3D::on_set_hover_id().

Here is the call graph for this function:

Here is the caller graph for this function:

set_icon_filename()

void Slic3r::GUI::GLGizmoBase::set_icon_filename ( const std::string & filename )

inherited

                                                             {
    m_icon_filename = filename;
}

References m_icon_filename.

set_parallel_distance()

void Slic3r::GUI::GLGizmoMeasure::set_parallel_distance ( bool same_model_object, float dist )

protectedinherited

{
    if (m_hit_different_volumes.size() == 2 && abs(dist) >= 0.0f) {
        auto v         = m_hit_different_volumes[1];
        auto selection = const_cast<Selection *>(&m_parent.get_selection());
        selection->setup_cache();
 
        wxGetApp().plater()->take_snapshot("SetParallelDistanceInMeasure", UndoRedo::SnapshotType::GizmoAction); // avoid storing another snapshot
 
        selection->set_mode(same_model_object ? Selection::Volume : Selection::Instance);
        m_pending_scale = 1;
 
        const auto [idx1, normal1, pt1] = m_selected_features.first.feature->get_plane();
        const auto [idx2, normal2, pt2] = m_selected_features.second.feature->get_plane();
        Vec3d proj_pt2;
        Measure::get_point_projection_to_plane(pt2, pt1, normal1, proj_pt2);
        Vec3d new_pt2 = proj_pt2 + normal1 * dist;
 
        Vec3d displacement = new_pt2 - pt2;
 
        if (same_model_object == false) {
            selection->translate(v->object_idx(), v->instance_idx(), displacement);
        } else {
            selection->translate(v->object_idx(), v->instance_idx(), v->volume_idx(), displacement);
        }
        wxGetApp().plater()->canvas3D()->do_move("");
        register_single_mesh_pick();
        if (same_model_object) {
            update_feature_by_tran(*m_selected_features.first.feature);
        }
        update_feature_by_tran(*m_selected_features.second.feature);
    }
}

References Slic3r::Geometry::dist(), Slic3r::Measure::get_point_projection_to_plane(), Slic3r::UndoRedo::GizmoAction, Slic3r::GUI::Selection::Instance, m_hit_different_volumes, Slic3r::GUI::GLGizmoBase::m_parent, m_pending_scale, m_selected_features, register_single_mesh_pick(), Slic3r::GUI::Selection::setup_cache(), update_feature_by_tran(), and Slic3r::GUI::Selection::Volume.

Referenced by show_face_face_assembly_senior().

Here is the call graph for this function:

Here is the caller graph for this function:

set_state()

void Slic3r::GUI::GLGizmoBase::set_state ( EState state )

inlineinherited

{ m_state = state; on_set_state(); }

References m_state, and on_set_state().

Referenced by Slic3r::GUI::GLGizmosManager::activate_gizmo().

Here is the call graph for this function:

Here is the caller graph for this function:

set_to_around_center_of_faces()

void Slic3r::GUI::GLGizmoMeasure::set_to_around_center_of_faces ( bool same_model_object, float rotate_degree )

protectedinherited

{
    if (m_hit_different_volumes.size() == 2 ) {
        auto &action    = m_assembly_action;
        auto  v         = m_hit_different_volumes[1];
        auto  selection = const_cast<Selection *>(&m_parent.get_selection());
        selection->setup_cache();
        wxGetApp().plater()->take_snapshot("ReverseRotateInMeasure", UndoRedo::SnapshotType::GizmoAction); // avoid storing another snapshot
 
        selection->set_mode(same_model_object ? Selection::Volume : Selection::Instance);
        m_pending_scale = 1;
 
        auto  radian = Geometry::deg2rad(rotate_degree);
        Vec3d plane_normal, plane_center;
        const auto [idx2, normal2, pt2] = m_selected_features.second.feature->get_plane();
        plane_normal                    = normal2;
        plane_center                    = pt2;
 
        if (same_model_object == false) {
            Geometry::Transformation inMat(v->get_instance_transformation());
            Geometry::Transformation outMat = Geometry::mat_around_a_point_rotate(inMat, plane_center, plane_normal, radian);
            selection->rotate(v->object_idx(), v->instance_idx(), outMat.get_matrix());
        } else {
            Geometry::Transformation inMat(v->world_matrix());
            Geometry::Transformation outMat      = Geometry::mat_around_a_point_rotate(inMat, plane_center, plane_normal, radian);
            Transform3d              volume_tran = v->get_instance_transformation().get_matrix().inverse() * outMat.get_matrix();
            selection->rotate(v->object_idx(), v->instance_idx(), v->volume_idx(), volume_tran);
        }
        wxGetApp().plater()->canvas3D()->do_rotate("");
        register_single_mesh_pick();
        if (same_model_object) {
            update_feature_by_tran(*m_selected_features.first.feature);
        }
        update_feature_by_tran(*m_selected_features.second.feature);
    }
}

References Slic3r::Geometry::deg2rad(), Slic3r::Geometry::Transformation::get_matrix(), Slic3r::UndoRedo::GizmoAction, Slic3r::GUI::Selection::Instance, m_assembly_action, m_hit_different_volumes, Slic3r::GUI::GLGizmoBase::m_parent, m_pending_scale, m_selected_features, Slic3r::Geometry::mat_around_a_point_rotate(), register_single_mesh_pick(), Slic3r::GUI::Selection::setup_cache(), update_feature_by_tran(), and Slic3r::GUI::Selection::Volume.

Referenced by show_face_face_assembly_senior().

Here is the call graph for this function:

Here is the caller graph for this function:

set_to_center_coincidence()

void Slic3r::GUI::GLGizmoMeasure::set_to_center_coincidence ( bool same_model_object )

protectedinherited

                                                                     {
    auto v = m_hit_different_volumes[1];
    wxGetApp().plater()->take_snapshot("RotateThenMoveInMeasure", UndoRedo::SnapshotType::GizmoAction);
    set_to_parallel(same_model_object, false,true);
 
    const auto [idx1, normal1, pt1] = m_selected_features.first.feature->get_plane();
    const auto [idx2, normal2, pt2] = m_selected_features.second.feature->get_plane();
    set_distance(same_model_object, pt1 - pt2, false);
    m_set_center_coincidence = true;
}

References Slic3r::UndoRedo::GizmoAction, m_hit_different_volumes, m_selected_features, m_set_center_coincidence, set_distance(), and set_to_parallel().

Referenced by show_face_face_assembly_common().

Here is the call graph for this function:

Here is the caller graph for this function:

set_to_parallel()

void Slic3r::GUI::GLGizmoMeasure::set_to_parallel ( bool same_model_object, bool take_shot = true, bool is_anti_parallel = false )

protectedinherited

{
    if (m_hit_different_volumes.size() == 2) {
        auto &action    = m_assembly_action;
        auto  v         = m_hit_different_volumes[1];
        auto  selection = const_cast<Selection *>(&m_parent.get_selection());
        selection->setup_cache();
        if (take_shot) {
            wxGetApp().plater()->take_snapshot("RotateInMeasure", UndoRedo::SnapshotType::GizmoAction); // avoid storing another snapshot
        }
        selection->set_mode(same_model_object ? Selection::Volume : Selection::Instance);
        const auto [idx1, normal1, pt1] = m_selected_features.first.feature->get_plane();
        const auto [idx2, normal2, pt2] = m_selected_features.second.feature->get_plane();
        if ((is_anti_parallel && normal1.dot(normal2) > -1 + 1e-3) ||
            (is_anti_parallel == false && (normal1.dot(normal2) < 1 - 1e-3))) {
            m_pending_scale ++;
            Vec3d    axis;
            double   angle;
            Matrix3d rotation_matrix;
            Geometry::rotation_from_two_vectors(normal2, -normal1, axis, angle, &rotation_matrix);
            Transform3d r_m = (Transform3d) rotation_matrix;
            if (same_model_object == false) {
                auto new_rotation_tran = r_m * v->get_instance_transformation().get_rotation_matrix();
                Vec3d rotation         = Geometry::extract_euler_angles(new_rotation_tran);
                v->set_instance_rotation(rotation);
                selection->rotate(v->object_idx(), v->instance_idx(), v->get_instance_transformation().get_matrix());
            } else {
                Geometry::Transformation world_tran(v->world_matrix());
                auto        new_tran         = r_m * world_tran.get_rotation_matrix();
                Transform3d volume_rotation_tran = v->get_instance_transformation().get_rotation_matrix().inverse() * new_tran;
                Vec3d       rotation             = Geometry::extract_euler_angles(volume_rotation_tran);
                v->set_volume_rotation(rotation);
                selection->rotate(v->object_idx(), v->instance_idx(), v->volume_idx(), v->get_volume_transformation().get_matrix());
            }
            wxGetApp().plater()->canvas3D()->do_rotate("");
            register_single_mesh_pick();
            if (same_model_object) {
                update_feature_by_tran(*m_selected_features.first.feature);
            }
            update_feature_by_tran(*m_selected_features.second.feature);
        }
    }
}

References Slic3r::angle(), Slic3r::Geometry::extract_euler_angles(), Slic3r::Geometry::Transformation::get_rotation_matrix(), Slic3r::UndoRedo::GizmoAction, Slic3r::GUI::Selection::Instance, m_assembly_action, m_hit_different_volumes, Slic3r::GUI::GLGizmoBase::m_parent, m_pending_scale, m_selected_features, register_single_mesh_pick(), Slic3r::Geometry::rotation_from_two_vectors(), Slic3r::GUI::Selection::setup_cache(), update_feature_by_tran(), and Slic3r::GUI::Selection::Volume.

Referenced by set_to_center_coincidence(), and show_face_face_assembly_common().

Here is the call graph for this function:

Here is the caller graph for this function:

set_to_reverse_rotation()

void Slic3r::GUI::GLGizmoMeasure::set_to_reverse_rotation ( bool same_model_object, int feature_index )

protectedinherited

{
    if (m_hit_different_volumes.size() == 2 && feature_index < 2) {
        auto &action    = m_assembly_action;
        auto  v         = m_hit_different_volumes[feature_index];
        auto  selection = const_cast<Selection *>(&m_parent.get_selection());
        selection->setup_cache();
        wxGetApp().plater()->take_snapshot("ReverseRotateInMeasure", UndoRedo::SnapshotType::GizmoAction); // avoid storing another snapshot
 
        selection->set_mode(same_model_object ? Selection::Volume : Selection::Instance);
        m_pending_scale                 = 1;
        Vec3d plane_normal,plane_center;
        if (feature_index ==0) {//feature 1
            const auto [idx1, normal1, pt1] = m_selected_features.first.feature->get_plane();
            plane_normal                    = normal1;
            plane_center                    = pt1;
        }
        else  { // feature 2
            const auto [idx2, normal2, pt2] = m_selected_features.second.feature->get_plane();
            plane_normal                    = normal2;
            plane_center                    = pt2;
        }
        auto  new_pt = Measure::get_one_point_in_plane(plane_center, plane_normal);
        Vec3d axis   = (new_pt - plane_center).normalized();
        if (axis.norm() < 0.1) {
            throw;
        }
        if (same_model_object == false) {
            Geometry::Transformation inMat(v->get_instance_transformation());
            Geometry::Transformation outMat = Geometry::mat_around_a_point_rotate(inMat, plane_center, axis, PI);
            selection->rotate(v->object_idx(), v->instance_idx(), outMat.get_matrix());
        } else {
            Geometry::Transformation inMat(v->world_matrix());
            Geometry::Transformation outMat      = Geometry::mat_around_a_point_rotate(inMat, plane_center, axis, PI);
            Transform3d volume_tran = v->get_instance_transformation().get_matrix().inverse() * outMat.get_matrix();
            selection->rotate(v->object_idx(), v->instance_idx(), v->volume_idx(), volume_tran);
        }
        wxGetApp().plater()->canvas3D()->do_rotate("");
        register_single_mesh_pick();
        if (same_model_object == false) {
            if (feature_index == 0) { // feature 1
                update_feature_by_tran(*m_selected_features.first.feature);
            } else { // feature 2
                update_feature_by_tran(*m_selected_features.second.feature);
            }
        }
        else {
            update_feature_by_tran(*m_selected_features.first.feature);
            update_feature_by_tran(*m_selected_features.second.feature);
        }
    }
}

References Slic3r::Geometry::Transformation::get_matrix(), Slic3r::Measure::get_one_point_in_plane(), Slic3r::UndoRedo::GizmoAction, Slic3r::GUI::Selection::Instance, m_assembly_action, m_hit_different_volumes, Slic3r::GUI::GLGizmoBase::m_parent, m_pending_scale, m_selected_features, Slic3r::Geometry::mat_around_a_point_rotate(), PI, register_single_mesh_pick(), Slic3r::GUI::Selection::setup_cache(), update_feature_by_tran(), and Slic3r::GUI::Selection::Volume.

Referenced by show_face_face_assembly_senior().

Here is the call graph for this function:

Here is the caller graph for this function:

shortcut()

std::optional< Shortcut > Slic3r::GUI::GLGizmoBase::shortcut ( ) const

inlineinherited

{ return m_shortcut; }

References m_shortcut.

Referenced by Slic3r::GUI::GLGizmoFdmSupports::on_tool_shortcut(), Slic3r::GUI::GLGizmoMmuSegmentation::on_tool_shortcut(), Slic3r::GUI::GLGizmoPainterBase::on_tool_shortcut(), and Slic3r::GUI::GLGizmoSeam::on_tool_shortcut().

Here is the caller graph for this function:

show_distance_xyz_ui()

void Slic3r::GUI::GLGizmoMeasure::show_distance_xyz_ui ( )

protectedinherited

{
    if (m_measure_mode == EMeasureMode::ONLY_MEASURE) {
        m_imgui->text(_u8L("Measure"));
    }
    auto add_measure_row_to_table = [this](const std::string &col_1, const ImVec4 &col_1_color, const std::string &col_2, const ImVec4 &col_2_color) {
        ImGui::TableNextRow();
        ImGui::TableSetColumnIndex(0);
        m_imgui->text_colored(col_1_color, col_1);
        ImGui::TableSetColumnIndex(1);
        m_imgui->text_colored(col_2_color, col_2);
        ImGui::TableSetColumnIndex(2);
        if (m_imgui->image_button(m_is_dark_mode ? ImGui::ClipboardBtnDarkIcon : ImGui::ClipboardBtnIcon, _L("Copy to clipboard"))) {
            wxTheClipboard->Open();
            wxTheClipboard->SetData(new wxTextDataObject(wxString((col_1 + ": " + col_2).c_str(), wxConvUTF8)));
            wxTheClipboard->Close();
        }
    };
    auto add_edit_distance_xyz_box = [this](Vec3d &distance) {
        //m_imgui->disabled_begin(m_hit_different_volumes.size() == 1);
        //{
            if (m_measure_mode == EMeasureMode::ONLY_MEASURE) {
                m_can_set_xyz_distance = false;
            }
            bool volume = m_hit_different_volumes.size() == 1;
            ImGui::TableNextRow();
            ImGui::TableSetColumnIndex(0);
            m_imgui->text_colored(ImGuiWrapper::to_ImVec4(ColorRGBA::X()), "X:"); // ORCA match axis color
            ImGui::TableSetColumnIndex(1);
            ImGui::PushItemWidth(m_input_size_max);
            m_imgui->disabled_begin(volume || !m_can_set_xyz_distance); // ORCA disable only input box othervise axis colors rendered dimmed
            ImGui::BBLInputDouble("##measure_distance_x", &m_buffered_distance[0], 0.0f, 0.0f, "%.2f");
            m_imgui->disabled_end();
 
            ImGui::TableNextRow();
            ImGui::TableSetColumnIndex(0);
            m_imgui->text_colored(ImGuiWrapper::to_ImVec4(ColorRGBA::Y()), "Y:"); // ORCA match axis color
            ImGui::TableSetColumnIndex(1);
            m_imgui->disabled_begin(volume || !m_can_set_xyz_distance); // ORCA disable only input box othervise axis colors rendered dimmed
            ImGui::BBLInputDouble("##measure_distance_y", &m_buffered_distance[1], 0.0f, 0.0f, "%.2f");
            m_imgui->disabled_end();
 
            ImGui::TableNextRow();
            ImGui::TableSetColumnIndex(0);
            m_imgui->text_colored(ImGuiWrapper::to_ImVec4(ColorRGBA::Z()), "Z:"); // ORCA match axis color
            ImGui::TableSetColumnIndex(1);
            m_imgui->disabled_begin(volume || !(m_same_model_object && m_can_set_xyz_distance)); // ORCA disable only input box othervise axis colors rendered dimmed
            ImGui::BBLInputDouble("##measure_distance_z", &m_buffered_distance[2], 0.0f, 0.0f, "%.2f");
            m_imgui->disabled_end();
        //}
        //m_imgui->disabled_end();
        if (m_last_active_item_imgui != m_current_active_imgui_id && m_hit_different_volumes.size() == 2) {
            Vec3d displacement = Vec3d::Zero();
            if (std::abs(m_buffered_distance[0] - distance[0]) > EPSILON) {
                displacement[0] = m_buffered_distance[0] - distance[0];
                distance[0]     = m_buffered_distance[0];
            } else if (std::abs(m_buffered_distance[1] - distance[1]) > EPSILON) {
                displacement[1] = m_buffered_distance[1] - distance[1];
                distance[1]     = m_buffered_distance[1];
            } else if (std::abs(m_buffered_distance[2] - distance[2]) > EPSILON) {
                displacement[2] = m_buffered_distance[2] - distance[2];
                distance[2]     = m_buffered_distance[2];
            }
            if (displacement.norm() > 0.0f) { set_distance(m_same_model_object, displacement); }
        }
    };
    const unsigned int max_measure_row_count = 2;
    unsigned int       measure_row_count     = 0;
    if (ImGui::BeginTable("Measure", 4)) {
        if (m_selected_features.second.feature.has_value()) {
            const Measure::MeasurementResult &measure = m_measurement_result;
            if (measure.angle.has_value() && m_measure_mode == EMeasureMode::ONLY_MEASURE)
                {
                ImGui::PushID("ClipboardAngle");
                add_measure_row_to_table(_u8L("Angle"), ImGuiWrapper::COL_ORCA, format_double(Geometry::rad2deg(measure.angle->angle)) + "°",
                                            ImGui::GetStyleColorVec4(ImGuiCol_Text));
                ++measure_row_count;
                ImGui::PopID();
            }
 
            const bool show_strict = measure.distance_strict.has_value() &&
                                        (!measure.distance_infinite.has_value() || std::abs(measure.distance_strict->dist - measure.distance_infinite->dist) > EPSILON);
 
            if (measure.distance_infinite.has_value() && m_measure_mode == EMeasureMode::ONLY_MEASURE) {
                double distance = measure.distance_infinite->dist;
                if (m_use_inches) distance = GizmoObjectManipulation::mm_to_in * distance;
                ImGui::PushID("ClipboardDistanceInfinite");
                add_measure_row_to_table(show_strict ? _u8L("Perpendicular distance") : _u8L("Distance"), ImGuiWrapper::COL_ORCA, format_double(distance) + m_units,
                                            ImGui::GetStyleColorVec4(ImGuiCol_Text));
                ++measure_row_count;
                ImGui::PopID();
            }
            if (show_strict &&
                (m_measure_mode == EMeasureMode::ONLY_MEASURE ||
                    (m_measure_mode == EMeasureMode::ONLY_ASSEMBLY && m_assembly_mode == AssemblyMode::POINT_POINT)))
                {
                double distance = measure.distance_strict->dist;
                if (m_use_inches)
                    distance = GizmoObjectManipulation::mm_to_in * distance;
                ImGui::PushID("ClipboardDistanceStrict");
                add_measure_row_to_table(_u8L("Direct distance"), ImGuiWrapper::COL_ORCA, format_double(distance) + m_units, ImGui::GetStyleColorVec4(ImGuiCol_Text));
                ++measure_row_count;
                ImGui::PopID();
            }
            if (measure.distance_xyz.has_value() && m_measure_mode == EMeasureMode::ONLY_MEASURE) {
                Vec3d distance = *measure.distance_xyz;
                if (m_use_inches) distance = GizmoObjectManipulation::mm_to_in * distance;
                if (measure.distance_xyz->norm() > EPSILON) {
                    ImGui::PushID("ClipboardDistanceXYZ");
                    add_measure_row_to_table(_u8L("Distance XYZ"), ImGuiWrapper::COL_ORCA, format_vec3(distance), ImGui::GetStyleColorVec4(ImGuiCol_Text));
                    ++measure_row_count;
                    ImGui::PopID();
                }
            }
 
            if (m_distance.norm() > 0.01) {
                if (!(m_measure_mode == EMeasureMode::ONLY_ASSEMBLY && m_assembly_mode == AssemblyMode::FACE_FACE)) {
                    add_edit_distance_xyz_box(m_distance);
                }
            }
        }
        // add dummy rows to keep dialog size fixed
        /*for (unsigned int i = measure_row_count; i < max_measure_row_count; ++i) {
            add_strings_row_to_table(*m_imgui, " ", ImGuiWrapper::COL_ORCA, " ", ImGui::GetStyleColorVec4(ImGuiCol_Text));
        }*/
        ImGui::EndTable();
    }
}

References _L, _u8L, Slic3r::GUI::ImGuiWrapper::COL_ORCA, EPSILON, Slic3r::GUI::FACE_FACE, format_double(), format_vec3(), m_assembly_mode, m_buffered_distance, m_can_set_xyz_distance, m_current_active_imgui_id, m_distance, m_hit_different_volumes, Slic3r::GUI::GLGizmoBase::m_imgui, m_input_size_max, Slic3r::GUI::GLGizmoBase::m_is_dark_mode, m_last_active_item_imgui, m_measure_mode, m_measurement_result, m_same_model_object, m_selected_features, m_units, m_use_inches, Slic3r::GUI::GizmoObjectManipulation::mm_to_in, Slic3r::GUI::ONLY_ASSEMBLY, Slic3r::GUI::ONLY_MEASURE, Slic3r::GUI::POINT_POINT, Slic3r::Geometry::rad2deg(), set_distance(), Slic3r::GUI::ImGuiWrapper::to_ImVec4(), Slic3r::ColorRGBA::X(), Slic3r::ColorRGBA::Y(), and Slic3r::ColorRGBA::Z().

Referenced by Slic3r::GUI::GLGizmoAssembly::on_render_input_window(), and on_render_input_window().

Here is the call graph for this function:

Here is the caller graph for this function:

show_face_face_assembly_common()

void Slic3r::GUI::GLGizmoMeasure::show_face_face_assembly_common ( )

protectedinherited

                                                    {
    if (m_measure_mode == EMeasureMode::ONLY_ASSEMBLY && m_hit_different_volumes.size() == 2 &&
        m_selected_features.first.feature->get_type() == Measure::SurfaceFeatureType::Plane &&
        m_selected_features.second.feature->get_type() == Measure::SurfaceFeatureType::Plane) {
        auto &action                         = m_assembly_action;
        auto  set_to_parallel_size           = m_imgui->calc_button_size(_L("Parallel")).x;
        auto  set_to_center_coincidence_size = m_imgui->calc_button_size(_L("Center coincidence")).x;
 
        m_imgui->disabled_begin(!(action.can_set_to_center_coincidence));
        {
            ImGui::PushItemWidth(set_to_center_coincidence_size);
            ImGui::PushStyleColor(ImGuiCol_Button, ImVec4(0 / 255.0, 150 / 255.0, 136 / 255.0, 1.0));
            ImGui::PushStyleColor(ImGuiCol_ButtonHovered, ImVec4(38 / 255.0f, 166 / 255.0f, 154 / 255.0f, 1.00f));
            ImGui::PushStyleColor(ImGuiCol_ButtonActive, ImVec4(0 / 255.0f, 137 / 255.0f, 123 / 255.0f, 1.00f));
            ImGui::PushStyleColor(ImGuiCol_Text, ImVec4(254 / 255.0f, 254 / 255.0f, 254 / 255.0f, 1.00f));
            if (m_imgui->button(_L("Center coincidence"))) {
                set_to_center_coincidence(m_same_model_object);
            }
            ImGui::PopStyleColor(4);
            ImGui::SameLine(set_to_center_coincidence_size + m_space_size * 2);
        }
        m_imgui->disabled_end();
 
        m_imgui->disabled_begin(!action.can_set_to_parallel);
        {
            if (m_imgui->button(_L("Parallel"))) { set_to_parallel(m_same_model_object); }
        }
        m_imgui->disabled_end();
    }
}

References _L, m_assembly_action, m_hit_different_volumes, Slic3r::GUI::GLGizmoBase::m_imgui, m_measure_mode, m_same_model_object, m_selected_features, m_space_size, Slic3r::GUI::ONLY_ASSEMBLY, Slic3r::Measure::Plane, set_to_center_coincidence(), and set_to_parallel().

Referenced by Slic3r::GUI::GLGizmoAssembly::on_render_input_window().

Here is the call graph for this function:

Here is the caller graph for this function:

show_face_face_assembly_senior()

void Slic3r::GUI::GLGizmoMeasure::show_face_face_assembly_senior ( )

protectedinherited

{
    if (m_measure_mode == EMeasureMode::ONLY_ASSEMBLY && m_hit_different_volumes.size() == 2 &&
        m_selected_features.first.feature->get_type() == Measure::SurfaceFeatureType::Plane &&
        m_selected_features.second.feature->get_type() == Measure::SurfaceFeatureType::Plane) {
        auto &action                         = m_assembly_action;
        auto  feature_text_size              = m_imgui->calc_button_size(_L("Feature 1")).x + m_imgui->calc_button_size(":").x;
        auto  set_to_reverse_rotation_size   = m_imgui->calc_button_size(_L("Reverse rotation")).x;
        auto  rotate_around_center_size      = m_imgui->calc_button_size(_L("Rotate around center:")).x;
        auto  parallel_distance_size         = m_imgui->calc_button_size(_L("Parallel distance:")).x;
 
        if (m_imgui->bbl_checkbox(_L("Flip by Face 2"), m_flip_volume_2)) {
            set_to_reverse_rotation(m_same_model_object, 1);
        }
 
        if (action.has_parallel_distance) {
            m_imgui->text(_u8L("Parallel distance:"));
            ImGui::SameLine(parallel_distance_size + m_space_size);
            ImGui::PushItemWidth(m_input_size_max);
            ImGui::BBLInputDouble("##parallel_distance_z", &m_buffered_parallel_distance, 0.0f, 0.0f, "%.2f");
            if (m_last_active_item_imgui != m_current_active_imgui_id && std::abs(m_buffered_parallel_distance - action.parallel_distance) > EPSILON) {
                set_parallel_distance(m_same_model_object, m_buffered_parallel_distance);
            }
        }
        if (action.can_around_center_of_faces) {
            m_imgui->text(_u8L("Rotate around center:"));
            ImGui::SameLine(rotate_around_center_size + m_space_size);
            ImGui::PushItemWidth(m_input_size_max);
            ImGui::BBLInputDouble("##rotate_around_center", &m_buffered_around_center, 0.0f, 0.0f, "%.2f");
            if (m_last_active_item_imgui != m_current_active_imgui_id && std::abs(m_buffered_around_center) > EPSILON) {
                set_to_around_center_of_faces(m_same_model_object, m_buffered_around_center);
                m_buffered_around_center = 0;
            }
            ImGui::SameLine(rotate_around_center_size + m_space_size + m_input_size_max + m_space_size / 2.0f);
            m_imgui->text("°");
        }
    }
}

References _L, _u8L, EPSILON, m_assembly_action, m_buffered_around_center, m_buffered_parallel_distance, m_current_active_imgui_id, m_flip_volume_2, m_hit_different_volumes, Slic3r::GUI::GLGizmoBase::m_imgui, m_input_size_max, m_last_active_item_imgui, m_measure_mode, m_same_model_object, m_selected_features, m_space_size, Slic3r::GUI::ONLY_ASSEMBLY, Slic3r::Measure::Plane, set_parallel_distance(), set_to_around_center_of_faces(), and set_to_reverse_rotation().

Referenced by Slic3r::GUI::GLGizmoAssembly::on_render_input_window().

Here is the call graph for this function:

Here is the caller graph for this function:

show_selection_ui()

void Slic3r::GUI::GLGizmoMeasure::show_selection_ui ( )

protectedinherited

{
    auto space_size = m_space_size;
    // Show selection
    {
        auto format_item_text = [this](const SelectedFeatures::Item &item) {
            if (!item.feature.has_value()) return _u8L("None");
 
            std::string text = (item.source == item.feature) ? surface_feature_type_as_string(item.feature->get_type()) :
                               item.is_center                ? center_on_feature_type_as_string(item.source->get_type()) :
                                                               point_on_feature_type_as_string(item.source->get_type(), m_hover_id);
            if (item.feature.has_value() && item.feature->get_type() == Measure::SurfaceFeatureType::Circle) {
                auto [center, radius, normal] = item.feature->get_circle();
                const Vec3d on_circle         = center + radius * Measure::get_orthogonal(normal, true);
                radius                        = (on_circle - center).norm();
                if (m_use_inches)
                    radius = GizmoObjectManipulation::mm_to_in * radius;
                text += " (" + _u8L("Diameter") + ": " + format_double(2.0 * radius) + m_units + ")";
            } else if (item.feature.has_value() && item.feature->get_type() == Measure::SurfaceFeatureType::Edge) {
                auto [start, end] = item.feature->get_edge();
                double length     = (end - start).norm();
                if (m_use_inches)
                    length = GizmoObjectManipulation::mm_to_in * length;
                text += " (" + _u8L("Length") + ": " + format_double(length) + m_units + ")";
            }
            return text;
        };
 
        float selection_cap_length = 0;
        if (m_measure_mode == EMeasureMode::ONLY_ASSEMBLY) {
            if (m_assembly_mode == AssemblyMode::FACE_FACE) {
                selection_cap_length = std::max(ImGui::CalcTextSize(_u8L("Face 1 (Fixed)").c_str()).x, ImGui::CalcTextSize(_u8L("Face 2 (Moving)").c_str()).x) * 1.2;
            } else if (m_assembly_mode == AssemblyMode::POINT_POINT) {
                selection_cap_length = std::max(ImGui::CalcTextSize(_u8L("Point 1 (Fixed)").c_str()).x, ImGui::CalcTextSize(_u8L("Point 2 (Moving)").c_str()).x) * 1.2;
            }
        }
        else {
            selection_cap_length = ImGui::CalcTextSize(_u8L("Selection 1").c_str()).x * 1.2;
        }
        auto        feature_first_text        = format_item_text(m_selected_features.first);
        const float feature_first_text_length = ImGui::CalcTextSize((_u8L(feature_first_text)).c_str()).x;
        ImGui::AlignTextToFramePadding();
        if (m_measure_mode == EMeasureMode::ONLY_ASSEMBLY) {
            m_only_select_plane = m_assembly_mode == AssemblyMode::FACE_FACE ? true : false;
            if (m_assembly_mode == AssemblyMode::FACE_FACE) {
                m_imgui->text(_u8L("Select 2 faces on objects and \n make objects assemble together.")); // tip
            } else if (m_assembly_mode == AssemblyMode::POINT_POINT) {
                m_imgui->text(_u8L("Select 2 points or circles on objects and \n specify distance between them.")); // tip
            }
        }
        ImGui::PushStyleColor(ImGuiCol_Text, ImGuiWrapper::to_ImVec4(SELECTED_1ST_COLOR));
        if (m_measure_mode == EMeasureMode::ONLY_ASSEMBLY) {
            if (m_assembly_mode == AssemblyMode::FACE_FACE) {
                m_imgui->text(_u8L("Face 1 (Fixed)"));
            } else if (m_assembly_mode == AssemblyMode::POINT_POINT) {
                m_imgui->text(_u8L("Point 1 (Fixed)"));
            }
        }
        else {
            m_imgui->text(_u8L("Selection 1"));
        }
        ImGui::SameLine(selection_cap_length + space_size);
        ImGui::PushItemWidth(feature_first_text_length);
        m_imgui->text(feature_first_text);
        if (m_selected_features.first.feature.has_value()) {
            ImGui::SameLine(selection_cap_length + feature_first_text_length + space_size * 2);
            ImGui::PushItemWidth(space_size * 2);
            ImGui::PushID("Reset1"); // for image_button
            if (m_imgui->image_button(m_is_dark_mode ? ImGui::RevertBtn : ImGui::RevertBtn, _L("Reset"))) { reset_feature1(); }
            ImGui::PopID();
        }
        ImGui::PopStyleColor();
 
        auto        feature_second_text        = format_item_text(m_selected_features.second);
        const float feature_second_text_length = ImGui::CalcTextSize((_u8L(feature_second_text)).c_str()).x;
        ImGui::AlignTextToFramePadding();
        ImGui::PushStyleColor(ImGuiCol_Text, ImGuiWrapper::to_ImVec4(SELECTED_2ND_COLOR));
        if (m_measure_mode == EMeasureMode::ONLY_ASSEMBLY) {
            if (m_assembly_mode == AssemblyMode::FACE_FACE) {
                m_imgui->text(_u8L("Face 2 (Moving)"));
            } else if (m_assembly_mode == AssemblyMode::POINT_POINT) {
                m_imgui->text(_u8L("Point 2 (Moving)"));
            }
        } else {
            m_imgui->text(_u8L("Selection 2"));
        }
        ImGui::SameLine(selection_cap_length + space_size);
        ImGui::PushItemWidth(feature_second_text_length);
        m_imgui->text(feature_second_text);
        if (m_selected_features.first.feature.has_value() && m_selected_features.second.feature.has_value()) {
            m_show_reset_first_tip = false;
            ImGui::SameLine(selection_cap_length + feature_second_text_length + space_size * 2);
            ImGui::PushItemWidth(space_size * 2);
            ImGui::PushID("Reset2");
            if (m_imgui->image_button(m_is_dark_mode ? ImGui::RevertBtn : ImGui::RevertBtn, _L("Reset"))) { reset_feature2(); }
            ImGui::PopID();
        }
        ImGui::PopStyleColor();
    }
 
    /*m_imgui->disabled_begin(!m_selected_features.first.feature.has_value());
    if (m_imgui->button(_L("Restart selection"))) {
        reset_all_feature();
        m_imgui->set_requires_extra_frame();
    }
    m_imgui->disabled_end();*/
 
    if (m_show_reset_first_tip) {
        m_imgui->text(_L("Feature 1 has been reset, \nfeature 2 has been feature 1"));
    }
}

References _L, _u8L, Slic3r::center(), center_on_feature_type_as_string(), Slic3r::Measure::Circle, Slic3r::Measure::Edge, Slic3r::GUI::FACE_FACE, format_double(), Slic3r::Measure::get_orthogonal(), Slic3r::length(), m_assembly_mode, Slic3r::GUI::GLGizmoBase::m_hover_id, Slic3r::GUI::GLGizmoBase::m_imgui, Slic3r::GUI::GLGizmoBase::m_is_dark_mode, m_measure_mode, m_only_select_plane, m_selected_features, m_show_reset_first_tip, m_space_size, m_units, m_use_inches, Slic3r::GUI::GizmoObjectManipulation::mm_to_in, Slic3r::normal(), Slic3r::GUI::ONLY_ASSEMBLY, point_on_feature_type_as_string(), Slic3r::GUI::POINT_POINT, reset_feature1(), reset_feature2(), Slic3r::GUI::SELECTED_1ST_COLOR, Slic3r::GUI::SELECTED_2ND_COLOR, surface_feature_type_as_string(), and Slic3r::GUI::ImGuiWrapper::to_ImVec4().

Referenced by Slic3r::GUI::GLGizmoAssembly::on_render_input_window(), and on_render_input_window().

Here is the call graph for this function:

Here is the caller graph for this function:

surface_feature_type_as_string()

std::string Slic3r::GUI::GLGizmoMeasure::surface_feature_type_as_string ( Measure::SurfaceFeatureType type )

protectedinherited

{
    switch (type)
    {
    default:
    case Measure::SurfaceFeatureType::Undef:  { return _u8L("No feature"); }
    case Measure::SurfaceFeatureType::Point:  { return _u8L("Vertex"); }
    case Measure::SurfaceFeatureType::Edge:   { return _u8L("Edge"); }
    case Measure::SurfaceFeatureType::Circle: { return _u8L("Circle"); }
    case Measure::SurfaceFeatureType::Plane:  { return _u8L("Plane"); }
    }
}

References _u8L, Slic3r::Measure::Circle, Slic3r::Measure::Edge, Slic3r::Measure::Plane, Slic3r::Measure::Point, and Slic3r::Measure::Undef.

Referenced by show_selection_ui().

Here is the caller graph for this function:

switch_to_mode()

void Slic3r::GUI::GLGizmoAssembly::switch_to_mode ( AssemblyMode new_mode )

protected

{
    m_assembly_mode = new_mode;
    reset_all_feature();
}

References Slic3r::GUI::GLGizmoMeasure::m_assembly_mode, and Slic3r::GUI::GLGizmoMeasure::reset_all_feature().

Referenced by render_assembly_mode_combo().

Here is the call graph for this function:

Here is the caller graph for this function:

unregister_grabbers_for_picking()

void Slic3r::GUI::GLGizmoBase::unregister_grabbers_for_picking ( )

protectedinherited

{
    for (size_t i = 0; i < m_grabbers.size(); ++i) {
        m_grabbers[i].unregister_raycasters_for_picking();
    }
}

References m_grabbers.

Referenced by unregister_raycasters_for_picking().

Here is the caller graph for this function:

unregister_raycasters_for_picking()

void Slic3r::GUI::GLGizmoBase::unregister_raycasters_for_picking ( )

inlineinherited

{ unregister_grabbers_for_picking(); on_unregister_raycasters_for_picking(); }

References on_unregister_raycasters_for_picking(), and unregister_grabbers_for_picking().

Referenced by Slic3r::GUI::GLGizmosManager::activate_gizmo(), and Slic3r::GUI::GLCanvas3D::reload_scene().

Here is the call graph for this function:

Here is the caller graph for this function:

update_feature_by_tran()

void Slic3r::GUI::GLGizmoMeasure::update_feature_by_tran ( Measure::SurfaceFeature & feature )

protectedinherited

{
    if (!feature.volume) { return; }
    auto  volume  = static_cast<GLVolume *>(feature.volume);
    Measure::Measuring *cur_measuring = get_measuring_of_mesh(volume, feature.world_tran);
    switch (feature.get_type()) {
    case Measure::SurfaceFeatureType::Point:
    case Measure::SurfaceFeatureType::Edge:
    case Measure::SurfaceFeatureType::Circle:
    case Measure::SurfaceFeatureType::Plane: {
        feature.clone(*feature.origin_surface_feature);
        feature.translate(feature.world_tran);
        if (feature.get_type() == Measure::SurfaceFeatureType::Circle) {
            m_feature_circle_first.last_circle_feature  = nullptr;
            m_feature_circle_first.inv_zoom             = 0;
            m_feature_circle_second.last_circle_feature = nullptr;
            m_feature_circle_second.inv_zoom            = 0;
        }
        if (feature.get_type() == Measure::SurfaceFeatureType::Plane) {
            if (cur_measuring) {
                update_world_plane_features(cur_measuring, feature);
            }
        }
        break;
    }
    default: {
        break;
    }
    }
}

References Slic3r::Measure::Circle, Slic3r::Measure::SurfaceFeature::clone(), Slic3r::Measure::Edge, get_measuring_of_mesh(), Slic3r::Measure::SurfaceFeature::get_type(), m_feature_circle_first, m_feature_circle_second, Slic3r::Measure::SurfaceFeature::origin_surface_feature, Slic3r::Measure::Plane, Slic3r::Measure::Point, Slic3r::Measure::SurfaceFeature::translate(), update_world_plane_features(), Slic3r::Measure::SurfaceFeature::volume, and Slic3r::Measure::SurfaceFeature::world_tran.

Referenced by render_dimensioning(), set_distance(), set_parallel_distance(), set_to_around_center_of_faces(), set_to_parallel(), and set_to_reverse_rotation().

Here is the call graph for this function:

Here is the caller graph for this function:

update_if_needed()

void Slic3r::GUI::GLGizmoMeasure::update_if_needed ( )

protectedinherited

{
    //const Selection& selection = m_parent.get_selection();
    //if (selection.is_empty())
    //    return;
 
    //const Selection::IndicesList& idxs = selection.get_volume_idxs();
    //std::vector<VolumeCacheItem> volumes_cache;
    //volumes_cache.reserve(idxs.size());
    //for (unsigned int idx : idxs) {
    //    const GLVolume* v = selection.get_volume(idx);
    //    const int volume_idx = v->volume_idx();
    //    if (volume_idx < 0)
    //        continue;
 
    //    const ModelObject* obj = selection.get_model()->objects[v->object_idx()];
    //    const ModelInstance* inst = obj->instances[v->instance_idx()];
    //    const ModelVolume* vol = obj->volumes[volume_idx];
    //    const VolumeCacheItem item = {
    //        obj, inst, vol,
    //        Geometry::translation_transform(selection.get_first_volume()->get_sla_shift_z() * Vec3d::UnitZ()) * inst->get_matrix() * vol->get_matrix()
    //    };
    //    volumes_cache.emplace_back(item);
    //}
 
    //if (m_state != On || volumes_cache.empty())
    //    return;
 
    //if (m_volumes_cache != volumes_cache) {
    //    m_volumes_cache = volumes_cache;
    //}
}

Referenced by data_changed(), and on_render().

Here is the caller graph for this function:

update_items_state()

bool Slic3r::GUI::GLGizmoBase::update_items_state ( )

inherited

{
    bool res = m_dirty;
    m_dirty  = false;
    return res;
}

References m_dirty.

update_measurement_result()

void Slic3r::GUI::GLGizmoMeasure::update_measurement_result ( )

protectedinherited

{
    if (!m_selected_features.first.feature.has_value()) {
        m_measurement_result = Measure::MeasurementResult();
        m_assembly_action    = Measure::AssemblyAction();
    }
    else if (m_selected_features.second.feature.has_value()) {
        m_measurement_result = Measure::get_measurement(*m_selected_features.first.feature, *m_selected_features.second.feature, true);
        m_assembly_action    = Measure::get_assembly_action(*m_selected_features.first.feature, *m_selected_features.second.feature);
        m_can_set_xyz_distance = Measure::can_set_xyz_distance(*m_selected_features.first.feature, *m_selected_features.second.feature);
        //update buffer
        const Measure::MeasurementResult &measure = m_measurement_result;
        m_distance                                = Vec3d::Zero();
        if (measure.distance_xyz.has_value() && measure.distance_xyz->norm() > EPSILON) {
            m_distance = *measure.distance_xyz;
        } else if (measure.distance_infinite.has_value()) {
            m_distance = measure.distance_infinite->to - measure.distance_infinite->from;
        } else if (measure.distance_strict.has_value()) {
            m_distance = measure.distance_strict->to - measure.distance_strict->from;
        }
        if (wxGetApp().app_config->get_bool("use_inches")) m_distance = GizmoObjectManipulation::mm_to_in * m_distance;
        m_buffered_distance = m_distance;
        if (m_assembly_action.has_parallel_distance) {
            m_buffered_parallel_distance = m_assembly_action.parallel_distance;
        }
    }
    else if (!m_selected_features.second.feature.has_value() && m_selected_features.first.feature->get_type() == Measure::SurfaceFeatureType::Circle)
        m_measurement_result = Measure::get_measurement(*m_selected_features.first.feature, Measure::SurfaceFeature(std::get<0>(m_selected_features.first.feature->get_circle())));
}

References Slic3r::Measure::can_set_xyz_distance(), Slic3r::Measure::Circle, EPSILON, Slic3r::Measure::get_assembly_action(), Slic3r::Measure::get_measurement(), m_assembly_action, m_buffered_distance, m_buffered_parallel_distance, m_can_set_xyz_distance, m_distance, m_measurement_result, m_selected_features, and Slic3r::GUI::GizmoObjectManipulation::mm_to_in.

Referenced by data_changed(), gizmo_event(), on_mouse(), reset_feature1(), and reset_feature2().

Here is the call graph for this function:

Here is the caller graph for this function:

update_render_colors()

void Slic3r::GUI::GLGizmoBase::update_render_colors ( )

staticinherited

{
    GLGizmoBase::AXES_COLOR = { {
                                ImGuiWrapper::from_ImVec4(RenderColor::colors[RenderCol_Grabber_X]),
                                ImGuiWrapper::from_ImVec4(RenderColor::colors[RenderCol_Grabber_Y]),
                                ImGuiWrapper::from_ImVec4(RenderColor::colors[RenderCol_Grabber_Z])
                                } };
 
    GLGizmoBase::FLATTEN_COLOR       = ImGuiWrapper::from_ImVec4(RenderColor::colors[RenderCol_Flatten_Plane]);
    GLGizmoBase::FLATTEN_HOVER_COLOR = ImGuiWrapper::from_ImVec4(RenderColor::colors[RenderCol_Flatten_Plane_Hover]);
}

References AXES_COLOR, Slic3r::RenderColor::colors, FLATTEN_COLOR, FLATTEN_HOVER_COLOR, Slic3r::GUI::ImGuiWrapper::from_ImVec4(), RenderCol_Flatten_Plane, RenderCol_Flatten_Plane_Hover, RenderCol_Grabber_X, RenderCol_Grabber_Y, and RenderCol_Grabber_Z.

Referenced by Slic3r::GUI::GLCanvas3D::_render_style_editor().

Here is the call graph for this function:

Here is the caller graph for this function:

update_world_plane_features()

void Slic3r::GUI::GLGizmoMeasure::update_world_plane_features ( Measure::Measuring * cur_measuring, Measure::SurfaceFeature & feautre )

protectedinherited

{
    if (cur_measuring) {
        const auto &[idx, normal, pt] = feautre.get_plane();
        feautre.plane_indices       = const_cast<std::vector<int> *>(&cur_measuring->get_plane_triangle_indices(idx));
        auto cur_plane_features       = const_cast<std::vector<Measure::SurfaceFeature> *>(&cur_measuring->get_plane_features(idx));
        if (cur_plane_features) {
            if (!feautre.world_plane_features) {
                feautre.world_plane_features = std::make_shared<std::vector<Measure::SurfaceFeature>>();
            }
            feautre.world_plane_features->clear(); // resize(cur_plane_features->size());
            for (size_t i = 0; i < cur_plane_features->size(); i++) {
                Measure::SurfaceFeature temp(cur_plane_features->at(i));
                temp.translate(feautre.world_tran);
                feautre.world_plane_features->push_back(std::move(temp));
            }
        }
    }
}

References Slic3r::Measure::SurfaceFeature::get_plane(), Slic3r::Measure::Measuring::get_plane_features(), Slic3r::Measure::Measuring::get_plane_triangle_indices(), Slic3r::normal(), Slic3r::Measure::SurfaceFeature::plane_indices, Slic3r::Measure::SurfaceFeature::translate(), Slic3r::Measure::SurfaceFeature::world_plane_features, and Slic3r::Measure::SurfaceFeature::world_tran.

Referenced by on_render(), and update_feature_by_tran().

Here is the call graph for this function:

Here is the caller graph for this function:

use_grabbers()

bool Slic3r::GUI::GLGizmoBase::use_grabbers ( const wxMouseEvent & mouse_event )

protectedinherited

function which Set up m_dragging and call functions on_start_dragging / on_dragging / on_stop_dragging

Parameters

mouse_event

Keep information about mouse click

Returns

same as on_mouse

                                                              {
    bool is_dragging_finished = false;
    if (mouse_event.Moving()) { 
        // it should not happen but for sure
        assert(!m_dragging);
        if (m_dragging) is_dragging_finished = true;
        else return false; 
    } 
 
    if (mouse_event.LeftDown()) {
        Selection &selection = m_parent.get_selection();
        if (!selection.is_empty() && m_hover_id != -1 /* &&
            (m_grabbers.empty() || m_hover_id < static_cast<int>(m_grabbers.size()))*/) {
            selection.setup_cache();
 
            m_dragging = true;
            for (auto &grabber : m_grabbers) grabber.dragging = false;
//            if (!m_grabbers.empty() && m_hover_id < int(m_grabbers.size()))
//                m_grabbers[m_hover_id].dragging = true;
            
            on_start_dragging();
 
            // Let the plater know that the dragging started
            m_parent.post_event(SimpleEvent(EVT_GLCANVAS_MOUSE_DRAGGING_STARTED));
            m_parent.set_as_dirty();
            return true;
        }
    } else if (m_dragging) {
        // when mouse cursor leave window than finish actual dragging operation
        bool is_leaving = mouse_event.Leaving() && !m_parent.has_mouse_capture(); // ORCA keep tracking mouse position while drag active and cursor not in window bounds
        if (mouse_event.Dragging()) {
            Point      mouse_coord(mouse_event.GetX(), mouse_event.GetY());
            auto       ray = m_parent.mouse_ray(mouse_coord);
            UpdateData data(ray, mouse_coord);
 
            on_dragging(data);
 
            wxGetApp().obj_manipul()->set_dirty();
            m_parent.set_as_dirty();
            return true;
        }
        else if (mouse_event.LeftUp() || is_leaving || is_dragging_finished) {
            do_stop_dragging(is_leaving);
            return true;
        }
    }
    return false;
}

References do_stop_dragging(), Slic3r::GUI::Selection::is_empty(), m_dragging, m_grabbers, m_hover_id, m_parent, on_dragging(), on_start_dragging(), Slic3r::GUI::Selection::setup_cache(), and Slic3r::GUI::wxMouseEvent.

Referenced by Slic3r::GUI::GLGizmoBrimEars::on_mouse(), Slic3r::GUI::GLGizmoCut3D::on_mouse(), Slic3r::GUI::GLGizmoMove3D::on_mouse(), Slic3r::GUI::GLGizmoRotate3D::on_mouse(), Slic3r::GUI::GLGizmoRotate::on_mouse(), Slic3r::GUI::GLGizmoScale3D::on_mouse(), Slic3r::GUI::GLGizmoEmboss::on_mouse_for_rotation(), and Slic3r::GUI::GLGizmoSVG::on_mouse_for_rotation().

Here is the call graph for this function:

Here is the caller graph for this function:

wants_enter_leave_snapshots()

bool Slic3r::GUI::GLGizmoAssembly::wants_enter_leave_snapshots ( ) const

inlineoverridevirtual

Apply rotation on select plane.

Parameters

mouse_event

Keep information about mouse click

Returns

Return True when use the information otherwise False.

Reimplemented from Slic3r::GUI::GLGizmoBase.

{ return true; }

Member Data Documentation

AXES_COLOR

std::array< ColorRGBA, 3 > Slic3r::GUI::GLGizmoBase::AXES_COLOR

staticinherited

Initial value:

= {{
    ColorRGBA::X(),
    ColorRGBA::Y(),
    ColorRGBA::Z()
}}

Referenced by Slic3r::GUI::get_color(), load_render_colors(), Slic3r::GUI::GLGizmoRotate3D::on_init(), Slic3r::GUI::GLGizmoMove3D::on_render(), Slic3r::GUI::GLGizmoRotate::on_render(), Slic3r::GUI::GLGizmoScale3D::update_grabbers_data(), and update_render_colors().

AXES_HOVER_COLOR

std::array< ColorRGBA, 3 > Slic3r::GUI::GLGizmoBase::AXES_HOVER_COLOR

staticinherited

Initial value:

= {{
    {ColorRGBA::X().r() * 1.2f, ColorRGBA::X().g() * 1.4f, ColorRGBA::X().b() * 1.4f, 1.0f},
    {ColorRGBA::Y().r() * 1.2f, ColorRGBA::Y().g() * 1.2f, ColorRGBA::Y().b() * 1.2f, 1.0f},
    {ColorRGBA::Z().r() * 1.2f, ColorRGBA::Z().g() * 1.2f, ColorRGBA::Z().b() * 1.2f, 1.0f},
}}

Referenced by Slic3r::GUI::GLGizmoMove3D::on_render(), Slic3r::GUI::GLGizmoRotate::on_render(), and Slic3r::GUI::GLGizmoScale3D::update_grabbers_data().

BASE_ID

const unsigned int Slic3r::GUI::GLGizmoBase::BASE_ID = 255 * 255 * 254

staticinherited

CONSTRAINED_COLOR

ColorRGBA Slic3r::GUI::GLGizmoBase::CONSTRAINED_COLOR = {0.5f, 0.5f, 0.5f, 1.0f}

staticinherited

Referenced by Slic3r::GUI::GLGizmoScale3D::update_grabbers_data().

count

int Slic3r::GUI::GLGizmoBase::count = 0

privateinherited

Referenced by get_count(), Slic3r::GUI::GLGizmoTextureDisplacement::pick_mixes(), Slic3r::GUI::GLGizmoTextureDisplacement::push_uv_pane_state(), Slic3r::GUI::GLGizmoMove3D::render_align_preview(), Slic3r::GUI::GLGizmoTextureDisplacement::render_texture_library_popup(), and Slic3r::GUI::GLGizmoTextureDisplacement::texture_volume_raycaster_index().

DEFAULT_BASE_COLOR

ColorRGBA Slic3r::GUI::GLGizmoBase::DEFAULT_BASE_COLOR = { 0.625f, 0.625f, 0.625f, 1.0f }

staticinherited

DEFAULT_DRAG_COLOR

ColorRGBA Slic3r::GUI::GLGizmoBase::DEFAULT_DRAG_COLOR = { 1.0f, 1.0f, 1.0f, 1.0f }

staticinherited

Referenced by Slic3r::GUI::GLGizmoRotate::GLGizmoRotate().

DEFAULT_HIGHLIGHT_COLOR

ColorRGBA Slic3r::GUI::GLGizmoBase::DEFAULT_HIGHLIGHT_COLOR = {1.0f, 0.38f, 0.0f, 1.0f}

staticinherited

Referenced by Slic3r::GUI::GLGizmoRotate::GLGizmoRotate().

FLATTEN_COLOR

ColorRGBA Slic3r::GUI::GLGizmoBase::FLATTEN_COLOR = {0.96f, 0.93f, 0.93f, 0.5f}

staticinherited

Referenced by load_render_colors(), Slic3r::GUI::GLGizmoFlatten::on_render(), and update_render_colors().

FLATTEN_HOVER_COLOR

ColorRGBA Slic3r::GUI::GLGizmoBase::FLATTEN_HOVER_COLOR = {1.0f, 1.0f, 1.0f, 0.75f}

staticinherited

Referenced by load_render_colors(), Slic3r::GUI::GLGizmoFlatten::on_render(), and update_render_colors().

GRABBER_ELEMENTS_MAX_COUNT

const unsigned int Slic3r::GUI::GLGizmoBase::GRABBER_ELEMENTS_MAX_COUNT = 7

staticinherited

GRABBER_HOVER_COL

ColorRGBA Slic3r::GUI::GLGizmoBase::GRABBER_HOVER_COL = {0.863f, 0.125f, 0.063f, 1.0f}

staticinherited

GRABBER_NORMAL_COL

ColorRGBA Slic3r::GUI::GLGizmoBase::GRABBER_NORMAL_COL = {1.0f, 1.0f, 1.0f, 1.0f}

staticinherited

GRABBER_UNIFORM_COL

ColorRGBA Slic3r::GUI::GLGizmoBase::GRABBER_UNIFORM_COL = {0, 1.0, 1.0, 1.0f}

staticinherited

Referenced by Slic3r::GUI::GLGizmoScale3D::update_grabbers_data().

GRABBER_UNIFORM_HOVER_COL

ColorRGBA Slic3r::GUI::GLGizmoBase::GRABBER_UNIFORM_HOVER_COL = {0, 0.7, 0.7, 1.0f}

staticinherited

Referenced by Slic3r::GUI::GLGizmoScale3D::update_grabbers_data().

INV_ZOOM

float Slic3r::GUI::GLGizmoBase::INV_ZOOM = 1.0f

staticinherited

Referenced by Slic3r::GUI::GLCanvas3D::_render_current_gizmo(), Slic3r::GUI::get_grabber_mean_size(), Slic3r::GUI::GLGizmoMove3D::on_render(), and Slic3r::GUI::GLGizmoBase::Grabber::render().

last_input_window_width

float Slic3r::GUI::GLGizmoBase::last_input_window_width = 0

protectedinherited

Referenced by GizmoImguiEnd(), and GizmoImguiSetNextWIndowPos().

m_assembly_action

Measure::AssemblyAction Slic3r::GUI::GLGizmoMeasure::m_assembly_action

protectedinherited

Referenced by set_to_around_center_of_faces(), set_to_parallel(), set_to_reverse_rotation(), show_face_face_assembly_common(), show_face_face_assembly_senior(), and update_measurement_result().

m_assembly_mode

AssemblyMode Slic3r::GUI::GLGizmoMeasure::m_assembly_mode {AssemblyMode::FACE_FACE}

protectedinherited

{AssemblyMode::FACE_FACE};

Referenced by is_pick_meet_assembly_mode(), on_render(), Slic3r::GUI::GLGizmoAssembly::render_assembly_mode_combo(), render_dimensioning(), Slic3r::GUI::GLGizmoAssembly::render_input_window_warning(), show_distance_xyz_ui(), show_selection_ui(), and Slic3r::GUI::GLGizmoAssembly::switch_to_mode().

m_buffered_around_center

double Slic3r::GUI::GLGizmoMeasure::m_buffered_around_center {0}

protectedinherited

{0};

Referenced by show_face_face_assembly_senior().

m_buffered_distance

Vec3d Slic3r::GUI::GLGizmoMeasure::m_buffered_distance

protectedinherited

Referenced by show_distance_xyz_ui(), and update_measurement_result().

m_buffered_parallel_distance

double Slic3r::GUI::GLGizmoMeasure::m_buffered_parallel_distance {0}

protectedinherited

{0};

Referenced by show_face_face_assembly_senior(), and update_measurement_result().

m_c

CommonGizmosDataPool* Slic3r::GUI::GLGizmoBase::m_c { nullptr }

protectedinherited

{ nullptr };

Referenced by Slic3r::GUI::GLGizmoTextureDisplacement::apply_projection_frame(), Slic3r::GUI::GLGizmoTextureDisplacement::bake(), Slic3r::GUI::GLGizmoTextureDisplacement::capture_view_projection(), Slic3r::GUI::GLGizmoCut3D::check_and_update_connectors_state(), Slic3r::GUI::GLGizmoBrimEars::data_changed(), Slic3r::GUI::GLGizmoCut3D::data_changed(), Slic3r::GUI::GLGizmoMmuSegmentation::data_changed(), Slic3r::GUI::GLGizmoPainterBase::data_changed(), Slic3r::GUI::GLGizmoCut3D::dragging_connector(), Slic3r::GUI::GLGizmoMeshBoolean::generate_new_volume(), Slic3r::GUI::GLGizmoPainterBase::get_clipping_plane_data(), Slic3r::GUI::GLGizmoPainterBase::get_clipping_plane_in_volume_coordinates(), Slic3r::GUI::GLGizmoBrimEars::get_config_options(), Slic3r::GUI::GLGizmoPainterBase::get_projected_height_range(), Slic3r::GUI::GLGizmoPainterBase::get_projected_mouse_positions(), Slic3r::GUI::GLGizmoFdmSupports::get_selection_support_threshold_angle(), Slic3r::GUI::GLGizmoBrimEars::gizmo_event(), Slic3r::GUI::GLGizmoCut3D::gizmo_event(), Slic3r::GUI::GLGizmoMeshBoolean::gizmo_event(), Slic3r::GUI::GLGizmoPainterBase::gizmo_event(), Slic3r::GUI::GLGizmoCut3D::has_valid_contour(), Slic3r::GUI::GLGizmoSimplify::init_model(), Slic3r::GUI::GLGizmoMmuSegmentation::init_model_triangle_selectors(), Slic3r::GUI::GLGizmoFdmSupports::init_print_instance(), Slic3r::GUI::GLGizmoBrimEars::is_mesh_point_clipped(), Slic3r::GUI::GLGizmoPainterBase::is_mesh_point_clipped(), Slic3r::GUI::GLGizmoCut3D::is_outside_of_cut_contour(), Slic3r::GUI::GLGizmoFlatten::is_plane_update_necessary(), Slic3r::GUI::GLGizmoPainterBase::mesh_trafo_matrices(), Slic3r::GUI::GLGizmoFdmSupports::need_regenerate_support_volumes(), Slic3r::GUI::GLGizmoMeshBoolean::on_get_requirements(), Slic3r::GUI::GLGizmoMeshBoolean::on_load(), Slic3r::GUI::GLGizmoTextureDisplacement::on_mouse_adjust_texture(), Slic3r::GUI::GLGizmoCut3D::on_register_raycasters_for_picking(), Slic3r::GUI::GLGizmoBrimEars::on_render(), Slic3r::GUI::GLGizmoMeshBoolean::on_render(), Slic3r::GUI::GLGizmoBrimEars::on_render_input_window(), Slic3r::GUI::GLGizmoCut3D::on_render_input_window(), Slic3r::GUI::GLGizmoFdmSupports::on_render_input_window(), Slic3r::GUI::GLGizmoFuzzySkin::on_render_input_window(), Slic3r::GUI::GLGizmoMmuSegmentation::on_render_input_window(), Slic3r::GUI::GLGizmoSeam::on_render_input_window(), Slic3r::GUI::GLGizmoTextureDisplacement::on_render_input_window(), Slic3r::GUI::GLGizmoCut3D::on_set_state(), Slic3r::GUI::GLGizmoFdmSupports::on_set_state(), Slic3r::GUI::GLGizmoMmuSegmentation::on_set_state(), Slic3r::GUI::GLGizmoSeam::on_set_state(), Slic3r::GUI::GLGizmoTextureDisplacement::preview_part(), Slic3r::GUI::GLGizmoCut3D::process_contours(), Slic3r::GUI::GLGizmoCut3D::process_selection_rectangle(), Slic3r::GUI::GLGizmoCut3D::put_connectors_on_cut_plane(), Slic3r::GUI::GLGizmoTextureDisplacement::queue_prepare(), Slic3r::GUI::GLGizmoBrimEars::reload_cache(), Slic3r::GUI::GLGizmoMmuSegmentation::remap_filament_assignments(), Slic3r::GUI::GLGizmoTextureDisplacement::render_adjust_texture_gizmo(), Slic3r::GUI::GLGizmoCut3D::render_clipper_cut(), Slic3r::GUI::GLGizmoCut3D::render_connectors(), Slic3r::GUI::GLGizmoCut3D::render_debug_input_window(), Slic3r::GUI::GLGizmoPainterBase::render_follows_cursor(), Slic3r::GUI::GLGizmoTextureDisplacement::render_island_overlay(), Slic3r::GUI::GLGizmoTextureDisplacement::render_paint_overlay(), Slic3r::GUI::GLGizmoTextureDisplacement::render_painted_colors(), Slic3r::GUI::GLGizmoFdmSupports::render_painter_gizmo(), Slic3r::GUI::GLGizmoFuzzySkin::render_painter_gizmo(), Slic3r::GUI::GLGizmoMmuSegmentation::render_painter_gizmo(), Slic3r::GUI::GLGizmoSeam::render_painter_gizmo(), Slic3r::GUI::GLGizmoTextureDisplacement::render_painter_gizmo(), Slic3r::GUI::GLGizmoBrimEars::render_points(), Slic3r::GUI::GLGizmoTextureDisplacement::render_preview_mesh(), Slic3r::GUI::GLGizmoTextureDisplacement::render_seam_overlay(), Slic3r::GUI::GLGizmoTextureDisplacement::render_shaded_preview_mesh(), Slic3r::GUI::GLGizmoTextureDisplacement::render_subdivide_preview(), Slic3r::GUI::GLGizmoPainterBase::render_triangles(), Slic3r::GUI::GLGizmoTextureDisplacement::render_uvcheck_mesh(), Slic3r::GUI::GLGizmoTextureDisplacement::render_wireframe_overlay(), Slic3r::GUI::GLGizmoCut3D::reset_connectors(), Slic3r::GUI::GLGizmoFdmSupports::run_thread(), Slic3r::GUI::GLGizmoTextureDisplacement::seam_edge_at(), Slic3r::GUI::GLGizmoTextureDisplacement::seam_vertex_at(), Slic3r::GUI::GLGizmoFdmSupports::select_facets_by_angle(), Slic3r::GUI::GLGizmoTextureDisplacement::select_visible_faces(), Slic3r::GUI::GLGizmoTextureDisplacement::select_whole_model(), Slic3r::GUI::GLGizmoBrimEars::set_brim_data(), set_common_data_pool(), Slic3r::GUI::GLGizmoCut3D::set_connectors_editing(), Slic3r::GUI::GLGizmoTextureDisplacement::shaded_preview_ready(), Slic3r::GUI::GLGizmoTextureDisplacement::smooth_model(), Slic3r::GUI::GLGizmoTextureDisplacement::subdivide_model(), Slic3r::GUI::GLGizmoTextureDisplacement::swap_layer_slots(), Slic3r::GUI::GLGizmoCut3D::switch_to_mode(), Slic3r::GUI::GLGizmoTextureDisplacement::texture_parts(), Slic3r::GUI::GLGizmoTextureDisplacement::texture_volume(), Slic3r::GUI::GLGizmoTextureDisplacement::texture_volume_raycaster_index(), Slic3r::GUI::GLGizmoCut3D::unproject_on_cut_plane(), Slic3r::GUI::GLGizmoBrimEars::unproject_on_mesh(), Slic3r::GUI::GLGizmoBrimEars::unproject_on_mesh2(), Slic3r::GUI::GLGizmoCut3D::update_bb(), Slic3r::GUI::GLGizmoCut3D::update_clipper(), Slic3r::GUI::GLGizmoFdmSupports::update_from_model_object(), Slic3r::GUI::GLGizmoFuzzySkin::update_from_model_object(), Slic3r::GUI::GLGizmoSeam::update_from_model_object(), Slic3r::GUI::GLGizmoTextureDisplacement::update_from_model_object(), Slic3r::GUI::GLGizmoBrimEars::update_model_object(), Slic3r::GUI::GLGizmoFdmSupports::update_model_object(), Slic3r::GUI::GLGizmoFuzzySkin::update_model_object(), Slic3r::GUI::GLGizmoMmuSegmentation::update_model_object(), Slic3r::GUI::GLGizmoSeam::update_model_object(), Slic3r::GUI::GLGizmoTextureDisplacement::update_model_object(), Slic3r::GUI::GLGizmoFlatten::update_planes(), Slic3r::GUI::GLGizmoPainterBase::update_raycast_cache(), and Slic3r::GUI::GLGizmoCut3D::update_raycasters_for_picking_transform().

m_can_set_xyz_distance

bool Slic3r::GUI::GLGizmoMeasure::m_can_set_xyz_distance {false}

protectedinherited

{false};

Referenced by show_distance_xyz_ui(), and update_measurement_result().

m_curr_circle

CircleGLModel Slic3r::GUI::GLGizmoMeasure::m_curr_circle

protectedinherited

Referenced by init_circle_glmodel(), and on_render().

m_curr_feature

std::optional<Measure::SurfaceFeature> Slic3r::GUI::GLGizmoMeasure::m_curr_feature

protectedinherited

Referenced by on_mouse(), on_render(), Slic3r::GUI::GLGizmoAssembly::on_render_input_window(), on_render_input_window(), and on_set_state().

m_curr_measuring

std::shared_ptr<Measure::Measuring> Slic3r::GUI::GLGizmoMeasure::m_curr_measuring {nullptr}

protectedinherited

{nullptr};

Referenced by on_render().

m_curr_plane

PlaneGLModel Slic3r::GUI::GLGizmoMeasure::m_curr_plane

protectedinherited

Referenced by on_render().

m_curr_point_on_feature_position

std::optional<Vec3d> Slic3r::GUI::GLGizmoMeasure::m_curr_point_on_feature_position

protectedinherited

Referenced by on_mouse(), on_render(), and on_set_state().

m_current_active_imgui_id

unsigned int Slic3r::GUI::GLGizmoMeasure::m_current_active_imgui_id

mutableprotectedinherited

Referenced by Slic3r::GUI::GLGizmoAssembly::on_render_input_window(), on_render_input_window(), show_distance_xyz_ui(), and show_face_face_assembly_senior().

m_cylinder

PickingModel Slic3r::GUI::GLGizmoMeasure::m_cylinder

protectedinherited

Referenced by GLGizmoMeasure(), and on_render().

m_dimensioning

Dimensioning Slic3r::GUI::GLGizmoMeasure::m_dimensioning

protectedinherited

Referenced by render_dimensioning().

m_dirty

bool Slic3r::GUI::GLGizmoBase::m_dirty { false }

privateinherited

{ false };

Referenced by set_dirty(), and update_items_state().

m_distance

Vec3d Slic3r::GUI::GLGizmoMeasure::m_distance

protectedinherited

Referenced by on_set_state(), show_distance_xyz_ui(), and update_measurement_result().

m_dragging

bool Slic3r::GUI::GLGizmoBase::m_dragging { false }

protectedinherited

{ false };

Referenced by do_stop_dragging(), Slic3r::GUI::GLGizmoCut3D::get_tooltip(), is_dragging(), Slic3r::GUI::GLGizmoRotate3D::on_mouse(), Slic3r::GUI::GLGizmoScale3D::on_mouse(), Slic3r::GUI::GLGizmoEmboss::on_mouse_for_rotation(), Slic3r::GUI::GLGizmoSVG::on_mouse_for_rotation(), Slic3r::GUI::GLGizmoEmboss::on_render(), Slic3r::GUI::GLGizmoSVG::on_render(), Slic3r::GUI::GLGizmoCut3D::render_cut_plane_grabbers(), Slic3r::GUI::GLGizmoCut3D::render_rotation_snapping(), Slic3r::GUI::GLGizmoCut3D::reset_cut_by_contours(), set_hover_id(), and use_grabbers().

m_editing_distance

bool Slic3r::GUI::GLGizmoMeasure::m_editing_distance { false }

protectedinherited

{ false };

Referenced by data_changed(), on_render(), Slic3r::GUI::GLGizmoAssembly::on_render_input_window(), on_render_input_window(), on_set_state(), render_dimensioning(), and render_follows_cursor().

m_feature_circle_first

CircleGLModel Slic3r::GUI::GLGizmoMeasure::m_feature_circle_first

protectedinherited

Referenced by on_render(), reset_feature1_render(), and update_feature_by_tran().

m_feature_circle_second

CircleGLModel Slic3r::GUI::GLGizmoMeasure::m_feature_circle_second

protectedinherited

Referenced by on_render(), reset_feature2_render(), and update_feature_by_tran().

m_feature_plane_first

PlaneGLModel Slic3r::GUI::GLGizmoMeasure::m_feature_plane_first

protectedinherited

Referenced by on_render(), and reset_feature1_render().

m_feature_plane_second

PlaneGLModel Slic3r::GUI::GLGizmoMeasure::m_feature_plane_second

protectedinherited

Referenced by on_render(), and reset_feature2_render().

m_first_input_window_render

bool Slic3r::GUI::GLGizmoBase::m_first_input_window_render { true }

protectedinherited

{ true };

Referenced by render_input_window().

m_flip_volume_2

bool Slic3r::GUI::GLGizmoMeasure::m_flip_volume_2 {false}

protectedinherited

{false};

Referenced by show_face_face_assembly_senior().

m_grabbers

std::vector<Grabber> Slic3r::GUI::GLGizmoBase::m_grabbers

mutableprotectedinherited

Referenced by Slic3r::GUI::GLGizmoMove3D::data_changed(), Slic3r::GUI::GLGizmoScale3D::data_changed(), Slic3r::GUI::GLGizmoRotate::disable_grabber(), do_stop_dragging(), Slic3r::GUI::GLGizmoRotate::enable_grabber(), Slic3r::GUI::GLGizmoScale3D::enable_ununiversal_scale(), Slic3r::GUI::GLGizmoMove3D::get_tooltip(), Slic3r::GUI::GLGizmoRotate::get_tooltip(), Slic3r::GUI::GLGizmoScale3D::get_tooltip(), Slic3r::GUI::GLGizmoCut3D::on_init(), Slic3r::GUI::GLGizmoMove3D::on_init(), Slic3r::GUI::GLGizmoRotate::on_init(), Slic3r::GUI::GLGizmoScale3D::on_init(), Slic3r::GUI::GLGizmoMove3D::on_render(), Slic3r::GUI::GLGizmoRotate::on_render(), Slic3r::GUI::GLGizmoScale3D::on_render(), Slic3r::GUI::GLGizmoMove3D::on_start_dragging(), Slic3r::GUI::GLGizmoScale3D::on_start_dragging(), Slic3r::GUI::GLGizmoBrimEars::on_unregister_raycasters_for_picking(), register_grabbers_for_picking(), Slic3r::GUI::GLGizmoRotate::render_grabber(), Slic3r::GUI::GLGizmoRotate::render_grabber_connection(), render_grabbers(), render_grabbers(), Slic3r::GUI::GLGizmoScale3D::render_grabbers_connection(), Slic3r::GUI::GLGizmoBrimEars::render_points(), Slic3r::GUI::GLGizmoRotate::start_dragging(), Slic3r::GUI::GLGizmoRotate::stop_dragging(), unregister_grabbers_for_picking(), Slic3r::GUI::GLGizmoScale3D::update_grabbers_data(), Slic3r::GUI::GLGizmoBrimEars::update_raycasters(), and use_grabbers().

m_gripper_id_raycast_map

std::map<GripperType, std::shared_ptr<PickRaycaster> > Slic3r::GUI::GLGizmoMeasure::m_gripper_id_raycast_map

protectedinherited

Referenced by GLGizmoMeasure(), disable_scene_raycasters(), init_circle_glmodel(), init_plane_glmodel(), on_mouse(), on_render(), render_follows_cursor(), reset_gripper_pick(), and restore_scene_raycasters_state().

m_group_id

int Slic3r::GUI::GLGizmoBase::m_group_id

protectedinherited

Referenced by GLGizmoBase(), Slic3r::GUI::GLGizmoRotate::GLGizmoRotate(), register_grabbers_for_picking(), and Slic3r::GUI::GLGizmoRotate::set_group_id().

m_hit_different_volumes

std::vector<GLVolume*> Slic3r::GUI::GLGizmoMeasure::m_hit_different_volumes

protectedinherited

Referenced by is_two_volume_in_same_model_object(), on_render(), render_dimensioning(), Slic3r::GUI::GLGizmoAssembly::render_input_window_warning(), reset_all_feature(), reset_feature1(), reset_feature2(), set_distance(), set_parallel_distance(), set_to_around_center_of_faces(), set_to_center_coincidence(), set_to_parallel(), set_to_reverse_rotation(), show_distance_xyz_ui(), show_face_face_assembly_common(), and show_face_face_assembly_senior().

m_hit_order_volumes

std::vector<GLVolume*> Slic3r::GUI::GLGizmoMeasure::m_hit_order_volumes

protectedinherited

Referenced by get_measuring_of_mesh(), on_render(), reset_all_feature(), reset_feature1(), and reset_feature2().

m_hover_id

int Slic3r::GUI::GLGizmoBase::m_hover_id { -1 }

protectedinherited

{ -1 };

Referenced by Slic3r::GUI::GLGizmoScale3D::calc_ratio(), Slic3r::GUI::GLGizmoScale3D::do_scale_along_axis(), Slic3r::GUI::GLGizmoScale3D::do_scale_uniform(), Slic3r::GUI::GLGizmoCut3D::dragging_connector(), Slic3r::GUI::GLGizmoCut3D::dragging_grabber_move(), Slic3r::GUI::GLGizmoCut3D::dragging_grabber_rotation(), get_hover_id(), Slic3r::GUI::GLGizmoCut3D::get_tooltip(), Slic3r::GUI::GLGizmoMove3D::get_tooltip(), Slic3r::GUI::GLGizmoRotate::get_tooltip(), Slic3r::GUI::GLGizmoScale3D::get_tooltip(), Slic3r::GUI::GLGizmoBrimEars::gizmo_event(), Slic3r::GUI::GLGizmoCut3D::gizmo_event(), Slic3r::GUI::GLGizmoCut3D::is_selection_changed(), Slic3r::GUI::GLGizmoBrimEars::on_dragging(), Slic3r::GUI::GLGizmoCut3D::on_dragging(), Slic3r::GUI::GLGizmoMove3D::on_dragging(), Slic3r::GUI::GLGizmoRotate3D::on_dragging(), Slic3r::GUI::GLGizmoScale3D::on_dragging(), Slic3r::GUI::GLGizmoCut3D::on_mouse(), Slic3r::GUI::GLGizmoFlatten::on_mouse(), Slic3r::GUI::GLGizmoMeasure::on_mouse(), Slic3r::GUI::GLGizmoFlatten::on_render(), Slic3r::GUI::GLGizmoMeasure::on_render(), Slic3r::GUI::GLGizmoMove3D::on_render(), Slic3r::GUI::GLGizmoRotate3D::on_render(), Slic3r::GUI::GLGizmoRotate::on_render(), Slic3r::GUI::GLGizmoScale3D::on_render(), Slic3r::GUI::GLGizmoBrimEars::on_set_hover_id(), Slic3r::GUI::GLGizmoEmboss::on_set_hover_id(), Slic3r::GUI::GLGizmoRotate3D::on_set_hover_id(), Slic3r::GUI::GLGizmoSVG::on_set_hover_id(), Slic3r::GUI::GLGizmoMeasure::on_set_state(), Slic3r::GUI::GLGizmoBrimEars::on_start_dragging(), Slic3r::GUI::GLGizmoCut3D::on_start_dragging(), Slic3r::GUI::GLGizmoMove3D::on_start_dragging(), Slic3r::GUI::GLGizmoRotate3D::on_start_dragging(), Slic3r::GUI::GLGizmoScale3D::on_start_dragging(), Slic3r::GUI::GLGizmoBrimEars::on_stop_dragging(), Slic3r::GUI::GLGizmoCut3D::on_stop_dragging(), Slic3r::GUI::GLGizmoRotate3D::on_stop_dragging(), Slic3r::GUI::GLGizmoCut3D::render_connectors(), Slic3r::GUI::GLGizmoCut3D::render_cut_plane_grabbers(), Slic3r::GUI::GLGizmoCut3D::render_flip_plane_button(), render_grabbers(), Slic3r::GUI::GLGizmoBrimEars::render_points(), set_hover_id(), Slic3r::GUI::GLGizmoMeasure::show_selection_ui(), Slic3r::GUI::GLGizmoScale3D::update_grabbers_data(), and use_grabbers().

m_icon_filename

std::string Slic3r::GUI::GLGizmoBase::m_icon_filename

protectedinherited

Referenced by GLGizmoBase(), get_icon_filename(), and set_icon_filename().

m_imgui

ImGuiWrapper* Slic3r::GUI::GLGizmoBase::m_imgui

protectedinherited

Referenced by GLGizmoBase(), Slic3r::GUI::GLGizmoEmboss::GLGizmoEmboss(), Slic3r::GUI::GLGizmoCut3D::add_horizontal_scaled_interval(), Slic3r::GUI::GLGizmoCut3D::add_vertical_scaled_interval(), Slic3r::GUI::GLGizmoSimplify::create_gui_cfg(), Slic3r::GUI::GLGizmoEmboss::draw_advanced(), Slic3r::GUI::GLGizmoEmboss::draw_bold_button(), Slic3r::GUI::GLGizmoEmboss::draw_delete_style_button(), Slic3r::GUI::GLGizmoSVG::draw_depth(), Slic3r::GUI::GLGizmoSVG::draw_distance(), Slic3r::GUI::GLGizmoSVG::draw_filename(), Slic3r::GUI::GLGizmoEmboss::draw_font_list(), Slic3r::GUI::GLGizmoEmboss::draw_font_list_line(), Slic3r::GUI::GLGizmoEmboss::draw_italic_button(), Slic3r::GUI::GLGizmoSVG::draw_mirroring(), Slic3r::GUI::GLGizmoEmboss::draw_model_type(), Slic3r::GUI::GLGizmoSVG::draw_model_type(), Slic3r::GUI::GLGizmoSVG::draw_rotation(), Slic3r::GUI::GLGizmoSVG::draw_size(), Slic3r::GUI::GLGizmoEmboss::draw_style_add_button(), Slic3r::GUI::GLGizmoEmboss::draw_style_list(), Slic3r::GUI::GLGizmoEmboss::draw_style_rename_button(), Slic3r::GUI::GLGizmoEmboss::draw_style_rename_popup(), Slic3r::GUI::GLGizmoEmboss::draw_style_save_as_popup(), Slic3r::GUI::GLGizmoEmboss::draw_style_save_button(), Slic3r::GUI::GLGizmoEmboss::draw_text_input(), Slic3r::GUI::GLGizmoSVG::draw_use_surface(), Slic3r::GUI::GLGizmoEmboss::draw_window(), GizmoImguiBegin(), GizmoImguiEnd(), GizmoImguiSetNextWIndowPos(), Slic3r::GUI::GLGizmoCut3D::init_input_window_data(), Slic3r::GUI::GLGizmoMeasure::on_mouse(), Slic3r::GUI::GLGizmoAssembly::on_render_input_window(), Slic3r::GUI::GLGizmoBrimEars::on_render_input_window(), Slic3r::GUI::GLGizmoEmboss::on_render_input_window(), Slic3r::GUI::GLGizmoFdmSupports::on_render_input_window(), Slic3r::GUI::GLGizmoFuzzySkin::on_render_input_window(), Slic3r::GUI::GLGizmoMeasure::on_render_input_window(), Slic3r::GUI::GLGizmoMeshBoolean::on_render_input_window(), Slic3r::GUI::GLGizmoMmuSegmentation::on_render_input_window(), Slic3r::GUI::GLGizmoMove3D::on_render_input_window(), Slic3r::GUI::GLGizmoRotate3D::on_render_input_window(), Slic3r::GUI::GLGizmoScale3D::on_render_input_window(), Slic3r::GUI::GLGizmoSeam::on_render_input_window(), Slic3r::GUI::GLGizmoSimplify::on_render_input_window(), Slic3r::GUI::GLGizmoSVG::on_render_input_window(), Slic3r::GUI::GLGizmoTextureDisplacement::on_render_input_window(), Slic3r::GUI::GLGizmoTextureDisplacement::panel_tooltip(), Slic3r::GUI::GLGizmoCut3D::render_angle_input(), Slic3r::GUI::GLGizmoCut3D::render_build_size(), Slic3r::GUI::GLGizmoCut3D::render_color_marker(), render_combo(), Slic3r::GUI::GLGizmoCut3D::render_connectors_input_window(), Slic3r::GUI::GLGizmoCut3D::render_cut_mode_combo(), Slic3r::GUI::GLGizmoCut3D::render_cut_plane_input_window(), Slic3r::GUI::GLGizmoCut3D::render_debug_input_window(), Slic3r::GUI::GLGizmoTextureDisplacement::render_debug_stage_panel(), Slic3r::GUI::GLGizmoMeasure::render_dimensioning(), Slic3r::GUI::GLGizmoCut3D::render_double_input(), Slic3r::GUI::GLGizmoMmuSegmentation::render_filament_remap_ui(), Slic3r::GUI::GLGizmoCut3D::render_flip_plane_button(), Slic3r::GUI::GLGizmoCut3D::render_groove_float_input(), Slic3r::GUI::GLGizmoCut3D::render_groove_int_input(), Slic3r::GUI::GLGizmoCut3D::render_groove_two_float_input(), Slic3r::GUI::GLGizmoTextureDisplacement::render_image_adjust_window(), Slic3r::GUI::GLGizmoAssembly::render_input_window_warning(), Slic3r::GUI::GLGizmoCut3D::render_input_window_warning(), Slic3r::GUI::GLGizmoCut3D::render_move_center_input(), Slic3r::GUI::GLGizmoCut3D::render_reset_button(), Slic3r::GUI::GLGizmoCut3D::render_slider_input(), Slic3r::GUI::GLGizmoCut3D::render_slider_two_input(), Slic3r::GUI::GLGizmoCut3D::render_snap_specific_input(), Slic3r::GUI::GLGizmoTextureDisplacement::render_texture_library_popup(), Slic3r::GUI::GLGizmoTextureDisplacement::render_tip_media(), Slic3r::GUI::GLGizmoCut3D::render_tooltip_button(), Slic3r::GUI::GLGizmoFdmSupports::render_tooltip_button(), Slic3r::GUI::GLGizmoFuzzySkin::render_tooltip_button(), Slic3r::GUI::GLGizmoMmuSegmentation::render_tooltip_button(), Slic3r::GUI::GLGizmoPainterBase::render_triangles(), Slic3r::GUI::GLGizmoEmboss::rev_checkbox(), Slic3r::GUI::GLGizmoEmboss::rev_input(), Slic3r::GUI::GLGizmoEmboss::rev_slider(), Slic3r::GUI::GLGizmoEmboss::rev_slider(), Slic3r::GUI::GLGizmoEmboss::rev_slider(), Slic3r::GUI::GLGizmoEmboss::revertible(), Slic3r::GUI::GLGizmoMeasure::show_distance_xyz_ui(), Slic3r::GUI::GLGizmoMeasure::show_face_face_assembly_common(), Slic3r::GUI::GLGizmoMeasure::show_face_face_assembly_senior(), and Slic3r::GUI::GLGizmoMeasure::show_selection_ui().

m_input_size_max

float Slic3r::GUI::GLGizmoMeasure::m_input_size_max

protectedinherited

Referenced by init_render_input_window(), show_distance_xyz_ui(), and show_face_face_assembly_senior().

m_is_dark_mode

bool Slic3r::GUI::GLGizmoBase::m_is_dark_mode = false

protectedinherited

Referenced by Slic3r::GUI::GLGizmoMmuSegmentation::draw_color_button(), on_change_color_mode(), Slic3r::GUI::GLGizmoEmboss::on_render_input_window(), Slic3r::GUI::GLGizmoFdmSupports::on_render_input_window(), Slic3r::GUI::GLGizmoFuzzySkin::on_render_input_window(), Slic3r::GUI::GLGizmoMeshBoolean::on_render_input_window(), Slic3r::GUI::GLGizmoMmuSegmentation::on_render_input_window(), Slic3r::GUI::GLGizmoSeam::on_render_input_window(), Slic3r::GUI::GLGizmoSVG::on_render_input_window(), Slic3r::GUI::GLGizmoEmboss::push_button_style(), Slic3r::GUI::GLGizmoMeasure::show_distance_xyz_ui(), and Slic3r::GUI::GLGizmoMeasure::show_selection_ui().

m_is_editing_distance_first_frame

bool Slic3r::GUI::GLGizmoMeasure::m_is_editing_distance_first_frame { true }

protectedinherited

{ true };

Referenced by data_changed(), on_set_state(), and render_dimensioning().

m_last_active_item_imgui

unsigned int Slic3r::GUI::GLGizmoMeasure::m_last_active_item_imgui {0}

protectedinherited

{0};

Referenced by Slic3r::GUI::GLGizmoAssembly::on_render_input_window(), on_render_input_window(), show_distance_xyz_ui(), and show_face_face_assembly_senior().

m_last_circle_feature

std::optional<Measure::SurfaceFeature> Slic3r::GUI::GLGizmoMeasure::m_last_circle_feature

protectedinherited

m_last_hit_volume

GLVolume* Slic3r::GUI::GLGizmoMeasure::m_last_hit_volume

protectedinherited

Referenced by on_render(), and reset_all_feature().

m_last_inv_zoom

float Slic3r::GUI::GLGizmoMeasure::m_last_inv_zoom { 0.0f }

protectedinherited

{ 0.0f };

Referenced by data_changed(), and on_render().

m_last_plane_idx

int Slic3r::GUI::GLGizmoMeasure::m_last_plane_idx { -1 }

protectedinherited

{ -1 };

Referenced by data_changed(), and on_render().

m_measure_mode

EMeasureMode Slic3r::GUI::GLGizmoMeasure::m_measure_mode {EMeasureMode::ONLY_MEASURE}

protectedinherited

{EMeasureMode::ONLY_MEASURE};

Referenced by Slic3r::GUI::GLGizmoAssembly::GLGizmoAssembly(), is_pick_meet_assembly_mode(), on_render(), render_dimensioning(), show_distance_xyz_ui(), show_face_face_assembly_common(), show_face_face_assembly_senior(), and show_selection_ui().

m_measurement_result

Measure::MeasurementResult Slic3r::GUI::GLGizmoMeasure::m_measurement_result

protectedinherited

Referenced by render_dimensioning(), show_distance_xyz_ui(), and update_measurement_result().

m_mesh_measure_map

std::map<GLVolume*, std::shared_ptr<Measure::Measuring> > Slic3r::GUI::GLGizmoMeasure::m_mesh_measure_map

protectedinherited

Referenced by get_measuring_of_mesh(), on_render(), on_set_state(), and register_single_mesh_pick().

m_mesh_raycaster_map

std::map<GLVolume*, std::shared_ptr<PickRaycaster> > Slic3r::GUI::GLGizmoMeasure::m_mesh_raycaster_map

protectedinherited

Referenced by get_measuring_of_mesh(), on_render(), register_single_mesh_pick(), render_follows_cursor(), and reset_all_pick().

m_mode

EMode Slic3r::GUI::GLGizmoMeasure::m_mode { EMode::FeatureSelection }

protectedinherited

{ EMode::FeatureSelection };

Referenced by gizmo_event(), on_mouse(), on_render(), Slic3r::GUI::GLGizmoAssembly::on_render_input_window(), on_render_input_window(), and on_set_state().

m_mouse_left_down

bool Slic3r::GUI::GLGizmoMeasure::m_mouse_left_down { false }

protectedinherited

{ false }; // for detection left_up of this gizmo

Referenced by on_mouse().

m_mouse_left_down_mesh_deal

bool Slic3r::GUI::GLGizmoMeasure::m_mouse_left_down_mesh_deal {false}

protectedinherited

{false};//for pick mesh

Referenced by on_mouse(), and on_render().

m_only_select_plane

bool Slic3r::GUI::GLGizmoMeasure::m_only_select_plane {false}

protectedinherited

{false};

Referenced by on_render(), on_set_state(), and show_selection_ui().

m_parent

GLCanvas3D& Slic3r::GUI::GLGizmoBase::m_parent

protectedinherited

Referenced by GLGizmoBase(), Slic3r::GUI::GLGizmoCut3D::add_connector(), Slic3r::GUI::GLGizmoTextureDisplacement::add_texture_layer(), Slic3r::GUI::GLGizmoCut3D::apply_color_clip_plane_colors(), Slic3r::GUI::GLGizmoTextureDisplacement::apply_projection_frame(), Slic3r::GUI::GLGizmoSimplify::apply_simplify(), Slic3r::GUI::GLGizmoTextureDisplacement::apply_view_mode(), Slic3r::GUI::GLGizmoBrimEars::auto_generate(), Slic3r::GUI::GLGizmoTextureDisplacement::bake(), Slic3r::GUI::GLGizmoCut3D::bounding_box(), Slic3r::GUI::GLGizmoPainterBase::bounding_box(), Slic3r::GUI::GLGizmoEmboss::calculate_scale(), Slic3r::GUI::GLGizmoSVG::calculate_scale(), Slic3r::GUI::GLGizmoTextureDisplacement::capture_view_projection(), Slic3r::GUI::GLGizmoMove3D::change_cs_by_selection(), Slic3r::GUI::GLGizmoScale3D::change_cs_by_selection(), Slic3r::GUI::GLGizmoEmboss::close(), Slic3r::GUI::GLGizmoSimplify::close(), Slic3r::GUI::GLGizmoSVG::close(), Slic3r::GUI::GLGizmoTextureDisplacement::close_image_adjust(), Slic3r::GUI::GLGizmoEmboss::create_volume(), Slic3r::GUI::GLGizmoEmboss::create_volume(), Slic3r::GUI::GLGizmoSVG::create_volume(), Slic3r::GUI::GLGizmoSVG::create_volume(), Slic3r::GUI::GLGizmoSVG::create_volume(), Slic3r::GUI::GLGizmoSVG::create_volume(), Slic3r::GUI::GLGizmoFlatten::data_changed(), Slic3r::GUI::GLGizmoMeasure::data_changed(), Slic3r::GUI::GLGizmoMove3D::data_changed(), Slic3r::GUI::GLGizmoPainterBase::data_changed(), Slic3r::GUI::GLGizmoRotate3D::data_changed(), Slic3r::GUI::GLGizmoScale3D::data_changed(), Slic3r::GUI::GLGizmoCut3D::delete_selected_connectors(), Slic3r::GUI::GLGizmoEmboss::do_mirror(), do_stop_dragging(), Slic3r::GUI::GLGizmoEmboss::draw_advanced(), Slic3r::GUI::GLGizmoSVG::draw_distance(), Slic3r::GUI::GLGizmoSVG::draw_face_the_camera(), Slic3r::GUI::GLGizmoSVG::draw_filename(), Slic3r::GUI::GLGizmoSVG::draw_mirroring(), Slic3r::GUI::GLGizmoEmboss::draw_model_type(), Slic3r::GUI::GLGizmoSVG::draw_model_type(), Slic3r::GUI::GLGizmoSVG::draw_rotation(), Slic3r::GUI::GLGizmoSVG::draw_size(), Slic3r::GUI::GLGizmoEmboss::draw_style_list(), Slic3r::GUI::GLGizmoEmboss::draw_window(), Slic3r::GUI::GLGizmoTextureDisplacement::ease_wheel_scroll(), Slic3r::GUI::GLGizmoBrimEars::find_single(), Slic3r::GUI::GLGizmoBrimEars::first_layer_slicer(), Slic3r::GUI::GLGizmoMeshBoolean::generate_new_volume(), Slic3r::GUI::GLGizmoPainterBase::get_projected_height_range(), Slic3r::GUI::GLGizmoMove3D::get_tooltip(), Slic3r::GUI::GLGizmoScale3D::get_tooltip(), Slic3r::GUI::GLGizmoBrimEars::gizmo_event(), Slic3r::GUI::GLGizmoMeasure::gizmo_event(), Slic3r::GUI::GLGizmoMeshBoolean::gizmo_event(), Slic3r::GUI::GLGizmoPainterBase::gizmo_event(), GizmoImguiSetNextWIndowPos(), Slic3r::GUI::GLGizmoCut3D::has_valid_groove(), Slic3r::GUI::GLGizmoSimplify::init_model(), Slic3r::GUI::GLGizmoMeasure::init_plane_glmodel(), Slic3r::GUI::GLGizmoFdmSupports::init_print_instance(), Slic3r::GUI::GLGizmoPainterBase::mesh_trafo_matrices(), Slic3r::GUI::GLGizmoTextureDisplacement::move_texture_layer(), Slic3r::GUI::GLGizmoMove3D::on_dragging(), Slic3r::GUI::GLGizmoAssembly::on_is_activable(), Slic3r::GUI::GLGizmoBrimEars::on_is_activable(), Slic3r::GUI::GLGizmoCut3D::on_is_activable(), Slic3r::GUI::GLGizmoFlatten::on_is_activable(), Slic3r::GUI::GLGizmoMeasure::on_is_activable(), Slic3r::GUI::GLGizmoMeshBoolean::on_is_activable(), Slic3r::GUI::GLGizmoMmuSegmentation::on_is_activable(), Slic3r::GUI::GLGizmoMove3D::on_is_activable(), Slic3r::GUI::GLGizmoPainterBase::on_is_activable(), Slic3r::GUI::GLGizmoRotate3D::on_is_activable(), Slic3r::GUI::GLGizmoScale3D::on_is_activable(), Slic3r::GUI::GLGizmoSimplify::on_is_activable(), Slic3r::GUI::GLGizmoTextureDisplacement::on_is_activable(), Slic3r::GUI::GLGizmoTextureDisplacement::on_island_edited(), Slic3r::GUI::GLGizmoCut3D::on_load(), Slic3r::GUI::GLGizmoBrimEars::on_mouse(), Slic3r::GUI::GLGizmoCut3D::on_mouse(), Slic3r::GUI::GLGizmoEmboss::on_mouse(), Slic3r::GUI::GLGizmoFlatten::on_mouse(), Slic3r::GUI::GLGizmoMeasure::on_mouse(), Slic3r::GUI::GLGizmoPainterBase::on_mouse(), Slic3r::GUI::GLGizmoRotate3D::on_mouse(), Slic3r::GUI::GLGizmoScale3D::on_mouse(), Slic3r::GUI::GLGizmoSVG::on_mouse(), Slic3r::GUI::GLGizmoTextureDisplacement::on_mouse_adjust_texture(), Slic3r::GUI::GLGizmoEmboss::on_mouse_change_selection(), Slic3r::GUI::GLGizmoEmboss::on_mouse_for_rotation(), Slic3r::GUI::GLGizmoSVG::on_mouse_for_rotation(), Slic3r::GUI::GLGizmoEmboss::on_mouse_for_translate(), Slic3r::GUI::GLGizmoSVG::on_mouse_for_translate(), Slic3r::GUI::GLGizmoTextureDisplacement::on_mouse_seam(), Slic3r::GUI::GLGizmoFdmSupports::on_opening(), Slic3r::GUI::GLGizmoCut3D::on_register_raycasters_for_picking(), Slic3r::GUI::GLGizmoFlatten::on_register_raycasters_for_picking(), Slic3r::GUI::GLGizmoMove3D::on_register_raycasters_for_picking(), Slic3r::GUI::GLGizmoRotate3D::on_register_raycasters_for_picking(), Slic3r::GUI::GLGizmoScale3D::on_register_raycasters_for_picking(), Slic3r::GUI::GLGizmoBrimEars::on_render(), Slic3r::GUI::GLGizmoCut3D::on_render(), Slic3r::GUI::GLGizmoEmboss::on_render(), Slic3r::GUI::GLGizmoFlatten::on_render(), Slic3r::GUI::GLGizmoMeasure::on_render(), Slic3r::GUI::GLGizmoMeshBoolean::on_render(), Slic3r::GUI::GLGizmoMove3D::on_render(), Slic3r::GUI::GLGizmoRotate::on_render(), Slic3r::GUI::GLGizmoSimplify::on_render(), Slic3r::GUI::GLGizmoSVG::on_render(), Slic3r::GUI::GLGizmoAssembly::on_render_input_window(), Slic3r::GUI::GLGizmoBrimEars::on_render_input_window(), Slic3r::GUI::GLGizmoCut3D::on_render_input_window(), Slic3r::GUI::GLGizmoEmboss::on_render_input_window(), Slic3r::GUI::GLGizmoFdmSupports::on_render_input_window(), Slic3r::GUI::GLGizmoFuzzySkin::on_render_input_window(), Slic3r::GUI::GLGizmoMeasure::on_render_input_window(), Slic3r::GUI::GLGizmoMeshBoolean::on_render_input_window(), Slic3r::GUI::GLGizmoMmuSegmentation::on_render_input_window(), Slic3r::GUI::GLGizmoSeam::on_render_input_window(), Slic3r::GUI::GLGizmoSimplify::on_render_input_window(), Slic3r::GUI::GLGizmoSVG::on_render_input_window(), Slic3r::GUI::GLGizmoTextureDisplacement::on_render_input_window(), Slic3r::GUI::GLGizmoCut3D::on_set_state(), Slic3r::GUI::GLGizmoEmboss::on_set_state(), Slic3r::GUI::GLGizmoMeasure::on_set_state(), Slic3r::GUI::GLGizmoMmuSegmentation::on_set_state(), Slic3r::GUI::GLGizmoPainterBase::on_set_state(), Slic3r::GUI::GLGizmoSimplify::on_set_state(), Slic3r::GUI::GLGizmoSVG::on_set_state(), Slic3r::GUI::GLGizmoEmboss::on_shortcut_key(), Slic3r::GUI::GLGizmoFdmSupports::on_shutdown(), Slic3r::GUI::GLGizmoFuzzySkin::on_shutdown(), Slic3r::GUI::GLGizmoMmuSegmentation::on_shutdown(), Slic3r::GUI::GLGizmoSeam::on_shutdown(), Slic3r::GUI::GLGizmoTextureDisplacement::on_shutdown(), Slic3r::GUI::GLGizmoMove3D::on_start_dragging(), Slic3r::GUI::GLGizmoRotate::on_start_dragging(), Slic3r::GUI::GLGizmoEmboss::on_stop_dragging(), Slic3r::GUI::GLGizmoMove3D::on_stop_dragging(), Slic3r::GUI::GLGizmoRotate3D::on_stop_dragging(), Slic3r::GUI::GLGizmoScale3D::on_stop_dragging(), Slic3r::GUI::GLGizmoSVG::on_stop_dragging(), Slic3r::GUI::GLGizmoBrimEars::on_unregister_raycasters_for_picking(), Slic3r::GUI::GLGizmoCut3D::on_unregister_raycasters_for_picking(), Slic3r::GUI::GLGizmoFlatten::on_unregister_raycasters_for_picking(), Slic3r::GUI::GLGizmoMove3D::on_unregister_raycasters_for_picking(), Slic3r::GUI::GLGizmoRotate3D::on_unregister_raycasters_for_picking(), Slic3r::GUI::GLGizmoScale3D::on_unregister_raycasters_for_picking(), Slic3r::GUI::GLGizmoTextureDisplacement::on_uv_command(), Slic3r::GUI::GLGizmoTextureDisplacement::panel_tooltip(), Slic3r::GUI::GLGizmoCut3D::perform_cut(), Slic3r::GUI::GLGizmoEmboss::process(), Slic3r::GUI::GLGizmoSVG::process(), Slic3r::GUI::GLGizmoCut3D::process_contours(), Slic3r::GUI::GLGizmoCut3D::process_cut_line(), Slic3r::GUI::GLGizmoTextureDisplacement::queue_prepare(), Slic3r::GUI::GLGizmoTextureDisplacement::queue_preview_job(), Slic3r::GUI::GLGizmoBrimEars::register_single_mesh_pick(), Slic3r::GUI::GLGizmoMeasure::register_single_mesh_pick(), Slic3r::GUI::GLGizmoEmboss::reinit_text_lines(), Slic3r::GUI::GLGizmoMmuSegmentation::remap_filament_assignments(), Slic3r::GUI::GLGizmoTextureDisplacement::remove_texture_layer(), Slic3r::GUI::GLGizmoTextureDisplacement::render_adjust_texture_gizmo(), Slic3r::GUI::GLGizmoMove3D::render_align_preview(), Slic3r::GUI::GLGizmoAssembly::render_assembly_mode_combo(), render_combo(), Slic3r::GUI::GLGizmoCut3D::render_connectors_input_window(), Slic3r::GUI::GLGizmoPainterBase::render_cursor(), Slic3r::GUI::GLGizmoPainterBase::render_cursor_circle(), Slic3r::GUI::GLGizmoPainterBase::render_cursor_height_range(), Slic3r::GUI::GLGizmoCut3D::render_cut_mode_combo(), Slic3r::GUI::GLGizmoCut3D::render_cut_plane_input_window(), Slic3r::GUI::GLGizmoMeasure::render_dimensioning(), Slic3r::GUI::GLGizmoMeasure::render_follows_cursor(), Slic3r::GUI::GLGizmoPainterBase::render_follows_cursor(), Slic3r::GUI::GLGizmoTextureDisplacement::render_image_adjust_window(), render_input_window(), Slic3r::GUI::GLGizmoTextureDisplacement::render_island_overlay(), Slic3r::GUI::GLGizmoTextureDisplacement::render_paint_overlay(), Slic3r::GUI::GLGizmoTextureDisplacement::render_painted_colors(), Slic3r::GUI::GLGizmoFdmSupports::render_painter_gizmo(), Slic3r::GUI::GLGizmoFuzzySkin::render_painter_gizmo(), Slic3r::GUI::GLGizmoMmuSegmentation::render_painter_gizmo(), Slic3r::GUI::GLGizmoSeam::render_painter_gizmo(), Slic3r::GUI::GLGizmoTextureDisplacement::render_painter_gizmo(), Slic3r::GUI::GLGizmoTextureDisplacement::render_preview_mesh(), Slic3r::GUI::GLGizmoTextureDisplacement::render_seam_overlay(), Slic3r::GUI::GLGizmoTextureDisplacement::render_shaded_preview_mesh(), Slic3r::GUI::GLGizmoTextureDisplacement::render_subdivide_preview(), Slic3r::GUI::GLGizmoTextureDisplacement::render_texture_library_popup(), Slic3r::GUI::GLGizmoTextureDisplacement::render_tip_media(), Slic3r::GUI::GLGizmoCut3D::render_tooltip_button(), Slic3r::GUI::GLGizmoFdmSupports::render_tooltip_button(), Slic3r::GUI::GLGizmoFuzzySkin::render_tooltip_button(), Slic3r::GUI::GLGizmoMmuSegmentation::render_tooltip_button(), Slic3r::GUI::GLGizmoPainterBase::render_triangles(), Slic3r::GUI::GLGizmoTextureDisplacement::render_uvcheck_mesh(), Slic3r::GUI::GLGizmoTextureDisplacement::render_wireframe_overlay(), Slic3r::GUI::GLGizmoSimplify::request_rerender(), Slic3r::GUI::GLGizmoCut3D::reset_cut_plane(), Slic3r::GUI::GLGizmoEmboss::reset_to_default_style(), Slic3r::GUI::GLGizmoTextureDisplacement::run_stage_debug(), Slic3r::GUI::GLGizmoFdmSupports::run_thread(), Slic3r::GUI::GLGizmoTextureDisplacement::run_uv_command(), Slic3r::GUI::GLGizmoTextureDisplacement::seam_edge_at(), Slic3r::GUI::GLGizmoTextureDisplacement::seam_vertex_at(), Slic3r::GUI::GLGizmoFdmSupports::select_facets_by_angle(), Slic3r::GUI::GLGizmoTextureDisplacement::select_visible_faces(), Slic3r::GUI::GLGizmoTextureDisplacement::select_whole_model(), Slic3r::GUI::GLGizmoCut3D::set_connectors_editing(), Slic3r::GUI::GLGizmoMeasure::set_distance(), Slic3r::GUI::GLGizmoTextureDisplacement::set_layer_texture(), Slic3r::GUI::GLGizmoMeasure::set_parallel_distance(), Slic3r::GUI::GLGizmoMeasure::set_to_around_center_of_faces(), Slic3r::GUI::GLGizmoMeasure::set_to_parallel(), Slic3r::GUI::GLGizmoMeasure::set_to_reverse_rotation(), Slic3r::GUI::GLGizmoEmboss::set_volume_by_selection(), Slic3r::GUI::GLGizmoSVG::set_volume_by_selection(), Slic3r::GUI::GLGizmoCut3D::set_volumes_picking_state(), Slic3r::GUI::GLGizmoTextureDisplacement::show_debug_stage(), Slic3r::GUI::GLGizmoTextureDisplacement::show_projector(), Slic3r::GUI::GLGizmoTextureDisplacement::smooth_model(), Slic3r::GUI::GLGizmoTextureDisplacement::subdivide_model(), Slic3r::GUI::GLGizmoCut3D::toggle_model_objects_visibility(), Slic3r::GUI::GLGizmoCut3D::transformed_bounding_box(), Slic3r::GUI::GLGizmoBrimEars::unproject_on_mesh(), Slic3r::GUI::GLGizmoCut3D::update_bb(), Slic3r::GUI::GLGizmoBrimEars::update_cache_radius(), Slic3r::GUI::GLGizmoCut3D::update_clipper(), Slic3r::GUI::GLGizmoPainterBase::update_contours(), Slic3r::GUI::GLGizmoScale3D::update_grabbers_data(), Slic3r::GUI::GLGizmoTextureDisplacement::update_image_adjust_preview(), Slic3r::GUI::GLGizmoBrimEars::update_model_object(), Slic3r::GUI::GLGizmoFdmSupports::update_model_object(), Slic3r::GUI::GLGizmoFuzzySkin::update_model_object(), Slic3r::GUI::GLGizmoMmuSegmentation::update_model_object(), Slic3r::GUI::GLGizmoSeam::update_model_object(), Slic3r::GUI::GLGizmoTextureDisplacement::update_model_object(), Slic3r::GUI::GLGizmoPainterBase::update_raycast_cache(), Slic3r::GUI::GLGizmoBrimEars::update_raycasters(), use_grabbers(), Slic3r::GUI::GLGizmoEmboss::volume_transformation_changed(), Slic3r::GUI::GLGizmoSVG::volume_transformation_changed(), and Slic3r::GUI::GLGizmoEmboss::volume_transformation_changing().

m_pending_scale

int Slic3r::GUI::GLGizmoMeasure::m_pending_scale { 0 }

protectedinherited

{ 0 };

Referenced by data_changed(), render_dimensioning(), set_distance(), set_parallel_distance(), set_to_around_center_of_faces(), set_to_parallel(), and set_to_reverse_rotation().

m_rendered_this_frame

bool Slic3r::GUI::GLGizmoMeasure::m_rendered_this_frame { false }

protectedinherited

{ false };

Referenced by on_render(), and render_dimensioning_if_scene_reused().

m_same_model_object

bool Slic3r::GUI::GLGizmoMeasure::m_same_model_object

mutableprotectedinherited

Referenced by init_render_input_window(), Slic3r::GUI::GLGizmoAssembly::on_render_input_window(), show_distance_xyz_ui(), show_face_face_assembly_common(), and show_face_face_assembly_senior().

m_selected_features

SelectedFeatures Slic3r::GUI::GLGizmoMeasure::m_selected_features

protectedinherited

Referenced by gizmo_event(), on_mouse(), on_render(), Slic3r::GUI::GLGizmoAssembly::on_render_input_window(), on_render_input_window(), render_dimensioning(), reset_feature1(), reset_feature2(), set_distance(), set_parallel_distance(), set_to_around_center_of_faces(), set_to_center_coincidence(), set_to_parallel(), set_to_reverse_rotation(), show_distance_xyz_ui(), show_face_face_assembly_common(), show_face_face_assembly_senior(), show_selection_ui(), and update_measurement_result().

m_selected_wrong_feature_waring_tip

bool Slic3r::GUI::GLGizmoMeasure::m_selected_wrong_feature_waring_tip {false}

protectedinherited

{false};

Referenced by on_mouse(), Slic3r::GUI::GLGizmoAssembly::render_input_window_warning(), reset_feature1(), and reset_feature2().

m_set_center_coincidence

bool Slic3r::GUI::GLGizmoMeasure::m_set_center_coincidence {false}

protectedinherited

{false};

Referenced by set_to_center_coincidence().

m_shift_kar_filter

KeyAutoRepeatFilter Slic3r::GUI::GLGizmoMeasure::m_shift_kar_filter

protectedinherited

Referenced by gizmo_event(), and on_set_state().

m_shortcut

std::optional<Shortcut> Slic3r::GUI::GLGizmoBase::m_shortcut

protectedinherited

Referenced by get_name(), Slic3r::GUI::GLGizmoAssembly::on_init(), Slic3r::GUI::GLGizmoBrimEars::on_init(), Slic3r::GUI::GLGizmoCut3D::on_init(), Slic3r::GUI::GLGizmoEmboss::on_init(), Slic3r::GUI::GLGizmoFdmSupports::on_init(), Slic3r::GUI::GLGizmoFlatten::on_init(), Slic3r::GUI::GLGizmoFuzzySkin::on_init(), Slic3r::GUI::GLGizmoMeasure::on_init(), Slic3r::GUI::GLGizmoMeshBoolean::on_init(), Slic3r::GUI::GLGizmoMmuSegmentation::on_init(), Slic3r::GUI::GLGizmoMove3D::on_init(), Slic3r::GUI::GLGizmoRotate3D::on_init(), Slic3r::GUI::GLGizmoScale3D::on_init(), Slic3r::GUI::GLGizmoSeam::on_init(), Slic3r::GUI::GLGizmoTextureDisplacement::on_init(), and shortcut().

m_shortcuts

std::vector<std::pair<wxString, wxString> > Slic3r::GUI::GLGizmoMeasure::m_shortcuts

protectedinherited

Referenced by on_init(), Slic3r::GUI::GLGizmoAssembly::on_render_input_window(), and on_render_input_window().

m_show_reset_first_tip

bool Slic3r::GUI::GLGizmoMeasure::m_show_reset_first_tip {false}

protectedinherited

{false};

Referenced by on_set_state(), reset_all_feature(), reset_feature1(), reset_feature2(), and show_selection_ui().

m_space_size

float Slic3r::GUI::GLGizmoMeasure::m_space_size

protectedinherited

Referenced by init_render_input_window(), Slic3r::GUI::GLGizmoAssembly::on_render_input_window(), show_face_face_assembly_common(), show_face_face_assembly_senior(), and show_selection_ui().

m_sphere

PickingModel Slic3r::GUI::GLGizmoMeasure::m_sphere

protectedinherited

Referenced by GLGizmoMeasure(), on_mouse(), and on_render().

m_sprite_id

unsigned int Slic3r::GUI::GLGizmoBase::m_sprite_id

protectedinherited

Referenced by GLGizmoBase(), and get_sprite_id().

m_state

EState Slic3r::GUI::GLGizmoBase::m_state

protectedinherited

Referenced by GLGizmoBase(), Slic3r::GUI::GLGizmoTextureDisplacement::bake(), Slic3r::GUI::GLGizmoTextureDisplacement::close_image_adjust(), Slic3r::GUI::GLGizmoMmuSegmentation::data_changed(), Slic3r::GUI::GLGizmoPainterBase::data_changed(), get_state(), Slic3r::GUI::GLGizmoFlatten::is_plane_update_necessary(), load(), Slic3r::GUI::GLGizmoAssembly::on_get_name(), Slic3r::GUI::GLGizmoBrimEars::on_get_name(), Slic3r::GUI::GLGizmoMeasure::on_get_name(), Slic3r::GUI::GLGizmoMove3D::on_get_name(), Slic3r::GUI::GLGizmoRotate3D::on_get_name(), Slic3r::GUI::GLGizmoScale3D::on_get_name(), Slic3r::GUI::GLGizmoBrimEars::on_render(), Slic3r::GUI::GLGizmoCut3D::on_render(), Slic3r::GUI::GLGizmoBrimEars::on_set_state(), Slic3r::GUI::GLGizmoCut3D::on_set_state(), Slic3r::GUI::GLGizmoEmboss::on_set_state(), Slic3r::GUI::GLGizmoMeasure::on_set_state(), Slic3r::GUI::GLGizmoMeshBoolean::on_set_state(), Slic3r::GUI::GLGizmoPainterBase::on_set_state(), Slic3r::GUI::GLGizmoRotate3D::on_set_state(), Slic3r::GUI::GLGizmoSimplify::on_set_state(), Slic3r::GUI::GLGizmoSVG::on_set_state(), Slic3r::GUI::GLGizmoTextureDisplacement::queue_prepare(), Slic3r::GUI::GLGizmoTextureDisplacement::queue_preview_job(), Slic3r::GUI::GLGizmoBrimEars::set_brim_data(), set_state(), and Slic3r::GUI::GLGizmoSimplify::worker_finished().

m_units

std::string Slic3r::GUI::GLGizmoMeasure::m_units

protectedinherited

Referenced by init_render_input_window(), show_distance_xyz_ui(), and show_selection_ui().

m_use_inches

bool Slic3r::GUI::GLGizmoMeasure::m_use_inches

protectedinherited

Referenced by init_render_input_window(), show_distance_xyz_ui(), and show_selection_ui().

---

The documentation for this class was generated from the following files:

• /home/runner/work/OrcaSlicer/OrcaSlicer/src/slic3r/GUI/Gizmos/GLGizmoAssembly.hpp
• /home/runner/work/OrcaSlicer/OrcaSlicer/src/slic3r/GUI/Gizmos/GLGizmoAssembly.cpp