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

Inheritance diagram for Slic3r::GUI::GLGizmoCut3D:

Collaboration diagram for Slic3r::GUI::GLGizmoCut3D:

Classes
struct	InvalidConnectorsStatistics
class	PartSelection

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
	GLGizmoCut3D (GLCanvas3D &parent, const std::string &icon_filename, unsigned int sprite_id)
	–
std::string	get_tooltip () const override
	Mouse tooltip text.
bool	unproject_on_cut_plane (const Vec2d &mouse_pos, Vec3d &pos, Vec3d &pos_world, bool respect_contours=true)
bool	gizmo_event (SLAGizmoEventType action, const Vec2d &mouse_position, bool shift_down, bool alt_down, bool control_down)
bool	is_in_editing_mode () const override
bool	is_selection_rectangle_dragging () const override
bool	is_looking_forward () const
bool	on_mouse (const wxMouseEvent &mouse_event) override
	Drag of plane.
void	shift_cut (double delta)
void	rotate_vec3d_around_plane_center (Vec3d &vec)
void	put_connectors_on_cut_plane (const Vec3d &cp_normal, double cp_offset)
void	update_clipper ()
void	invalidate_cut_plane ()
BoundingBoxf3	bounding_box () const
BoundingBoxf3	transformed_bounding_box (const Vec3d &plane_center, const Transform3d &rotation_m=Transform3d::Identity()) const
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 bool	render_follows_cursor () 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)
int	get_count ()
std::string	get_gizmo_name ()
void	register_raycasters_for_picking ()
void	unregister_raycasters_for_picking ()

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 Member Functions
bool	on_init () override
void	on_load (cereal::BinaryInputArchive &ar) override
void	on_save (cereal::BinaryOutputArchive &ar) const override
std::string	on_get_name () const override
void	on_set_state () override
CommonGizmosDataID	on_get_requirements () const override
void	on_set_hover_id () override
bool	on_is_activable () const override
bool	on_is_selectable () const override
Vec3d	mouse_position_in_local_plane (GrabberID axis, const Linef3 &mouse_ray) const
void	dragging_grabber_move (const GLGizmoBase::UpdateData &data)
void	dragging_grabber_rotation (const GLGizmoBase::UpdateData &data)
void	dragging_connector (const GLGizmoBase::UpdateData &data)
void	on_dragging (const UpdateData &data) override
void	on_start_dragging () override
void	on_stop_dragging () override
void	on_render () override
void	render_debug_input_window (float x)
void	unselect_all_connectors ()
void	select_all_connectors ()
void	apply_selected_connectors (std::function< void(size_t idx)> apply_fn)
void	render_connectors_input_window (CutConnectors &connectors, float x, float y, float bottom_limit)
void	render_build_size ()
void	reset_cut_plane ()
void	set_connectors_editing (bool connectors_editing)
void	flip_cut_plane ()
void	process_contours ()
void	reset_cut_by_contours ()
void	render_flip_plane_button (bool disable_pred=false)
void	add_vertical_scaled_interval (float interval)
void	add_horizontal_scaled_interval (float interval)
void	add_horizontal_shift (float shift)
void	render_color_marker (float size, const ImU32 &color)
void	render_groove_two_float_input (const std::string &label, float &in_val, const float &init_val, float &in_tolerance)
void	render_groove_float_input (const std::string &label, float &in_val, const float &init_val, const bool disabled)
void	render_groove_angle_input (const std::string &label, float &in_val, const float &init_val, float min_val, float max_val)
void	render_groove_int_input (const std::string &label, int &in_val, const int &init_val, int min_val, int max_val)
bool	render_angle_input (const std::string &label, float &in_val, const float &init_val, float min_val, float max_val)
void	render_snap_specific_input (const std::string &label, const wxString &tooltip, float &in_val, const float &init_val, const float min_val, const float max_val)
void	render_cut_plane_input_window (CutConnectors &connectors, float x, float y, float bottom_limit)
void	init_input_window_data (CutConnectors &connectors)
void	render_input_window_warning () const
bool	add_connector (CutConnectors &connectors, const Vec2d &mouse_position)
bool	delete_selected_connectors (CutConnectors &connectors)
void	select_connector (int idx, bool select)
bool	is_selection_changed (bool alt_down, bool shift_down)
void	process_selection_rectangle (CutConnectors &connectors)
virtual void	on_register_raycasters_for_picking () override
virtual void	on_unregister_raycasters_for_picking () override
void	update_raycasters_for_picking ()
void	set_volumes_picking_state (bool state)
void	update_raycasters_for_picking_transform ()
void	update_plane_model ()
void	on_render_input_window (float x, float y, float bottom_limit) override
void	render_tooltip_button (float x, float y)
bool	wants_enter_leave_snapshots () const override
std::string	get_gizmo_entering_text () const override
std::string	get_gizmo_leaving_text () const override
std::string	get_action_snapshot_name () const override
void	data_changed (bool is_serializing) override
	Is called when data (Selection) is changed.
Transform3d	get_cut_matrix (const Selection &selection)
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_enable_grabber (unsigned int id)
virtual void	on_disable_grabber (unsigned int id)
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 ()
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
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 Types
enum	GrabberID { X = 0 , Y , Z , CutPlane , CutPlaneZRotation , CutPlaneXMove , CutPlaneYMove , Count }
enum class	CutMode { cutPlanar , cutTongueAndGroove }
enum class	CutConnectorMode { Auto , Manual }

Private Member Functions
void	set_center (const Vec3d &center, bool update_tbb=false)
void	switch_to_mode (size_t new_mode)
bool	render_cut_mode_combo ()
bool	render_double_input (const std::string &label, double &value_in)
bool	render_slider_two_input (const std::string &label, float &value_in, float &tolerance_in, float min_val=-0.1f, float max_tolerance=-0.1f)
bool	render_slider_input (const std::string &label, float &value_in, float min_val=-0.1f, float max_val=100.f)
void	render_move_center_input (int axis)
void	render_connect_mode_radio_button (CutConnectorMode mode)
bool	render_reset_button (const std::string &label_id, const std::string &tooltip) const
bool	render_connect_type_radio_button (CutConnectorType type)
bool	is_outside_of_cut_contour (size_t idx, const CutConnectors &connectors, const Vec3d cur_pos)
bool	is_conflict_for_connector (size_t idx, const CutConnectors &connectors, const Vec3d cur_pos)
void	render_connectors ()
bool	can_perform_cut () const
bool	has_valid_groove () const
bool	has_valid_contour () const
void	apply_connectors_in_model (ModelObject *mo, int &dowels_count)
bool	cut_line_processing () const
void	discard_cut_line_processing ()
void	apply_color_clip_plane_colors ()
void	render_cut_plane ()
void	render_line (GLModel &line_model, const ColorRGBA &color, Transform3d view_model_matrix, float width)
void	render_rotation_snapping (GrabberID axis, const ColorRGBA &color)
void	render_grabber_connection (const ColorRGBA &color, Transform3d view_matrix, double line_len_koef=1.0)
void	render_cut_plane_grabbers ()
void	render_cut_line ()
void	perform_cut (const Selection &selection)
void	set_center_pos (const Vec3d &center_pos, bool update_tbb=false)
void	update_bb ()
void	init_picking_models ()
void	init_rendering_items ()
void	render_clipper_cut ()
void	clear_selection ()
void	reset_connectors ()
void	init_connector_shapes ()
void	update_connector_shape ()
void	validate_connector_settings ()
bool	process_cut_line (SLAGizmoEventType action, const Vec2d &mouse_position)
void	check_and_update_connectors_state ()
void	toggle_model_objects_visibility ()
std::vector< Vec3i32 >	offset_indices (const std::vector< Vec3i32 > &base_indices, size_t vo)
indexed_triangle_set	its_make_groove_plane ()
indexed_triangle_set	get_connector_mesh (CutConnectorAttributes connector_attributes)
void	apply_cut_connectors (ModelObject *mo, const std::string &connector_name)

Static Private Member Functions
static void	render_model (GLModel &model, const ColorRGBA &color, Transform3d view_model_matrix)

Private Attributes
Transform3d	m_rotation_m { Transform3d::Identity() }
double	m_snap_step { 1.0 }
int	m_connectors_group_id
Vec3d	m_ar_plane_center { Vec3d::Zero() }
Transform3d	m_start_dragging_m { Transform3d::Identity() }
Vec3d	m_plane_center { Vec3d::Zero() }
Vec3d	m_min_pos { Vec3d::Zero() }
Vec3d	m_max_pos { Vec3d::Zero() }
Vec3d	m_bb_center { Vec3d::Zero() }
Vec3d	m_center_offset { Vec3d::Zero() }
BoundingBoxf3	m_bounding_box
BoundingBoxf3	m_transformed_bounding_box
double	m_radius { 0.0 }
double	m_grabber_radius { 0.0 }
double	m_grabber_connection_len { 0.0 }
Vec3d	m_cut_plane_start_move_pos {Vec3d::Zero()}
double	m_snap_coarse_in_radius { 0.0 }
double	m_snap_coarse_out_radius { 0.0 }
double	m_snap_fine_in_radius { 0.0 }
double	m_snap_fine_out_radius { 0.0 }
double	m_angle { 0.0 }
TriangleMesh	m_connector_mesh
Vec3d	m_clp_normal { Vec3d::Ones() }
Vec3d	m_line_beg { Vec3d::Zero() }
Vec3d	m_line_end { Vec3d::Zero() }
Vec2d	m_ldown_mouse_position { Vec2d::Zero() }
GLModel	m_grabber_connection
GLModel	m_cut_line
PickingModel	m_plane
PickingModel	m_sphere
PickingModel	m_cone
PickingModel	m_cube
std::map< CutConnectorAttributes, PickingModel >	m_shapes
std::vector< std::shared_ptr< SceneRaycasterItem > >	m_raycasters
GLModel	m_circle
GLModel	m_scale
GLModel	m_snap_radii
GLModel	m_reference_radius
GLModel	m_angle_arc
Vec3d	m_cut_normal
struct Slic3r::GUI::GLGizmoCut3D::InvalidConnectorsStatistics	m_info_stats
bool	m_keep_upper { true }
bool	m_keep_lower { true }
bool	m_keep_as_parts { false }
bool	m_place_on_cut_upper { true }
bool	m_place_on_cut_lower { false }
bool	m_rotate_upper { false }
bool	m_rotate_lower { false }
Cut::Groove	m_groove
bool	m_groove_editing { false }
bool	m_is_slider_editing_done { false }
int	m_groove_count_init { 1 }
int	m_groove_count { 1 }
float	m_groove_gap { 10.f }
float	m_groove_gap_init { 10.f }
float	m_snap_bulge_proportion { 0.15f }
float	m_snap_space_proportion { 0.3f }
bool	m_hide_cut_plane { false }
bool	m_connectors_editing { false }
bool	m_cut_plane_as_circle { false }
float	m_connector_depth_ratio { 3.f }
float	m_connector_size { 2.5f }
float	m_connector_angle { 0.f }
float	m_connector_depth_ratio_tolerance { 0.1f }
float	m_connector_size_tolerance { 0.f }
float	m_label_width { 0.f }
float	m_control_width { 200.f }
double	m_editing_window_width
bool	m_imperial_units { false }
float	m_contour_width { 0.4f }
float	m_cut_plane_radius_koef { 1.5f }
std::vector< bool >	m_selected
int	m_selected_count { 0 }
GLSelectionRectangle	m_selection_rectangle
std::vector< size_t >	m_invalid_connectors_idxs
bool	m_was_cut_plane_dragged { false }
bool	m_was_contour_selected { false }
std::vector< Vec3d >	m_groove_vertices
PartSelection	m_part_selection
std::vector< std::pair< wxString, wxString > >	m_shortcuts_cut
std::vector< std::pair< wxString, wxString > >	m_shortcuts_connector
std::vector< std::string >	m_modes
size_t	m_mode { size_t(CutMode::cutPlanar) }
std::vector< std::string >	m_connector_modes
CutConnectorMode	m_connector_mode { CutConnectorMode::Manual }
std::vector< std::string >	m_connector_types
CutConnectorType	m_connector_type
std::vector< std::string >	m_connector_styles
int	m_connector_style
std::vector< std::string >	m_connector_shapes
int	m_connector_shape_id
std::vector< std::string >	m_axis_names
std::map< std::string, wxString >	m_part_orientation_names
std::map< std::string, std::string >	m_labels_map
bool	m_dirty { false }
int	count = 0

Detailed Description

Member Enumeration Documentation

◆ CutConnectorMode

enum class Slic3r::GUI::GLGizmoCut3D::CutConnectorMode

strongprivate

Enumerator
Auto
Manual

◆ CutMode

enum class Slic3r::GUI::GLGizmoCut3D::CutMode

strongprivate

Enumerator
cutPlanar
cutTongueAndGroove

                       {
        cutPlanar
        , cutTongueAndGroove
        //, cutGrig
        //,cutRadial
        //,cutModular
    };

◆ 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,
    };

◆ EState

enum Slic3r::GUI::GLGizmoBase::EState

inherited

Enumerator
Off
On
Num_States

    {
        Off,
        On,
        Num_States
    };

◆ GrabberID

enum Slic3r::GUI::GLGizmoCut3D::GrabberID

private

Enumerator
X
Y
Z
CutPlane
CutPlaneZRotation
CutPlaneXMove
CutPlaneYMove
Count

                   {
        X = 0,
        Y,
        Z,
        CutPlane,
        CutPlaneZRotation,
        CutPlaneXMove,
        CutPlaneYMove,
        Count,
    };

Constructor & Destructor Documentation

◆ GLGizmoCut3D()

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

–

    : GLGizmoBase(parent, icon_filename, sprite_id)
    , m_connectors_group_id (GrabberID::Count)
    , m_connector_type (CutConnectorType::Plug)
    , m_connector_style (int(CutConnectorStyle::Prism))
    , m_connector_shape_id (int(CutConnectorShape::Circle))
{
    m_modes = { _u8L("Planar"), _u8L("Dovetail")//, _u8L("Grid")
//              , _u8L("Radial"), _u8L("Modular")
    };
 
    m_connector_modes = { _u8L("Auto"), _u8L("Manual") };
 
    m_connector_types = { _u8L("Plug"), _u8L("Dowel"), _u8L("Snap") };
 
    m_connector_styles = { _u8L("Prism"), _u8L("Frustum")
//              , _u8L("Claw")
    };
 
    m_connector_shapes = { _u8L("Triangle"), _u8L("Square"), _u8L("Hexagon"), _u8L("Circle")
//              , _u8L("D-shape")
    };
 
    m_axis_names = { "X", "Y", "Z" };
 
    m_part_orientation_names = {
        {"none",    _L("Keep orientation")},
        {"on_cut",  _L("Place on cut")},
        {"flip",    _L("Flip upside down")},
    };
 
    m_labels_map = {
        {"Connectors"   , _u8L("Connectors")},
        {"Type"         , _u8L("Type")},
        {"Style"        , _u8L("Style")},
        {"Shape"        , _u8L("Shape")},
        {"Depth"        , _u8L("Depth")},
        {"Size"         , _u8L("Size")},
        {"Rotation"     , _u8L("Rotation")},
        {"Groove"       , _u8L("Groove")},
        {"Width"        , _u8L("Width")},
        {"Flap Angle"   , _u8L("Flap Angle")},
        {"Groove Angle" , _u8L("Groove Angle")},
        {"Cut position" , _u8L("Cut position")}, // ORCA
        {"Multiple"     , _u8L("Multiple")}, // ORCA
        {"Count"        , _u8L("Count")}, // ORCA
        {"Gap"          , _u8L("Gap")}, // ORCA
        {"Spacing"      , _u8L("Spacing")} // ORCA
    };
 
//    update_connector_shape();
}

References Slic3r::GUI::GLGizmoBase::GLGizmoBase(), _L, _u8L, Count, m_axis_names, m_connector_modes, m_connector_shape_id, m_connector_shapes, m_connector_style, m_connector_styles, m_connector_type, m_connector_types, m_connectors_group_id, m_labels_map, m_modes, and m_part_orientation_names.

Here is the call graph for this function:

Member Function Documentation

◆ add_connector()

bool Slic3r::GUI::GLGizmoCut3D::add_connector	(	CutConnectors &	connectors,
		const Vec2d &	mouse_position )

protected

{
    if (!m_connectors_editing)
        return false;
 
    Vec3d pos;
    Vec3d pos_world;
    if (unproject_on_cut_plane(mouse_position.cast<double>(), pos, pos_world)) {
        Plater::TakeSnapshot snapshot(wxGetApp().plater(), _u8L("Add connector"), UndoRedo::SnapshotType::GizmoAction);
        unselect_all_connectors();
 
        connectors.emplace_back(pos, m_rotation_m,
                                m_connector_size * 0.5f, m_connector_depth_ratio,
                                m_connector_size_tolerance * 0.5f, m_connector_depth_ratio_tolerance,
                                m_connector_angle,
                                CutConnectorAttributes( CutConnectorType(m_connector_type),
                                                        CutConnectorStyle(m_connector_style),
                                                        CutConnectorShape(m_connector_shape_id)));
        m_selected.push_back(true);
        m_selected_count = 1;
        assert(m_selected.size() == connectors.size());
        update_raycasters_for_picking();
        m_parent.set_as_dirty();
        check_and_update_connectors_state();
 
        return true;
    }
    return false;
}

References _u8L, check_and_update_connectors_state(), Slic3r::UndoRedo::GizmoAction, m_connector_angle, m_connector_depth_ratio, m_connector_depth_ratio_tolerance, m_connector_shape_id, m_connector_size, m_connector_size_tolerance, m_connector_style, m_connector_type, m_connectors_editing, Slic3r::GUI::GLGizmoBase::m_parent, m_rotation_m, m_selected, m_selected_count, Slic3r::GUI::plater(), unproject_on_cut_plane(), unselect_all_connectors(), and update_raycasters_for_picking().

Referenced by gizmo_event().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ add_horizontal_scaled_interval()

void Slic3r::GUI::GLGizmoCut3D::add_horizontal_scaled_interval ( float interval )

protected

{
    ImGui::GetCurrentWindow()->DC.CursorPos.x += m_imgui->scaled(interval);
}

References Slic3r::GUI::GLGizmoBase::m_imgui.

◆ add_horizontal_shift()

void Slic3r::GUI::GLGizmoCut3D::add_horizontal_shift ( float shift )

protected

{
    ImGui::GetCurrentWindow()->DC.CursorPos.x += shift;
}

◆ add_vertical_scaled_interval()

void Slic3r::GUI::GLGizmoCut3D::add_vertical_scaled_interval ( float interval )

protected

{
    ImGui::GetCurrentWindow()->DC.CursorPos.y += m_imgui->scaled(interval);
}

References Slic3r::GUI::GLGizmoBase::m_imgui.

◆ apply_clipping_plane()

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

inlinevirtualinherited

195{ 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:

◆ apply_color_clip_plane_colors()

void Slic3r::GUI::GLGizmoCut3D::apply_color_clip_plane_colors ( )

private

{
    if (CutMode(m_mode) == CutMode::cutTongueAndGroove)
        m_parent.set_color_clip_plane_colors({ CUT_PLANE_DEF_COLOR , CUT_PLANE_DEF_COLOR });
    else
        m_parent.set_color_clip_plane_colors({ UPPER_PART_COLOR , LOWER_PART_COLOR });
}

References Slic3r::GUI::CUT_PLANE_DEF_COLOR, cutTongueAndGroove, Slic3r::GUI::LOWER_PART_COLOR, m_mode, Slic3r::GUI::GLGizmoBase::m_parent, and Slic3r::GUI::UPPER_PART_COLOR.

Referenced by switch_to_mode(), and update_bb().

Here is the caller graph for this function:

◆ apply_connectors_in_model()

void Slic3r::GUI::GLGizmoCut3D::apply_connectors_in_model	(	ModelObject *	mo,
		int &	dowels_count )

private

{
    if (CutMode(m_mode) == CutMode::cutTongueAndGroove)
        return;
    if (m_connector_mode == CutConnectorMode::Manual) {
        clear_selection();
 
        for (CutConnector&connector : mo->cut_connectors) {
            connector.rotation_m = m_rotation_m;
 
            if (connector.attribs.type == CutConnectorType::Dowel) {
                if (connector.attribs.style == CutConnectorStyle::Prism)
                    connector.height *= 2;
                dowels_count ++;
            }
            else {
                // calculate shift of the connector center regarding to the position on the cut plane
                connector.pos += m_cut_normal * 0.5 * double(connector.height);
            }
        }
        apply_cut_connectors(mo, _u8L("Connector"));
    }
}

References _u8L, apply_cut_connectors(), Slic3r::CutConnector::attribs, clear_selection(), Slic3r::ModelObject::cut_connectors, cutTongueAndGroove, Slic3r::Dowel, Slic3r::CutConnector::height, m_connector_mode, m_cut_normal, m_mode, m_rotation_m, Manual, Slic3r::CutConnector::pos, Slic3r::Prism, Slic3r::CutConnector::rotation_m, Slic3r::CutConnectorAttributes::style, and Slic3r::CutConnectorAttributes::type.

Referenced by perform_cut().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ apply_cut_connectors()

void Slic3r::GUI::GLGizmoCut3D::apply_cut_connectors	(	ModelObject *	mo,
		const std::string &	connector_name )

private

{
    if (mo->cut_connectors.empty())
        return;
 
    size_t connector_id = mo->cut_id.connectors_cnt();
    for (const CutConnector& connector : mo->cut_connectors) {
        TriangleMesh mesh = TriangleMesh(get_connector_mesh(connector.attribs));
        // Mesh will be centered when loading.
        ModelVolume* new_volume = mo->add_volume(std::move(mesh), ModelVolumeType::NEGATIVE_VOLUME);
 
        // Transform the new modifier to be aligned inside the instance
        new_volume->set_transformation(translation_transform(connector.pos) * connector.rotation_m *
            rotation_transform(-connector.z_angle * Vec3d::UnitZ()) *
            scale_transform(Vec3f(connector.radius, connector.radius, connector.height).cast<double>()));
 
        new_volume->cut_info = { connector.attribs.type, connector.radius_tolerance, connector.height_tolerance };
        new_volume->name = connector_name + "-" + std::to_string(++connector_id);
    }
    mo->cut_id.increase_connectors_cnt(mo->cut_connectors.size());
 
    // delete all connectors
    mo->cut_connectors.clear();
}

Referenced by apply_connectors_in_model().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ apply_selected_connectors()

void Slic3r::GUI::GLGizmoCut3D::apply_selected_connectors ( std::function< void(size_t idx)> apply_fn )

protected

{
    for (size_t idx = 0; idx < m_selected.size(); idx++)
        if (m_selected[idx])
            apply_fn(idx);
    check_and_update_connectors_state();
    update_raycasters_for_picking_transform();
}

References check_and_update_connectors_state(), m_selected, and update_raycasters_for_picking_transform().

Referenced by render_connectors_input_window().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ bounding_box()

BoundingBoxf3 Slic3r::GUI::GLGizmoCut3D::bounding_box ( ) const

{
    BoundingBoxf3 ret;
    const Selection& selection = m_parent.get_selection();
    const Selection::IndicesList& idxs = selection.get_volume_idxs();
    for (unsigned int i : idxs) {
        const GLVolume* volume = selection.get_volume(i);
        // respect just to the solid parts for FFF and ignore pad and supports for SLA
        if (!volume->is_modifier && !volume->is_sla_pad() && !volume->is_sla_support())
            ret.merge(volume->transformed_convex_hull_bounding_box());
    }
    return ret;
}

References Slic3r::GUI::Selection::get_volume(), Slic3r::GUI::Selection::get_volume_idxs(), Slic3r::GLVolume::is_sla_pad(), Slic3r::GLVolume::is_sla_support(), Slic3r::GUI::GLGizmoBase::m_parent, Slic3r::BoundingBox3Base< PointType >::merge(), and Slic3r::GLVolume::transformed_convex_hull_bounding_box().

Referenced by update_bb().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ can_perform_cut()

bool Slic3r::GUI::GLGizmoCut3D::can_perform_cut ( ) const

private

{
    if (! m_invalid_connectors_idxs.empty() || (!m_keep_upper && !m_keep_lower) || m_connectors_editing)
        return false;
 
    if (CutMode(m_mode) == CutMode::cutTongueAndGroove)
        return has_valid_groove();
 
    if (m_part_selection.valid())
        return ! m_part_selection.is_one_object();
 
    return true;
}

References cutTongueAndGroove, has_valid_groove(), m_connectors_editing, m_invalid_connectors_idxs, m_keep_lower, m_keep_upper, m_mode, and m_part_selection.

Referenced by perform_cut(), render_cut_plane(), and render_cut_plane_input_window().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ check_and_update_connectors_state()

void Slic3r::GUI::GLGizmoCut3D::check_and_update_connectors_state ( )

private

{
    m_info_stats.invalidate();
    m_invalid_connectors_idxs.clear();
    if (CutMode(m_mode) != CutMode::cutPlanar)
        return;
    const ModelObject* mo = m_c->selection_info()->model_object();
    auto inst_id = m_c->selection_info()->get_active_instance();
    if (inst_id < 0)
        return;
    const CutConnectors& connectors = mo->cut_connectors;
    const ModelInstance* mi = mo->instances[inst_id];
    const Vec3d& instance_offset = mi->get_offset();
    const double sla_shift       = double(m_c->selection_info()->get_sla_shift());
 
     for (size_t i = 0; i < connectors.size(); ++i) {
        const CutConnector& connector = connectors[i];
        Vec3d pos = connector.pos + instance_offset + sla_shift * Vec3d::UnitZ(); // recalculate connector position to world position
        if (is_conflict_for_connector(i, connectors, pos))
            m_invalid_connectors_idxs.emplace_back(i);
     }
}

References Slic3r::ModelObject::cut_connectors, cutPlanar, Slic3r::ModelInstance::get_offset(), Slic3r::ModelObject::instances, is_conflict_for_connector(), Slic3r::GUI::GLGizmoBase::m_c, m_info_stats, m_invalid_connectors_idxs, m_mode, and Slic3r::CutConnector::pos.

Referenced by add_connector(), apply_selected_connectors(), delete_selected_connectors(), on_dragging(), on_mouse(), render_cut_mode_combo(), reset_connectors(), and set_center().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ clear_selection()

void Slic3r::GUI::GLGizmoCut3D::clear_selection ( )

private

{
    m_selected.clear();
    m_selected_count = 0;
}

References m_selected, and m_selected_count.

Referenced by apply_connectors_in_model(), render_connectors(), reset_connectors(), and update_bb().

Here is the caller graph for this function:

◆ cut_line_processing()

bool Slic3r::GUI::GLGizmoCut3D::cut_line_processing ( ) const

private

{
    return !m_line_beg.isApprox(Vec3d::Zero());
}

References m_line_beg.

Referenced by on_mouse(), on_register_raycasters_for_picking(), process_cut_line(), render_connectors(), render_cut_line(), render_cut_plane(), and update_raycasters_for_picking_transform().

Here is the caller graph for this function:

◆ data_changed()

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

overrideprotectedvirtual

Is called when data (Selection) is changed.

Reimplemented from Slic3r::GUI::GLGizmoBase.

{
    update_bb();
    if (auto oc = m_c->object_clipper())
        oc->set_behavior(m_connectors_editing, m_connectors_editing, double(m_contour_width));
}

References Slic3r::GUI::GLGizmoBase::m_c, m_connectors_editing, m_contour_width, and update_bb().

Here is the call graph for this function:

◆ delete_selected_connectors()

bool Slic3r::GUI::GLGizmoCut3D::delete_selected_connectors ( CutConnectors & connectors )

protected

{
    if (connectors.empty())
        return false;
 
    Plater::TakeSnapshot snapshot(wxGetApp().plater(), _u8L("Delete connector"), UndoRedo::SnapshotType::GizmoAction);
 
    // remove  connectors
    for (int i = int(connectors.size()) - 1; i >= 0; i--)
        if (m_selected[i])
            connectors.erase(connectors.begin() + i);
    // remove selections
    m_selected.erase(std::remove_if(m_selected.begin(), m_selected.end(), [](const auto& selected) {
        return selected; }), m_selected.end());
    m_selected_count = 0;
 
    assert(m_selected.size() == connectors.size());
    update_raycasters_for_picking();
    m_parent.set_as_dirty();
    check_and_update_connectors_state();
    return true;
}

References _u8L, check_and_update_connectors_state(), Slic3r::UndoRedo::GizmoAction, Slic3r::GUI::GLGizmoBase::m_parent, m_selected, m_selected_count, Slic3r::GUI::plater(), and update_raycasters_for_picking().

Referenced by gizmo_event().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ discard_cut_line_processing()

void Slic3r::GUI::GLGizmoCut3D::discard_cut_line_processing ( )

private

{
    m_line_beg = m_line_end = Vec3d::Zero();
}

References m_line_beg, and m_line_end.

Referenced by on_mouse(), and process_cut_line().

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:

◆ dragging_connector()

void Slic3r::GUI::GLGizmoCut3D::dragging_connector ( const GLGizmoBase::UpdateData & data )

protected

{
    CutConnectors&          connectors = m_c->selection_info()->model_object()->cut_connectors;
    Vec3d                   pos;
    Vec3d                   pos_world;
 
    if (unproject_on_cut_plane(data.mouse_pos.cast<double>(), pos, pos_world)) {
        connectors[m_hover_id - m_connectors_group_id].pos = pos;
        update_raycasters_for_picking_transform();
    }
}

References Slic3r::GUI::GLGizmoBase::m_c, m_connectors_group_id, Slic3r::GUI::GLGizmoBase::m_hover_id, Slic3r::GUI::GLGizmoBase::UpdateData::mouse_pos, unproject_on_cut_plane(), and update_raycasters_for_picking_transform().

Referenced by on_dragging().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ dragging_grabber_move()

void Slic3r::GUI::GLGizmoCut3D::dragging_grabber_move ( const GLGizmoBase::UpdateData & data )

protected

{
    Vec3d starting_drag_position;
    if (m_hover_id == Z)
        starting_drag_position = translation_transform(m_plane_center) * m_rotation_m * (m_grabber_connection_len * Vec3d::UnitZ());
    else
        starting_drag_position = m_cut_plane_start_move_pos;
 
    double projection  = 0.0;
 
    Vec3d starting_vec = m_rotation_m * (m_hover_id == CutPlaneXMove ? Vec3d::UnitX() : m_hover_id == CutPlaneYMove ? Vec3d::UnitY() : Vec3d::UnitZ());
    if (starting_vec.norm() != 0.0) {
        const Vec3d mouse_dir = data.mouse_ray.unit_vector();
        // finds the intersection of the mouse ray with the plane parallel to the camera viewport and passing through the starting position
        // use ray-plane intersection see i.e. https://en.wikipedia.org/wiki/Line%E2%80%93plane_intersection algebraic form
        // in our case plane normal and ray direction are the same (orthogonal view)
        // when moving to perspective camera the negative z unit axis of the camera needs to be transformed in world space and used as plane normal
        const Vec3d inters = data.mouse_ray.a + (starting_drag_position - data.mouse_ray.a).dot(mouse_dir) * mouse_dir;
        // vector from the starting position to the found intersection
        const Vec3d inters_vec = inters - starting_drag_position;
 
        starting_vec.normalize();
        // finds projection of the vector along the staring direction
        projection = inters_vec.dot(starting_vec);
    }
    if (wxGetKeyState(WXK_SHIFT))
        projection = m_snap_step * std::round(projection / m_snap_step);
 
    const Vec3d shift = starting_vec * projection;
    if (shift != Vec3d::Zero())
        reset_cut_by_contours();
 
    // move  cut plane center
    set_center(m_plane_center + shift, true);
 
    m_was_cut_plane_dragged = true;
}

References Slic3r::Linef3::a, CutPlaneXMove, CutPlaneYMove, Slic3r::dot(), m_cut_plane_start_move_pos, m_grabber_connection_len, Slic3r::GUI::GLGizmoBase::m_hover_id, m_plane_center, m_rotation_m, m_snap_step, m_was_cut_plane_dragged, Slic3r::GUI::GLGizmoBase::UpdateData::mouse_ray, reset_cut_by_contours(), set_center(), Slic3r::Geometry::translation_transform(), Slic3r::Linef3::unit_vector(), and Z.

Referenced by on_dragging().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ dragging_grabber_rotation()

void Slic3r::GUI::GLGizmoCut3D::dragging_grabber_rotation ( const GLGizmoBase::UpdateData & data )

protected

{
    const Vec2d mouse_pos = to_2d(mouse_position_in_local_plane((GrabberID)m_hover_id, data.mouse_ray));
 
    const Vec2d orig_dir = Vec2d::UnitX();
    const Vec2d new_dir  = mouse_pos.normalized();
 
    const double two_pi = 2.0 * PI;
 
    double theta = ::acos(std::clamp(new_dir.dot(orig_dir), -1.0, 1.0));
    if (cross2(orig_dir, new_dir) < 0.0)
        theta = two_pi - theta;
 
    const double len = mouse_pos.norm();
    // snap to coarse snap region
    if (m_snap_coarse_in_radius <= len && len <= m_snap_coarse_out_radius) {
        const double step = two_pi / double(SnapRegionsCount);
        theta             = step * std::round(theta / step);
    }
    // snap to fine snap region (scale)
    else if (m_snap_fine_in_radius <= len && len <= m_snap_fine_out_radius) {
        const double step = two_pi / double(ScaleStepsCount);
        theta             = step * std::round(theta / step);
    }
 
    if (is_approx(theta, two_pi))
        theta = 0.0;
    if (m_hover_id != Y)
        theta += 0.5 * PI;
 
    if (!is_approx(theta, 0.0))
        reset_cut_by_contours();
 
    Vec3d rotation = Vec3d::Zero();
    rotation[m_hover_id == CutPlaneZRotation ? Z : m_hover_id] = theta;
 
    const Transform3d rotation_tmp = m_start_dragging_m * rotation_transform(rotation);
    const bool update_tbb = !m_rotation_m.rotation().isApprox(rotation_tmp.rotation());
    m_rotation_m = rotation_tmp;
    if (update_tbb)
        m_transformed_bounding_box = transformed_bounding_box(m_plane_center, m_rotation_m);
 
    m_angle = theta;
    while (m_angle > two_pi)
        m_angle -= two_pi;
    if (m_angle < 0.0)
        m_angle += two_pi;
 
    update_clipper();
}

References Slic3r::cross2(), CutPlaneZRotation, Slic3r::is_approx(), m_angle, Slic3r::GUI::GLGizmoBase::m_hover_id, m_plane_center, m_rotation_m, m_snap_coarse_in_radius, m_snap_coarse_out_radius, m_snap_fine_in_radius, m_snap_fine_out_radius, m_start_dragging_m, m_transformed_bounding_box, mouse_position_in_local_plane(), Slic3r::GUI::GLGizmoBase::UpdateData::mouse_ray, PI, reset_cut_by_contours(), Slic3r::Geometry::rotation_transform(), Slic3r::GUI::ScaleStepsCount, Slic3r::GUI::SnapRegionsCount, Slic3r::to_2d(), transformed_bounding_box(), update_clipper(), Y, and Z.

Referenced by on_dragging().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ flip_cut_plane()

void Slic3r::GUI::GLGizmoCut3D::flip_cut_plane ( )

protected

{
    m_rotation_m = m_rotation_m * rotation_transform(PI * Vec3d::UnitX());
    m_transformed_bounding_box = transformed_bounding_box(m_plane_center, m_rotation_m);
 
    Plater::TakeSnapshot snapshot(wxGetApp().plater(), _u8L("Flip cut plane"), UndoRedo::SnapshotType::GizmoAction);
    m_start_dragging_m = m_rotation_m;
 
    update_clipper();
    m_part_selection.turn_over_selection();
 
    if (CutMode(m_mode) == CutMode::cutTongueAndGroove)
        reset_cut_by_contours();
}

References _u8L, cutTongueAndGroove, Slic3r::UndoRedo::GizmoAction, m_mode, m_part_selection, m_plane_center, m_rotation_m, m_start_dragging_m, m_transformed_bounding_box, PI, Slic3r::GUI::plater(), reset_cut_by_contours(), Slic3r::Geometry::rotation_transform(), transformed_bounding_box(), and update_clipper().

Referenced by on_mouse(), and render_flip_plane_button().

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().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ get_action_snapshot_name()

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

inlineoverrideprotectedvirtual

Reimplemented from Slic3r::GUI::GLGizmoBase.

351{ return _u8L("Cut gizmo editing"); }

References _u8L.

◆ get_connector_mesh()

indexed_triangle_set Slic3r::GUI::GLGizmoCut3D::get_connector_mesh ( CutConnectorAttributes connector_attributes )

private

{
    indexed_triangle_set connector_mesh;
 
    int   sectorCount{ 1 };
    switch (CutConnectorShape(connector_attributes.shape)) {
    case CutConnectorShape::Triangle:
        sectorCount = 3;
        break;
    case CutConnectorShape::Square:
        sectorCount = 4;
        break;
    case CutConnectorShape::Circle:
        sectorCount = 360;
        break;
    case CutConnectorShape::Hexagon:
        sectorCount = 6;
        break;
    default:
        break;
    }
 
    if (connector_attributes.type == CutConnectorType::Snap)
        connector_mesh = its_make_snap(1.0, 1.0, m_snap_space_proportion, m_snap_bulge_proportion);
    else if (connector_attributes.style == CutConnectorStyle::Prism)
        connector_mesh = its_make_cylinder(1.0, 1.0, (2 * PI / sectorCount));
    else if (connector_attributes.type == CutConnectorType::Plug)
        connector_mesh = its_make_frustum(1.0, 1.0, (2 * PI / sectorCount));
    else
        connector_mesh = its_make_frustum_dowel(1.0, 1.0, sectorCount);
 
    return connector_mesh;
}

References Slic3r::Circle, Slic3r::Hexagon, Slic3r::its_make_cylinder(), Slic3r::its_make_frustum(), Slic3r::its_make_frustum_dowel(), Slic3r::its_make_snap(), m_snap_bulge_proportion, m_snap_space_proportion, PI, Slic3r::Plug, Slic3r::Prism, Slic3r::CutConnectorAttributes::shape, Slic3r::Snap, Slic3r::Square, Slic3r::CutConnectorAttributes::style, Slic3r::Triangle, and Slic3r::CutConnectorAttributes::type.

Referenced by apply_cut_connectors(), init_connector_shapes(), and update_connector_shape().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ get_count()

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

inlineinherited

224{ return ++count; }

Slic3r::GUI::GLGizmoBase::count

int count

Definition GLGizmoBase.hpp:294

References count.

◆ get_cut_matrix()

Transform3d Slic3r::GUI::GLGizmoCut3D::get_cut_matrix ( const Selection & selection )

protected

{
    const int instance_idx = selection.get_instance_idx();
    const int object_idx = selection.get_object_idx();
    ModelObject* mo = selection.get_model()->objects[object_idx];
    if (!mo)
        return Transform3d::Identity();
 
    // m_cut_z is the distance from the bed. Subtract possible SLA elevation.
    const double sla_shift_z = selection.get_first_volume()->get_sla_shift_z();
 
    const Vec3d instance_offset = mo->instances[instance_idx]->get_offset();
    Vec3d cut_center_offset = m_plane_center - instance_offset;
    cut_center_offset[Z] -= sla_shift_z;
 
    return translation_transform(cut_center_offset) * m_rotation_m;
}

References Slic3r::GUI::Selection::get_first_volume(), Slic3r::GUI::Selection::get_instance_idx(), Slic3r::GUI::Selection::get_model(), Slic3r::GUI::Selection::get_object_idx(), Slic3r::GLVolume::get_sla_shift_z(), Slic3r::ModelObject::instances, m_plane_center, m_rotation_m, Slic3r::Model::objects, Slic3r::Geometry::translation_transform(), and Z.

Referenced by perform_cut(), and process_contours().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ get_gizmo_entering_text()

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

inlineoverrideprotectedvirtual

Reimplemented from Slic3r::GUI::GLGizmoBase.

349{ return _u8L("Entering Cut gizmo"); }

References _u8L.

◆ get_gizmo_leaving_text()

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

inlineoverrideprotectedvirtual

Reimplemented from Slic3r::GUI::GLGizmoBase.

350{ return _u8L("Leaving Cut gizmo"); }

References _u8L.

◆ get_gizmo_name()

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

inlineinherited

225{ return on_get_name(); }

Slic3r::GUI::GLGizmoBase::on_get_name

virtual std::string on_get_name() const =0

References on_get_name().

Here is the call graph for this function:

◆ get_hover_id()

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

inlineinherited

206{ 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

180{ return m_icon_filename; }

Slic3r::GUI::GLGizmoBase::m_icon_filename

std::string m_icon_filename

Definition GLGizmoBase.hpp:148

References m_icon_filename.

◆ 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().

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

186{ return on_get_requirements(); }

Slic3r::GUI::GLGizmoBase::on_get_requirements

virtual CommonGizmosDataID on_get_requirements() const

Definition GLGizmoBase.hpp:248

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

204{ return m_sprite_id; }

Slic3r::GUI::GLGizmoBase::m_sprite_id

unsigned int m_sprite_id

Definition GLGizmoBase.hpp:149

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

175{ return m_state; }

Slic3r::GUI::GLGizmoBase::m_state

EState m_state

Definition GLGizmoBase.hpp:146

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()

std::string Slic3r::GUI::GLGizmoCut3D::get_tooltip ( ) const

overridevirtual

Mouse tooltip text.

Returns: Text to be visible in mouse tooltip

Reimplemented from Slic3r::GUI::GLGizmoBase.

{
    std::string tooltip;
    if (m_hover_id == Z || (m_dragging && m_hover_id == CutPlane)) {
        double koef = m_imperial_units ? GizmoObjectManipulation::mm_to_in : 1.0;
        std::string unit_str = " " + (m_imperial_units ? _u8L_CONTEXT("in", "inches") : _u8L("mm"));
        const BoundingBoxf3& tbb = m_transformed_bounding_box;
 
        const std::string name = m_keep_as_parts ? _u8L("Part") : _u8L("Object");
        if (tbb.max.z() >= 0.0) {
            double top = (tbb.min.z() <= 0.0 ? tbb.max.z() : tbb.size().z()) * koef;
            tooltip += format(static_cast<float>(top), 2) + " " + unit_str + " (" + name + " A)";
            if (tbb.min.z() <= 0.0)
                tooltip += "\n";
        }
        if (tbb.min.z() <= 0.0) {
            double bottom = (tbb.max.z() <= 0.0 ? tbb.size().z() : (tbb.min.z() * (-1))) * koef;
            tooltip += format(static_cast<float>(bottom), 2) + " " + unit_str + " (" + name + " B)";
        }
        return tooltip;
    }
 
    if (!m_dragging && m_hover_id == CutPlane) {
        if (CutMode(m_mode) == CutMode::cutTongueAndGroove)
            return _u8L("Click to flip the cut plane\n"
                        "Drag to move the cut plane");
        return _u8L("Click to flip the cut plane\n"
                    "Drag to move the cut plane\n"
                    "Right-click a part to assign it to the other side");
    }
 
    if (tooltip.empty() && (m_hover_id == X || m_hover_id == Y || m_hover_id == CutPlaneZRotation)) {
        std::string axis = m_hover_id == X ? "X" : m_hover_id == Y ? "Y" : "Z";
        return axis + ": " + format(float(rad2deg(m_angle)), 1) + "°";
    }
 
    return tooltip;
}

References _u8L, _u8L_CONTEXT, CutPlane, CutPlaneZRotation, cutTongueAndGroove, Slic3r::GUI::GLGizmoBase::format(), m_angle, Slic3r::GUI::GLGizmoBase::m_dragging, Slic3r::GUI::GLGizmoBase::m_hover_id, m_imperial_units, m_keep_as_parts, m_mode, m_transformed_bounding_box, Slic3r::BoundingBoxBase< PointType, std::vector< PointType > >::max, Slic3r::BoundingBoxBase< PointType, std::vector< PointType > >::min, Slic3r::GUI::GizmoObjectManipulation::mm_to_in, Slic3r::Geometry::rad2deg(), Slic3r::BoundingBox3Base< PointType >::size(), X, Y, and Z.

Here is the call graph for this function:

◆ gizmo_event()

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

{
    if (is_dragging() || m_connector_mode == CutConnectorMode::Auto)
        return false;
 
    if ( (m_hover_id < 0 || m_hover_id == CutPlane) && shift_down &&  ! m_connectors_editing &&
        (action == SLAGizmoEventType::LeftDown || action == SLAGizmoEventType::LeftUp || action == SLAGizmoEventType::Moving) )
        return process_cut_line(action, mouse_position);
 
    if (!m_keep_upper || !m_keep_lower)
        return false;
 
    if (!m_connectors_editing)
        return false;
 
    CutConnectors& connectors = m_c->selection_info()->model_object()->cut_connectors;
 
    if (action == SLAGizmoEventType::LeftDown) {
        if (shift_down || alt_down) {
            // left down with shift - show the selection rectangle:
            if (m_hover_id == -1)
                m_selection_rectangle.start_dragging(mouse_position, shift_down ? GLSelectionRectangle::EState::Select : GLSelectionRectangle::EState::Deselect);
        }
        else
            // If there is no selection and no hovering, add new point
            if (m_hover_id == -1 && !shift_down && !alt_down)
                if (!add_connector(connectors, mouse_position))
                    m_ldown_mouse_position = mouse_position;
        return true;
    }
 
    if (action == SLAGizmoEventType::LeftUp && !m_selection_rectangle.is_dragging()) {
        if ((m_ldown_mouse_position - mouse_position).norm() < 5.)
            unselect_all_connectors();
        return is_selection_changed(alt_down, shift_down);
    }
 
    // left up with selection rectangle - select points inside the rectangle:
    if ((action == SLAGizmoEventType::LeftUp || action == SLAGizmoEventType::ShiftUp || action == SLAGizmoEventType::AltUp) && m_selection_rectangle.is_dragging()) {
        // Is this a selection or deselection rectangle?
        process_selection_rectangle(connectors);
        return true;
    }
 
    // dragging the selection rectangle:
    if (action == SLAGizmoEventType::Dragging) {
        if (m_selection_rectangle.is_dragging()) {
            m_selection_rectangle.dragging(mouse_position);
            return true;
        }
        return false;
    }
    
    if (action == SLAGizmoEventType::RightDown && !shift_down) {
        // If any point is in hover state, this should initiate its move - return control back to GLCanvas:
        if (m_hover_id < m_connectors_group_id)
            return false;
        unselect_all_connectors();
        select_connector(m_hover_id - m_connectors_group_id, true);
        return delete_selected_connectors(connectors);
    }
    
    if (action == SLAGizmoEventType::Delete)
        return delete_selected_connectors(connectors);
 
    if (action == SLAGizmoEventType::SelectAll) {
        select_all_connectors();
        return true;
    }
 
    return false;
}

References add_connector(), Slic3r::GUI::AltUp, Auto, CutPlane, Slic3r::GUI::Delete, delete_selected_connectors(), Slic3r::GUI::GLSelectionRectangle::Deselect, Slic3r::GUI::Dragging, Slic3r::GUI::GLGizmoBase::is_dragging(), is_selection_changed(), Slic3r::GUI::LeftDown, Slic3r::GUI::LeftUp, Slic3r::GUI::GLGizmoBase::m_c, m_connector_mode, m_connectors_editing, m_connectors_group_id, Slic3r::GUI::GLGizmoBase::m_hover_id, m_keep_lower, m_keep_upper, m_ldown_mouse_position, m_selection_rectangle, Slic3r::GUI::Moving, process_cut_line(), process_selection_rectangle(), Slic3r::GUI::RightDown, Slic3r::GUI::GLSelectionRectangle::Select, select_all_connectors(), select_connector(), Slic3r::GUI::SelectAll, Slic3r::GUI::ShiftUp, and unselect_all_connectors().

Referenced by Slic3r::GUI::GLGizmosManager::gizmo_event(), and on_mouse().

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.

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.

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.

Here is the call graph for this function:

Here is the caller graph for this function:

◆ has_valid_contour()

bool Slic3r::GUI::GLGizmoCut3D::has_valid_contour ( ) const

private

{
    const auto clipper = m_c->object_clipper();
    return clipper && clipper->has_valid_contour();
}

References Slic3r::GUI::GLGizmoBase::m_c.

Referenced by render_input_window_warning().

Here is the caller graph for this function:

◆ has_valid_groove()

bool Slic3r::GUI::GLGizmoCut3D::has_valid_groove ( ) const

private

{
    if (CutMode(m_mode) != CutMode::cutTongueAndGroove)
        return true;
 
    const float flaps_width = -2.f * m_groove.depth / tan(m_groove.flaps_angle);
    if (flaps_width > m_groove.width)
        return false;
 
    const Selection& selection  = m_parent.get_selection();
    const auto&list = selection.get_volume_idxs();
    // is more volumes selected?
    if (list.empty())
        return false;
 
    const Transform3d cp_matrix = translation_transform(m_plane_center) * m_rotation_m;
 
    for (size_t id = 0; id < m_groove_vertices.size(); id += 2) {
        const Vec3d beg = cp_matrix * m_groove_vertices[id];
        const Vec3d end = cp_matrix * m_groove_vertices[id + 1];
 
        bool intersection = false;
        for (const unsigned int volume_idx : list) {
            const GLVolume* glvol = selection.get_volume(volume_idx);
            if (!glvol->is_modifier && 
                glvol->mesh_raycaster->intersects_line(beg, end - beg, glvol->world_matrix())) {
                intersection = true;
                break;
            }
        }
        if (!intersection)
            return false;
    }
 
    return true;
}

References cutTongueAndGroove, Slic3r::GUI::Selection::get_volume(), Slic3r::GUI::Selection::get_volume_idxs(), Slic3r::intersection(), m_groove, m_groove_vertices, m_mode, Slic3r::GUI::GLGizmoBase::m_parent, m_plane_center, m_rotation_m, Slic3r::GLVolume::mesh_raycaster, Slic3r::Geometry::translation_transform(), and Slic3r::GLVolume::world_matrix().

Referenced by can_perform_cut(), process_contours(), render_cut_plane(), render_input_window_warning(), and reset_cut_by_contours().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ init()

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

inlineinherited

168{ return on_init(); }

Slic3r::GUI::GLGizmoBase::on_init

virtual bool on_init()=0

References on_init().

Here is the call graph for this function:

◆ init_connector_shapes()

void Slic3r::GUI::GLGizmoCut3D::init_connector_shapes ( )

private

{
    for (const CutConnectorType& type : {CutConnectorType::Dowel, CutConnectorType::Plug, CutConnectorType::Snap})
        for (const CutConnectorStyle& style : {CutConnectorStyle::Frustum, CutConnectorStyle::Prism}) {
            if (type == CutConnectorType::Dowel && style == CutConnectorStyle::Frustum)
                continue;
            for (const CutConnectorShape& shape : {CutConnectorShape::Circle, CutConnectorShape::Hexagon, CutConnectorShape::Square, CutConnectorShape::Triangle}) {
                if (type == CutConnectorType::Snap && shape != CutConnectorShape::Circle)
                    continue;
                const CutConnectorAttributes attribs = { type, style, shape };
                indexed_triangle_set its = get_connector_mesh(attribs);
                m_shapes[attribs].model.init_from(its);
                m_shapes[attribs].mesh_raycaster = std::make_unique<MeshRaycaster>(std::make_shared<const TriangleMesh>(std::move(its)));
            }
        }
}

References Slic3r::Circle, Slic3r::Dowel, Slic3r::Frustum, get_connector_mesh(), Slic3r::Hexagon, m_shapes, Slic3r::Plug, Slic3r::Prism, Slic3r::Snap, Slic3r::Square, style, and Slic3r::Triangle.

Referenced by init_picking_models().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ init_input_window_data()

void Slic3r::GUI::GLGizmoCut3D::init_input_window_data ( CutConnectors & connectors )

protected

{
    m_imperial_units = wxGetApp().app_config->get_bool("use_inches");
    m_control_width  = m_imgui->get_font_size() * 9.f;
 
    m_editing_window_width = 1.45 * m_control_width + 11;
 
    if (m_connectors_editing && m_selected_count > 0) {
        float               depth_ratio             { UndefFloat };
        float               depth_ratio_tolerance   { UndefFloat };
        float               radius                  { UndefFloat };
        float               radius_tolerance        { UndefFloat };
        float               angle                   { UndefFloat };
        CutConnectorType    type                    { CutConnectorType::Undef };
        CutConnectorStyle   style                   { CutConnectorStyle::Undef };
        CutConnectorShape   shape                   { CutConnectorShape::Undef };
 
        bool is_init = false;
        for (size_t idx = 0; idx < m_selected.size(); idx++)
            if (m_selected[idx]) {
                const CutConnector& connector = connectors[idx];
                if (!is_init) {
                    depth_ratio             = connector.height;
                    depth_ratio_tolerance   = connector.height_tolerance;
                    radius                  = connector.radius;
                    radius_tolerance        = connector.radius_tolerance;
                    angle                   = connector.z_angle;
                    type                    = connector.attribs.type;
                    style                   = connector.attribs.style;
                    shape                   = connector.attribs.shape;
 
                    if (m_selected_count == 1)
                        break;
                    is_init = true;
                }
                else {
                    if (!is_approx(depth_ratio, connector.height))
                        depth_ratio         = UndefFloat;
                    if (!is_approx(depth_ratio_tolerance, connector.height_tolerance))
                        depth_ratio_tolerance = UndefFloat;
                    if (!is_approx(radius,connector.radius))
                        radius              = UndefFloat;
                    if (!is_approx(radius_tolerance, connector.radius_tolerance))
                        radius_tolerance    = UndefFloat;
                    if (!is_approx(angle, connector.z_angle))
                        angle               = UndefFloat;
 
                    if (type != connector.attribs.type)
                        type = CutConnectorType::Undef;
                    if (style != connector.attribs.style)
                        style = CutConnectorStyle::Undef;
                    if (shape != connector.attribs.shape)
                        shape = CutConnectorShape::Undef;
                }
            }
 
        m_connector_depth_ratio             = depth_ratio;
        m_connector_depth_ratio_tolerance   = depth_ratio_tolerance;
        m_connector_size                    = 2.f * radius;
        m_connector_size_tolerance          = 2.f * radius_tolerance;
        m_connector_type                    = type;
        m_connector_angle                   = angle;
        m_connector_style                   = int(style);
        m_connector_shape_id                = int(shape);
    }
 
    if (m_label_width == 0.f) {
        for (const auto& item : m_labels_map) {
            const float width = m_imgui->calc_text_size(item.second).x;
            if (m_label_width < width)
                m_label_width = width;
        }
        m_label_width += m_imgui->scaled(1.f);
        m_label_width += ImGui::GetStyle().WindowPadding.x;
    }
}

References Slic3r::angle(), Slic3r::CutConnector::attribs, Slic3r::CutConnector::height, Slic3r::CutConnector::height_tolerance, Slic3r::is_approx(), m_connector_angle, m_connector_depth_ratio, m_connector_depth_ratio_tolerance, m_connector_shape_id, m_connector_size, m_connector_size_tolerance, m_connector_style, m_connector_type, m_connectors_editing, m_control_width, m_editing_window_width, Slic3r::GUI::GLGizmoBase::m_imgui, m_imperial_units, m_label_width, m_labels_map, m_selected, m_selected_count, Slic3r::CutConnector::radius, Slic3r::CutConnector::radius_tolerance, Slic3r::CutConnectorAttributes::shape, Slic3r::CutConnectorAttributes::style, style, Slic3r::CutConnectorAttributes::type, Slic3r::Undef, Slic3r::GUI::UndefFloat, and Slic3r::CutConnector::z_angle.

Referenced by on_render_input_window().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ init_picking_models()

void Slic3r::GUI::GLGizmoCut3D::init_picking_models ( )

private

{
    if (!m_cone.model.is_initialized()) {
        indexed_triangle_set its = its_make_cone(1.0, 1.0, PI / 12.0);
        m_cone.model.init_from(its);
        m_cone.mesh_raycaster = std::make_unique<MeshRaycaster>(std::make_shared<const TriangleMesh>(std::move(its)));
    }
    if (!m_sphere.model.is_initialized()) {
        indexed_triangle_set its = its_make_sphere(1.0, PI / 12.0);
        m_sphere.model.init_from(its);
        m_sphere.mesh_raycaster = std::make_unique<MeshRaycaster>(std::make_shared<const TriangleMesh>(std::move(its)));
    }
    if (!m_cube.model.is_initialized()) {
        indexed_triangle_set its = its_make_cube(1., 1., 1.);
        m_cube.model.init_from(its);
        m_cube.mesh_raycaster = std::make_unique<MeshRaycaster>(std::make_shared<const TriangleMesh>(std::move(its)));
    }
 
    if (!m_plane.model.is_initialized() && !m_hide_cut_plane && !m_connectors_editing) {
        const double cp_width = 0.02 * get_grabber_mean_size(m_bounding_box);
        indexed_triangle_set its = m_mode == size_t(CutMode::cutTongueAndGroove) ? its_make_groove_plane() :
                                   its_make_frustum_dowel((double)m_cut_plane_radius_koef * m_radius, cp_width, m_cut_plane_as_circle ? 180 : 4);
 
        m_plane.model.init_from(its);
        m_plane.mesh_raycaster = std::make_unique<MeshRaycaster>(std::make_shared<const TriangleMesh>(std::move(its)));
    }
 
    if (m_shapes.empty())
        init_connector_shapes();
}

References cutTongueAndGroove, Slic3r::GUI::get_grabber_mean_size(), init_connector_shapes(), Slic3r::its_make_cone(), Slic3r::its_make_cube(), Slic3r::its_make_frustum_dowel(), its_make_groove_plane(), Slic3r::its_make_sphere(), m_bounding_box, m_cone, m_connectors_editing, m_cube, m_cut_plane_as_circle, m_cut_plane_radius_koef, m_hide_cut_plane, m_mode, m_plane, m_radius, m_shapes, m_sphere, and PI.

Referenced by on_register_raycasters_for_picking(), on_render(), and update_plane_model().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ init_rendering_items()

void Slic3r::GUI::GLGizmoCut3D::init_rendering_items ( )

private

{
    if (!m_grabber_connection.is_initialized())
        m_grabber_connection.init_from(its_make_line(Vec3f::Zero(), Vec3f::UnitZ()));
    if (!m_circle.is_initialized())
        init_from_circle(m_circle, m_grabber_radius);
    if (!m_scale.is_initialized())
        init_from_scale(m_scale, m_grabber_radius);
    if (!m_snap_radii.is_initialized())
        init_from_snap_radii(m_snap_radii, m_grabber_radius);
    if (!m_reference_radius.is_initialized()) {
        m_reference_radius.init_from(its_make_line(Vec3f::Zero(), m_grabber_connection_len * Vec3f::UnitX()));
        m_reference_radius.set_color(ColorRGBA::WHITE());
    }
    if (!m_angle_arc.is_initialized() || m_angle != 0.0)
        init_from_angle_arc(m_angle_arc, m_angle, m_grabber_connection_len);
}

References Slic3r::GUI::init_from_angle_arc(), Slic3r::GUI::init_from_circle(), Slic3r::GUI::init_from_scale(), Slic3r::GUI::init_from_snap_radii(), Slic3r::GUI::its_make_line(), m_angle, m_angle_arc, m_circle, m_grabber_connection, m_grabber_connection_len, m_grabber_radius, m_reference_radius, m_scale, m_snap_radii, and Slic3r::ColorRGBA::WHITE().

Referenced by on_render().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ invalidate_cut_plane()

void Slic3r::GUI::GLGizmoCut3D::invalidate_cut_plane ( )

{
    m_rotation_m    = Transform3d::Identity();
    m_plane_center  = Vec3d::Zero();
    m_min_pos       = Vec3d::Zero();
    m_max_pos       = Vec3d::Zero();
    m_bb_center     = Vec3d::Zero();
    m_center_offset = Vec3d::Zero();
}

References m_bb_center, m_center_offset, m_max_pos, m_min_pos, m_plane_center, and m_rotation_m.

Referenced by update_bb().

Here is the caller graph for this function:

◆ is_activable()

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

inlineinherited

184{ return on_is_activable(); }

Slic3r::GUI::GLGizmoBase::on_is_activable

virtual bool on_is_activable() const

Definition GLGizmoBase.hpp:246

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_conflict_for_connector()

bool Slic3r::GUI::GLGizmoCut3D::is_conflict_for_connector	(	size_t	idx,
		const CutConnectors &	connectors,
		const Vec3d	cur_pos )

private

{
    if (is_outside_of_cut_contour(idx, connectors, cur_pos))
        return true;
 
    const CutConnector& cur_connector = connectors[idx];    
 
    const Transform3d matrix = translation_transform(cur_pos) * m_rotation_m *
                               scale_transform(Vec3f(cur_connector.radius, cur_connector.radius, cur_connector.height).cast<double>());
    const BoundingBoxf3 cur_tbb = m_shapes[cur_connector.attribs].model.get_bounding_box().transformed(matrix);
 
    // check if connector's bounding box is inside the object's bounding box
    if (!m_bounding_box.contains(cur_tbb)) {
        m_info_stats.outside_bb++;
        return true;
    }
 
    // check if connectors are overlapping 
    for (size_t i = 0; i < connectors.size(); ++i) {
        if (i == idx)
            continue;
        const CutConnector& connector = connectors[i];
 
        if ((connector.pos - cur_connector.pos).norm() < double(connector.radius + cur_connector.radius)) {
            m_info_stats.is_overlap = true;
            return true;
        }
    }
 
    return false;
}

References Slic3r::CutConnector::attribs, Slic3r::CutConnector::height, is_outside_of_cut_contour(), m_bounding_box, m_info_stats, m_rotation_m, m_shapes, Slic3r::CutConnector::pos, Slic3r::CutConnector::radius, Slic3r::Geometry::scale_transform(), and Slic3r::Geometry::translation_transform().

Referenced by check_and_update_connectors_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

209{ 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_in_editing_mode()

bool Slic3r::GUI::GLGizmoCut3D::is_in_editing_mode ( ) const

inlineoverridevirtual

Reimplemented from Slic3r::GUI::GLGizmoBase.

267{ return m_connectors_editing; }

References m_connectors_editing.

◆ is_looking_forward()

bool Slic3r::GUI::GLGizmoCut3D::is_looking_forward ( ) const

{
    const Camera& camera = wxGetApp().plater()->get_camera();
    const double dot = camera.get_dir_forward().dot(m_cut_normal);
    return dot < 0.05;
}

References Slic3r::dot(), Slic3r::GUI::Camera::get_dir_forward(), and m_cut_normal.

Referenced by Slic3r::GUI::GLGizmoCut3D::PartSelection::render(), render_connectors(), update_clipper(), and update_raycasters_for_picking_transform().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ is_outside_of_cut_contour()

bool Slic3r::GUI::GLGizmoCut3D::is_outside_of_cut_contour	(	size_t	idx,
		const CutConnectors &	connectors,
		const Vec3d	cur_pos )

private

{
    // check if connector pos is out of clipping plane
    if (m_c->object_clipper() && m_c->object_clipper()->is_projection_inside_cut(cur_pos) == -1) {
        m_info_stats.outside_cut_contour++;
        return true;
    }
 
    // check if connector bottom contour is out of clipping plane
    const CutConnector& cur_connector = connectors[idx];
    const CutConnectorShape shape = CutConnectorShape(cur_connector.attribs.shape);
    const int   sectorCount = shape == CutConnectorShape::Triangle  ? 3 :
                              shape == CutConnectorShape::Square    ? 4 :
                              shape == CutConnectorShape::Circle    ? 60: // supposably, 60 points are enough for conflict detection
                              shape == CutConnectorShape::Hexagon   ? 6 : 1 ;
 
    indexed_triangle_set mesh;
    auto& vertices = mesh.vertices;
    vertices.reserve(sectorCount + 1);
 
    float fa = 2 * PI / sectorCount;
    auto vec = Eigen::Vector2f(0, cur_connector.radius);
    for (float angle = 0; angle < 2.f * PI; angle += fa) {
        Vec2f p = Eigen::Rotation2Df(angle) * vec;
        vertices.emplace_back(Vec3f(p(0), p(1), 0.f));
    }
    its_transform(mesh, translation_transform(cur_pos) * m_rotation_m);
 
    for (const Vec3f& vertex : vertices) {
        if (m_c->object_clipper()) {
            int contour_idx = m_c->object_clipper()->is_projection_inside_cut(vertex.cast<double>());
            bool is_invalid = (contour_idx == -1);
            if (m_part_selection.valid() && ! is_invalid) {
                assert(contour_idx >= 0);
                const std::vector<size_t>& ignored = *(m_part_selection.get_ignored_contours_ptr());
                is_invalid = (std::find(ignored.begin(), ignored.end(), size_t(contour_idx)) != ignored.end());
            }
            if (is_invalid) {
                m_info_stats.outside_cut_contour++;
                return true;
            }
        }
    }
 
    return false;
}

References Slic3r::angle(), Slic3r::CutConnector::attribs, Slic3r::Circle, Slic3r::Hexagon, Slic3r::GUI::GLGizmoBase::m_c, m_info_stats, m_part_selection, m_rotation_m, PI, Slic3r::CutConnector::radius, Slic3r::CutConnectorAttributes::shape, Slic3r::Square, Slic3r::Geometry::translation_transform(), and Slic3r::Triangle.

Referenced by is_conflict_for_connector().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ is_selectable()

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

inlineinherited

185{ return on_is_selectable(); }

Slic3r::GUI::GLGizmoBase::on_is_selectable

virtual bool on_is_selectable() const

Definition GLGizmoBase.hpp:247

References on_is_selectable().

Here is the call graph for this function:

◆ is_selection_changed()

bool Slic3r::GUI::GLGizmoCut3D::is_selection_changed	(	bool	alt_down,
		bool	shift_down )

protected

{
    if (m_hover_id >= m_connectors_group_id) {
        if (alt_down)
            select_connector(m_hover_id - m_connectors_group_id, false);
        else {
            if (!shift_down)
                unselect_all_connectors();
            select_connector(m_hover_id - m_connectors_group_id, true);
        }
        return true;
    }
    return false;
}

References m_connectors_group_id, Slic3r::GUI::GLGizmoBase::m_hover_id, select_connector(), and unselect_all_connectors().

Referenced by gizmo_event().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ is_selection_rectangle_dragging()

bool Slic3r::GUI::GLGizmoCut3D::is_selection_rectangle_dragging ( ) const

inlineoverridevirtual

Reimplemented from Slic3r::GUI::GLGizmoBase.

268{ return m_selection_rectangle.is_dragging(); }

References m_selection_rectangle.

◆ its_make_groove_plane()

indexed_triangle_set Slic3r::GUI::GLGizmoCut3D::its_make_groove_plane ( )

private

{
    // This function generates a dovetail slot in a wall, viewed from above (top-down).
    // The slot has a wide "mouth" (closest to the wall surface) and a narrow "neck" (deepest into the wall).
    // The flaps are the tapered sides connecting the mouth to the neck.
 
    const float flap_taper_width  = is_approx(m_groove.flaps_angle, 0.f) ? m_groove.depth : (m_groove.depth / sin(m_groove.flaps_angle));
    const float total_flap_taper_width = 2.f * flap_taper_width * cos(m_groove.flaps_angle);
 
    const float slot_neck_half_width = 0.5f * (m_groove.width);
    const float slot_mouth_half_width = 0.5f * (m_groove.width + total_flap_taper_width);
 
    const float cut_plane_radius = 1.5f * float(m_radius);
    const float cut_plane_length = 1.5f * cut_plane_radius;
 
    const float plane_half_width    = 0.5f * cut_plane_radius;  // x
    const float plane_half_height   = 0.5f * cut_plane_length;  // y
 
    const float slot_half_depth   = 0.5f * m_groove.depth;    // z
    float slot_front_z          = slot_half_depth;
    float slot_back_z           = -slot_half_depth;
 
    const float flap_taper_offset = plane_half_height * tan(m_groove.angle);
 
    float slot_mouth_outer_x = slot_neck_half_width + flap_taper_offset; // upper_x extension
    float slot_neck_outer_x = slot_mouth_half_width + flap_taper_offset; // lower_x extension
    float slot_outer_x_max   = std::max(slot_neck_outer_x, slot_mouth_outer_x);  // max x extension
 
    float slot_neck_inner_x = slot_neck_half_width - flap_taper_offset; // upper_x narrowing
    float slot_mouth_inner_x = slot_mouth_half_width - flap_taper_offset; // lower_x narrowing
 
    const float wall_thickness = 0.02f; // 0.02f * (float)get_grabber_mean_size(m_bounding_box);   // cut_plane_thiknes
 
    int   groove_count    = this->m_groove_count;
    float groove_gap = this->m_groove_gap;
 
    indexed_triangle_set mesh;
 
    // handle multiple dovetails/grooves
    m_groove_vertices.clear();
    m_groove_vertices.reserve(8 * groove_count);
    for (int i = 0; i < groove_count; ++i) {
        bool is_first_groove = i == 0; // when a groove is not the last groove, then limit the extent of the right plane so that it doesnt overlap the next groove 
        bool is_last_groove  = i == groove_count - 1; // do the same in reverse if a groove is not the first groove
        size_t vertex_index_offset      = mesh.vertices.size();
 
        // Calculate the x-axis offset for this dovetail
        float groove_offset_factor_start = -.5 * ((groove_count - 1));
        float  groove_offset_factor   = groove_offset_factor_start + i;
        // Recalculate x with offset (only X-axis offset)
        float offset_x = groove_offset_factor * (groove_gap + (2 * slot_outer_x_max));
 
        // Vertices of the groove used to detection if groove is valid (not used in mesh)
        {
            m_groove_vertices.emplace_back(Vec3f(-slot_neck_outer_x + offset_x, -plane_half_height, slot_front_z).cast<double>());
            m_groove_vertices.emplace_back(Vec3f(-slot_mouth_inner_x + offset_x, plane_half_height, slot_front_z).cast<double>());
            m_groove_vertices.emplace_back(Vec3f(-slot_mouth_outer_x + offset_x, -plane_half_height, slot_back_z).cast<double>());
            m_groove_vertices.emplace_back(Vec3f(-slot_neck_outer_x + offset_x, plane_half_height, slot_back_z).cast<double>());
            m_groove_vertices.emplace_back(Vec3f(slot_neck_outer_x + offset_x, -plane_half_height, slot_front_z).cast<double>());
            m_groove_vertices.emplace_back(Vec3f(slot_mouth_inner_x + offset_x, plane_half_height, slot_front_z).cast<double>());
            m_groove_vertices.emplace_back(Vec3f(slot_mouth_outer_x + offset_x, -plane_half_height, slot_back_z).cast<double>());
            m_groove_vertices.emplace_back(Vec3f(slot_neck_outer_x + offset_x, plane_half_height, slot_back_z).cast<double>());
        }
 
        //                                     ___
        // Case: Groove is open (Top&bottom: __\ /__ )
        if (slot_neck_half_width > flap_taper_offset && slot_mouth_half_width > flap_taper_offset) {
            auto get_vertices = [plane_half_width, plane_half_height]
                (float slot_front_z, float slot_back_z, float slot_neck_inner_x, float slot_mouth_inner_x, float slot_mouth_outer_x, float slot_neck_outer_x, 
                float slot_outer_x_max, bool is_first_groove, bool is_last_groove, float groove_gap, float offset_x)
                {
 
                return std::vector<stl_vertex>({
                    // front left part vertices
                    {is_first_groove ? -plane_half_width + offset_x : -(groove_gap / 2.f) - slot_outer_x_max + offset_x,    -plane_half_height, slot_front_z},    // *__/ \__
                    {is_first_groove ? -plane_half_width + offset_x : -(groove_gap / 2.f) - slot_outer_x_max + offset_x,    plane_half_height,  slot_front_z},    // *__/ \__
                    {-slot_neck_inner_x + offset_x,     plane_half_height,      slot_front_z},   // __*/ \__
                    {-slot_mouth_outer_x + offset_x,    -plane_half_height,     slot_front_z},   // __/* \__
                    // back part vertices
                    {-slot_neck_outer_x + offset_x,     -plane_half_height,     slot_back_z},   // __*/ \__
                    {-slot_mouth_inner_x + offset_x,    plane_half_height,      slot_back_z},   // __/* \__
                    {slot_mouth_inner_x + offset_x,     plane_half_height,      slot_back_z},   // __/ *\__
                    {slot_neck_outer_x + offset_x,      -plane_half_height,     slot_back_z},   // __/ \*__
                    // front right part vertices
                    {slot_mouth_outer_x + offset_x,     -plane_half_height,     slot_front_z},   // __/ \*__
                    {slot_neck_inner_x + offset_x,      plane_half_height,      slot_front_z},   // __/ *\__
                    {is_last_groove ? plane_half_width + offset_x : (groove_gap / 2.f) + slot_outer_x_max + offset_x,       plane_half_height,  slot_front_z},      // __/ \__*
                    {is_last_groove ? plane_half_width + offset_x : (groove_gap / 2.f) + slot_outer_x_max + offset_x,       -plane_half_height, slot_front_z}});    // __/ \__*
            };
 
            std::vector<stl_vertex> vertices = get_vertices(slot_front_z, slot_back_z, slot_neck_inner_x, slot_mouth_inner_x, slot_mouth_outer_x, slot_neck_outer_x, slot_outer_x_max,
                                                            is_first_groove, is_last_groove, groove_gap, offset_x);
            mesh.vertices.insert(mesh.vertices.end(), vertices.begin(), vertices.end());
 
            // Back face
            slot_front_z        -= wall_thickness;
            slot_back_z         -= wall_thickness;
 
            const float slot_back_face_x_offset = wall_thickness / tan(0.5f * m_groove.flaps_angle);
            slot_neck_inner_x   += slot_back_face_x_offset;
            slot_mouth_inner_x  += slot_back_face_x_offset;
            slot_mouth_outer_x  += slot_back_face_x_offset;
            slot_neck_outer_x   += slot_back_face_x_offset;
 
            vertices = get_vertices(slot_front_z, slot_back_z, slot_neck_inner_x, slot_mouth_inner_x, slot_mouth_outer_x, slot_neck_outer_x,
                                    slot_outer_x_max, is_first_groove,
                                    is_last_groove, groove_gap, offset_x);
            mesh.vertices.insert(mesh.vertices.end(), vertices.begin(), vertices.end());
 
            std::vector<Vec3i32> base_indices;
            
            base_indices  = {
                // above view
                {5,4,7}, {5,7,6},       // lower part
                {3,4,5}, {3,5,2},       // left side
                {9,6,8}, {8,6,7},       // right side
                {1,0,2}, {2,0,3},       // upper left part
                {9,8,10}, {10,8,11},    // upper right part
                // under view
                {20,21,22}, {20,22,23}, // upper right part
                {12,13,14}, {12,14,15}, // upper left part
                {18,21,20}, {18,20,19}, // right side
                {16,15,14}, {16,14,17}, // left side
                {16,17,18}, {16,18,19}, // lower part  
                // left edge
                {1,13,0}, {0,13,12},
                // front edge
                {0,12,3}, {3,12,15}, {3,15,4}, {4,15,16}, {4,16,7}, {7,16,19}, {7,19,20}, {7,20,8}, {8,20,11}, {11,20,23},
                // right edge
                {11,23,10}, {10,23,22},
                // back edge
                {1,13,2}, {2,13,14}, {2,14,17}, {2,17,5}, {5,17,6}, {6,17,18}, {6,18,9}, {9,18,21}, {9,21,10}, {10,21,22}
            };            
               
            std::vector<Vec3i32> indices = offset_indices(base_indices, vertex_index_offset);
            mesh.indices.insert(mesh.indices.end(), indices.begin(), indices.end());
        }
 
        //                                         __
        // CASE: Groove is closed (Top&Bottom: ___/  \___)
        else if (slot_neck_half_width < flap_taper_offset && slot_mouth_half_width < flap_taper_offset) {
            float slot_neck_apex_y = slot_neck_half_width / tan(m_groove.angle);
            float slot_mouth_apex_y = slot_mouth_half_width / tan(m_groove.angle);
 
            auto get_vertices = [plane_half_width, plane_half_height]
            (float slot_front_z, float slot_back_z, float slot_neck_apex_y, float slot_mouth_apex_y, float slot_mouth_outer_x, float slot_neck_outer_x,
             float slot_outer_x_max, bool is_first_groove, bool is_last_groove, float groove_gap, float offset_x)
            {
                return std::vector<stl_vertex>({
                    // front part vertices
                    {is_first_groove ? -plane_half_width + offset_x : -(groove_gap / 2.f) - slot_outer_x_max + offset_x,  -plane_half_height,     slot_front_z},   // *__/\__
                    {is_first_groove ? -plane_half_width + offset_x : -(groove_gap / 2.f) - slot_outer_x_max + offset_x,  plane_half_height,      slot_front_z},   // *__/\__
                    {is_last_groove ? plane_half_width + offset_x : (groove_gap / 2.f) + slot_outer_x_max + offset_x,     plane_half_height,      slot_front_z},   // __/\__*
                    {is_last_groove ? plane_half_width + offset_x : (groove_gap / 2.f) + slot_outer_x_max + offset_x,     -plane_half_height,     slot_front_z},   // __/\__*
                    {slot_mouth_outer_x + offset_x,     -plane_half_height,     slot_front_z},    // __*/\__
                    {offset_x,                          slot_neck_apex_y,       slot_front_z},    // __/*\__
                    {-slot_mouth_outer_x + offset_x,    -plane_half_height,     slot_front_z},    // __/\*__
                    // back part vertices
                    {-slot_neck_outer_x + offset_x,     -plane_half_height,     slot_back_z},    // __*/\__
                    {offset_x,                          slot_mouth_apex_y,      slot_back_z},    // __/*\__
                    {slot_neck_outer_x + offset_x,      -plane_half_height,     slot_back_z}});  // __/\*__
            };
 
            std::vector<stl_vertex> vertices = get_vertices(slot_front_z, slot_back_z, slot_neck_apex_y, slot_mouth_apex_y,
                                                            slot_mouth_outer_x, slot_neck_outer_x, slot_outer_x_max,
                                                            is_first_groove, is_last_groove, groove_gap, offset_x);
            mesh.vertices.insert(mesh.vertices.end(), vertices.begin(), vertices.end());
 
            // Back face
            slot_front_z        -= wall_thickness;
            slot_back_z         -= wall_thickness;
            slot_neck_apex_y    += wall_thickness;
            slot_mouth_apex_y   += wall_thickness;
 
            const float slot_back_face_x_offset = wall_thickness / tan(0.5f * m_groove.flaps_angle);
            slot_mouth_outer_x  += slot_back_face_x_offset;
            slot_neck_outer_x   += slot_back_face_x_offset;
 
            vertices = get_vertices(slot_front_z, slot_back_z, slot_neck_apex_y, slot_mouth_apex_y, slot_mouth_outer_x, slot_neck_outer_x,
                                    slot_outer_x_max, is_first_groove,
                                    is_last_groove, groove_gap, offset_x);
            mesh.vertices.insert(mesh.vertices.end(), vertices.begin(), vertices.end());
 
            std::vector<Vec3i32> base_indices = {
                // above view
                {8,7,9},                // lower part
                {5,8,6}, {6,8,7},       // left side
                {4,9,8}, {4,8,5},       // right side
                {1,0,6}, {1,6,5},{1,5,2},
                {2,5,4}, {2,4,3},       // upper part
                // under view
                {10,11,16}, {16,11,15}, 
                {15,11,12}, {15,12,14}, {14,12,13},   // upper part
                {18,15,14}, {14,18,19}, // right side
                {17,16,15}, {17,15,18}, // left side
                {17,18,19},             // lower part  
                // left edge
                {1,11,0}, {0,11,10},
                // front edge
                {0,10,6}, {6,10,16}, {6,17,16}, {6,7,17}, {7,17,19}, {7,19,9}, {4,14,19}, {4,19,9}, {4,14,13}, {4,13,3},
                // right edge
                {3,13,12}, {3,12,2},
                // back edge
                {2,12,11}, {2,11,1}
            };
            std::vector<Vec3i32> indices      = offset_indices(base_indices, vertex_index_offset);
 
            mesh.indices.insert(mesh.indices.end(), indices.begin(), indices.end());
        }
 
        // Case: Groove is closed from the roof (TOP&Bottom: __/\__ )
        else {
            float slot_neck_apex_y = slot_neck_half_width / tan(m_groove.angle);
 
            std::vector<stl_vertex> vertices = {
                // front part vertices
                {is_first_groove ? -plane_half_width + offset_x : -(groove_gap / 2.f) - slot_outer_x_max + offset_x,  -plane_half_height,     slot_front_z},
                {is_first_groove ? -plane_half_width + offset_x : -(groove_gap / 2.f) - slot_outer_x_max + offset_x,  plane_half_height,      slot_front_z},
                {is_last_groove ? plane_half_width + offset_x : (groove_gap / 2.f) + slot_outer_x_max + offset_x,     plane_half_height,      slot_front_z},
                {is_last_groove ? plane_half_width + offset_x : (groove_gap / 2.f) + slot_outer_x_max + offset_x,     -plane_half_height,     slot_front_z},
                {slot_mouth_outer_x + offset_x,     -plane_half_height,     slot_front_z},
                {offset_x,                          slot_neck_apex_y,       slot_front_z},
                {-slot_mouth_outer_x + offset_x,    -plane_half_height,     slot_front_z},
                // back part vertices
                {-slot_neck_outer_x + offset_x,     -plane_half_height,     slot_back_z},
                {-slot_mouth_inner_x + offset_x,    plane_half_height,      slot_back_z},
                {slot_mouth_inner_x + offset_x,     plane_half_height,      slot_back_z},
                {slot_neck_outer_x + offset_x,      -plane_half_height,     slot_back_z}};
            mesh.vertices.insert(mesh.vertices.end(), vertices.begin(), vertices.end());
 
            // Back face
            slot_front_z        -= wall_thickness;
            slot_back_z         -= wall_thickness;
 
            const float slot_back_face_x_offset = wall_thickness / tan(0.5f * m_groove.flaps_angle);
            slot_mouth_inner_x  += slot_back_face_x_offset;
            slot_mouth_outer_x  += slot_back_face_x_offset;
            slot_neck_outer_x   += slot_back_face_x_offset;
 
            vertices = {
                // upper part vertices
                {is_first_groove ? -plane_half_width + offset_x : -(groove_gap / 2.f) - slot_outer_x_max + offset_x,  -plane_half_height, slot_front_z},
                {is_first_groove ? -plane_half_width + offset_x : -(groove_gap / 2.f) - slot_outer_x_max + offset_x,  plane_half_height,  slot_front_z},
                {is_last_groove ? plane_half_width + offset_x : (groove_gap / 2.f) + slot_outer_x_max + offset_x,     plane_half_height,  slot_front_z},
                {is_last_groove ? plane_half_width + offset_x : (groove_gap / 2.f) + slot_outer_x_max + offset_x,     -plane_half_height, slot_front_z},
                {slot_mouth_outer_x + offset_x,         -plane_half_height,     slot_front_z},
                {slot_back_face_x_offset + offset_x,    slot_neck_apex_y,       slot_front_z},
                {-slot_back_face_x_offset + offset_x,   slot_neck_apex_y,       slot_front_z},
                {-slot_mouth_outer_x + offset_x,        -plane_half_height,     slot_front_z},
                // lower part vertices
                {-slot_neck_outer_x + offset_x,         -plane_half_height,     slot_back_z},
                {-slot_mouth_inner_x + offset_x,        plane_half_height,      slot_back_z},
                {slot_mouth_inner_x + offset_x,         plane_half_height,      slot_back_z},
                {slot_neck_outer_x + offset_x,          -plane_half_height,     slot_back_z}};
            mesh.vertices.insert(mesh.vertices.end(), vertices.begin(), vertices.end());
 
            // Indices for this dovetail
            std::vector<Vec3i32> base_indices = {
                // above view
                {8,7,10}, {8,10,9},     // lower part
                {5,8,7}, {5,7,6},       // left side
                {4,10,9}, {4,9,5},      // right side
                {1,0,6}, {1,6,5},{1,5,2}, {2,5,4}, {2,4,3},   // upper part
                // under view
                {11,12,18}, {18,12,17}, {17,12,16}, {16,12,13}, {16,13,15}, {15,13,14},   // upper part
                {21,16,15}, {21,15,22}, // right side
                {19,18,17}, {19,17,20}, // left side
                {19,20,21}, {19,21,22}, // lower part  
                // left edge
                {1,12,11}, {1,11,0},
                // front edge
                {0,11,18}, {0,18,6}, {7,19,18}, {7,18,6}, {7,19,22}, {7,22,10}, {10,22,15}, {10,15,4}, {4,15,14}, {4,14,3},
                // right edge
                {3,14,13}, {3,14,2},
                // back edge
                {2,13,12}, {2,12,1}, {5,16,21}, {5,21,9}, {9,21,20}, {9,20,8}, {5,17,20}, {5,20,8}
            };
            std::vector<Vec3i32> indices      = offset_indices(base_indices, vertex_index_offset);
 
            mesh.indices.insert(mesh.indices.end(), indices.begin(), indices.end());
        }
    }
 
    return mesh;
}

References Slic3r::cast(), Slic3r::is_approx(), m_groove, m_groove_count, m_groove_gap, m_groove_vertices, m_radius, and offset_indices().

Referenced by init_picking_models().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ load()

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

inlineinherited

170{ m_state = On; on_load(ar); }

Slic3r::GUI::GLGizmoBase::on_load

virtual void on_load(cereal::BinaryInputArchive &ar)

Definition GLGizmoBase.hpp:241

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:

◆ mouse_position_in_local_plane()

Vec3d Slic3r::GUI::GLGizmoCut3D::mouse_position_in_local_plane	(	GrabberID	axis,
		const Linef3 &	mouse_ray ) const

protected

{
    double half_pi = 0.5 * PI;
 
    Transform3d m = Transform3d::Identity();
 
    switch (axis)
    {
    case X:
    {
        m.rotate(Eigen::AngleAxisd(half_pi, Vec3d::UnitZ()));
        m.rotate(Eigen::AngleAxisd(-half_pi, Vec3d::UnitY()));
        break;
    }
    case Y:
    {
        m.rotate(Eigen::AngleAxisd(half_pi, Vec3d::UnitY()));
        m.rotate(Eigen::AngleAxisd(half_pi, Vec3d::UnitZ()));
        break;
    }
    case Z:
    default:
    {
        // no rotation applied
        break;
    }
    }
 
    m = m * m_start_dragging_m.inverse();
    m.translate(-m_plane_center);
 
    return transform(mouse_ray, m).intersect_plane(0.0);
}

References Slic3r::Linef3::intersect_plane(), m_plane_center, m_start_dragging_m, PI, Slic3r::transform(), X, Y, and Z.

Referenced by dragging_grabber_rotation().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ offset_indices()

std::vector< Vec3i32 > Slic3r::GUI::GLGizmoCut3D::offset_indices	(	const std::vector< Vec3i32 > &	base_indices,
		size_t	vo )

private

{
    std::vector<Vec3i32> offset;
    int                  vo_int = static_cast<int>(vo);
    for (const auto& tri : base_indices) {
        offset.push_back({tri[0] + vo_int, tri[1] + vo_int, tri[2] + vo_int});
    }
    return offset;
}

References Slic3r::offset().

Referenced by its_make_groove_plane().

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

216{ m_is_dark_mode = is_dark; }

is_dark

static bool is_dark()

Definition TextureImportDialog.cpp:85

Slic3r::GUI::GLGizmoBase::m_is_dark_mode

bool m_is_dark_mode

Definition GLGizmoBase.hpp:157

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.

250{}

◆ on_dragging()

void Slic3r::GUI::GLGizmoCut3D::on_dragging ( const UpdateData & data )

overrideprotectedvirtual

Reimplemented from Slic3r::GUI::GLGizmoBase.

{
    if (m_hover_id < 0)
        return;
    if (m_hover_id == Z || m_hover_id == CutPlane || m_hover_id == CutPlaneXMove || m_hover_id == CutPlaneYMove)
        dragging_grabber_move(data);
    else if (m_hover_id == X || m_hover_id == Y || m_hover_id == CutPlaneZRotation)
        dragging_grabber_rotation(data);
    else if (m_hover_id >= m_connectors_group_id && m_connector_mode == CutConnectorMode::Manual)
        dragging_connector(data);
    check_and_update_connectors_state();
 
    if (CutMode(m_mode) == CutMode::cutTongueAndGroove)
        reset_cut_by_contours();
}

References check_and_update_connectors_state(), CutPlane, CutPlaneXMove, CutPlaneYMove, CutPlaneZRotation, cutTongueAndGroove, dragging_connector(), dragging_grabber_move(), dragging_grabber_rotation(), m_connector_mode, m_connectors_group_id, Slic3r::GUI::GLGizmoBase::m_hover_id, m_mode, Manual, reset_cut_by_contours(), X, Y, and Z.

Here is the call 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.

249{}

◆ on_get_name()

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

overrideprotectedvirtual

Implements Slic3r::GUI::GLGizmoBase.

{
    return _u8L_CONTEXT("Cut", "Cut tool");
}

References _u8L_CONTEXT.

◆ on_get_requirements()

CommonGizmosDataID Slic3r::GUI::GLGizmoCut3D::on_get_requirements ( ) const

overrideprotectedvirtual

Reimplemented from Slic3r::GUI::GLGizmoBase.

                                                           {
    return CommonGizmosDataID(
                int(CommonGizmosDataID::SelectionInfo)
              | int(CommonGizmosDataID::InstancesHider)
              | int(CommonGizmosDataID::ObjectClipper));
}

References Slic3r::GUI::InstancesHider, Slic3r::GUI::ObjectClipper, and Slic3r::GUI::SelectionInfo.

◆ on_init()

bool Slic3r::GUI::GLGizmoCut3D::on_init ( )

overrideprotectedvirtual

Implements Slic3r::GUI::GLGizmoBase.

{
    m_grabbers.emplace_back();
    m_shortcut = Shortcut::GizmoCut;
 
    // initiate info shortcuts
    const wxString ctrl  = GUI::shortkey_ctrl_prefix();
    const wxString alt   = GUI::shortkey_alt_prefix();
    const wxString shift = GUI::shortkey_shift_prefix();
 
    m_shortcuts_cut = {
        {_L("Drag"),                        _L("Move cut line")},
        {shift + _L("Drag"),                _L("Draw cut line")}
    };
 
    m_shortcuts_connector = {
        {_L("Left mouse button"),           _L("Add connector")},
        {_L("Right mouse button"),          _L("Remove connector")},
        {_L("Drag"),                        _L("Move connector")},
        {shift + _L("Left mouse button"),   _L("Add connector to selection")},
        {alt + _L("Left mouse button"),     _L("Remove connector from selection")},
        {ctrl + "A",                        _L("Select all connectors")},
    };
 
    return true;
}

References _L, Slic3r::GUI::GizmoCut, Slic3r::GUI::GLGizmoBase::m_grabbers, Slic3r::GUI::GLGizmoBase::m_shortcut, m_shortcuts_connector, m_shortcuts_cut, Slic3r::GUI::shortkey_alt_prefix(), Slic3r::GUI::shortkey_ctrl_prefix(), and Slic3r::GUI::shortkey_shift_prefix().

Here is the call graph for this function:

◆ on_is_activable()

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

overrideprotectedvirtual

Reimplemented from Slic3r::GUI::GLGizmoBase.

{
    const Selection& selection = m_parent.get_selection();
    const int object_idx = selection.get_object_idx();
    if (object_idx < 0 || selection.is_wipe_tower())
        return false;
 
    if (const ModelObject* mo = wxGetApp().plater()->model().objects[object_idx];
        mo->is_cut() && mo->volumes.size() == 1) {
        const ModelVolume* volume = mo->volumes[0];
        if (volume->is_cut_connector() && volume->cut_info.connector_type == CutConnectorType::Dowel)
            return false;
    }
 
    // This is assumed in GLCanvas3D::do_rotate, do not change this
    // without updating that function too.
    return selection.is_single_full_instance() && !m_parent.is_layers_editing_enabled();
}

References Slic3r::ModelVolume::CutInfo::connector_type, Slic3r::ModelVolume::cut_info, Slic3r::Dowel, Slic3r::GUI::Selection::get_object_idx(), Slic3r::ModelVolume::is_cut_connector(), Slic3r::GUI::Selection::is_single_full_instance(), Slic3r::GUI::Selection::is_wipe_tower(), Slic3r::GUI::GLGizmoBase::m_parent, and Slic3r::GUI::plater().

Here is the call graph for this function:

◆ on_is_selectable()

bool Slic3r::GUI::GLGizmoCut3D::on_is_selectable ( ) const

overrideprotectedvirtual

Reimplemented from Slic3r::GUI::GLGizmoBase.

{
    return wxGetApp().get_mode() != comSimple;
}

References Slic3r::comSimple.

◆ on_load()

void Slic3r::GUI::GLGizmoCut3D::on_load ( cereal::BinaryInputArchive & ar )

overrideprotectedvirtual

Reimplemented from Slic3r::GUI::GLGizmoBase.

{
    size_t mode;
    float groove_depth;
    float groove_width;
    float groove_flaps_angle;
    float groove_angle;
    float groove_depth_tolerance;
    float groove_width_tolerance;
 
    ar( m_keep_upper, m_keep_lower, m_rotate_lower, m_rotate_upper, m_hide_cut_plane, mode, m_connectors_editing,
        m_ar_plane_center, m_rotation_m,
        groove_depth, groove_width, groove_flaps_angle, groove_angle, groove_depth_tolerance, groove_width_tolerance);
 
    m_start_dragging_m = m_rotation_m;
 
    m_transformed_bounding_box = transformed_bounding_box(m_ar_plane_center, m_rotation_m);
    set_center_pos(m_ar_plane_center);
 
    if (m_mode != mode)
        switch_to_mode(mode);
    else if (CutMode(m_mode) == CutMode::cutTongueAndGroove) {
        if (!is_approx(m_groove.depth          , groove_depth) ||
            !is_approx(m_groove.width          , groove_width) ||
            !is_approx(m_groove.flaps_angle    , groove_flaps_angle) ||
            !is_approx(m_groove.angle          , groove_angle) ||
            !is_approx(m_groove.depth_tolerance, groove_depth_tolerance) ||
            !is_approx(m_groove.width_tolerance, groove_width_tolerance) ) 
        {
            m_groove.depth          = groove_depth;
            m_groove.width          = groove_width;
            m_groove.flaps_angle    = groove_flaps_angle;
            m_groove.angle          = groove_angle;
            m_groove.depth_tolerance= groove_depth_tolerance;
            m_groove.width_tolerance= groove_width_tolerance;
            update_plane_model();
        }
        reset_cut_by_contours();
    }
 
    m_parent.request_extra_frame();
}

References cutTongueAndGroove, Slic3r::is_approx(), m_ar_plane_center, m_connectors_editing, m_groove, m_hide_cut_plane, m_keep_lower, m_keep_upper, m_mode, Slic3r::GUI::GLGizmoBase::m_parent, m_rotate_lower, m_rotate_upper, m_rotation_m, m_start_dragging_m, m_transformed_bounding_box, reset_cut_by_contours(), set_center_pos(), switch_to_mode(), transformed_bounding_box(), and update_plane_model().

Here is the call graph for this function:

◆ on_mouse()

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

overridevirtual

Drag of plane.

Parameters

mouse_event Keep information about mouse click

Returns: Return True when use the information otherwise False.

Reimplemented from Slic3r::GUI::GLGizmoBase.

{
    Vec2i32 mouse_coord(mouse_event.GetX(), mouse_event.GetY());
    Vec2d mouse_pos = mouse_coord.cast<double>();
 
    if (mouse_event.ShiftDown() && mouse_event.LeftDown())
        return gizmo_event(SLAGizmoEventType::LeftDown, mouse_pos, mouse_event.ShiftDown(), mouse_event.AltDown(), mouse_event.CmdDown());
    if (mouse_event.CmdDown() && mouse_event.LeftDown())
        return false;
    if (cut_line_processing()) {
        if (mouse_event.ShiftDown()) {
            if (mouse_event.Moving()|| mouse_event.Dragging())
                return gizmo_event(SLAGizmoEventType::Moving, mouse_pos, mouse_event.ShiftDown(), mouse_event.AltDown(), mouse_event.CmdDown());
            if (mouse_event.LeftUp())
                return gizmo_event(SLAGizmoEventType::LeftUp, mouse_pos, mouse_event.ShiftDown(), mouse_event.AltDown(), mouse_event.CmdDown());
        }
        discard_cut_line_processing();
    }
    else if (mouse_event.Moving())
        return false;
 
    if (m_hover_id >= CutPlane && mouse_event.LeftDown() && !m_connectors_editing) {
        // before processing of a use_grabbers(), detect start move position as a projection of mouse position to the cut plane
        Vec3d pos;
        Vec3d pos_world;
        if (unproject_on_cut_plane(mouse_pos, pos, pos_world, false))
            m_cut_plane_start_move_pos = pos_world;
    }
 
    if (use_grabbers(mouse_event)) {
        if (m_hover_id >= m_connectors_group_id) {
            if (mouse_event.LeftDown() && !mouse_event.CmdDown() && !mouse_event.AltDown())
                unselect_all_connectors();
            if (mouse_event.LeftUp() && !mouse_event.ShiftDown())
                gizmo_event(SLAGizmoEventType::LeftUp, mouse_pos, mouse_event.ShiftDown(), mouse_event.AltDown(), mouse_event.CmdDown());
        }
        else if (m_hover_id == CutPlane) {
            if (mouse_event.LeftDown()) {
                m_was_cut_plane_dragged = m_was_contour_selected = false;
 
                // disable / enable current contour
                Vec3d pos;
                Vec3d pos_world;
                m_was_contour_selected = unproject_on_cut_plane(mouse_pos.cast<double>(), pos, pos_world);
                if (m_was_contour_selected) {
                    // Following would inform the clipper about the mouse click, so it can
                    // toggle the respective contour as disabled.
                    //m_c->object_clipper()->pass_mouse_click(pos_world);
                    //process_contours();
                    return true;
                }
 
            }
            else if (mouse_event.LeftUp() && !m_was_cut_plane_dragged && !m_was_contour_selected)
                flip_cut_plane();
        }
 
        if (m_hover_id >= CutPlane && mouse_event.Dragging() && !m_connectors_editing) {
            // if we continue to dragging a cut plane, than update a start move position as a projection of mouse position to the cut plane after processing of a use_grabbers()
            Vec3d pos;
            Vec3d pos_world;
            if (unproject_on_cut_plane(mouse_pos, pos, pos_world, false))
                m_cut_plane_start_move_pos = pos_world;
        }
 
        toggle_model_objects_visibility();
        return true;
    }
 
    static bool pending_right_up = false;
    if (mouse_event.LeftDown()) {
        bool grabber_contains_mouse = (get_hover_id() != -1);
        const bool shift_down = mouse_event.ShiftDown();
        if ((!shift_down || grabber_contains_mouse) &&
            gizmo_event(SLAGizmoEventType::LeftDown, mouse_pos, mouse_event.ShiftDown(), mouse_event.AltDown(), false))
            return true;
    }
    else if (mouse_event.Dragging()) {
        bool control_down = mouse_event.CmdDown();
        if (m_parent.get_move_volume_id() != -1) {
            // don't allow dragging objects with the Sla gizmo on
            return true;
        }
        if (!control_down &&
            gizmo_event(SLAGizmoEventType::Dragging, mouse_pos, mouse_event.ShiftDown(), mouse_event.AltDown(), false)) {
            // the gizmo got the event and took some action, no need to do
            // anything more here
            m_parent.set_as_dirty();
            return true;
        }
        if (control_down && (mouse_event.LeftIsDown() || mouse_event.RightIsDown())) {
            // CTRL has been pressed while already dragging -> stop current action
            if (mouse_event.LeftIsDown())
                gizmo_event(SLAGizmoEventType::LeftUp, mouse_pos, mouse_event.ShiftDown(), mouse_event.AltDown(), true);
            else if (mouse_event.RightIsDown())
                pending_right_up = false;
        }
    }
    else if (mouse_event.LeftUp() && !m_parent.is_mouse_dragging()) {
        // in case SLA/FDM gizmo is selected, we just pass the LeftUp event
        // and stop processing - neither object moving or selecting is
        // suppressed in that case
        gizmo_event(SLAGizmoEventType::LeftUp, mouse_pos, mouse_event.ShiftDown(), mouse_event.AltDown(), mouse_event.CmdDown());
        return true;
    }
    else if (mouse_event.RightDown()) {
        if (! m_connectors_editing && mouse_event.GetModifiers() == wxMOD_NONE &&
            CutMode(m_mode) == CutMode::cutPlanar) {
            // Check the internal part raycasters.
            if (! m_part_selection.valid())
                process_contours();
            m_part_selection.toggle_selection(mouse_pos);
            check_and_update_connectors_state(); // after a contour is deactivated, its connectors are inside the object
            return true;
        }
 
        if (m_parent.get_selection().get_object_idx() != -1 &&
            gizmo_event(SLAGizmoEventType::RightDown, mouse_pos, false, false, false)) {
            // we need to set the following right up as processed to avoid showing
            // the context menu if the user release the mouse over the object
            pending_right_up = true;
            // event was taken care of by the SlaSupports gizmo
            return true;
        }
    }
    else if (pending_right_up && mouse_event.RightUp()) {
        pending_right_up = false;
        return true;
    }
    return false;
}

References check_and_update_connectors_state(), cut_line_processing(), cutPlanar, CutPlane, discard_cut_line_processing(), Slic3r::GUI::Dragging, flip_cut_plane(), Slic3r::GUI::GLGizmoBase::get_hover_id(), gizmo_event(), Slic3r::GUI::LeftDown, Slic3r::GUI::LeftUp, m_connectors_editing, m_connectors_group_id, m_cut_plane_start_move_pos, Slic3r::GUI::GLGizmoBase::m_hover_id, m_mode, Slic3r::GUI::GLGizmoBase::m_parent, m_part_selection, m_was_contour_selected, m_was_cut_plane_dragged, Slic3r::GUI::Moving, process_contours(), Slic3r::GUI::RightDown, toggle_model_objects_visibility(), unproject_on_cut_plane(), unselect_all_connectors(), Slic3r::GUI::GLGizmoBase::use_grabbers(), and Slic3r::GUI::wxMouseEvent.

Here is the call graph for this function:

◆ on_register_raycasters_for_picking()

void Slic3r::GUI::GLGizmoCut3D::on_register_raycasters_for_picking ( )

overrideprotectedvirtual

Reimplemented from Slic3r::GUI::GLGizmoBase.

{
 //   assert(m_raycasters.empty());
    if (!m_raycasters.empty())
        on_unregister_raycasters_for_picking();
    // the gizmo grabbers are rendered on top of the scene, so the raytraced picker should take it into account
    m_parent.set_raycaster_gizmos_on_top(true);
 
    init_picking_models();
 
    if (m_connectors_editing) {
        if (CommonGizmosDataObjects::SelectionInfo* si = m_c->selection_info()) {
            const CutConnectors& connectors = si->model_object()->cut_connectors;
            for (int i = 0; i < int(connectors.size()); ++i)
                m_raycasters.emplace_back(m_parent.add_raycaster_for_picking(SceneRaycaster::EType::Gizmo, i + m_connectors_group_id, *(m_shapes[connectors[i].attribs]).mesh_raycaster, Transform3d::Identity()));
        }
    }
    else if (!cut_line_processing()) {
        m_raycasters.emplace_back(m_parent.add_raycaster_for_picking(SceneRaycaster::EType::Gizmo, X, *m_cone.mesh_raycaster, Transform3d::Identity()));
        m_raycasters.emplace_back(m_parent.add_raycaster_for_picking(SceneRaycaster::EType::Gizmo, X, *m_cone.mesh_raycaster, Transform3d::Identity()));
 
        m_raycasters.emplace_back(m_parent.add_raycaster_for_picking(SceneRaycaster::EType::Gizmo, Y, *m_cone.mesh_raycaster, Transform3d::Identity()));
        m_raycasters.emplace_back(m_parent.add_raycaster_for_picking(SceneRaycaster::EType::Gizmo, Y, *m_cone.mesh_raycaster, Transform3d::Identity()));
 
        m_raycasters.emplace_back(m_parent.add_raycaster_for_picking(SceneRaycaster::EType::Gizmo, Z, *m_sphere.mesh_raycaster, Transform3d::Identity()));
 
        m_raycasters.emplace_back(m_parent.add_raycaster_for_picking(SceneRaycaster::EType::FallbackGizmo, CutPlane, *m_plane.mesh_raycaster, Transform3d::Identity()));
 
        if (CutMode(m_mode) == CutMode::cutTongueAndGroove) {
            m_raycasters.emplace_back(m_parent.add_raycaster_for_picking(SceneRaycaster::EType::Gizmo, CutPlaneZRotation, *m_sphere.mesh_raycaster, Transform3d::Identity()));
            m_raycasters.emplace_back(m_parent.add_raycaster_for_picking(SceneRaycaster::EType::Gizmo, CutPlaneZRotation, *m_cone.mesh_raycaster, Transform3d::Identity()));
            m_raycasters.emplace_back(m_parent.add_raycaster_for_picking(SceneRaycaster::EType::Gizmo, CutPlaneZRotation, *m_cone.mesh_raycaster, Transform3d::Identity()));
 
            m_raycasters.emplace_back(m_parent.add_raycaster_for_picking(SceneRaycaster::EType::Gizmo, CutPlaneXMove, *m_cube.mesh_raycaster, Transform3d::Identity()));
            m_raycasters.emplace_back(m_parent.add_raycaster_for_picking(SceneRaycaster::EType::Gizmo, CutPlaneXMove, *m_cone.mesh_raycaster, Transform3d::Identity()));
 
            m_raycasters.emplace_back(m_parent.add_raycaster_for_picking(SceneRaycaster::EType::Gizmo, CutPlaneYMove, *m_cube.mesh_raycaster, Transform3d::Identity()));
            m_raycasters.emplace_back(m_parent.add_raycaster_for_picking(SceneRaycaster::EType::Gizmo, CutPlaneYMove, *m_cone.mesh_raycaster, Transform3d::Identity()));
        }
    }
 
    update_raycasters_for_picking_transform();
}

References cut_line_processing(), CutPlane, CutPlaneXMove, CutPlaneYMove, CutPlaneZRotation, cutTongueAndGroove, Slic3r::GUI::SceneRaycaster::FallbackGizmo, Slic3r::GUI::SceneRaycaster::Gizmo, init_picking_models(), Slic3r::GUI::GLGizmoBase::m_c, m_cone, m_connectors_editing, m_connectors_group_id, m_cube, m_mode, Slic3r::GUI::GLGizmoBase::m_parent, m_plane, m_raycasters, m_shapes, m_sphere, on_unregister_raycasters_for_picking(), update_raycasters_for_picking_transform(), X, Y, and Z.

Referenced by update_clipper(), and update_raycasters_for_picking().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ on_render()

void Slic3r::GUI::GLGizmoCut3D::on_render ( )

overrideprotectedvirtual

Implements Slic3r::GUI::GLGizmoBase.

{
    if (m_state == On) {
        // This gizmo is showing the object elevated. Tell the common
        // SelectionInfo object to lie about the actual shift.
        //m_c->selection_info()->set_use_shift(true);
    }
 
    // check objects visibility
    toggle_model_objects_visibility();
 
    update_clipper();
 
    init_picking_models();
 
    init_rendering_items();
 
    render_connectors();
 
    if (!m_connectors_editing)
        m_part_selection.render(nullptr, m_sphere.model);
    else
        m_part_selection.render(&m_cut_normal, m_sphere.model);
 
    render_clipper_cut();
 
    if (!m_hide_cut_plane && !m_connectors_editing) {
        render_cut_plane();
        render_cut_plane_grabbers();
    }
 
    render_cut_line();
 
    m_selection_rectangle.render(m_parent);
}

References init_picking_models(), init_rendering_items(), m_connectors_editing, m_cut_normal, m_hide_cut_plane, Slic3r::GUI::GLGizmoBase::m_parent, m_part_selection, m_selection_rectangle, m_sphere, Slic3r::GUI::GLGizmoBase::m_state, Slic3r::GUI::GLGizmoBase::On, render_clipper_cut(), render_connectors(), render_cut_line(), render_cut_plane(), render_cut_plane_grabbers(), toggle_model_objects_visibility(), and update_clipper().

Here is the call graph for this function:

◆ on_render_input_window()

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

overrideprotectedvirtual

Reimplemented from Slic3r::GUI::GLGizmoBase.

{
    GizmoImguiSetNextWIndowPos(x, y, ImGuiCond_Always, 0.0f, 0.0f);
    ImGuiWrapper::push_toolbar_style(m_parent.get_scale());
    GizmoImguiBegin(get_name(), ImGuiWindowFlags_NoMove | ImGuiWindowFlags_AlwaysAutoResize | ImGuiWindowFlags_NoCollapse | ImGuiWindowFlags_NoTitleBar);
 
    CutConnectors& connectors = m_c->selection_info()->model_object()->cut_connectors;
 
    init_input_window_data(connectors);
 
    if (m_connectors_editing) // connectors mode
        render_connectors_input_window(connectors, x, y, bottom_limit); 
    else
        render_cut_plane_input_window(connectors, x, y, bottom_limit);
 
    render_input_window_warning();
 
    GizmoImguiEnd();
 
    // Orca
    ImGuiWrapper::pop_toolbar_style();
 
    if (!m_connectors_editing) // connectors mode
        render_debug_input_window(x);
}

References Slic3r::GUI::GLGizmoBase::get_name(), Slic3r::GUI::GLGizmoBase::GizmoImguiBegin(), Slic3r::GUI::GLGizmoBase::GizmoImguiEnd(), Slic3r::GUI::GLGizmoBase::GizmoImguiSetNextWIndowPos(), init_input_window_data(), Slic3r::GUI::GLGizmoBase::m_c, m_connectors_editing, Slic3r::GUI::GLGizmoBase::m_parent, Slic3r::GUI::ImGuiWrapper::pop_toolbar_style(), Slic3r::GUI::ImGuiWrapper::push_toolbar_style(), render_connectors_input_window(), render_cut_plane_input_window(), render_debug_input_window(), and render_input_window_warning().

Here is the call graph for this function:

◆ on_save()

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

overrideprotectedvirtual

Reimplemented from Slic3r::GUI::GLGizmoBase.

{ 
    ar( m_keep_upper, m_keep_lower, m_rotate_lower, m_rotate_upper, m_hide_cut_plane, m_mode, m_connectors_editing,
        m_ar_plane_center, m_start_dragging_m,
        m_groove.depth, m_groove.width, m_groove.flaps_angle, m_groove.angle, m_groove.depth_tolerance, m_groove.width_tolerance);
}

References m_ar_plane_center, m_connectors_editing, m_groove, m_hide_cut_plane, m_keep_lower, m_keep_upper, m_mode, m_rotate_lower, m_rotate_upper, and m_start_dragging_m.

◆ on_set_hover_id()

void Slic3r::GUI::GLGizmoCut3D::on_set_hover_id ( )

overrideprotectedvirtual

Reimplemented from Slic3r::GUI::GLGizmoBase.

1666{

1667}

◆ on_set_state()

void Slic3r::GUI::GLGizmoCut3D::on_set_state ( )

overrideprotectedvirtual

Reimplemented from Slic3r::GUI::GLGizmoBase.

{
    if (m_state == On) {
        m_parent.set_use_color_clip_plane(true);
 
        update_bb();
        m_connectors_editing = !m_selected.empty();
        m_transformed_bounding_box = transformed_bounding_box(m_plane_center, m_rotation_m);
 
        // initiate archived values
        m_ar_plane_center   = m_plane_center;
        m_start_dragging_m  = m_rotation_m;
        reset_cut_by_contours();
 
        m_parent.request_extra_frame();
    }
    else {
        if (auto oc = m_c->object_clipper()) {
            oc->set_behavior(true, true, 0.);
            oc->release();
        }
        m_selected.clear();
        m_parent.set_use_color_clip_plane(false);
        //m_c->selection_info()->set_use_shift(false);
 
        // Make sure that the part selection data are released when the gizmo is closed.
        // The CallAfter is needed because in perform_cut, the gizmo is closed BEFORE
        // the cut is performed (because of undo/redo snapshots), so the data would
        // be deleted prematurely.
        if (m_part_selection.valid())
            wxGetApp().CallAfter([this]() { m_part_selection = PartSelection(); });
    }
}

References m_ar_plane_center, Slic3r::GUI::GLGizmoBase::m_c, m_connectors_editing, Slic3r::GUI::GLGizmoBase::m_parent, m_part_selection, m_plane_center, m_rotation_m, m_selected, m_start_dragging_m, Slic3r::GUI::GLGizmoBase::m_state, m_transformed_bounding_box, Slic3r::GUI::GLGizmoBase::On, reset_cut_by_contours(), transformed_bounding_box(), and update_bb().

Here is the call graph for this function:

◆ on_start_dragging()

void Slic3r::GUI::GLGizmoCut3D::on_start_dragging ( )

overrideprotectedvirtual

Reimplemented from Slic3r::GUI::GLGizmoBase.

{
    m_angle = 0.0;
    if (m_hover_id >= m_connectors_group_id && m_connector_mode == CutConnectorMode::Manual)
        Plater::TakeSnapshot snapshot(wxGetApp().plater(), _u8L("Move connector"), UndoRedo::SnapshotType::GizmoAction);
 
    if (m_hover_id == X || m_hover_id == Y || m_hover_id == CutPlaneZRotation)
        m_start_dragging_m = m_rotation_m;
}

References _u8L, CutPlaneZRotation, Slic3r::UndoRedo::GizmoAction, m_angle, m_connector_mode, m_connectors_group_id, Slic3r::GUI::GLGizmoBase::m_hover_id, m_rotation_m, m_start_dragging_m, Manual, Slic3r::GUI::plater(), X, and Y.

Here is the call graph for this function:

◆ on_stop_dragging()

void Slic3r::GUI::GLGizmoCut3D::on_stop_dragging ( )

overrideprotectedvirtual

Reimplemented from Slic3r::GUI::GLGizmoBase.

{
    if (m_hover_id == X || m_hover_id == Y || m_hover_id == CutPlaneZRotation) {
        m_angle_arc.reset();
        m_angle = 0.0;
        Plater::TakeSnapshot snapshot(wxGetApp().plater(), _u8L("Rotate cut plane"), UndoRedo::SnapshotType::GizmoAction);
        m_start_dragging_m = m_rotation_m;
    }
    else if (m_hover_id == Z || m_hover_id == CutPlane || m_hover_id == CutPlaneXMove|| m_hover_id == CutPlaneYMove) {
        if (m_was_cut_plane_dragged)
            Plater::TakeSnapshot snapshot(wxGetApp().plater(), _u8L("Move cut plane"), UndoRedo::SnapshotType::GizmoAction);
        m_ar_plane_center = m_plane_center;
    }
 
    if (CutMode(m_mode) == CutMode::cutTongueAndGroove)
        reset_cut_by_contours();
    //check_and_update_connectors_state();
}

References _u8L, CutPlane, CutPlaneXMove, CutPlaneYMove, CutPlaneZRotation, cutTongueAndGroove, Slic3r::UndoRedo::GizmoAction, m_angle, m_angle_arc, m_ar_plane_center, Slic3r::GUI::GLGizmoBase::m_hover_id, m_mode, m_plane_center, m_rotation_m, m_start_dragging_m, m_was_cut_plane_dragged, Slic3r::GUI::plater(), reset_cut_by_contours(), X, Y, and Z.

Here is the call graph for this function:

◆ on_unregister_raycasters_for_picking()

void Slic3r::GUI::GLGizmoCut3D::on_unregister_raycasters_for_picking ( )

overrideprotectedvirtual

Reimplemented from Slic3r::GUI::GLGizmoBase.

{
    m_parent.remove_raycasters_for_picking(SceneRaycaster::EType::Gizmo);
    m_parent.remove_raycasters_for_picking(SceneRaycaster::EType::FallbackGizmo);
    m_raycasters.clear();
    // the gizmo grabbers are rendered on top of the scene, so the raytraced picker should take it into account
    m_parent.set_raycaster_gizmos_on_top(false);
}

References Slic3r::GUI::SceneRaycaster::FallbackGizmo, Slic3r::GUI::SceneRaycaster::Gizmo, Slic3r::GUI::GLGizmoBase::m_parent, and m_raycasters.

Referenced by on_register_raycasters_for_picking(), process_cut_line(), update_bb(), update_plane_model(), and update_raycasters_for_picking().

Here is the caller graph for this function:

◆ perform_cut()

void Slic3r::GUI::GLGizmoCut3D::perform_cut ( const Selection & selection )

private

{
    if (!can_perform_cut())
        return;
    const int instance_idx = selection.get_instance_idx();
    const int object_idx = selection.get_object_idx();
 
    wxCHECK_RET(instance_idx >= 0 && object_idx >= 0, "GLGizmoCut: Invalid object selection");
 
    Plater* plater = wxGetApp().plater();
    ModelObject* mo = plater->model().objects[object_idx];
    if (!mo)
        return;
 
    // deactivate CutGizmo and than perform a cut
    m_parent.reset_all_gizmos();
 
    // perform cut
    {
        Plater::TakeSnapshot snapshot(wxGetApp().plater(), _u8L("Cut by Plane"));
 
        // This shall delete the part selection class and deallocate the memory.
        ScopeGuard part_selection_killer([this]() { m_part_selection = PartSelection(); });
 
        const bool cut_with_groove = CutMode(m_mode) == CutMode::cutTongueAndGroove;
        const bool cut_by_contour = !cut_with_groove && m_part_selection.valid();
 
        ModelObject* cut_mo = cut_by_contour ? m_part_selection.model_object() : nullptr;
        if (cut_mo)
            cut_mo->cut_connectors = mo->cut_connectors;
        else
            cut_mo = mo;
 
        int dowels_count = 0;
        const bool has_connectors = !mo->cut_connectors.empty();
        // update connectors pos as offset of its center before cut performing
        apply_connectors_in_model(cut_mo , dowels_count);
 
        wxBusyCursor wait;
 
        const bool keep_painting = GUI::wxGetApp().app_config->get_bool("keep_painting");
        ModelObjectCutAttributes attributes = only_if(has_connectors ? true : m_keep_upper, ModelObjectCutAttribute::KeepUpper) |
                                              only_if(has_connectors ? true : m_keep_lower, ModelObjectCutAttribute::KeepLower) |
                                              only_if(has_connectors ? false : m_keep_as_parts, ModelObjectCutAttribute::KeepAsParts) |
                                              only_if(m_place_on_cut_upper, ModelObjectCutAttribute::PlaceOnCutUpper) |
                                              only_if(m_place_on_cut_lower, ModelObjectCutAttribute::PlaceOnCutLower) |
                                              only_if(m_rotate_upper, ModelObjectCutAttribute::FlipUpper) |
                                              only_if(m_rotate_lower, ModelObjectCutAttribute::FlipLower) |
                                              only_if(dowels_count > 0, ModelObjectCutAttribute::CreateDowels) |
                                              only_if(!has_connectors && !cut_with_groove && cut_mo->cut_id.id().invalid(), ModelObjectCutAttribute::InvalidateCutInfo) |
                                              only_if(keep_painting, ModelObjectCutAttribute::KeepPaint);
 
        // update cut_id for the cut object in respect to the attributes
        update_object_cut_id(cut_mo->cut_id, attributes, dowels_count);
 
        Cut cut(cut_mo, instance_idx, get_cut_matrix(selection), attributes);
        const ModelObjectPtrs& new_objects = cut_by_contour    ? cut.perform_by_contour(mo, m_part_selection.get_cut_parts(), dowels_count):
                                             cut_with_groove   ? cut.perform_with_groove(m_groove, m_rotation_m, m_groove_count, m_groove_gap, m_radius) :
                                                                 cut.perform_with_plane();
 
        // fix_non_manifold_edges
        {
            bool is_showed_dialog = false;
            bool user_fix_model   = false;
            for (size_t i = 0; i < new_objects.size(); i++) {
                for (size_t j = 0; j < new_objects[i]->volumes.size(); j++) {
                    if (its_num_open_edges(new_objects[i]->volumes[j]->mesh().its) > 0) {
                        if (!is_showed_dialog) {
                            is_showed_dialog = true;
                            MessageDialog dlg(nullptr, _L("Non-manifold edges be caused by cut tool: do you want to fix now\?"), "", wxYES | wxCANCEL);
                            int           ret = dlg.ShowModal();
                            if (ret == wxID_YES) {
                                user_fix_model = true;
                            }
                        }
                        if (!user_fix_model) {
                            break;
                        }
                        // model_name
                        std::vector<std::string> succes_models;
                        // model_name     failing reason
                        std::vector<std::pair<std::string, std::string>> failed_models;
                        auto                                             plater = wxGetApp().plater();
                        auto fix_and_update_progress = [keep_painting](ModelObject *model_object, const int vol_idx, const std::string &model_name, ProgressDialog &progress_dlg,
                                                                      std::vector<std::string> &succes_models, std::vector<std::pair<std::string, std::string>> &failed_models) {
                            wxString msg = _L("Repairing model object");
                            msg += ": " + from_u8(model_name) + "\n";
                            std::string res;
                            if (!fix_model_with_cgal_gui(*model_object, vol_idx, progress_dlg, msg, res, keep_painting)) return false;
                            return true;
                        };
                        ProgressDialog progress_dlg(_L("Repairing model object"), "", 100, find_toplevel_parent(plater), wxPD_AUTO_HIDE | wxPD_APP_MODAL | wxPD_CAN_ABORT, true);
 
                        auto model_name = new_objects[i]->name;
                        if (!fix_and_update_progress(new_objects[i], j, model_name, progress_dlg, succes_models, failed_models)) {
                            BOOST_LOG_TRIVIAL(error) << __FUNCTION__ << "run fix_and_update_progress error";
                        };
                    };
                }
            }
        }
        check_objects_after_cut(new_objects);
 
        // save cut_id to post update synchronization
        const CutObjectBase cut_id = cut_mo->cut_id;
 
        // update cut results on plater and in the model 
        plater->apply_cut_object_to_model(object_idx, new_objects);
 
        synchronize_model_after_cut(plater->model(), cut_id);
    }
}

References _L, _u8L, apply_connectors_in_model(), can_perform_cut(), Slic3r::GUI::check_objects_after_cut(), Slic3r::CreateDowels, Slic3r::ModelObject::cut_connectors, Slic3r::ModelObject::cut_id, cutTongueAndGroove, Slic3r::GUI::find_toplevel_parent(), Slic3r::fix_model_with_cgal_gui(), Slic3r::FlipLower, Slic3r::FlipUpper, Slic3r::GUI::from_u8(), get_cut_matrix(), Slic3r::GUI::Selection::get_instance_idx(), Slic3r::GUI::Selection::get_object_idx(), Slic3r::ObjectBase::id(), Slic3r::ObjectID::invalid(), Slic3r::InvalidateCutInfo, Slic3r::its_num_open_edges(), Slic3r::KeepAsParts, Slic3r::KeepLower, Slic3r::KeepPaint, Slic3r::KeepUpper, m_groove, m_groove_count, m_groove_gap, m_keep_as_parts, m_keep_lower, m_keep_upper, m_mode, Slic3r::GUI::GLGizmoBase::m_parent, m_part_selection, m_place_on_cut_lower, m_place_on_cut_upper, m_radius, m_rotate_lower, m_rotate_upper, m_rotation_m, Slic3r::only_if(), Slic3r::Cut::perform_by_contour(), Slic3r::Cut::perform_with_groove(), Slic3r::Cut::perform_with_plane(), Slic3r::PlaceOnCutLower, Slic3r::PlaceOnCutUpper, Slic3r::GUI::plater(), Slic3r::GUI::DPIAware< P >::ShowModal(), Slic3r::GUI::synchronize_model_after_cut(), and Slic3r::GUI::update_object_cut_id().

Referenced by render_cut_plane_input_window().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ process_contours()

void Slic3r::GUI::GLGizmoCut3D::process_contours ( )

protected

{
    const Selection& selection = m_parent.get_selection();
    const ModelObjectPtrs& model_objects = selection.get_model()->objects;
 
    const int instance_idx = selection.get_instance_idx();
    if (instance_idx < 0)
        return;
    const int object_idx = selection.get_object_idx();
 
    wxBusyCursor wait;
 
    if (CutMode(m_mode) == CutMode::cutTongueAndGroove) {
        if (has_valid_groove()) {
            Cut cut(model_objects[object_idx], instance_idx, get_cut_matrix(selection));
            const ModelObjectPtrs& new_objects = cut.perform_with_groove(m_groove, m_rotation_m, m_groove_count, m_groove_gap, m_radius,  true);
            if (!new_objects.empty())
                m_part_selection = PartSelection(new_objects.front(), instance_idx);
        }
    }
    else {
        reset_cut_by_contours();
        m_part_selection = PartSelection(model_objects[object_idx], get_cut_matrix(selection), instance_idx, m_plane_center, m_cut_normal, *m_c->object_clipper());
    }
 
    toggle_model_objects_visibility();
}

References cutTongueAndGroove, get_cut_matrix(), Slic3r::GUI::Selection::get_instance_idx(), Slic3r::GUI::Selection::get_model(), Slic3r::GUI::Selection::get_object_idx(), has_valid_groove(), Slic3r::GUI::GLGizmoBase::m_c, m_cut_normal, m_groove, m_groove_count, m_groove_gap, m_mode, Slic3r::GUI::GLGizmoBase::m_parent, m_part_selection, m_plane_center, m_radius, m_rotation_m, Slic3r::Model::objects, Slic3r::Cut::perform_with_groove(), reset_cut_by_contours(), and toggle_model_objects_visibility().

Referenced by on_mouse(), and reset_cut_by_contours().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ process_cut_line()

bool Slic3r::GUI::GLGizmoCut3D::process_cut_line	(	SLAGizmoEventType	action,
		const Vec2d &	mouse_position )

private

{
    const Camera& camera = wxGetApp().plater()->get_camera();
 
    Vec3d pt;
    Vec3d dir;
    MeshRaycaster::line_from_mouse_pos(mouse_position, Transform3d::Identity(), camera, pt, dir);
    dir.normalize();
    pt += dir; // Move the pt along dir so it is not clipped.
 
    if (action == SLAGizmoEventType::LeftDown && !cut_line_processing()) {
        m_line_beg = pt;
        m_line_end = pt;
        on_unregister_raycasters_for_picking();
        return true;
    }
 
    if (cut_line_processing()) {
        if (CutMode(m_mode) == CutMode::cutTongueAndGroove)
            m_groove_editing = true;
        reset_cut_by_contours();
 
        m_line_end = pt;
        if (action == SLAGizmoEventType::LeftDown || action == SLAGizmoEventType::LeftUp) {
            Vec3d line_dir = m_line_end - m_line_beg;
            if (line_dir.norm() < 3.0)
                return true;
 
            Vec3d cross_dir = line_dir.cross(dir).normalized();
            Eigen::Quaterniond q;
            Transform3d m = Transform3d::Identity();
            m.matrix().block(0, 0, 3, 3) = q.setFromTwoVectors(Vec3d::UnitZ(), cross_dir).toRotationMatrix();
 
            const Vec3d new_plane_center = m_bb_center + cross_dir * cross_dir.dot(pt - m_bb_center);
            // update transformed bb
            const auto new_tbb = transformed_bounding_box(new_plane_center, m);
            const GLVolume* first_volume = m_parent.get_selection().get_first_volume();
            Vec3d instance_offset = first_volume->get_instance_offset();
            instance_offset[Z] += first_volume->get_sla_shift_z();
 
            const Vec3d trans_center_pos = m.inverse() * (new_plane_center - instance_offset) + new_tbb.center();
            if (new_tbb.contains(trans_center_pos)) {
                Plater::TakeSnapshot snapshot(wxGetApp().plater(), _u8L("Cut by line"), UndoRedo::SnapshotType::GizmoAction);
                m_transformed_bounding_box = new_tbb;
                set_center(new_plane_center);
                m_start_dragging_m = m_rotation_m = m;
                m_ar_plane_center = m_plane_center;
            }
 
            m_angle_arc.reset();
            discard_cut_line_processing();
 
            if (CutMode(m_mode) == CutMode::cutTongueAndGroove) {
                m_groove_editing = false;
                reset_cut_by_contours();
            }
        }
        else if (action == SLAGizmoEventType::Moving)
            this->set_dirty();
        return true;
    }
    return false;
}

References _u8L, cut_line_processing(), cutTongueAndGroove, discard_cut_line_processing(), Slic3r::GLVolume::get_instance_offset(), Slic3r::GLVolume::get_sla_shift_z(), Slic3r::UndoRedo::GizmoAction, Slic3r::GUI::LeftDown, Slic3r::GUI::LeftUp, Slic3r::GUI::MeshRaycaster::line_from_mouse_pos(), m_angle_arc, m_ar_plane_center, m_bb_center, m_groove_editing, m_line_beg, m_line_end, m_mode, Slic3r::GUI::GLGizmoBase::m_parent, m_plane_center, m_rotation_m, m_start_dragging_m, m_transformed_bounding_box, Slic3r::GUI::Moving, on_unregister_raycasters_for_picking(), Slic3r::GUI::plater(), reset_cut_by_contours(), set_center(), Slic3r::GUI::GLGizmoBase::set_dirty(), transformed_bounding_box(), and Z.

Referenced by gizmo_event().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ process_selection_rectangle()

void Slic3r::GUI::GLGizmoCut3D::process_selection_rectangle ( CutConnectors & connectors )

protected

{
    GLSelectionRectangle::EState rectangle_status = m_selection_rectangle.get_state();
 
    ModelObject* mo          = m_c->selection_info()->model_object();
    int          active_inst = m_c->selection_info()->get_active_instance();
 
    // First collect positions of all the points in world coordinates.
    Transformation trafo = mo->instances[active_inst]->get_transformation();
    trafo.set_offset(trafo.get_offset() + double(m_c->selection_info()->get_sla_shift()) * Vec3d::UnitZ());
 
    std::vector<Vec3d> points;
    for (const CutConnector&connector : connectors)
        points.push_back(connector.pos + trafo.get_offset());
 
    // Now ask the rectangle which of the points are inside.
    std::vector<unsigned int> points_idxs = m_selection_rectangle.contains(points);
    m_selection_rectangle.stop_dragging();
 
    for (size_t idx : points_idxs)
        select_connector(int(idx), rectangle_status == GLSelectionRectangle::EState::Select);
}

References Slic3r::Geometry::Transformation::get_offset(), Slic3r::ModelObject::instances, Slic3r::GUI::GLGizmoBase::m_c, m_selection_rectangle, Slic3r::GUI::GLSelectionRectangle::Select, select_connector(), and Slic3r::Geometry::Transformation::set_offset().

Referenced by gizmo_event().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ put_connectors_on_cut_plane()

void Slic3r::GUI::GLGizmoCut3D::put_connectors_on_cut_plane	(	const Vec3d &	cp_normal,
		double	cp_offset )

{
    ModelObject* mo = m_c->selection_info()->model_object();
    if (CutConnectors& connectors = mo->cut_connectors; !connectors.empty()) {
        const float sla_shift        = m_c->selection_info()->get_sla_shift();
        const Vec3d& instance_offset = mo->instances[m_c->selection_info()->get_active_instance()]->get_offset();
 
        for (auto& connector : connectors) {
            // convert connetor pos to the world coordinates
            Vec3d pos = connector.pos + instance_offset;
            pos[Z] += sla_shift;
            // scalar distance from point to plane along the normal
            double distance = -cp_normal.dot(pos) + cp_offset;
            // move connector
            connector.pos += distance * cp_normal;
        }
    }
}

References Slic3r::ModelObject::cut_connectors, Slic3r::ModelObject::instances, Slic3r::GUI::GLGizmoBase::m_c, and Z.

Referenced by update_clipper().

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

232{ register_grabbers_for_picking(); on_register_raycasters_for_picking(); }

Slic3r::GUI::GLGizmoBase::register_grabbers_for_picking

void register_grabbers_for_picking()

Definition GLGizmoBase.cpp:398

Slic3r::GUI::GLGizmoBase::on_register_raycasters_for_picking

virtual void on_register_raycasters_for_picking()

Definition GLGizmoBase.hpp:267

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:

◆ render()

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

inlineinherited

214{ on_render(); }

Slic3r::GUI::GLGizmoBase::on_render

virtual void on_render()=0

References on_render().

Here is the call graph for this function:

◆ render_angle_input()

bool Slic3r::GUI::GLGizmoCut3D::render_angle_input	(	const std::string &	label,
		float &	in_val,
		const float &	init_val,
		float	min_val,
		float	max_val )

protected

{
    // -------- [ ]
    // slider_with + item_in_gap + input_width
    double slider_with = 0.24 * m_editing_window_width; // m_control_width * 0.35;
    double item_in_gap = 0.01 * m_editing_window_width;
    double input_width = 0.29 * m_editing_window_width;
 
    ImGui::AlignTextToFramePadding();
    m_imgui->text(label);
    ImGui::SameLine(m_label_width);
    ImGui::PushItemWidth(slider_with);
 
    double left_width = m_label_width + slider_with + item_in_gap;
 
    bool is_changed{ false };
 
    float val = rad2deg(in_val);
    const float old_val = val;
 
    const std::string format = "%.0f°";
    m_imgui->bbl_slider_float_style("##angle_" + label, &val, min_val, max_val, format.c_str(), 1.f, true, from_u8(label));
 
    ImGui::SameLine(left_width);
    ImGui::PushItemWidth(input_width);
    ImGui::BBLDragFloat(("##angle_input_" + label).c_str(), &val, 0.05f, min_val, max_val, format.c_str());
 
    m_is_slider_editing_done |= m_imgui->get_last_slider_status().deactivated_after_edit;
    if (!is_approx(old_val, val)) {
        if (m_imgui->get_last_slider_status().can_take_snapshot) {
            // TRN: This is an entry in the Undo/Redo stack. The whole line will be 'Edited: (name of whatever was edited)'.
            Plater::TakeSnapshot snapshot(wxGetApp().plater(), GUI::format("%1%: %2%", _L("Edited"), label), UndoRedo::SnapshotType::GizmoAction);
            m_imgui->get_last_slider_status().invalidate_snapshot();
            if (m_mode == size_t(CutMode::cutTongueAndGroove))
                m_groove_editing = true;
        }
        in_val = deg2rad(val);
        is_changed = true;
    }
 
    ImGui::SameLine();
 
    m_imgui->disabled_begin(is_approx(in_val, init_val));
    const std::string act_name = _u8L("Reset");
    if (render_reset_button("##angle_" + label + act_name, act_name)) {
        Plater::TakeSnapshot snapshot(wxGetApp().plater(), GUI::format("%1%: %2%", act_name, label), UndoRedo::SnapshotType::GizmoAction);
        in_val = init_val;
        is_changed = true;
    }
    m_imgui->disabled_end();
 
    return is_changed;
}

References _L, _u8L, cutTongueAndGroove, Slic3r::Geometry::deg2rad(), Slic3r::GUI::format(), Slic3r::GUI::GLGizmoBase::format(), Slic3r::GUI::from_u8(), Slic3r::UndoRedo::GizmoAction, Slic3r::is_approx(), m_editing_window_width, m_groove_editing, Slic3r::GUI::GLGizmoBase::m_imgui, m_is_slider_editing_done, m_label_width, m_mode, Slic3r::GUI::plater(), Slic3r::Geometry::rad2deg(), and render_reset_button().

Referenced by render_connectors_input_window(), and render_groove_angle_input().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ render_build_size()

void Slic3r::GUI::GLGizmoCut3D::render_build_size ( )

protected

{
    double   koef     = m_imperial_units ? GizmoObjectManipulation::mm_to_in : 1.0;
    wxString unit_str = m_imperial_units ? _L_CONTEXT("in", "inches") : _L("mm");
    Vec3d    tbb_sz   = m_transformed_bounding_box.size() * koef; // ORCA 
 
    ImGui::AlignTextToFramePadding();
    m_imgui->text(_L("Size"));
    ImGui::SameLine(m_label_width);
    ImGui::Text("%.2f x %.2f x %.2f %s", tbb_sz.x(), tbb_sz.y(), tbb_sz.z(), unit_str.ToUTF8().data()); // ORCA use regular text color and simplify format
}

References _L, _L_CONTEXT, Slic3r::GUI::GLGizmoBase::m_imgui, m_imperial_units, m_label_width, m_transformed_bounding_box, and Slic3r::GUI::GizmoObjectManipulation::mm_to_in.

Referenced by render_cut_plane_input_window().

Here is the caller graph for this function:

◆ render_clipper_cut()

void Slic3r::GUI::GLGizmoCut3D::render_clipper_cut ( )

private

{
    if (! m_connectors_editing)
        ::glDisable(GL_DEPTH_TEST);
 
    GLboolean cull_face = GL_FALSE;
    ::glGetBooleanv(GL_CULL_FACE, &cull_face);
    ::glDisable(GL_CULL_FACE);
    m_c->object_clipper()->render_cut(m_part_selection.get_ignored_contours_ptr());
    if (cull_face)
        ::glEnable(GL_CULL_FACE);
 
    if (! m_connectors_editing)
        ::glEnable(GL_DEPTH_TEST);
}

References GL_CULL_FACE, GL_DEPTH_TEST, GL_FALSE, glDisable, glEnable, glGetBooleanv, Slic3r::GUI::GLGizmoBase::m_c, m_connectors_editing, and m_part_selection.

Referenced by on_render().

Here is the caller graph for this function:

◆ render_color_marker()

void Slic3r::GUI::GLGizmoCut3D::render_color_marker	(	float	size,
		const ImU32 &	color )

protected

{
    const float radius = 0.5f * size;
    ImVec2 pos = ImGui::GetCurrentWindow()->DC.CursorPos;
    pos.x += radius;
    pos.y += 1.4f * radius;
    ImGui::GetCurrentWindow()->DrawList->AddNgonFilled(pos, radius, color, 6);
    m_imgui->text("  ");
    ImGui::SameLine();
}

References Slic3r::GUI::GLGizmoBase::m_imgui.

Referenced by render_cut_plane_input_window().

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_connect_mode_radio_button()

void Slic3r::GUI::GLGizmoCut3D::render_connect_mode_radio_button ( CutConnectorMode mode )

private

{
    ImGui::SameLine(mode == CutConnectorMode::Auto ? m_label_width : 2 * m_label_width);
    ImGui::PushItemWidth(m_control_width);
    if (ImGui::RadioButton(m_connector_modes[int(mode)].c_str(), m_connector_mode == mode))
        m_connector_mode = mode;
}

References Auto, m_connector_mode, m_connector_modes, m_control_width, and m_label_width.

◆ render_connect_type_radio_button()

bool Slic3r::GUI::GLGizmoCut3D::render_connect_type_radio_button ( CutConnectorType type )

private

{
    ImGui::SameLine(type == CutConnectorType::Plug ? m_label_width : 0);
    ImGui::PushItemWidth(m_control_width);
    if (ImGui::RadioButton(m_connector_types[size_t(type)].c_str(), m_connector_type == type)) {
        m_connector_type = type;
//        update_connector_shape();
        return true;
    }
    return false;
}

References m_connector_type, m_connector_types, m_control_width, m_label_width, and Slic3r::Plug.

Referenced by render_connectors_input_window().

Here is the caller graph for this function:

◆ render_connectors()

void Slic3r::GUI::GLGizmoCut3D::render_connectors ( )

private

{
    ::glEnable(GL_DEPTH_TEST);
 
    if (cut_line_processing() ||
        CutMode(m_mode) != CutMode::cutPlanar ||
        m_connector_mode == CutConnectorMode::Auto || !m_c->selection_info())
        return;
 
    const ModelObject* mo = m_c->selection_info()->model_object();
    auto inst_id = m_c->selection_info()->get_active_instance();
    if (inst_id < 0)
        return;
    const CutConnectors& connectors = mo->cut_connectors;
    if (connectors.size() != m_selected.size()) {
        // #ysFIXME
        clear_selection();
        m_selected.resize(connectors.size(), false);
    }
 
    ColorRGBA render_color = CONNECTOR_DEF_COLOR;
 
    const ModelInstance* mi = mo->instances[inst_id];
    const Vec3d& instance_offset = mi->get_offset();
    const double sla_shift       = double(m_c->selection_info()->get_sla_shift());
 
    const bool looking_forward = is_looking_forward();
 
    for (size_t i = 0; i < connectors.size(); ++i) {
        const CutConnector& connector = connectors[i];
 
        float height = connector.height;
        // recalculate connector position to world position
        Vec3d pos = connector.pos + instance_offset + sla_shift * Vec3d::UnitZ();
 
        // First decide about the color of the point.
        assert(std::is_sorted(m_invalid_connectors_idxs.begin(), m_invalid_connectors_idxs.end()));
        const bool conflict_connector = std::binary_search(m_invalid_connectors_idxs.begin(), m_invalid_connectors_idxs.end(), i);
        if (conflict_connector)
            render_color = CONNECTOR_ERR_COLOR;
        else // default connector color
            render_color = connector.attribs.type == CutConnectorType::Dowel ? DOWEL_COLOR          : PLAG_COLOR;
 
        if (!m_connectors_editing)
            render_color = CONNECTOR_ERR_COLOR;
        else if (size_t(m_hover_id - m_connectors_group_id) == i)
            render_color = conflict_connector ? HOVERED_ERR_COLOR :
                           connector.attribs.type == CutConnectorType::Dowel ? HOVERED_DOWEL_COLOR  : HOVERED_PLAG_COLOR;
        else if (m_selected[i])
            render_color = connector.attribs.type == CutConnectorType::Dowel ? SELECTED_DOWEL_COLOR : SELECTED_PLAG_COLOR;
 
        const Camera& camera = wxGetApp().plater()->get_camera();
        if (connector.attribs.type  == CutConnectorType::Dowel &&
            connector.attribs.style == CutConnectorStyle::Prism) {
            if (m_connectors_editing) {
                height = 0.05f;
                if (!looking_forward)
                    pos += 0.05 * m_clp_normal;
            }
            else {
                if (looking_forward)
                    pos -= static_cast<double>(height) * m_clp_normal;
                else
                    pos += static_cast<double>(height) * m_clp_normal;
                height *= 2;
            }
        }
        else if (!looking_forward)
            pos += 0.05 * m_clp_normal;
 
        const Transform3d view_model_matrix = camera.get_view_matrix() * translation_transform(pos) * m_rotation_m *
                                              rotation_transform(-connector.z_angle * Vec3d::UnitZ()) *
                                              scale_transform(Vec3f(connector.radius, connector.radius, height).cast<double>());
 
        render_model(m_shapes[connector.attribs].model, render_color, view_model_matrix);
    }
}

References Slic3r::CutConnector::attribs, Auto, clear_selection(), Slic3r::GUI::CONNECTOR_DEF_COLOR, Slic3r::GUI::CONNECTOR_ERR_COLOR, Slic3r::ModelObject::cut_connectors, cut_line_processing(), cutPlanar, Slic3r::Dowel, Slic3r::GUI::DOWEL_COLOR, Slic3r::ModelInstance::get_offset(), Slic3r::GUI::Camera::get_view_matrix(), GL_DEPTH_TEST, glEnable, Slic3r::CutConnector::height, Slic3r::GUI::HOVERED_DOWEL_COLOR, Slic3r::GUI::HOVERED_ERR_COLOR, Slic3r::GUI::HOVERED_PLAG_COLOR, Slic3r::ModelObject::instances, is_looking_forward(), Slic3r::GUI::GLGizmoBase::m_c, m_clp_normal, m_connector_mode, m_connectors_editing, m_connectors_group_id, Slic3r::GUI::GLGizmoBase::m_hover_id, m_invalid_connectors_idxs, m_mode, m_rotation_m, m_selected, m_shapes, Slic3r::GUI::PLAG_COLOR, Slic3r::CutConnector::pos, Slic3r::Prism, Slic3r::CutConnector::radius, render_model(), Slic3r::Geometry::rotation_transform(), Slic3r::Geometry::scale_transform(), Slic3r::GUI::SELECTED_DOWEL_COLOR, Slic3r::GUI::SELECTED_PLAG_COLOR, Slic3r::CutConnectorAttributes::style, Slic3r::Geometry::translation_transform(), Slic3r::CutConnectorAttributes::type, and Slic3r::CutConnector::z_angle.

Referenced by on_render().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ render_connectors_input_window()

void Slic3r::GUI::GLGizmoCut3D::render_connectors_input_window	(	CutConnectors &	connectors,
		float	x,
		float	y,
		float	bottom_limit )

protected

{
    // Connectors section
        
    float f_scale = m_parent.get_gizmos_manager().get_layout_scale();
    ImGui::PushStyleVar(ImGuiStyleVar_FramePadding, ImVec2(6.0f, 4.0f * f_scale));
    
    ImGui::Separator();
 
    // WIP : Auto : Need to implement
    // m_imgui->text(_L("Mode"));
    // render_connect_mode_radio_button(CutConnectorMode::Auto);
    // render_connect_mode_radio_button(CutConnectorMode::Manual);
 
    ImGui::AlignTextToFramePadding();
    m_imgui->text_colored(ImGuiWrapper::COL_ORANGE_LIGHT, m_labels_map["Connectors"]);
 
    m_imgui->disabled_begin(connectors.empty());
    ImGui::SameLine(m_label_width);
    const std::string act_name = _u8L("Remove connectors");
    if (render_reset_button("connectors", act_name)) {
        Plater::TakeSnapshot snapshot(wxGetApp().plater(), act_name, UndoRedo::SnapshotType::GizmoAction);
        reset_connectors();
    }
    m_imgui->disabled_end();
 
    render_flip_plane_button(m_connectors_editing && connectors.empty());
 
    m_imgui->text(m_labels_map["Type"]);
    ImGuiWrapper::push_radio_style(m_parent.get_scale()); // ORCA
    bool type_changed = render_connect_type_radio_button(CutConnectorType::Plug);
    type_changed     |= render_connect_type_radio_button(CutConnectorType::Dowel);
    type_changed     |= render_connect_type_radio_button(CutConnectorType::Snap);
    if (type_changed)
        apply_selected_connectors([this, &connectors] (size_t idx) { connectors[idx].attribs.type = CutConnectorType(m_connector_type); });
    ImGuiWrapper::pop_radio_style();
 
    m_imgui->disabled_begin(m_connector_type != CutConnectorType::Plug);
        if (type_changed && m_connector_type == CutConnectorType::Dowel) {
            m_connector_style = int(CutConnectorStyle::Prism);
            apply_selected_connectors([this, &connectors](size_t idx) { connectors[idx].attribs.style = CutConnectorStyle(m_connector_style); });
        }
        if (render_combo(m_labels_map["Style"], m_connector_styles, m_connector_style, m_label_width, m_editing_window_width))
            apply_selected_connectors([this, &connectors](size_t idx) { connectors[idx].attribs.style = CutConnectorStyle(m_connector_style); });
    m_imgui->disabled_end();
 
    m_imgui->disabled_begin(m_connector_type == CutConnectorType::Snap);
        if (type_changed && m_connector_type == CutConnectorType::Snap) {
            m_connector_shape_id = int(CutConnectorShape::Circle);
            apply_selected_connectors([this, &connectors](size_t idx) { connectors[idx].attribs.shape = CutConnectorShape(m_connector_shape_id); });
        }
        if (render_combo(m_labels_map["Shape"], m_connector_shapes, m_connector_shape_id, m_label_width, m_editing_window_width))
            apply_selected_connectors([this, &connectors](size_t idx) { connectors[idx].attribs.shape = CutConnectorShape(m_connector_shape_id); });
    m_imgui->disabled_end();
 
    const float depth_min_value = m_connector_type == CutConnectorType::Snap ? m_connector_size : -0.1f;
    if (render_slider_two_input(m_labels_map["Depth"], m_connector_depth_ratio, m_connector_depth_ratio_tolerance, depth_min_value))
        apply_selected_connectors([this, &connectors](size_t idx) {
            if (m_connector_depth_ratio > 0)
                connectors[idx].height           = m_connector_depth_ratio;
            if (m_connector_depth_ratio_tolerance >= 0)
                connectors[idx].height_tolerance = m_connector_depth_ratio_tolerance;
        });
 
    if (render_slider_two_input(m_labels_map["Size"], m_connector_size, m_connector_size_tolerance))
        apply_selected_connectors([this, &connectors](size_t idx) {
            if (m_connector_size > 0)
                connectors[idx].radius           = 0.5f * m_connector_size;
            if (m_connector_size_tolerance >= 0)
                connectors[idx].radius_tolerance = 0.5f * m_connector_size_tolerance;
        });
 
    if (render_angle_input(m_labels_map["Rotation"], m_connector_angle, 0.f, 0.f, 180.f))
        apply_selected_connectors([this, &connectors](size_t idx) {
            connectors[idx].z_angle = m_connector_angle;
        });
 
    if (m_connector_type == CutConnectorType::Snap) {
        render_snap_specific_input(_u8L("Bulge"), _L("Bulge proportion related to radius"), m_snap_bulge_proportion, 0.15f, 5.f, 100.f * m_snap_space_proportion);
        render_snap_specific_input(_u8L("Space"), _L("Space proportion related to radius"), m_snap_space_proportion, 0.3f, 10.f, 50.f);
    }
 
    ImGui::Separator();
 
    render_tooltip_button(x, y);
 
    ImGui::SameLine();
    GLGizmoUtils::begin_right_aligned_buttons({_L("Confirm connectors"), _L("Cancel")});
    GLGizmoUtils::push_orca_button_style();
    if (m_imgui->button(_L("Confirm connectors"))) {
        unselect_all_connectors();
        set_connectors_editing(false);
    }
    GLGizmoUtils::pop_orca_button_style();
 
    ImGui::SameLine();
    if (m_imgui->button(_L("Cancel"))) {
        reset_connectors();
        set_connectors_editing(false);
    }
 
    ImGui::PopStyleVar(1); // ImGuiStyleVar_FramePadding
}

References _L, _u8L, apply_selected_connectors(), Slic3r::GUI::GLGizmoUtils::begin_right_aligned_buttons(), Slic3r::Circle, Slic3r::GUI::ImGuiWrapper::COL_ORANGE_LIGHT, Slic3r::Dowel, Slic3r::UndoRedo::GizmoAction, m_connector_angle, m_connector_depth_ratio, m_connector_depth_ratio_tolerance, m_connector_shape_id, m_connector_shapes, m_connector_size, m_connector_size_tolerance, m_connector_style, m_connector_styles, m_connector_type, m_connectors_editing, m_editing_window_width, Slic3r::GUI::GLGizmoBase::m_imgui, m_label_width, m_labels_map, Slic3r::GUI::GLGizmoBase::m_parent, m_snap_bulge_proportion, m_snap_space_proportion, Slic3r::GUI::plater(), Slic3r::Plug, Slic3r::GUI::GLGizmoUtils::pop_orca_button_style(), Slic3r::GUI::ImGuiWrapper::pop_radio_style(), Slic3r::Prism, Slic3r::GUI::GLGizmoUtils::push_orca_button_style(), Slic3r::GUI::ImGuiWrapper::push_radio_style(), render_angle_input(), Slic3r::GUI::GLGizmoBase::render_combo(), render_connect_type_radio_button(), render_flip_plane_button(), render_reset_button(), render_slider_two_input(), render_snap_specific_input(), render_tooltip_button(), reset_connectors(), set_connectors_editing(), Slic3r::Snap, and unselect_all_connectors().

Referenced by on_render_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
    }
}

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

Here is the call graph for this function:

Here is the caller graph for this function:

◆ render_cut_line()

void Slic3r::GUI::GLGizmoCut3D::render_cut_line ( )

private

{
    if (!cut_line_processing() || m_line_end.isApprox(Vec3d::Zero()))
        return;
 
    glsafe(::glEnable(GL_DEPTH_TEST));
    glsafe(::glClear(GL_DEPTH_BUFFER_BIT));
 
    m_cut_line.reset();
    m_cut_line.init_from(its_make_line((Vec3f)m_line_beg.cast<float>(), (Vec3f)m_line_end.cast<float>()));
 
    render_line(m_cut_line, GRABBER_COLOR, wxGetApp().plater()->get_camera().get_view_matrix(), 0.25f);
}

References cut_line_processing(), GL_DEPTH_BUFFER_BIT, GL_DEPTH_TEST, glClear, glEnable, glsafe, Slic3r::GUI::GRABBER_COLOR, Slic3r::GUI::its_make_line(), m_cut_line, m_line_beg, m_line_end, Slic3r::GUI::plater(), and render_line().

Referenced by on_render().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ render_cut_mode_combo()

bool Slic3r::GUI::GLGizmoCut3D::render_cut_mode_combo ( )

private

{
    ImGui::AlignTextToFramePadding();
    ImGuiWrapper::push_combo_style(m_parent.get_scale());
    int selection_idx = int(m_mode);
    const bool is_changed = m_imgui->combo(_u8L("Mode"), m_modes, selection_idx, 0, m_label_width, m_control_width);
    ImGuiWrapper::pop_combo_style();
 
    if (is_changed) {
        Plater::TakeSnapshot snapshot(wxGetApp().plater(), _u8L("Change cut mode"), UndoRedo::SnapshotType::GizmoAction);
        switch_to_mode(size_t(selection_idx));
        check_and_update_connectors_state();
    }
 
    return is_changed;
}

References _u8L, check_and_update_connectors_state(), Slic3r::UndoRedo::GizmoAction, m_control_width, Slic3r::GUI::GLGizmoBase::m_imgui, m_label_width, m_mode, m_modes, Slic3r::GUI::GLGizmoBase::m_parent, Slic3r::GUI::plater(), Slic3r::GUI::ImGuiWrapper::pop_combo_style(), Slic3r::GUI::ImGuiWrapper::push_combo_style(), and switch_to_mode().

Referenced by render_cut_plane_input_window().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ render_cut_plane()

void Slic3r::GUI::GLGizmoCut3D::render_cut_plane ( )

private

{
    if (cut_line_processing())
        return;
 
    GLShaderProgram* shader = wxGetApp().get_shader("flat");
    if (shader == nullptr)
        return;
 
    glsafe(::glEnable(GL_DEPTH_TEST));
    glsafe(::glDisable(GL_CULL_FACE));
    glsafe(::glEnable(GL_BLEND));
    glsafe(::glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA));
 
    shader->start_using();
 
    const Camera& camera = wxGetApp().plater()->get_camera();
 
    shader->set_uniform("projection_matrix", camera.get_projection_matrix());
 
    ColorRGBA cp_clr = can_perform_cut() && has_valid_groove() ? CUT_PLANE_DEF_COLOR : CUT_PLANE_ERR_COLOR;
    if (m_mode == size_t(CutMode::cutTongueAndGroove))
        cp_clr.a(cp_clr.a() - 0.1f);
    m_plane.model.set_color(cp_clr);
 
    const Transform3d view_model_matrix = camera.get_view_matrix() * translation_transform(m_plane_center) * m_rotation_m;
    shader->set_uniform("view_model_matrix", view_model_matrix);
    m_plane.model.render();
 
    glsafe(::glEnable(GL_CULL_FACE));
    glsafe(::glDisable(GL_BLEND));
 
    shader->stop_using();
}

References Slic3r::ColorRGBA::a(), can_perform_cut(), cut_line_processing(), Slic3r::GUI::CUT_PLANE_DEF_COLOR, Slic3r::GUI::CUT_PLANE_ERR_COLOR, cutTongueAndGroove, Slic3r::GUI::Camera::get_projection_matrix(), Slic3r::GUI::Camera::get_view_matrix(), GL_BLEND, GL_CULL_FACE, GL_DEPTH_TEST, GL_ONE_MINUS_SRC_ALPHA, GL_SRC_ALPHA, glBlendFunc, glDisable, glEnable, glsafe, has_valid_groove(), m_mode, m_plane, m_plane_center, m_rotation_m, Slic3r::GLShaderProgram::set_uniform(), Slic3r::GLShaderProgram::start_using(), Slic3r::GLShaderProgram::stop_using(), and Slic3r::Geometry::translation_transform().

Referenced by on_render().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ render_cut_plane_grabbers()

void Slic3r::GUI::GLGizmoCut3D::render_cut_plane_grabbers ( )

private

{
    glsafe(::glClear(GL_DEPTH_BUFFER_BIT));
 
    ColorRGBA color = ColorRGBA::GRAY();
 
    const Transform3d view_matrix = wxGetApp().plater()->get_camera().get_view_matrix() * translation_transform(m_plane_center) * m_rotation_m;
 
    const double mean_size = get_grabber_mean_size(m_bounding_box);
    double size;
 
    const bool no_xy_dragging = m_dragging && m_hover_id == CutPlane;
 
    if (!no_xy_dragging && m_hover_id != CutPlaneZRotation && m_hover_id != CutPlaneXMove && m_hover_id != CutPlaneYMove) {
        render_grabber_connection(GRABBER_COLOR, view_matrix);
 
        // render sphere grabber
        size = m_dragging ? get_dragging_half_size(mean_size) : get_half_size(mean_size);
        color = m_hover_id == Y ? ColorRGBA::Y() : // ORCA match axis colors
                m_hover_id == X ? ColorRGBA::X() : // ORCA match axis colors
                m_hover_id == Z ? GRABBER_COLOR                     :   ColorRGBA::GRAY();
        render_model(m_sphere.model, color, view_matrix * translation_transform(m_grabber_connection_len * Vec3d::UnitZ()) * scale_transform(size));
    }
 
    const bool no_xy_grabber_hovered = !m_dragging && (m_hover_id < 0 || m_hover_id == CutPlane);
 
    // render X grabber
 
    if (no_xy_grabber_hovered || m_hover_id == X)
    {
        size = m_dragging && m_hover_id == X ? get_dragging_half_size(mean_size) : get_half_size(mean_size);
        const Vec3d cone_scale = Vec3d(0.75 * size, 0.75 * size, 1.8 * size);
        //color = m_hover_id == X ? complementary(ColorRGBA::X()) : ColorRGBA::X();
        color = ColorRGBA::X(); // ORCA match axis colors
 
        if (m_hover_id == X) {
            render_grabber_connection(color, view_matrix);
            render_rotation_snapping(X, color);
        }
 
        Vec3d offset = Vec3d(0.0, 1.25 * size, m_grabber_connection_len);
        render_model(m_cone.model, color, view_matrix * translation_transform(offset) * rotation_transform(-0.5 * PI * Vec3d::UnitX()) * scale_transform(cone_scale));
        offset = Vec3d(0.0, -1.25 * size, m_grabber_connection_len);
        render_model(m_cone.model, color, view_matrix * translation_transform(offset) * rotation_transform(0.5 * PI * Vec3d::UnitX()) * scale_transform(cone_scale));
    }
 
    // render Y grabber
 
    if (no_xy_grabber_hovered || m_hover_id == Y)
    {
        size = m_dragging && m_hover_id == Y ? get_dragging_half_size(mean_size) : get_half_size(mean_size);
        const Vec3d cone_scale = Vec3d(0.75 * size, 0.75 * size, 1.8 * size);
        //color = m_hover_id == Y ? complementary(ColorRGBA::Y()) : ColorRGBA::Y();
        color = ColorRGBA::Y(); // ORCA match axis colors
 
        if (m_hover_id == Y) {
            render_grabber_connection(color, view_matrix);
            render_rotation_snapping(Y, color);
        }
 
        Vec3d offset = Vec3d(1.25 * size, 0.0, m_grabber_connection_len);
        render_model(m_cone.model, color, view_matrix * translation_transform(offset) * rotation_transform(0.5 * PI * Vec3d::UnitY()) * scale_transform(cone_scale));
        offset = Vec3d(-1.25 * size, 0.0, m_grabber_connection_len);
        render_model(m_cone.model, color, view_matrix * translation_transform(offset) * rotation_transform(-0.5 * PI * Vec3d::UnitY()) * scale_transform(cone_scale));
    }
 
    if (CutMode(m_mode) == CutMode::cutTongueAndGroove) {
 
        // render CutPlaneZRotation grabber
 
        if (no_xy_grabber_hovered || m_hover_id == CutPlaneZRotation)
        {
            size = 0.75 * (m_dragging ? get_dragging_half_size(mean_size) : get_half_size(mean_size));
            color = ColorRGBA::Z(); // ORCA match axis colors
            const ColorRGBA cp_color = m_hover_id == CutPlaneZRotation ? color : m_plane.model.get_color();
 
            const double grabber_shift = -1.75 * m_grabber_connection_len;
 
            render_model(m_sphere.model, cp_color, view_matrix * translation_transform(grabber_shift * Vec3d::UnitY()) * scale_transform(size));
 
            if (m_hover_id == CutPlaneZRotation) {
                const Vec3d cone_scale = Vec3d(0.75 * size, 0.75 * size, 1.8 * size);
 
                render_rotation_snapping(CutPlaneZRotation, color);
                render_grabber_connection(GRABBER_COLOR, view_matrix * rotation_transform(0.5 * PI * Vec3d::UnitX()), 1.75);
 
                Vec3d offset = Vec3d(1.25 * size, grabber_shift, 0.0);
                render_model(m_cone.model, color, view_matrix * translation_transform(offset) * rotation_transform(0.5 * PI * Vec3d::UnitY()) * scale_transform(cone_scale));
                offset = Vec3d(-1.25 * size, grabber_shift, 0.0);
                render_model(m_cone.model, color, view_matrix * translation_transform(offset) * rotation_transform(-0.5 * PI * Vec3d::UnitY()) * scale_transform(cone_scale));
            }
        }
 
        const double xy_connection_len = 0.75 * m_grabber_connection_len;
 
        // render CutPlaneXMove grabber
 
        if (no_xy_grabber_hovered || m_hover_id == CutPlaneXMove)
        {
            size = (m_dragging ? get_dragging_half_size(mean_size) : get_half_size(mean_size));
            color = m_hover_id == CutPlaneXMove ? ColorRGBA::X() : m_plane.model.get_color(); // ORCA match axis colors
 
            render_grabber_connection(GRABBER_COLOR, view_matrix * rotation_transform(0.5 * PI * Vec3d::UnitY()), 0.75);
 
            Vec3d offset = xy_connection_len * Vec3d::UnitX() - 0.5 * size * Vec3d::Ones();
            render_model(m_cube.model, color, view_matrix * translation_transform(offset) * scale_transform(size));
 
            const Vec3d cone_scale = Vec3d(0.5 * size, 0.5 * size, 1.8 * size);
 
            offset = (size + xy_connection_len) * Vec3d::UnitX();
            render_model(m_cone.model, color, view_matrix * translation_transform(offset) * rotation_transform(0.5 * PI * Vec3d::UnitY()) * scale_transform(cone_scale));
        }
 
        // render CutPlaneYMove grabber
 
        if (m_groove.angle > 0.0f && (no_xy_grabber_hovered || m_hover_id == CutPlaneYMove))
        {
            size = (m_dragging ? get_dragging_half_size(mean_size) : get_half_size(mean_size));
            color = m_hover_id == CutPlaneYMove ? ColorRGBA::Y() : m_plane.model.get_color(); // ORCA match axis colors
 
            render_grabber_connection(GRABBER_COLOR, view_matrix * rotation_transform(-0.5 * PI * Vec3d::UnitX()), 0.75);
 
            Vec3d offset = xy_connection_len * Vec3d::UnitY() - 0.5 * size * Vec3d::Ones();
            render_model(m_cube.model, color, view_matrix * translation_transform(offset) * scale_transform(size));
 
            const Vec3d cone_scale = Vec3d(0.5 * size, 0.5 * size, 1.8 * size);
 
            offset = (size + xy_connection_len) * Vec3d::UnitY();
            render_model(m_cone.model, color, view_matrix * translation_transform(offset) * rotation_transform(-0.5 * PI * Vec3d::UnitX()) * scale_transform(cone_scale));
        }
    }
}

References CutPlane, CutPlaneXMove, CutPlaneYMove, CutPlaneZRotation, cutTongueAndGroove, Slic3r::GUI::get_dragging_half_size(), Slic3r::GUI::get_grabber_mean_size(), Slic3r::GUI::get_half_size(), GL_DEPTH_BUFFER_BIT, glClear, glsafe, Slic3r::GUI::GRABBER_COLOR, Slic3r::ColorRGBA::GRAY(), m_bounding_box, m_cone, m_cube, Slic3r::GUI::GLGizmoBase::m_dragging, m_grabber_connection_len, m_groove, Slic3r::GUI::GLGizmoBase::m_hover_id, m_mode, m_plane, m_plane_center, m_rotation_m, m_sphere, Slic3r::offset(), PI, render_grabber_connection(), render_model(), render_rotation_snapping(), Slic3r::Geometry::rotation_transform(), Slic3r::Geometry::scale_transform(), Slic3r::Geometry::translation_transform(), Slic3r::ColorRGBA::X(), X, Slic3r::ColorRGBA::Y(), Y, Slic3r::ColorRGBA::Z(), and Z.

Referenced by on_render().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ render_cut_plane_input_window()

void Slic3r::GUI::GLGizmoCut3D::render_cut_plane_input_window	(	CutConnectors &	connectors,
		float	x,
		float	y,
		float	bottom_limit )

protected

{
    const bool has_connectors = !connectors.empty();
    const bool is_cut_plane_init = m_rotation_m.isApprox(Transform3d::Identity()) && m_bb_center.isApprox(m_plane_center);
 
    float f_scale = m_parent.get_gizmos_manager().get_layout_scale();
    ImGui::PushStyleVar(ImGuiStyleVar_FramePadding, ImVec2(6.0f, 4.0f * f_scale));
    
    CutMode mode = CutMode(m_mode);
    if (mode == CutMode::cutPlanar || mode == CutMode::cutTongueAndGroove) {
 
        m_imgui->disabled_begin(has_connectors);
        if (render_cut_mode_combo())
            mode = CutMode(m_mode);
        m_imgui->disabled_end();
 
        render_build_size();
 
        ImGui::AlignTextToFramePadding();
        m_imgui->text(_L("Cut position"));
        ImGui::SameLine(m_label_width);
        render_move_center_input(Z);
        ImGui::SameLine();
 
        m_imgui->disabled_begin(is_cut_plane_init);
            std::string act_name = _u8L("Reset cutting plane");
            if (render_reset_button("cut_plane", act_name)) {
                Plater::TakeSnapshot snapshot(wxGetApp().plater(), act_name, UndoRedo::SnapshotType::GizmoAction);
                reset_cut_plane();
            }
        m_imgui->disabled_end();
 
        if (mode == CutMode::cutPlanar) {
            ImGui::Separator();
 
            m_imgui->disabled_begin(!m_keep_upper || !m_keep_lower || m_keep_as_parts || (m_part_selection.valid() && m_part_selection.is_one_object()));
                if (m_imgui->button(has_connectors ? _L("Edit connectors") : _L("Add connectors")))
                    set_connectors_editing(true);
            m_imgui->disabled_end();
        }
        else if (mode == CutMode::cutTongueAndGroove) {
            m_is_slider_editing_done = false;
            ImGui::Separator();
            m_imgui->text_colored(ImGuiWrapper::COL_ORANGE_LIGHT, m_labels_map["Groove"] + ": ");
            render_groove_two_float_input(m_labels_map["Depth"], m_groove.depth, m_groove.depth_init, m_groove.depth_tolerance);
            render_groove_two_float_input(m_labels_map["Width"], m_groove.width, m_groove.width_init, m_groove.width_tolerance);
            render_groove_angle_input(m_labels_map["Flap Angle"], m_groove.flaps_angle, m_groove.flaps_angle_init, 30.f, 120.f);
            render_groove_angle_input(m_labels_map["Groove Angle"], m_groove.angle, m_groove.angle_init, 0.f, 15.f);
 
            ImGui::Spacing();
            m_imgui->text_colored(ImGuiWrapper::COL_ORANGE_LIGHT, m_labels_map["Multiple"] + ": ");
            render_groove_int_input(m_labels_map["Count"], m_groove_count, m_groove_count_init , 1, 100);
            render_groove_float_input(m_labels_map["Gap"], m_groove_gap, m_groove_gap_init, m_groove_count == 1);
 
            m_imgui->disabled_begin(true);
            const float groove_width = Cut::calculate_groove_width(m_groove, m_radius);
            m_imgui->text(m_labels_map["Spacing"]);
            ImGui::SameLine(m_label_width);
            std::ostringstream oss;
            oss << std::fixed << std::setprecision(2) << (m_groove_gap + groove_width);
            m_imgui->text(oss.str() + "mm");        
            m_imgui->disabled_end();
        }
 
        ImGui::Separator();
 
        // render "After Cut" section
 
        ImVec2 label_size;
        for (const wxString &label : {_L("Upper part"), _L("Lower part")}) {
            const ImVec2 text_size = ImGuiWrapper::calc_text_size(label);
            if (label_size.x < text_size.x)
                label_size.x = text_size.x;
            if (label_size.y < text_size.y)
                label_size.y = text_size.y;
        }
 
        const float marker_size = label_size.y;
        const float h_shift     = marker_size + label_size.x + m_imgui->scaled(2.f);
 
        auto render_part_action_line = [this, h_shift, marker_size, &connectors](const wxString &label, const wxString &suffix, bool &keep_part,
                                                                        bool &place_on_cut_part, bool &rotate_part) {
            bool keep = true;
 
            ImGui::AlignTextToFramePadding();
            render_color_marker(marker_size, ImGuiWrapper::to_ImU32(suffix == "##upper" ? UPPER_PART_COLOR : LOWER_PART_COLOR));
            m_imgui->text(label);
 
            ImGui::SameLine(h_shift);
 
            m_imgui->disabled_begin(!connectors.empty() || m_keep_as_parts);
            m_imgui->bbl_checkbox(_L("Keep") + suffix, connectors.empty() ? keep_part : keep);
            m_imgui->disabled_end();
 
            ImGui::SameLine();
 
            m_imgui->disabled_begin(!keep_part || m_keep_as_parts);
            if (m_imgui->bbl_checkbox(_L("Place on cut") + suffix, place_on_cut_part))
                rotate_part = false;
            ImGui::SameLine();
            if (m_imgui->bbl_checkbox(_L("Flip") + suffix, rotate_part))
                place_on_cut_part = false;
            m_imgui->disabled_end();
        };
 
        m_imgui->text(_L("After cut") + ": ");
        render_part_action_line(_L("Upper part"), "##upper", m_keep_upper, m_place_on_cut_upper, m_rotate_upper);
        render_part_action_line(_L("Lower part"), "##lower", m_keep_lower, m_place_on_cut_lower, m_rotate_lower);
 
        m_imgui->disabled_begin(has_connectors || m_part_selection.valid() || mode == CutMode::cutTongueAndGroove);
 
            if (m_part_selection.valid())
                m_keep_as_parts = false;
 
            m_imgui->bbl_checkbox(_L("Cut to parts"), m_keep_as_parts);
            if (m_keep_as_parts) {
                m_keep_upper = m_keep_lower = true;
                m_place_on_cut_upper = m_place_on_cut_lower = false;
                m_rotate_upper = m_rotate_lower = false;
            }
        m_imgui->disabled_end();
    }
 
    ImGui::Separator();
    
    render_tooltip_button(x, y);
 
    if (mode == CutMode::cutPlanar) {
        ImGui::SameLine();
        m_imgui->disabled_begin(is_cut_plane_init && !has_connectors);
        if (m_imgui->button(_L("Reset"), _L("Reset cutting plane and remove connectors"))) {
            Plater::TakeSnapshot snapshot(wxGetApp().plater(), _u8L("Reset Cut"), UndoRedo::SnapshotType::GizmoAction);
            reset_cut_plane();
            reset_connectors();
        }
        m_imgui->disabled_end();
    }
 
    ImGui::SameLine();
    GLGizmoUtils::begin_right_aligned_buttons({_L("Perform cut"), _L("Cancel")});
    m_imgui->disabled_begin(!can_perform_cut());
    GLGizmoUtils::push_orca_button_style();
    if(m_imgui->button(_L("Perform cut")))
        perform_cut(m_parent.get_selection());
    GLGizmoUtils::pop_orca_button_style();
    m_imgui->disabled_end();
 
    ImGui::SameLine();
    if (m_imgui->button(_L("Cancel"))) {
        m_parent.reset_all_gizmos();
    }
 
    ImGui::PopStyleVar(1); // ImGuiStyleVar_FramePadding
}

References _L, _u8L, Slic3r::GUI::GLGizmoUtils::begin_right_aligned_buttons(), Slic3r::GUI::ImGuiWrapper::calc_text_size(), Slic3r::Cut::calculate_groove_width(), can_perform_cut(), Slic3r::GUI::ImGuiWrapper::COL_ORANGE_LIGHT, cutPlanar, cutTongueAndGroove, Slic3r::UndoRedo::GizmoAction, Slic3r::GUI::LOWER_PART_COLOR, m_bb_center, m_groove, m_groove_count, m_groove_count_init, m_groove_gap, m_groove_gap_init, Slic3r::GUI::GLGizmoBase::m_imgui, m_is_slider_editing_done, m_keep_as_parts, m_keep_lower, m_keep_upper, m_label_width, m_labels_map, m_mode, Slic3r::GUI::GLGizmoBase::m_parent, m_part_selection, m_place_on_cut_lower, m_place_on_cut_upper, m_plane_center, m_radius, m_rotate_lower, m_rotate_upper, m_rotation_m, perform_cut(), Slic3r::GUI::plater(), Slic3r::GUI::GLGizmoUtils::pop_orca_button_style(), Slic3r::GUI::GLGizmoUtils::push_orca_button_style(), render_build_size(), render_color_marker(), render_cut_mode_combo(), render_groove_angle_input(), render_groove_float_input(), render_groove_int_input(), render_groove_two_float_input(), render_move_center_input(), render_reset_button(), render_tooltip_button(), reset_connectors(), reset_cut_plane(), set_connectors_editing(), Slic3r::GUI::ImGuiWrapper::to_ImU32(), Slic3r::GUI::UPPER_PART_COLOR, and Z.

Referenced by on_render_input_window().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ render_debug_input_window()

void Slic3r::GUI::GLGizmoCut3D::render_debug_input_window ( float x )

protected

{
    return;
    m_imgui->begin(wxString("DEBUG"));
 
    m_imgui->end();
/*
    static bool  hide_clipped  = false;
    static bool  fill_cut      = false;
    static float contour_width = 0.4f;
 
    m_imgui->checkbox(_L("Hide cut plane and grabbers"), m_hide_cut_plane);
    if (m_imgui->checkbox("hide_clipped", hide_clipped) && !hide_clipped)
        m_clp_normal = m_c->object_clipper()->get_clipping_plane()->get_normal();
    m_imgui->checkbox("fill_cut", fill_cut);
    m_imgui->slider_float("contour_width", &contour_width, 0.f, 3.f);
    if (auto oc = m_c->object_clipper())
        oc->set_behavior(hide_clipped || m_connectors_editing, fill_cut || m_connectors_editing, double(contour_width));
*/
    ImGui::PushItemWidth(0.5f * m_label_width);
    if (auto oc = m_c->object_clipper(); oc && m_imgui->slider_float("contour_width", &m_contour_width, 0.f, 3.f))
        oc->set_behavior(m_connectors_editing, m_connectors_editing, double(m_contour_width));
 
    ImGui::Separator();
 
    if (m_imgui->checkbox(("Render cut plane as disc"), m_cut_plane_as_circle))
        m_plane.reset();
 
    ImGui::PushItemWidth(0.5f * m_label_width);
    if (m_imgui->slider_float("cut_plane_radius_koef", &m_cut_plane_radius_koef, 1.f, 2.f))
        m_plane.reset();
 
    m_imgui->end();
}

References Slic3r::GUI::GLGizmoBase::m_c, m_connectors_editing, m_contour_width, m_cut_plane_as_circle, m_cut_plane_radius_koef, Slic3r::GUI::GLGizmoBase::m_imgui, m_label_width, and m_plane.

Referenced by on_render_input_window().

Here is the caller graph for this function:

◆ render_double_input()

bool Slic3r::GUI::GLGizmoCut3D::render_double_input	(	const std::string &	label,
		double &	value_in )

private

{
    ImGui::AlignTextToFramePadding();
    m_imgui->text(label);
    ImGui::SameLine(m_label_width);
    ImGui::PushItemWidth(m_control_width);
 
    double value = value_in;
    if (m_imperial_units)
        value *= GizmoObjectManipulation::mm_to_in;
    double old_val = value;
    ImGui::InputDouble(("##" + label).c_str(), &value, 0.0f, 0.0f, "%.2f", ImGuiInputTextFlags_CharsDecimal);
 
    ImGui::SameLine();
    m_imgui->text(m_imperial_units ? _L_CONTEXT("in", "inches") : _L("mm"));
 
    value_in = value * (m_imperial_units ? GizmoObjectManipulation::in_to_mm : 1.0);
    return !is_approx(old_val, value);
}

References _L, _L_CONTEXT, Slic3r::GUI::GizmoObjectManipulation::in_to_mm, Slic3r::is_approx(), m_control_width, Slic3r::GUI::GLGizmoBase::m_imgui, m_imperial_units, m_label_width, and Slic3r::GUI::GizmoObjectManipulation::mm_to_in.

Here is the call graph for this function:

◆ render_flip_plane_button()

void Slic3r::GUI::GLGizmoCut3D::render_flip_plane_button ( bool disable_pred = false )

protected

{
    ImGui::SameLine();
 
    if (m_hover_id == CutPlane)
        ImGui::PushStyleColor(ImGuiCol_Button, ImGui::GetColorU32(ImGuiCol_ButtonHovered));
 
    m_imgui->disabled_begin(disable_pred);
        if (m_imgui->button(_L("Flip cut plane")))
            flip_cut_plane();
    m_imgui->disabled_end();
 
    if (m_hover_id == CutPlane)
        ImGui::PopStyleColor();
}

References _L, CutPlane, flip_cut_plane(), Slic3r::GUI::GLGizmoBase::m_hover_id, and Slic3r::GUI::GLGizmoBase::m_imgui.

Referenced by render_connectors_input_window().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ render_follows_cursor()

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

inlinevirtualinherited

Reimplemented in Slic3r::GUI::GLGizmoBrimEars, Slic3r::GUI::GLGizmoMeasure, and Slic3r::GUI::GLGizmoPainterBase.

189{ return false; }

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

Here is the caller graph for this function:

◆ render_grabber_connection()

void Slic3r::GUI::GLGizmoCut3D::render_grabber_connection	(	const ColorRGBA &	color,
		Transform3d	view_matrix,
		double	line_len_koef = 1.0 )

private

{
    const Transform3d line_view_matrix = view_matrix * scale_transform(Vec3d(1.0, 1.0, line_len_koef * m_grabber_connection_len));
 
    render_line(m_grabber_connection, color, line_view_matrix, 0.2f);
};

References m_grabber_connection, m_grabber_connection_len, render_line(), and Slic3r::Geometry::scale_transform().

Referenced by render_cut_plane_grabbers().

Here is the call graph for this function:

Here is the caller 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_groove_angle_input()

void Slic3r::GUI::GLGizmoCut3D::render_groove_angle_input	(	const std::string &	label,
		float &	in_val,
		const float &	init_val,
		float	min_val,
		float	max_val )

protected

{
    if (render_angle_input(label, in_val, init_val, min_val, max_val)) {
        update_plane_model();
        reset_cut_by_contours();
    }
 
    if (m_is_slider_editing_done) {
        m_groove_editing = false;
        reset_cut_by_contours();
    }
}

References m_groove_editing, m_is_slider_editing_done, render_angle_input(), reset_cut_by_contours(), and update_plane_model().

Referenced by render_cut_plane_input_window().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ render_groove_float_input()

void Slic3r::GUI::GLGizmoCut3D::render_groove_float_input	(	const std::string &	label,
		float &	in_val,
		const float &	init_val,
		const bool	disabled )

protected

{
    if (disabled)
        m_imgui->disabled_begin(true);
 
    bool is_changed{false};
    Vec2d plate_size = wxGetApp().plater()->get_partplate_list().get_plate(0)->get_size();
    float max_val    = std::max(plate_size.x(), plate_size.y()) / (std::max(m_groove_count - 1, 1));
 
    float val       = in_val;
    if (render_slider_input(label, val, -0.1f, max_val)) {
        if (m_imgui->get_last_slider_status().can_take_snapshot) {
            Plater::TakeSnapshot snapshot(wxGetApp().plater(), GUI::format("%1%: %2%", _u8L("Groove change"), label),
                                          UndoRedo::SnapshotType::GizmoAction);
            m_imgui->get_last_slider_status().invalidate_snapshot();
            m_groove_editing = true;
        }
        in_val       = val;
        is_changed   = true;
    }
 
    ImGui::SameLine();
 
    if (!disabled) m_imgui->disabled_begin(is_approx(in_val, init_val) );
    const std::string act_name = _u8L("Reset");
    if (render_reset_button("##groove_" + label + act_name, act_name)) {
        Plater::TakeSnapshot snapshot(wxGetApp().plater(), GUI::format("%1%: %2%", act_name, label), UndoRedo::SnapshotType::GizmoAction);
        in_val       = init_val;
        is_changed   = true;
    }
    if (!disabled) m_imgui->disabled_end();
 
    if (is_changed) {
        update_plane_model();
        reset_cut_by_contours();
    }
 
    if (m_is_slider_editing_done) {
        m_groove_editing = false;
        reset_cut_by_contours();
    }
 
    if (disabled)
        m_imgui->disabled_end();
}

References _u8L, Slic3r::GUI::format(), Slic3r::UndoRedo::GizmoAction, Slic3r::is_approx(), m_groove_count, m_groove_editing, Slic3r::GUI::GLGizmoBase::m_imgui, m_is_slider_editing_done, Slic3r::GUI::plater(), render_reset_button(), render_slider_input(), reset_cut_by_contours(), and update_plane_model().

Referenced by render_cut_plane_input_window().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ render_groove_int_input()

void Slic3r::GUI::GLGizmoCut3D::render_groove_int_input	(	const std::string &	label,
		int &	in_val,
		const int &	init_val,
		int	min_val,
		int	max_val )

protected

{
    bool is_changed{false};
 
    m_imgui->text(label);
    ImGui::AlignTextToFramePadding();
    ImGui::SameLine(m_label_width);
    ImGui::PushItemWidth(m_control_width);
    int val = in_val;
    if (ImGui::InputInt("##int_input", &val, 1, 5)) {
        val = std::clamp(val, min_val, max_val);
        // ORCA Holding +/- at the limit clamps back to the same value, don't rebuild for that.
        if (val != in_val) {
            in_val     = val;
            is_changed = true;
        }
    }
    m_imgui->request_frames_while_held(); // ORCA auto-repeat of the +/- buttons
    
    ImGui::SameLine();
    m_imgui->disabled_begin(in_val == init_val);
    const std::string act_name = _u8L("Reset");
    if (render_reset_button("##int_" + label + act_name, act_name)) {
        Plater::TakeSnapshot snapshot(wxGetApp().plater(), GUI::format("%1%: %2%", act_name, label), UndoRedo::SnapshotType::GizmoAction);
        in_val     = init_val;
        is_changed = true;
    }
    m_imgui->disabled_end();
 
    if (is_changed) {
        update_plane_model();
        reset_cut_by_contours();
    }
}

References _u8L, Slic3r::GUI::format(), Slic3r::UndoRedo::GizmoAction, m_control_width, Slic3r::GUI::GLGizmoBase::m_imgui, m_label_width, Slic3r::GUI::plater(), render_reset_button(), reset_cut_by_contours(), and update_plane_model().

Referenced by render_cut_plane_input_window().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ render_groove_two_float_input()

void Slic3r::GUI::GLGizmoCut3D::render_groove_two_float_input	(	const std::string &	label,
		float &	in_val,
		const float &	init_val,
		float &	in_tolerance )

protected

{
    bool is_changed{false};
 
    float val = in_val;
    float tolerance = in_tolerance;
    if (render_slider_two_input(label, val, tolerance, -0.1f, std::min(0.3f*in_val, 1.5f))) {
        if (m_imgui->get_last_slider_status().can_take_snapshot) {
            Plater::TakeSnapshot snapshot(wxGetApp().plater(), GUI::format("%1%: %2%", _u8L("Groove change"), label), UndoRedo::SnapshotType::GizmoAction);
            m_imgui->get_last_slider_status().invalidate_snapshot();
            m_groove_editing = true;
        }
        in_val = val;
        in_tolerance = tolerance;
        is_changed = true;
    }
 
    ImGui::SameLine();
 
    m_imgui->disabled_begin(is_approx(in_val, init_val) && is_approx(in_tolerance, 0.1f));
        const std::string act_name = _u8L("Reset");
        if (render_reset_button("##groove_" + label + act_name, act_name)) {
        Plater::TakeSnapshot snapshot(wxGetApp().plater(), GUI::format("%1%: %2%", act_name, label), UndoRedo::SnapshotType::GizmoAction);
            in_val = init_val;
            in_tolerance = 0.1f;
            is_changed = true;
        }
    m_imgui->disabled_end();
 
    if (is_changed) {
        update_plane_model();
        reset_cut_by_contours();
    }
 
    if (m_is_slider_editing_done) {
        m_groove_editing = false;
        reset_cut_by_contours();
    }
}

References _u8L, Slic3r::GUI::format(), Slic3r::UndoRedo::GizmoAction, Slic3r::is_approx(), m_groove_editing, Slic3r::GUI::GLGizmoBase::m_imgui, m_is_slider_editing_done, Slic3r::GUI::plater(), render_reset_button(), render_slider_two_input(), reset_cut_by_contours(), and update_plane_model().

Referenced by render_cut_plane_input_window().

Here is the call graph for this function:

Here is the caller 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::GLGizmoCut3D::render_input_window_warning ( ) const

protected

{
    const bool invalid_connector_warning = !m_invalid_connectors_idxs.empty();
    const bool keep_after_cut_warning    = !m_keep_upper && !m_keep_lower;
    const bool invalid_contour_warning   = !has_valid_contour();
    const bool invalid_groove_warning    = !has_valid_groove();
 
    if (invalid_connector_warning || keep_after_cut_warning || invalid_contour_warning || invalid_groove_warning) {
        ImGui::Separator();
    }
 
    if (invalid_connector_warning) {
        wxString out = /*wxString(ImGui::WarningMarkerSmall)*/ _L("Warning") + ": " + _L("Invalid connectors detected") + ":";
        if (m_info_stats.outside_cut_contour > size_t(0))
            out += "\n - " + format_wxstr(_L_PLURAL("%1$d connector is out of cut contour", "%1$d connectors are out of cut contour", m_info_stats.outside_cut_contour),
                                          m_info_stats.outside_cut_contour);
        if (m_info_stats.outside_bb > size_t(0))
            out += "\n - " + format_wxstr(_L_PLURAL("%1$d connector is out of object", "%1$d connectors are out of object", m_info_stats.outside_bb),
                                           m_info_stats.outside_bb);
        if (m_info_stats.is_overlap)
            out += "\n - " + _L("Some connectors are overlapped");
        m_imgui->warning_text(out);
    }
    if (keep_after_cut_warning)
        m_imgui->warning_text(/*wxString(ImGui::WarningMarkerSmall)*/ _L("Warning") + ": " + _L("Select at least one object to keep after cutting."));
    if (invalid_contour_warning)
        m_imgui->warning_text(/*wxString(ImGui::WarningMarkerSmall)*/ _L("Warning") + ": " + _L("Cut plane is placed out of object"));
    else if (invalid_groove_warning)
        m_imgui->warning_text(/*wxString(ImGui::WarningMarkerSmall)*/ _L("Warning") + ": " + _L("Cut plane with groove is invalid"));
}

References _L, _L_PLURAL, Slic3r::GUI::format_wxstr(), has_valid_contour(), has_valid_groove(), Slic3r::GUI::GLGizmoBase::m_imgui, m_info_stats, m_invalid_connectors_idxs, m_keep_lower, and m_keep_upper.

Referenced by on_render_input_window().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ render_line()

void Slic3r::GUI::GLGizmoCut3D::render_line	(	GLModel &	line_model,
		const ColorRGBA &	color,
		Transform3d	view_model_matrix,
		float	width )

private

{
    GLShaderProgram* shader = wxGetApp().get_shader("flat");
    if (shader) {
        shader->start_using();
 
        shader->set_uniform("view_model_matrix", view_model_matrix);
        shader->set_uniform("projection_matrix", wxGetApp().plater()->get_camera().get_projection_matrix());
        shader->set_uniform("width", width);
 
        line_model.set_color(color);
        line_model.render();
 
        shader->stop_using();
    }
}

References Slic3r::GUI::plater(), Slic3r::GUI::GLModel::render(), Slic3r::GUI::GLModel::set_color(), Slic3r::GLShaderProgram::set_uniform(), Slic3r::GLShaderProgram::start_using(), and Slic3r::GLShaderProgram::stop_using().

Referenced by render_cut_line(), and render_grabber_connection().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ render_model()

void Slic3r::GUI::GLGizmoCut3D::render_model	(	GLModel &	model,
		const ColorRGBA &	color,
		Transform3d	view_model_matrix )

staticprivate

{
    GLShaderProgram* shader = wxGetApp().get_shader("gouraud_light");
    if (shader) {
        shader->start_using();
 
        shader->set_uniform("view_model_matrix", view_model_matrix);
        shader->set_uniform("emission_factor", 0.2f);
        shader->set_uniform("projection_matrix", wxGetApp().plater()->get_camera().get_projection_matrix());
 
        model.set_color(color);
        model.render();
 
        shader->stop_using();
    }
}

References Slic3r::GUI::plater(), Slic3r::GUI::GLModel::render(), Slic3r::GUI::GLModel::set_color(), Slic3r::GLShaderProgram::set_uniform(), Slic3r::GLShaderProgram::start_using(), and Slic3r::GLShaderProgram::stop_using().

Referenced by render_connectors(), and render_cut_plane_grabbers().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ render_move_center_input()

void Slic3r::GUI::GLGizmoCut3D::render_move_center_input ( int axis )

private

{
    m_imgui->text(m_axis_names[axis]+":");
    ImGui::SameLine();
    ImGui::PushItemWidth(0.3f*m_control_width);
 
    Vec3d move = m_plane_center;
    double in_val, value = in_val = move[axis];
    if (m_imperial_units)
        value *= GizmoObjectManipulation::mm_to_in;
    ImGui::InputDouble(("##move_" + m_axis_names[axis]).c_str(), &value, 0.0, 0.0, "%.2f", ImGuiInputTextFlags_CharsDecimal);
    ImGui::SameLine();
 
    double val = value * (m_imperial_units ? GizmoObjectManipulation::in_to_mm : 1.0);
 
    if (in_val != val) {
        move[axis] = val;
        Plater::TakeSnapshot snapshot(wxGetApp().plater(), _u8L("Move cut plane"), UndoRedo::SnapshotType::GizmoAction);
        set_center(move, true);
        m_ar_plane_center = m_plane_center;
 
        reset_cut_by_contours();
    }
}

References _u8L, Slic3r::UndoRedo::GizmoAction, Slic3r::GUI::GizmoObjectManipulation::in_to_mm, m_ar_plane_center, m_axis_names, m_control_width, Slic3r::GUI::GLGizmoBase::m_imgui, m_imperial_units, m_plane_center, Slic3r::GUI::GizmoObjectManipulation::mm_to_in, Slic3r::GUI::plater(), reset_cut_by_contours(), and set_center().

Referenced by render_cut_plane_input_window().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ render_reset_button()

bool Slic3r::GUI::GLGizmoCut3D::render_reset_button	(	const std::string &	label_id,
		const std::string &	tooltip ) const

private

{
    const ImGuiStyle &style = ImGui::GetStyle();
 
    ImGui::PushStyleVar(ImGuiStyleVar_ItemSpacing, {1, style.ItemSpacing.y});
    ImGui::PushStyleVar(ImGuiStyleVar_FrameBorderSize, 0);       // ORCA match button style
 
    ImGui::PushStyleColor(ImGuiCol_Button, {0.25f, 0.25f, 0.25f, 0.0f});
    ImGui::PushStyleColor(ImGuiCol_ButtonHovered, {0, 0, 0, 0}); // ORCA match button style
    ImGui::PushStyleColor(ImGuiCol_ButtonActive,  {0, 0, 0, 0}); // ORCA match button style
 
    const bool revert = m_imgui->button(wxString(ImGui::RevertBtn) + "##" + wxString::FromUTF8(label_id));
 
    ImGui::PopStyleColor(3);
 
    if (ImGui::IsItemHovered())
        m_imgui->tooltip(tooltip.c_str(), ImGui::GetFontSize() * 20.0f);
 
    ImGui::PopStyleVar(2); // ORCA
 
    return revert;
}

References Slic3r::GUI::GLGizmoBase::m_imgui, revert(), and style.

Referenced by render_angle_input(), render_connectors_input_window(), render_cut_plane_input_window(), render_groove_float_input(), render_groove_int_input(), render_groove_two_float_input(), and render_snap_specific_input().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ render_rotation_snapping()

void Slic3r::GUI::GLGizmoCut3D::render_rotation_snapping	(	GrabberID	axis,
		const ColorRGBA &	color )

private

{
    GLShaderProgram* line_shader = wxGetApp().get_shader("flat");
    if (!line_shader)
        return;
 
    const Camera& camera = wxGetApp().plater()->get_camera();
    Transform3d view_model_matrix = camera.get_view_matrix() * translation_transform(m_plane_center) * m_start_dragging_m;
 
    if (axis == X)
        view_model_matrix = view_model_matrix * rotation_transform(0.5 * PI * Vec3d::UnitY()) * rotation_transform(-PI * Vec3d::UnitZ());
    else if (axis == Y)
        view_model_matrix = view_model_matrix * rotation_transform(-0.5 * PI * Vec3d::UnitZ()) * rotation_transform(-0.5 * PI * Vec3d::UnitY());
    else
        view_model_matrix = view_model_matrix * rotation_transform(-0.5 * PI * Vec3d::UnitZ());
 
    line_shader->start_using();
    line_shader->set_uniform("projection_matrix", camera.get_projection_matrix());
    line_shader->set_uniform("view_model_matrix", view_model_matrix);
    line_shader->set_uniform("width", 0.25f);
 
    m_circle.render();
    m_scale.render();
    m_snap_radii.render();
    m_reference_radius.render();
    if (m_dragging) {
        line_shader->set_uniform("width", 1.5f);
        m_angle_arc.set_color(color);
        m_angle_arc.render();
    }
 
    line_shader->stop_using();
}

References Slic3r::GUI::Camera::get_projection_matrix(), Slic3r::GUI::Camera::get_view_matrix(), m_angle_arc, m_circle, Slic3r::GUI::GLGizmoBase::m_dragging, m_plane_center, m_reference_radius, m_scale, m_snap_radii, m_start_dragging_m, PI, Slic3r::Geometry::rotation_transform(), Slic3r::GLShaderProgram::set_uniform(), Slic3r::GLShaderProgram::start_using(), Slic3r::GLShaderProgram::stop_using(), Slic3r::Geometry::translation_transform(), X, and Y.

Referenced by render_cut_plane_grabbers().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ render_slider_input()

bool Slic3r::GUI::GLGizmoCut3D::render_slider_input	(	const std::string &	label,
		float &	value_in,
		float	min_val = -0.1f,
		float	max_val = 100.f )

private

{
    // -------- [ ]
    // slider_with + input_width + slider_with + item_in_gap
    double slider_with        = 0.42 * m_editing_window_width; // m_control_width * 0.35;
    double item_in_gap        = 0.01 * m_editing_window_width;
    double input_width  = 0.29 * m_editing_window_width;
 
    constexpr float UndefMinVal = -0.1f;
    const float     f_mm_to_in  = static_cast<float>(GizmoObjectManipulation::mm_to_in);
 
    ImGui::AlignTextToFramePadding();
    m_imgui->text(label);
    ImGui::SameLine(m_label_width);
    ImGui::PushItemWidth(slider_with);
 
    double left_width = m_label_width + slider_with + item_in_gap;
 
    bool m_imperial_units = false;
 
    float value = value_in;
    float max_value = max_val;
    if (m_imperial_units) {
        value *= f_mm_to_in;
        max_value *= f_mm_to_in;
    }
    float old_val = value;
 
    const BoundingBoxf3 bbox = m_bounding_box;
    //const float mean_size    = float((bbox.size().x() + bbox.size().y() + bbox.size().z())) * (m_imperial_units ? f_mm_to_in : 1.f);
    const float min_v        = min_val > 0.f ? /*std::min(max_val, mean_size)*/ min_val : 1.f;
 
    float min_size = value_in < 0.f ? UndefMinVal : min_v;
    if (m_imperial_units) {
        min_size *= f_mm_to_in;
    }
    std::string format = value_in < 0.f ? " " : m_imperial_units ? "%.4f  " + _u8L_CONTEXT("in", "inches") : "%.2f  " + _u8L("mm");
 
    m_imgui->bbl_slider_float_style(("##" + label).c_str(), &value, min_size, max_value, format.c_str());
 
    ImGui::SameLine(left_width);
    ImGui::PushItemWidth(input_width);
    ImGui::BBLDragFloat(("##input_" + label).c_str(), &value, 0.05f, min_size, max_value, format.c_str());
 
    value_in = value * float(m_imperial_units ? GizmoObjectManipulation::in_to_mm : 1.0);
 
    return !is_approx(old_val, value);
}

References _u8L, _u8L_CONTEXT, Slic3r::GUI::GLGizmoBase::format(), Slic3r::GUI::GizmoObjectManipulation::in_to_mm, Slic3r::is_approx(), m_bounding_box, m_editing_window_width, Slic3r::GUI::GLGizmoBase::m_imgui, m_imperial_units, m_label_width, and Slic3r::GUI::GizmoObjectManipulation::mm_to_in.

Referenced by render_groove_float_input().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ render_slider_two_input()

bool Slic3r::GUI::GLGizmoCut3D::render_slider_two_input	(	const std::string &	label,
		float &	value_in,
		float &	tolerance_in,
		float	min_val = -0.1f,
		float	max_tolerance = -0.1f )

private

{
    // -------- [ ] -------- [ ]
    // slider_with + item_in_gap + first_input_width + item_out_gap + slider_with + item_in_gap + second_input_width
    double slider_with        = 0.24 * m_editing_window_width; // m_control_width * 0.35;
    double item_in_gap        = 0.01 * m_editing_window_width;
    double item_out_gap       = 0.01 * m_editing_window_width;
    double first_input_width  = 0.29 * m_editing_window_width;
    double second_input_width = 0.29 * m_editing_window_width;
 
    constexpr float UndefMinVal = -0.1f;
    const float f_mm_to_in = static_cast<float>(GizmoObjectManipulation::mm_to_in);
 
    ImGui::AlignTextToFramePadding();
    m_imgui->text(label);
    ImGui::SameLine(m_label_width);
    ImGui::PushItemWidth(slider_with);
 
    double left_width = m_label_width + slider_with + item_in_gap;
 
    bool m_imperial_units = false;
 
    float value = value_in;
    if (m_imperial_units)
        value *= f_mm_to_in;
    float old_val = value;
 
    const BoundingBoxf3 bbox = m_bounding_box;
    const float mean_size = float((bbox.size().x() + bbox.size().y() + bbox.size().z()) / 9.0) * (m_imperial_units ? f_mm_to_in : 1.f);
    const float min_v = min_val > 0.f ? /*std::min(max_val, mean_size)*/min_val : 1.f;
 
    float min_size = value_in < 0.f ? UndefMinVal : min_v;
    if (m_imperial_units) {
        min_size *= f_mm_to_in;
    }
    std::string format = value_in < 0.f ? " " : m_imperial_units ? "%.4f " + _u8L_CONTEXT("in", "inches") : "%.2f " + _u8L("mm");
 
    m_imgui->bbl_slider_float_style(("##" + label).c_str(), &value, min_size, mean_size, format.c_str());
 
    ImGui::SameLine(left_width);
    ImGui::PushItemWidth(first_input_width);
    ImGui::BBLDragFloat(("##input_" + label).c_str(), &value, 0.05f, min_size, mean_size, format.c_str());
 
    value_in = value * float(m_imperial_units ? GizmoObjectManipulation::in_to_mm : 1.0);
 
    left_width += (first_input_width + item_out_gap);
    ImGui::SameLine(left_width);
    ImGui::PushItemWidth(slider_with);
 
    float tolerance = tolerance_in;
    if (m_imperial_units)
        tolerance *= f_mm_to_in;
    float old_tolerance = tolerance;
    // std::string format_t      = tolerance_in < 0.f ? " " : "%.f %%";
    float min_tolerance = tolerance_in < 0.f ? UndefMinVal : 0.f;
    const float max_tolerance_v = max_tolerance > 0.f ? std::min(max_tolerance, 0.5f * mean_size) : 0.5f * mean_size;
 
    m_imgui->bbl_slider_float_style("##tolerance_" + label, &tolerance, min_tolerance, max_tolerance_v, format.c_str(), 1.f, true,
                                    _L("Tolerance"));
 
    left_width += (slider_with + item_in_gap);
    ImGui::SameLine(left_width);
    ImGui::PushItemWidth(second_input_width);
    ImGui::BBLDragFloat(("##tolerance_input_" + label).c_str(), &tolerance, 0.05f, min_tolerance, max_tolerance_v, format.c_str());
 
    tolerance_in = tolerance * float(m_imperial_units ? GizmoObjectManipulation::in_to_mm : 1.0);
 
    return !is_approx(old_val, value) || !is_approx(old_tolerance, tolerance);
}

References _L, _u8L, _u8L_CONTEXT, Slic3r::GUI::GLGizmoBase::format(), Slic3r::GUI::GizmoObjectManipulation::in_to_mm, Slic3r::is_approx(), m_bounding_box, m_editing_window_width, Slic3r::GUI::GLGizmoBase::m_imgui, m_imperial_units, m_label_width, Slic3r::GUI::GizmoObjectManipulation::mm_to_in, and Slic3r::BoundingBox3Base< PointType >::size().

Referenced by render_connectors_input_window(), and render_groove_two_float_input().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ render_snap_specific_input()

void Slic3r::GUI::GLGizmoCut3D::render_snap_specific_input	(	const std::string &	label,
		const wxString &	tooltip,
		float &	in_val,
		const float &	init_val,
		const float	min_val,
		const float	max_val )

protected

{
    // -------- [ ]
    // slider_with + item_in_gap + input_width
    double slider_with = 0.24 * m_editing_window_width; // m_control_width * 0.35;
    double item_in_gap = 0.01 * m_editing_window_width;
    double input_width = 0.29 * m_editing_window_width;
 
    ImGui::AlignTextToFramePadding();
    m_imgui->text(label);
    ImGui::SameLine(m_label_width);
    ImGui::PushItemWidth(slider_with);
 
    double left_width = m_label_width + slider_with + item_in_gap;
 
    bool is_changed = false;
    const std::string format = "%.0f %%";
 
    float val = in_val * 100.f;
    const float old_val = val;
    m_imgui->bbl_slider_float_style("##snap_" + label, &val, min_val, max_val, format.c_str(), 1.f, true, tooltip);
 
    ImGui::SameLine(left_width);
    ImGui::PushItemWidth(input_width);
    ImGui::BBLDragFloat(("##snap_input_" + label).c_str(), &val, 0.05f, min_val, max_val, format.c_str());
 
    if (!is_approx(old_val, val)) {
        in_val = val * 0.01f;
        is_changed = true;
    }
    
    ImGui::SameLine();
 
    m_imgui->disabled_begin(is_approx(in_val, init_val));
    const std::string act_name = _u8L("Reset");
    if (render_reset_button("##snap_" + label + act_name, act_name)) {
        in_val = init_val;
        is_changed = true;
    }
    m_imgui->disabled_end();
 
    if (is_changed) {
        update_connector_shape();
        update_raycasters_for_picking();
    }
}

References _u8L, Slic3r::GUI::GLGizmoBase::format(), Slic3r::is_approx(), m_editing_window_width, Slic3r::GUI::GLGizmoBase::m_imgui, m_label_width, render_reset_button(), update_connector_shape(), and update_raycasters_for_picking().

Referenced by render_connectors_input_window().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ render_tooltip_button()

void Slic3r::GUI::GLGizmoCut3D::render_tooltip_button	(	float	x,
		float	y )

protected

{
    auto& shortcuts = m_connectors_editing ? m_shortcuts_connector : m_shortcuts_cut;
 
    GLGizmoUtils::render_tooltip_button(m_imgui, m_parent, shortcuts, x, y);
}

References m_connectors_editing, Slic3r::GUI::GLGizmoBase::m_imgui, Slic3r::GUI::GLGizmoBase::m_parent, m_shortcuts_connector, m_shortcuts_cut, and Slic3r::GUI::GLGizmoUtils::render_tooltip_button().

Referenced by render_connectors_input_window(), and render_cut_plane_input_window().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ reset_connectors()

void Slic3r::GUI::GLGizmoCut3D::reset_connectors ( )

private

{
    m_c->selection_info()->model_object()->cut_connectors.clear();
    update_raycasters_for_picking();
    clear_selection();
    check_and_update_connectors_state();
}

References check_and_update_connectors_state(), clear_selection(), Slic3r::GUI::GLGizmoBase::m_c, and update_raycasters_for_picking().

Referenced by render_connectors_input_window(), and render_cut_plane_input_window().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ reset_cut_by_contours()

void Slic3r::GUI::GLGizmoCut3D::reset_cut_by_contours ( )

protected

{
    m_part_selection = PartSelection();
 
    if (CutMode(m_mode) == CutMode::cutTongueAndGroove) {
        if (m_dragging || m_groove_editing || !has_valid_groove())
            return;
        process_contours();
    }
    else
        toggle_model_objects_visibility();
}

References cutTongueAndGroove, has_valid_groove(), Slic3r::GUI::GLGizmoBase::m_dragging, m_groove_editing, m_mode, m_part_selection, process_contours(), and toggle_model_objects_visibility().

Referenced by dragging_grabber_move(), dragging_grabber_rotation(), flip_cut_plane(), on_dragging(), on_load(), on_set_state(), on_stop_dragging(), process_contours(), process_cut_line(), render_groove_angle_input(), render_groove_float_input(), render_groove_int_input(), render_groove_two_float_input(), render_move_center_input(), reset_cut_plane(), switch_to_mode(), and update_bb().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ reset_cut_plane()

void Slic3r::GUI::GLGizmoCut3D::reset_cut_plane ( )

protected

{
    m_angle_arc.reset();
    m_transformed_bounding_box = transformed_bounding_box(m_bb_center);
    set_center(m_bb_center);
    m_start_dragging_m = m_rotation_m = Transform3d::Identity();
    m_ar_plane_center  = m_plane_center;
 
    reset_cut_by_contours();
    m_parent.request_extra_frame();
}

References m_angle_arc, m_ar_plane_center, m_bb_center, Slic3r::GUI::GLGizmoBase::m_parent, m_plane_center, m_rotation_m, m_start_dragging_m, m_transformed_bounding_box, reset_cut_by_contours(), set_center(), and transformed_bounding_box().

Referenced by render_cut_plane_input_window().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ rotate_vec3d_around_plane_center()

void Slic3r::GUI::GLGizmoCut3D::rotate_vec3d_around_plane_center ( Vec3d & vec )

{
    vec = Transformation(translation_transform(m_plane_center) * m_rotation_m * translation_transform(-m_plane_center)).get_matrix() * vec;
}

References Slic3r::Geometry::Transformation::get_matrix(), m_plane_center, m_rotation_m, and Slic3r::Geometry::translation_transform().

Referenced by update_clipper().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ save()

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

inlineinherited

171{ on_save(ar); }

Slic3r::GUI::GLGizmoBase::on_save

virtual void on_save(cereal::BinaryOutputArchive &ar) const

Definition GLGizmoBase.hpp:242

References on_save().

Here is the call graph for this function:

◆ select_all_connectors()

void Slic3r::GUI::GLGizmoCut3D::select_all_connectors ( )

protected

{
    std::fill(m_selected.begin(), m_selected.end(), true);
    m_selected_count = int(m_selected.size());
}

References m_selected, and m_selected_count.

Referenced by gizmo_event().

Here is the caller graph for this function:

◆ select_connector()

void Slic3r::GUI::GLGizmoCut3D::select_connector	(	int	idx,
		bool	select )

protected

{
    m_selected[idx] = select;
    if (select)
        ++m_selected_count;
    else
        --m_selected_count;
}

References m_selected, and m_selected_count.

Referenced by gizmo_event(), is_selection_changed(), and process_selection_rectangle().

Here is the caller graph for this function:

◆ set_center()

void Slic3r::GUI::GLGizmoCut3D::set_center	(	const Vec3d &	center,
		bool	update_tbb = false )

private

{
    set_center_pos(center, update_tbb);
    check_and_update_connectors_state();
    update_clipper();
}

References Slic3r::center(), check_and_update_connectors_state(), set_center_pos(), and update_clipper().

Referenced by dragging_grabber_move(), process_cut_line(), render_move_center_input(), reset_cut_plane(), and shift_cut().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ set_center_pos()

void Slic3r::GUI::GLGizmoCut3D::set_center_pos	(	const Vec3d &	center_pos,
		bool	update_tbb = false )

private

{
    BoundingBoxf3 tbb = m_transformed_bounding_box;
    if (update_tbb) {
        Vec3d normal = m_rotation_m.inverse() * Vec3d(m_plane_center - center_pos);
        tbb.translate(normal.z() * Vec3d::UnitZ());
    }
 
    bool can_set_center_pos = false;
    {
        double limit_val = /*CutMode(m_mode) == CutMode::cutTongueAndGroove ? 0.5 * double(m_groove.depth) : */0.5;
        if (tbb.max.z() > -limit_val && tbb.min.z() < limit_val)
            can_set_center_pos = true;
        else {
            const double old_dist = (m_bb_center - m_plane_center).norm();
            const double new_dist = (m_bb_center - center_pos).norm();
            // check if forcing is reasonable
            if (new_dist < old_dist)
                can_set_center_pos = true;
        }
    }
 
    if (can_set_center_pos) {
        m_transformed_bounding_box = tbb;
        m_plane_center = center_pos;
        m_center_offset = m_plane_center - m_bb_center;
    }
}

References m_bb_center, m_center_offset, m_plane_center, m_rotation_m, m_transformed_bounding_box, Slic3r::BoundingBoxBase< PointType, std::vector< PointType > >::max, Slic3r::BoundingBoxBase< PointType, std::vector< PointType > >::min, Slic3r::normal(), and Slic3r::BoundingBox3Base< PointType >::translate().

Referenced by on_load(), set_center(), and update_bb().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ set_common_data_pool()

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

inlineinherited

193{ m_c = ptr; }

References m_c.

◆ set_connectors_editing()

void Slic3r::GUI::GLGizmoCut3D::set_connectors_editing ( bool connectors_editing )

protected

{
    if (m_connectors_editing == connectors_editing)
        return;
 
    m_connectors_editing = connectors_editing;
    update_raycasters_for_picking();
 
    m_c->object_clipper()->set_behavior(m_connectors_editing, m_connectors_editing, double(m_contour_width));
 
    m_parent.request_extra_frame();
}

References Slic3r::GUI::GLGizmoBase::m_c, m_connectors_editing, m_contour_width, Slic3r::GUI::GLGizmoBase::m_parent, and update_raycasters_for_picking().

Referenced by render_connectors_input_window(), and render_cut_plane_input_window().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ 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_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_state()

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

inlineinherited

176{ m_state = state; on_set_state(); }

Slic3r::GUI::GLGizmoBase::on_set_state

virtual void on_set_state()

Definition GLGizmoBase.hpp:244

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_volumes_picking_state()

void Slic3r::GUI::GLGizmoCut3D::set_volumes_picking_state ( bool state )

protected

{
    std::vector<std::shared_ptr<SceneRaycasterItem>>* raycasters = m_parent.get_raycasters_for_picking(SceneRaycaster::EType::Volume);
    if (raycasters != nullptr) {
        const Selection& selection = m_parent.get_selection();
        const Selection::IndicesList ids = selection.get_volume_idxs();
        for (unsigned int id : ids) {
            const GLVolume* v = selection.get_volume(id);
            auto it = std::find_if(raycasters->begin(), raycasters->end(), [v](std::shared_ptr<SceneRaycasterItem> item) { return item->get_raycaster() == v->mesh_raycaster.get(); });
            if (it != raycasters->end())
                (*it)->set_active(state);
        }
    }
}

References Slic3r::GUI::Selection::get_volume(), Slic3r::GUI::Selection::get_volume_idxs(), Slic3r::GUI::GLGizmoBase::m_parent, and Slic3r::GUI::SceneRaycaster::Volume.

Here is the call graph for this function:

◆ shift_cut()

void Slic3r::GUI::GLGizmoCut3D::shift_cut ( double delta )

{
    Plater::TakeSnapshot snapshot(wxGetApp().plater(), _u8L("Move cut plane"), UndoRedo::SnapshotType::GizmoAction);
    set_center(m_plane_center + m_cut_normal * delta, true);
    m_ar_plane_center = m_plane_center;
}

References _u8L, Slic3r::UndoRedo::GizmoAction, m_ar_plane_center, m_cut_normal, m_plane_center, Slic3r::GUI::plater(), and set_center().

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

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

178{ 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:

◆ switch_to_mode()

void Slic3r::GUI::GLGizmoCut3D::switch_to_mode ( size_t new_mode )

private

{
    m_mode = new_mode;
    update_raycasters_for_picking();
 
    apply_color_clip_plane_colors();
    if (auto oc = m_c->object_clipper()) {
        m_contour_width = CutMode(m_mode) == CutMode::cutTongueAndGroove ? 0.f : 0.4f;
        oc->set_behavior(m_connectors_editing, m_connectors_editing, double(m_contour_width));
    }
 
    update_plane_model();
    reset_cut_by_contours();
}

References apply_color_clip_plane_colors(), cutTongueAndGroove, Slic3r::GUI::GLGizmoBase::m_c, m_connectors_editing, m_contour_width, m_mode, reset_cut_by_contours(), update_plane_model(), and update_raycasters_for_picking().

Referenced by on_load(), and render_cut_mode_combo().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ toggle_model_objects_visibility()

void Slic3r::GUI::GLGizmoCut3D::toggle_model_objects_visibility ( )

private

{
    bool has_active_volume = false;
    std::vector<std::shared_ptr<SceneRaycasterItem>>* raycasters = m_parent.get_raycasters_for_picking(SceneRaycaster::EType::Volume);
    for (const std::shared_ptr<SceneRaycasterItem> &raycaster : *raycasters)
        if (raycaster->is_active()) {
            has_active_volume = true;
            break;
        }
 
    if (m_part_selection.valid() && has_active_volume)
        m_parent.toggle_model_objects_visibility(false);
    else if (!m_part_selection.valid() && !has_active_volume) {
        const Selection& selection = m_parent.get_selection();
        const ModelObjectPtrs& model_objects = selection.get_model()->objects;
        m_parent.toggle_model_objects_visibility(true, model_objects[selection.get_object_idx()], selection.get_instance_idx());        
    }
}

References Slic3r::GUI::Selection::get_instance_idx(), Slic3r::GUI::Selection::get_model(), Slic3r::GUI::Selection::get_object_idx(), Slic3r::GUI::GLGizmoBase::m_parent, m_part_selection, Slic3r::Model::objects, and Slic3r::GUI::SceneRaycaster::Volume.

Referenced by on_mouse(), on_render(), process_contours(), and reset_cut_by_contours().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ transformed_bounding_box()

BoundingBoxf3 Slic3r::GUI::GLGizmoCut3D::transformed_bounding_box	(	const Vec3d &	plane_center,
		const Transform3d &	rotation_m = Transform3d::Identity() ) const

{
    const Selection& selection = m_parent.get_selection();
 
    const auto first_volume = selection.get_first_volume();
    Vec3d instance_offset   = first_volume->get_instance_offset();
    instance_offset[Z]     += first_volume->get_sla_shift_z();
 
    const auto cut_matrix = Transform3d::Identity() * rotation_m.inverse() * translation_transform(instance_offset - plane_center);
 
    const Selection::IndicesList& idxs = selection.get_volume_idxs();
    BoundingBoxf3 ret;
    for (unsigned int i : idxs) {
        const GLVolume* volume = selection.get_volume(i);
        // respect just to the solid parts for FFF and ignore pad and supports for SLA
        if (!volume->is_modifier && !volume->is_sla_pad() && !volume->is_sla_support()) {
 
            const auto instance_matrix = volume->get_instance_transformation().get_matrix_no_offset();
            auto volume_trafo = instance_matrix * volume->get_volume_transformation().get_matrix();
            ret.merge(volume->transformed_convex_hull_bounding_box(cut_matrix * volume_trafo));
        }
    }
    return ret;
}

References Slic3r::GUI::Selection::get_first_volume(), Slic3r::GLVolume::get_instance_transformation(), Slic3r::Geometry::Transformation::get_matrix(), Slic3r::Geometry::Transformation::get_matrix_no_offset(), Slic3r::GUI::Selection::get_volume(), Slic3r::GUI::Selection::get_volume_idxs(), Slic3r::GLVolume::get_volume_transformation(), Slic3r::GLVolume::is_sla_pad(), Slic3r::GLVolume::is_sla_support(), Slic3r::GUI::GLGizmoBase::m_parent, Slic3r::BoundingBox3Base< PointType >::merge(), Slic3r::GLVolume::transformed_convex_hull_bounding_box(), Slic3r::Geometry::translation_transform(), and Z.

Referenced by dragging_grabber_rotation(), flip_cut_plane(), on_load(), on_set_state(), process_cut_line(), reset_cut_plane(), and update_bb().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ unproject_on_cut_plane()

bool Slic3r::GUI::GLGizmoCut3D::unproject_on_cut_plane	(	const Vec2d &	mouse_pos,
		Vec3d &	pos,
		Vec3d &	pos_world,
		bool	respect_contours = true )

{
    const float sla_shift = m_c->selection_info()->get_sla_shift();
 
    const ModelObject* mo = m_c->selection_info()->model_object();
    const ModelInstance* mi = mo->instances[m_c->selection_info()->get_active_instance()];
    const Camera& camera = wxGetApp().plater()->get_camera();
 
    // Calculate intersection with the clipping plane.
    const ClippingPlane* cp = m_c->object_clipper()->get_clipping_plane(true);
    Vec3d point;
    Vec3d direction;
    Vec3d hit;
    MeshRaycaster::line_from_mouse_pos(mouse_position, Transform3d::Identity(), camera, point, direction);
    Vec3d normal = -cp->get_normal().cast<double>();
    double den = normal.dot(direction);
    if (den != 0.) {
        double t = (-cp->get_offset() - normal.dot(point))/den;
        hit = (point + t * direction);
    } else
        return false;
 
    // Now check if the hit is not obscured by a selected part on this side of the plane.
    // FIXME: This would be better solved by remembering which contours are active. We will
    // probably need that anyway because there is not other way to find out which contours
    // to render. If you want to uncomment it, fix it first. It does not work yet.
    /*for (size_t id = 0; id < m_part_selection.parts.size(); ++id) {
        if (! m_part_selection.parts[id].selected) {
            Vec3f pos, normal;
            const ModelObject* model_object = m_part_selection.model_object;
            const Vec3d volume_offset = m_part_selection.model_object->volumes[id]->get_offset();
            Transform3d tr = model_object->instances[m_part_selection.instance_idx]->get_matrix() * model_object->volumes[id]->get_matrix();
            if (m_part_selection.parts[id].raycaster.unproject_on_mesh(mouse_position, tr, camera, pos, normal))
                return false;
        }
    }*/
 
    if (respect_contours)
    {
        // Do not react to clicks outside a contour (or inside a contour that is ignored)
        int cont_id = m_c->object_clipper()->is_projection_inside_cut(hit);
        if (cont_id == -1)
            return false;
        if (m_part_selection.valid()) {
            const std::vector<size_t>& ign = *m_part_selection.get_ignored_contours_ptr();
            if (std::find(ign.begin(), ign.end(), cont_id) != ign.end())
                return false;
        }    
    }
    
 
    // recalculate hit to object's local position
    Vec3d hit_d = hit;
    hit_d -= mi->get_offset();
    hit_d[Z] -= sla_shift;
 
    // Return both the point and the facet normal.
    pos = hit_d;
    pos_world = hit;
 
    return true; 
}

References Slic3r::GUI::ClippingPlane::get_normal(), Slic3r::GUI::ClippingPlane::get_offset(), Slic3r::ModelInstance::get_offset(), Slic3r::ModelObject::instances, Slic3r::GUI::MeshRaycaster::line_from_mouse_pos(), Slic3r::GUI::GLGizmoBase::m_c, m_part_selection, Slic3r::normal(), and Z.

Referenced by add_connector(), dragging_connector(), and on_mouse().

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

233{ unregister_grabbers_for_picking(); on_unregister_raycasters_for_picking(); }

Slic3r::GUI::GLGizmoBase::on_unregister_raycasters_for_picking

virtual void on_unregister_raycasters_for_picking()

Definition GLGizmoBase.hpp:268

Slic3r::GUI::GLGizmoBase::unregister_grabbers_for_picking

void unregister_grabbers_for_picking()

Definition GLGizmoBase.cpp:405

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:

◆ unselect_all_connectors()

void Slic3r::GUI::GLGizmoCut3D::unselect_all_connectors ( )

protected

{
    std::fill(m_selected.begin(), m_selected.end(), false);
    m_selected_count = 0;
    validate_connector_settings();
}

References m_selected, m_selected_count, and validate_connector_settings().

Referenced by add_connector(), gizmo_event(), is_selection_changed(), on_mouse(), and render_connectors_input_window().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ update_bb()

void Slic3r::GUI::GLGizmoCut3D::update_bb ( )

private

{
    const BoundingBoxf3 box = bounding_box();
    if (!box.defined)
        return;
    if (!m_max_pos.isApprox(box.max) || !m_min_pos.isApprox(box.min)) {
 
        m_bounding_box = box;
 
        // check, if mode is set to Planar, when object has a connectors
        if (const int object_idx = m_parent.get_selection().get_object_idx();
            object_idx >= 0 && !wxGetApp().plater()->model().objects[object_idx]->cut_connectors.empty())
            m_mode = size_t(CutMode::cutPlanar);
 
        invalidate_cut_plane();
        reset_cut_by_contours();
        apply_color_clip_plane_colors();
 
        m_max_pos = box.max;
        m_min_pos = box.min;
        m_bb_center = box.center();
        m_transformed_bounding_box = transformed_bounding_box(m_bb_center);
        if (box.contains(m_center_offset))
            set_center_pos(m_bb_center + m_center_offset);
        else
            set_center_pos(m_bb_center);
 
        m_contour_width = CutMode(m_mode) == CutMode::cutTongueAndGroove ? 0.f : 0.4f;
 
        m_radius = box.radius();
        m_grabber_connection_len = 0.5 * m_radius;// std::min<double>(0.75 * m_radius, 35.0);
        m_grabber_radius = m_grabber_connection_len * 0.85;
 
        m_snap_coarse_in_radius   = m_grabber_radius / 3.0;
        m_snap_coarse_out_radius  = m_snap_coarse_in_radius * 2.;
        m_snap_fine_in_radius     = m_grabber_connection_len * 0.85;
        m_snap_fine_out_radius    = m_grabber_connection_len * 1.15;
 
        // input params for cut with tongue and groove
        m_groove.depth = m_groove.depth_init = std::max(1.f , 0.5f * float(get_grabber_mean_size(m_bounding_box)));
        m_groove.width = m_groove.width_init = 4.0f * m_groove.depth;
        m_groove.flaps_angle = m_groove.flaps_angle_init = float(PI) / 3.f;
        m_groove.angle = m_groove.angle_init = 0.f;
        m_plane.reset();
        m_cone.reset();
        m_sphere.reset();
        m_cube.reset();
        m_grabber_connection.reset();
        m_circle.reset();
        m_scale.reset();
        m_snap_radii.reset();
        m_reference_radius.reset();
 
        on_unregister_raycasters_for_picking();
 
        clear_selection();
        if (CommonGizmosDataObjects::SelectionInfo* selection = m_c->selection_info();
            selection && selection->model_object())
            m_selected.resize(selection->model_object()->cut_connectors.size(), false);
    }
}

References apply_color_clip_plane_colors(), bounding_box(), Slic3r::BoundingBox3Base< PointType >::center(), clear_selection(), Slic3r::BoundingBox3Base< PointType >::contains(), cutPlanar, cutTongueAndGroove, Slic3r::BoundingBoxBase< PointType, std::vector< PointType > >::defined, Slic3r::GUI::get_grabber_mean_size(), invalidate_cut_plane(), m_bb_center, m_bounding_box, Slic3r::GUI::GLGizmoBase::m_c, m_center_offset, m_circle, m_cone, m_contour_width, m_cube, m_grabber_connection, m_grabber_connection_len, m_grabber_radius, m_groove, m_max_pos, m_min_pos, m_mode, Slic3r::GUI::GLGizmoBase::m_parent, m_plane, m_radius, m_reference_radius, m_scale, m_selected, m_snap_coarse_in_radius, m_snap_coarse_out_radius, m_snap_fine_in_radius, m_snap_fine_out_radius, m_snap_radii, m_sphere, m_transformed_bounding_box, Slic3r::BoundingBoxBase< PointType, std::vector< PointType > >::max, Slic3r::BoundingBoxBase< PointType, std::vector< PointType > >::min, on_unregister_raycasters_for_picking(), PI, Slic3r::GUI::plater(), Slic3r::BoundingBox3Base< PointType >::radius(), reset_cut_by_contours(), set_center_pos(), and transformed_bounding_box().

Referenced by data_changed(), and on_set_state().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ update_clipper()

void Slic3r::GUI::GLGizmoCut3D::update_clipper ( )

{
    // update cut_normal
    Vec3d normal = m_rotation_m * Vec3d::UnitZ();
    normal.normalize();
    m_cut_normal = normal;
 
    // calculate normal and offset for clipping plane
    Vec3d beg = m_bb_center;
    beg[Z] -= m_radius;
    rotate_vec3d_around_plane_center(beg);
 
    m_clp_normal  = normal;
    double offset = normal.dot(m_plane_center);
    double dist   = normal.dot(beg);
 
    m_parent.set_color_clip_plane(normal, offset);
 
    if (!is_looking_forward()) {
        // recalculate normal and offset for clipping plane, if camera is looking downward to cut plane
        normal = m_rotation_m * (-1. * Vec3d::UnitZ());
        normal.normalize();
 
        beg = m_bb_center;
        beg[Z] += m_radius;
        rotate_vec3d_around_plane_center(beg);
 
        m_clp_normal = normal;
        offset       = normal.dot(m_plane_center);
        dist         = normal.dot(beg);
    }
 
    m_c->object_clipper()->set_range_and_pos(normal, offset, dist);
 
    put_connectors_on_cut_plane(normal, offset);
 
    if (m_raycasters.empty())
        on_register_raycasters_for_picking();
    else
        update_raycasters_for_picking_transform();
}

References Slic3r::Geometry::dist(), is_looking_forward(), m_bb_center, Slic3r::GUI::GLGizmoBase::m_c, m_clp_normal, m_cut_normal, Slic3r::GUI::GLGizmoBase::m_parent, m_plane_center, m_radius, m_raycasters, m_rotation_m, Slic3r::normal(), Slic3r::offset(), on_register_raycasters_for_picking(), put_connectors_on_cut_plane(), rotate_vec3d_around_plane_center(), update_raycasters_for_picking_transform(), and Z.

Referenced by dragging_grabber_rotation(), flip_cut_plane(), on_render(), and set_center().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ update_connector_shape()

void Slic3r::GUI::GLGizmoCut3D::update_connector_shape ( )

private

{
    CutConnectorAttributes attribs = { m_connector_type, CutConnectorStyle(m_connector_style), CutConnectorShape(m_connector_shape_id) };
 
    if (m_connector_type == CutConnectorType::Snap) {
        indexed_triangle_set its = get_connector_mesh(attribs);
        m_shapes[attribs].reset();
        m_shapes[attribs].model.init_from(its);
        m_shapes[attribs].mesh_raycaster = std::make_unique<MeshRaycaster>(std::make_shared<const TriangleMesh>(std::move(its)));
 
        //const indexed_triangle_set its = get_connector_mesh(attribs);
        //m_connector_mesh.clear();
        //m_connector_mesh = TriangleMesh(its);
    }
 
 
}

References get_connector_mesh(), m_connector_shape_id, m_connector_style, m_connector_type, m_shapes, and Slic3r::Snap.

Referenced by render_snap_specific_input().

Here is the call graph for this function:

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_plane_model()

void Slic3r::GUI::GLGizmoCut3D::update_plane_model ( )

protected

{
    m_plane.reset();
    on_unregister_raycasters_for_picking();
 
    init_picking_models();
}

References init_picking_models(), m_plane, and on_unregister_raycasters_for_picking().

Referenced by on_load(), render_groove_angle_input(), render_groove_float_input(), render_groove_int_input(), render_groove_two_float_input(), and switch_to_mode().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ update_raycasters_for_picking()

void Slic3r::GUI::GLGizmoCut3D::update_raycasters_for_picking ( )

protected

{
    on_unregister_raycasters_for_picking();
    on_register_raycasters_for_picking();
}

References on_register_raycasters_for_picking(), and on_unregister_raycasters_for_picking().

Referenced by add_connector(), delete_selected_connectors(), render_snap_specific_input(), reset_connectors(), set_connectors_editing(), and switch_to_mode().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ update_raycasters_for_picking_transform()

void Slic3r::GUI::GLGizmoCut3D::update_raycasters_for_picking_transform ( )

protected

{
    if (m_connectors_editing) {
        CommonGizmosDataObjects::SelectionInfo* si = m_c->selection_info();
        if (!si) 
            return;
        const ModelObject* mo = si->model_object();
        const CutConnectors& connectors = mo->cut_connectors;
        if (connectors.empty())
            return;
        auto inst_id = m_c->selection_info()->get_active_instance();
        if (inst_id < 0)
            return;
 
        const Vec3d& instance_offset = mo->instances[inst_id]->get_offset();
        const double sla_shift = double(m_c->selection_info()->get_sla_shift());
 
        const bool looking_forward = is_looking_forward();
 
        for (size_t i = 0; i < connectors.size(); ++i) {
            const CutConnector& connector = connectors[i];
 
            float height = connector.height;
            // recalculate connector position to world position
            Vec3d pos = connector.pos + instance_offset;
            if (connector.attribs.type == CutConnectorType::Dowel &&
                connector.attribs.style == CutConnectorStyle::Prism) {
                height = 0.05f;
                if (!looking_forward)
                    pos += 0.05 * m_clp_normal;
            }
            pos[Z] += sla_shift;
 
            const Transform3d scale_trafo = scale_transform(Vec3f(connector.radius, connector.radius, height).cast<double>());
            m_raycasters[i]->set_transform(translation_transform(pos) * m_rotation_m * scale_trafo);
        }
    }
    else if (!cut_line_processing()){
        const Transform3d trafo = translation_transform(m_plane_center) * m_rotation_m;
 
        const BoundingBoxf3 box = m_bounding_box;
 
        const double size = get_half_size(get_grabber_mean_size(box));
        Vec3d scale = Vec3d(0.75 * size, 0.75 * size, 1.8 * size);
 
        int id = 0;
 
        Vec3d offset = Vec3d(0.0, 1.25 * size, m_grabber_connection_len);
        m_raycasters[id++]->set_transform(trafo * translation_transform(offset) * rotation_transform(-0.5 * PI * Vec3d::UnitX()) * scale_transform(scale));
        offset = Vec3d(0.0, -1.25 * size, m_grabber_connection_len);
        m_raycasters[id++]->set_transform(trafo * translation_transform(offset) * rotation_transform(0.5 * PI * Vec3d::UnitX()) * scale_transform(scale));
 
        offset = Vec3d(1.25 * size, 0.0, m_grabber_connection_len);
        m_raycasters[id++]->set_transform(trafo * translation_transform(offset) * rotation_transform(0.5 * PI * Vec3d::UnitY()) * scale_transform(scale));
        offset = Vec3d(-1.25 * size, 0.0, m_grabber_connection_len);
        m_raycasters[id++]->set_transform(trafo * translation_transform(offset) * rotation_transform(-0.5 * PI * Vec3d::UnitY()) * scale_transform(scale));
 
        m_raycasters[id++]->set_transform(trafo * translation_transform(m_grabber_connection_len * Vec3d::UnitZ()) * scale_transform(size));
 
        m_raycasters[id++]->set_transform(trafo);
 
        if (CutMode(m_mode) == CutMode::cutTongueAndGroove) {
 
            double grabber_y_shift = -1.75 * m_grabber_connection_len;
 
            m_raycasters[id++]->set_transform(trafo * translation_transform(grabber_y_shift * Vec3d::UnitY()) * scale_transform(size));
 
            offset = Vec3d(1.25 * size, grabber_y_shift, 0.0);
            m_raycasters[id++]->set_transform(trafo * translation_transform(offset) * rotation_transform(0.5 * PI * Vec3d::UnitY()) * scale_transform(scale));
            offset = Vec3d(-1.25 * size, grabber_y_shift, 0.0);
            m_raycasters[id++]->set_transform(trafo * translation_transform(offset) * rotation_transform(-0.5 * PI * Vec3d::UnitY()) * scale_transform(scale));
 
            const double xy_connection_len = 0.75 * m_grabber_connection_len;
            const Vec3d cone_scale = Vec3d(0.5 * size, 0.5 * size, 1.8 * size);
 
            offset = xy_connection_len * Vec3d::UnitX() - 0.5 * size * Vec3d::Ones();
            m_raycasters[id++]->set_transform(trafo * translation_transform(offset) * scale_transform(size));
            offset = (size + xy_connection_len) * Vec3d::UnitX();
            m_raycasters[id++]->set_transform(trafo * translation_transform(offset) * rotation_transform(0.5 * PI * Vec3d::UnitY()) * scale_transform(cone_scale));
 
            if (m_groove.angle > 0.0f) {
                offset = xy_connection_len * Vec3d::UnitY() - 0.5 * size * Vec3d::Ones();
                m_raycasters[id++]->set_transform(trafo * translation_transform(offset) * scale_transform(size));
                offset = (size + xy_connection_len) * Vec3d::UnitY();
                m_raycasters[id++]->set_transform(trafo * translation_transform(offset) * rotation_transform(-0.5 * PI * Vec3d::UnitX()) * scale_transform(cone_scale));
            }
            else {
                // discard transformation for CutPlaneYMove grabbers
                m_raycasters[id++]->set_transform(Transform3d::Identity());
                m_raycasters[id++]->set_transform(Transform3d::Identity());
            }
        }
    }
}

References Slic3r::CutConnector::attribs, Slic3r::ModelObject::cut_connectors, cut_line_processing(), cutTongueAndGroove, Slic3r::Dowel, Slic3r::GUI::get_grabber_mean_size(), Slic3r::GUI::get_half_size(), Slic3r::CutConnector::height, Slic3r::ModelObject::instances, is_looking_forward(), m_bounding_box, Slic3r::GUI::GLGizmoBase::m_c, m_clp_normal, m_connectors_editing, m_grabber_connection_len, m_groove, m_mode, m_plane_center, m_raycasters, m_rotation_m, Slic3r::GUI::CommonGizmosDataObjects::SelectionInfo::model_object(), Slic3r::offset(), PI, Slic3r::CutConnector::pos, Slic3r::Prism, Slic3r::CutConnector::radius, Slic3r::Geometry::rotation_transform(), scale(), Slic3r::Geometry::scale_transform(), Slic3r::CutConnectorAttributes::style, Slic3r::Geometry::translation_transform(), Slic3r::CutConnectorAttributes::type, and Z.

Referenced by apply_selected_connectors(), dragging_connector(), on_register_raycasters_for_picking(), and update_clipper().

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:

◆ 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:

◆ validate_connector_settings()

void Slic3r::GUI::GLGizmoCut3D::validate_connector_settings ( )

private

{
    if (m_connector_depth_ratio < 0.f)
        m_connector_depth_ratio = 3.f;
    if (m_connector_depth_ratio_tolerance < 0.f)
        m_connector_depth_ratio_tolerance = 0.1f;
    if (m_connector_size < 0.f)
        m_connector_size = 2.5f;
    if (m_connector_size_tolerance < 0.f)
        m_connector_size_tolerance = 0.f;
    if (m_connector_angle < 0.f || m_connector_angle > float(PI) )
        m_connector_angle = 0.f;
 
    if (m_connector_type == CutConnectorType::Undef)
        m_connector_type = CutConnectorType::Plug;
    if (m_connector_style == int(CutConnectorStyle::Undef))
        m_connector_style = int(CutConnectorStyle::Prism);
    if (m_connector_shape_id == int(CutConnectorShape::Undef))
        m_connector_shape_id = int(CutConnectorShape::Circle);
}

References Slic3r::Circle, m_connector_angle, m_connector_depth_ratio, m_connector_depth_ratio_tolerance, m_connector_shape_id, m_connector_size, m_connector_size_tolerance, m_connector_style, m_connector_type, PI, Slic3r::Plug, Slic3r::Prism, and Slic3r::Undef.

Referenced by unselect_all_connectors().

Here is the caller graph for this function:

◆ wants_enter_leave_snapshots()

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

inlineoverrideprotectedvirtual

Reimplemented from Slic3r::GUI::GLGizmoBase.

348{ 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_angle

double Slic3r::GUI::GLGizmoCut3D::m_angle { 0.0 }

private

83{ 0.0 };

Referenced by dragging_grabber_rotation(), get_tooltip(), init_rendering_items(), on_start_dragging(), and on_stop_dragging().

◆ m_angle_arc

GLModel Slic3r::GUI::GLGizmoCut3D::m_angle_arc

private

Referenced by init_rendering_items(), on_stop_dragging(), process_cut_line(), render_rotation_snapping(), and reset_cut_plane().

◆ m_ar_plane_center

Vec3d Slic3r::GUI::GLGizmoCut3D::m_ar_plane_center { Vec3d::Zero() }

private

58{ Vec3d::Zero() };

Referenced by on_load(), on_save(), on_set_state(), on_stop_dragging(), process_cut_line(), render_move_center_input(), reset_cut_plane(), and shift_cut().

◆ m_axis_names

std::vector<std::string> Slic3r::GUI::GLGizmoCut3D::m_axis_names

private

Referenced by GLGizmoCut3D(), and render_move_center_input().

◆ m_bb_center

Vec3d Slic3r::GUI::GLGizmoCut3D::m_bb_center { Vec3d::Zero() }

private

65{ Vec3d::Zero() };

Referenced by invalidate_cut_plane(), process_cut_line(), render_cut_plane_input_window(), reset_cut_plane(), set_center_pos(), update_bb(), and update_clipper().

◆ m_bounding_box

BoundingBoxf3 Slic3r::GUI::GLGizmoCut3D::m_bounding_box

private

Referenced by init_picking_models(), is_conflict_for_connector(), render_cut_plane_grabbers(), render_slider_input(), render_slider_two_input(), update_bb(), and update_raycasters_for_picking_transform().

◆ m_c

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

protectedinherited

155{ nullptr };

◆ m_center_offset

Vec3d Slic3r::GUI::GLGizmoCut3D::m_center_offset { Vec3d::Zero() }

private

66{ Vec3d::Zero() };

Referenced by invalidate_cut_plane(), set_center_pos(), and update_bb().

◆ m_circle

GLModel Slic3r::GUI::GLGizmoCut3D::m_circle

private

Referenced by init_rendering_items(), render_rotation_snapping(), and update_bb().

◆ m_clp_normal

Vec3d Slic3r::GUI::GLGizmoCut3D::m_clp_normal { Vec3d::Ones() }

private

87{ Vec3d::Ones() };

Referenced by render_connectors(), update_clipper(), and update_raycasters_for_picking_transform().

◆ m_cone

PickingModel Slic3r::GUI::GLGizmoCut3D::m_cone

private

Referenced by init_picking_models(), on_register_raycasters_for_picking(), render_cut_plane_grabbers(), and update_bb().

◆ m_connector_angle

float Slic3r::GUI::GLGizmoCut3D::m_connector_angle { 0.f }

private

155{ 0.f };

Referenced by add_connector(), init_input_window_data(), render_connectors_input_window(), and validate_connector_settings().

◆ m_connector_depth_ratio

float Slic3r::GUI::GLGizmoCut3D::m_connector_depth_ratio { 3.f }

private

153{ 3.f };

Referenced by add_connector(), init_input_window_data(), render_connectors_input_window(), and validate_connector_settings().

◆ m_connector_depth_ratio_tolerance

float Slic3r::GUI::GLGizmoCut3D::m_connector_depth_ratio_tolerance { 0.1f }

private

157{ 0.1f };

Referenced by add_connector(), init_input_window_data(), render_connectors_input_window(), and validate_connector_settings().

◆ m_connector_mesh

TriangleMesh Slic3r::GUI::GLGizmoCut3D::m_connector_mesh

private

◆ m_connector_mode

CutConnectorMode Slic3r::GUI::GLGizmoCut3D::m_connector_mode { CutConnectorMode::Manual }

private

243{ CutConnectorMode::Manual };

Referenced by apply_connectors_in_model(), gizmo_event(), on_dragging(), on_start_dragging(), render_connect_mode_radio_button(), and render_connectors().

◆ m_connector_modes

std::vector<std::string> Slic3r::GUI::GLGizmoCut3D::m_connector_modes

private

Referenced by GLGizmoCut3D(), and render_connect_mode_radio_button().

◆ m_connector_shape_id

int Slic3r::GUI::GLGizmoCut3D::m_connector_shape_id

private

Referenced by GLGizmoCut3D(), add_connector(), init_input_window_data(), render_connectors_input_window(), update_connector_shape(), and validate_connector_settings().

◆ m_connector_shapes

std::vector<std::string> Slic3r::GUI::GLGizmoCut3D::m_connector_shapes

private

Referenced by GLGizmoCut3D(), and render_connectors_input_window().

◆ m_connector_size

float Slic3r::GUI::GLGizmoCut3D::m_connector_size { 2.5f }

private

154{ 2.5f };

Referenced by add_connector(), init_input_window_data(), render_connectors_input_window(), and validate_connector_settings().

◆ m_connector_size_tolerance

float Slic3r::GUI::GLGizmoCut3D::m_connector_size_tolerance { 0.f }

private

158{ 0.f };

Referenced by add_connector(), init_input_window_data(), render_connectors_input_window(), and validate_connector_settings().

◆ m_connector_style

int Slic3r::GUI::GLGizmoCut3D::m_connector_style

private

Referenced by GLGizmoCut3D(), add_connector(), init_input_window_data(), render_connectors_input_window(), update_connector_shape(), and validate_connector_settings().

◆ m_connector_styles

std::vector<std::string> Slic3r::GUI::GLGizmoCut3D::m_connector_styles

private

Referenced by GLGizmoCut3D(), and render_connectors_input_window().

◆ m_connector_type

CutConnectorType Slic3r::GUI::GLGizmoCut3D::m_connector_type

private

Referenced by GLGizmoCut3D(), add_connector(), init_input_window_data(), render_connect_type_radio_button(), render_connectors_input_window(), update_connector_shape(), and validate_connector_settings().

◆ m_connector_types

std::vector<std::string> Slic3r::GUI::GLGizmoCut3D::m_connector_types

private

Referenced by GLGizmoCut3D(), and render_connect_type_radio_button().

◆ m_connectors_editing

bool Slic3r::GUI::GLGizmoCut3D::m_connectors_editing { false }

private

◆ m_connectors_group_id

int Slic3r::GUI::GLGizmoCut3D::m_connectors_group_id

private

Referenced by GLGizmoCut3D(), dragging_connector(), gizmo_event(), is_selection_changed(), on_dragging(), on_mouse(), on_register_raycasters_for_picking(), on_start_dragging(), and render_connectors().

◆ m_contour_width

float Slic3r::GUI::GLGizmoCut3D::m_contour_width { 0.4f }

private

165{ 0.4f };

Referenced by data_changed(), render_debug_input_window(), set_connectors_editing(), switch_to_mode(), and update_bb().

◆ m_control_width

float Slic3r::GUI::GLGizmoCut3D::m_control_width { 200.f }

private

161{ 200.f };

Referenced by init_input_window_data(), render_connect_mode_radio_button(), render_connect_type_radio_button(), render_cut_mode_combo(), render_double_input(), render_groove_int_input(), and render_move_center_input().

◆ m_cube

PickingModel Slic3r::GUI::GLGizmoCut3D::m_cube

private

Referenced by init_picking_models(), on_register_raycasters_for_picking(), render_cut_plane_grabbers(), and update_bb().

◆ m_cut_line

GLModel Slic3r::GUI::GLGizmoCut3D::m_cut_line

private

Referenced by render_cut_line().

◆ m_cut_normal

Vec3d Slic3r::GUI::GLGizmoCut3D::m_cut_normal

private

Referenced by apply_connectors_in_model(), is_looking_forward(), on_render(), process_contours(), shift_cut(), and update_clipper().

◆ m_cut_plane_as_circle

bool Slic3r::GUI::GLGizmoCut3D::m_cut_plane_as_circle { false }

private

151{ false };

Referenced by init_picking_models(), and render_debug_input_window().

◆ m_cut_plane_radius_koef

float Slic3r::GUI::GLGizmoCut3D::m_cut_plane_radius_koef { 1.5f }

private

166{ 1.5f };

Referenced by init_picking_models(), and render_debug_input_window().

◆ m_cut_plane_start_move_pos

Vec3d Slic3r::GUI::GLGizmoCut3D::m_cut_plane_start_move_pos {Vec3d::Zero()}

private

75{Vec3d::Zero()};

Referenced by dragging_grabber_move(), and on_mouse().

◆ m_dirty

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

privateinherited

293{ false };

Referenced by set_dirty(), and update_items_state().

◆ m_dragging

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

protectedinherited

151{ false };

◆ m_editing_window_width

double Slic3r::GUI::GLGizmoCut3D::m_editing_window_width

private

Referenced by init_input_window_data(), render_angle_input(), render_connectors_input_window(), render_slider_input(), render_slider_two_input(), and render_snap_specific_input().

◆ m_first_input_window_render

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

protectedinherited

154{ true };

Referenced by render_input_window().

◆ m_grabber_connection

GLModel Slic3r::GUI::GLGizmoCut3D::m_grabber_connection

private

Referenced by init_rendering_items(), render_grabber_connection(), and update_bb().

◆ m_grabber_connection_len

double Slic3r::GUI::GLGizmoCut3D::m_grabber_connection_len { 0.0 }

private

74{ 0.0 };

Referenced by dragging_grabber_move(), init_rendering_items(), render_cut_plane_grabbers(), render_grabber_connection(), update_bb(), and update_raycasters_for_picking_transform().

◆ m_grabber_radius

double Slic3r::GUI::GLGizmoCut3D::m_grabber_radius { 0.0 }

private

73{ 0.0 };

Referenced by init_rendering_items(), and update_bb().

◆ m_grabbers

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

mutableprotectedinherited

◆ m_groove

Cut::Groove Slic3r::GUI::GLGizmoCut3D::m_groove

private

Referenced by has_valid_groove(), its_make_groove_plane(), on_load(), on_save(), perform_cut(), process_contours(), render_cut_plane_grabbers(), render_cut_plane_input_window(), update_bb(), and update_raycasters_for_picking_transform().

◆ m_groove_count

int Slic3r::GUI::GLGizmoCut3D::m_groove_count { 1 }

private

141{ 1 };

Referenced by its_make_groove_plane(), perform_cut(), process_contours(), render_cut_plane_input_window(), and render_groove_float_input().

◆ m_groove_count_init

int Slic3r::GUI::GLGizmoCut3D::m_groove_count_init { 1 }

private

140{ 1 };

Referenced by render_cut_plane_input_window().

◆ m_groove_editing

bool Slic3r::GUI::GLGizmoCut3D::m_groove_editing { false }

private

135{ false };

Referenced by process_cut_line(), render_angle_input(), render_groove_angle_input(), render_groove_float_input(), render_groove_two_float_input(), and reset_cut_by_contours().

◆ m_groove_gap

float Slic3r::GUI::GLGizmoCut3D::m_groove_gap { 10.f }

private

142{ 10.f }; // distance between multiple dovetail cuts

Referenced by its_make_groove_plane(), perform_cut(), process_contours(), and render_cut_plane_input_window().

◆ m_groove_gap_init

float Slic3r::GUI::GLGizmoCut3D::m_groove_gap_init { 10.f }

private

143{ 10.f };

Referenced by render_cut_plane_input_window().

◆ m_groove_vertices

std::vector<Vec3d> Slic3r::GUI::GLGizmoCut3D::m_groove_vertices

private

Referenced by has_valid_groove(), and its_make_groove_plane().

◆ 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_hide_cut_plane

bool Slic3r::GUI::GLGizmoCut3D::m_hide_cut_plane { false }

private

149{ false };

Referenced by init_picking_models(), on_load(), on_render(), and on_save().

◆ m_hover_id

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

protectedinherited

150{ -1 };

◆ 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

◆ m_imperial_units

bool Slic3r::GUI::GLGizmoCut3D::m_imperial_units { false }

private

163{ false };

Referenced by get_tooltip(), init_input_window_data(), render_build_size(), render_double_input(), render_move_center_input(), render_slider_input(), and render_slider_two_input().

◆ m_info_stats

struct Slic3r::GUI::GLGizmoCut3D::InvalidConnectorsStatistics Slic3r::GUI::GLGizmoCut3D::m_info_stats

private

Referenced by check_and_update_connectors_state(), is_conflict_for_connector(), is_outside_of_cut_contour(), and render_input_window_warning().

◆ m_invalid_connectors_idxs

std::vector<size_t> Slic3r::GUI::GLGizmoCut3D::m_invalid_connectors_idxs

private

Referenced by can_perform_cut(), check_and_update_connectors_state(), render_connectors(), and render_input_window_warning().

◆ m_is_dark_mode

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

protectedinherited

◆ m_is_slider_editing_done

bool Slic3r::GUI::GLGizmoCut3D::m_is_slider_editing_done { false }

private

137{ false };

Referenced by render_angle_input(), render_cut_plane_input_window(), render_groove_angle_input(), render_groove_float_input(), and render_groove_two_float_input().

◆ m_keep_as_parts

bool Slic3r::GUI::GLGizmoCut3D::m_keep_as_parts { false }

private

127{ false };

Referenced by get_tooltip(), perform_cut(), and render_cut_plane_input_window().

◆ m_keep_lower

bool Slic3r::GUI::GLGizmoCut3D::m_keep_lower { true }

private

126{ true };

Referenced by can_perform_cut(), gizmo_event(), on_load(), on_save(), perform_cut(), render_cut_plane_input_window(), and render_input_window_warning().

◆ m_keep_upper

bool Slic3r::GUI::GLGizmoCut3D::m_keep_upper { true }

private

125{ true };

Referenced by can_perform_cut(), gizmo_event(), on_load(), on_save(), perform_cut(), render_cut_plane_input_window(), and render_input_window_warning().

◆ m_label_width

float Slic3r::GUI::GLGizmoCut3D::m_label_width { 0.f }

private

160{ 0.f };

Referenced by init_input_window_data(), render_angle_input(), render_build_size(), render_connect_mode_radio_button(), render_connect_type_radio_button(), render_connectors_input_window(), render_cut_mode_combo(), render_cut_plane_input_window(), render_debug_input_window(), render_double_input(), render_groove_int_input(), render_slider_input(), render_slider_two_input(), and render_snap_specific_input().

◆ m_labels_map

std::map<std::string, std::string> Slic3r::GUI::GLGizmoCut3D::m_labels_map

private

Referenced by GLGizmoCut3D(), init_input_window_data(), render_connectors_input_window(), and render_cut_plane_input_window().

◆ m_ldown_mouse_position

Vec2d Slic3r::GUI::GLGizmoCut3D::m_ldown_mouse_position { Vec2d::Zero() }

private

92{ Vec2d::Zero() };

Referenced by gizmo_event().

◆ m_line_beg

Vec3d Slic3r::GUI::GLGizmoCut3D::m_line_beg { Vec3d::Zero() }

private

89{ Vec3d::Zero() };

Referenced by cut_line_processing(), discard_cut_line_processing(), process_cut_line(), and render_cut_line().

◆ m_line_end

Vec3d Slic3r::GUI::GLGizmoCut3D::m_line_end { Vec3d::Zero() }

private

90{ Vec3d::Zero() };

Referenced by discard_cut_line_processing(), process_cut_line(), and render_cut_line().

◆ m_max_pos

Vec3d Slic3r::GUI::GLGizmoCut3D::m_max_pos { Vec3d::Zero() }

private

64{ Vec3d::Zero() };

Referenced by invalidate_cut_plane(), and update_bb().

◆ m_min_pos

Vec3d Slic3r::GUI::GLGizmoCut3D::m_min_pos { Vec3d::Zero() }

private

63{ Vec3d::Zero() };

Referenced by invalidate_cut_plane(), and update_bb().

◆ m_mode

size_t Slic3r::GUI::GLGizmoCut3D::m_mode { size_t(CutMode::cutPlanar) }

private

◆ m_modes

std::vector<std::string> Slic3r::GUI::GLGizmoCut3D::m_modes

private

Referenced by GLGizmoCut3D(), and render_cut_mode_combo().

◆ m_parent

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

protectedinherited

◆ m_part_orientation_names

std::map<std::string, wxString> Slic3r::GUI::GLGizmoCut3D::m_part_orientation_names

private

Referenced by GLGizmoCut3D().

◆ m_part_selection

PartSelection Slic3r::GUI::GLGizmoCut3D::m_part_selection

private

Referenced by can_perform_cut(), flip_cut_plane(), is_outside_of_cut_contour(), on_mouse(), on_render(), on_set_state(), perform_cut(), process_contours(), render_clipper_cut(), render_cut_plane_input_window(), reset_cut_by_contours(), toggle_model_objects_visibility(), and unproject_on_cut_plane().

◆ m_place_on_cut_lower

bool Slic3r::GUI::GLGizmoCut3D::m_place_on_cut_lower { false }

private

129{ false };

Referenced by perform_cut(), and render_cut_plane_input_window().

◆ m_place_on_cut_upper

bool Slic3r::GUI::GLGizmoCut3D::m_place_on_cut_upper { true }

private

128{ true };

Referenced by perform_cut(), and render_cut_plane_input_window().

◆ m_plane

PickingModel Slic3r::GUI::GLGizmoCut3D::m_plane

private

Referenced by init_picking_models(), on_register_raycasters_for_picking(), render_cut_plane(), render_cut_plane_grabbers(), render_debug_input_window(), update_bb(), and update_plane_model().

◆ m_plane_center

Vec3d Slic3r::GUI::GLGizmoCut3D::m_plane_center { Vec3d::Zero() }

private

◆ m_radius

double Slic3r::GUI::GLGizmoCut3D::m_radius { 0.0 }

private

72{ 0.0 };

Referenced by init_picking_models(), its_make_groove_plane(), perform_cut(), process_contours(), render_cut_plane_input_window(), update_bb(), and update_clipper().

◆ m_raycasters

std::vector<std::shared_ptr<SceneRaycasterItem> > Slic3r::GUI::GLGizmoCut3D::m_raycasters

private

Referenced by on_register_raycasters_for_picking(), on_unregister_raycasters_for_picking(), update_clipper(), and update_raycasters_for_picking_transform().

◆ m_reference_radius

GLModel Slic3r::GUI::GLGizmoCut3D::m_reference_radius

private

Referenced by init_rendering_items(), render_rotation_snapping(), and update_bb().

◆ m_rotate_lower

bool Slic3r::GUI::GLGizmoCut3D::m_rotate_lower { false }

private

131{ false };

Referenced by on_load(), on_save(), perform_cut(), and render_cut_plane_input_window().

◆ m_rotate_upper

bool Slic3r::GUI::GLGizmoCut3D::m_rotate_upper { false }

private

130{ false };

Referenced by on_load(), on_save(), perform_cut(), and render_cut_plane_input_window().

◆ m_rotation_m

Transform3d Slic3r::GUI::GLGizmoCut3D::m_rotation_m { Transform3d::Identity() }

private

◆ m_scale

GLModel Slic3r::GUI::GLGizmoCut3D::m_scale

private

Referenced by init_rendering_items(), render_rotation_snapping(), and update_bb().

◆ m_selected

std::vector<bool> Slic3r::GUI::GLGizmoCut3D::m_selected

mutableprivate

Referenced by add_connector(), apply_selected_connectors(), clear_selection(), delete_selected_connectors(), init_input_window_data(), on_set_state(), render_connectors(), select_all_connectors(), select_connector(), unselect_all_connectors(), and update_bb().

◆ m_selected_count

int Slic3r::GUI::GLGizmoCut3D::m_selected_count { 0 }

private

169{ 0 };

Referenced by add_connector(), clear_selection(), delete_selected_connectors(), init_input_window_data(), select_all_connectors(), select_connector(), and unselect_all_connectors().

◆ m_selection_rectangle

GLSelectionRectangle Slic3r::GUI::GLGizmoCut3D::m_selection_rectangle

private

Referenced by gizmo_event(), is_selection_rectangle_dragging(), on_render(), and process_selection_rectangle().

◆ m_shapes

std::map<CutConnectorAttributes, PickingModel> Slic3r::GUI::GLGizmoCut3D::m_shapes

private

Referenced by init_connector_shapes(), init_picking_models(), is_conflict_for_connector(), on_register_raycasters_for_picking(), render_connectors(), and update_connector_shape().

◆ m_shortcut

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

protectedinherited

◆ m_shortcuts_connector

std::vector<std::pair<wxString, wxString> > Slic3r::GUI::GLGizmoCut3D::m_shortcuts_connector

private

Referenced by on_init(), and render_tooltip_button().

◆ m_shortcuts_cut

std::vector<std::pair<wxString, wxString> > Slic3r::GUI::GLGizmoCut3D::m_shortcuts_cut

private

Referenced by on_init(), and render_tooltip_button().

◆ m_snap_bulge_proportion

float Slic3r::GUI::GLGizmoCut3D::m_snap_bulge_proportion { 0.15f }

private

146{ 0.15f };

Referenced by get_connector_mesh(), and render_connectors_input_window().

◆ m_snap_coarse_in_radius

double Slic3r::GUI::GLGizmoCut3D::m_snap_coarse_in_radius { 0.0 }

private

77{ 0.0 };

Referenced by dragging_grabber_rotation(), and update_bb().

◆ m_snap_coarse_out_radius

double Slic3r::GUI::GLGizmoCut3D::m_snap_coarse_out_radius { 0.0 }

private

78{ 0.0 };

Referenced by dragging_grabber_rotation(), and update_bb().

◆ m_snap_fine_in_radius

double Slic3r::GUI::GLGizmoCut3D::m_snap_fine_in_radius { 0.0 }

private

79{ 0.0 };

Referenced by dragging_grabber_rotation(), and update_bb().

◆ m_snap_fine_out_radius

double Slic3r::GUI::GLGizmoCut3D::m_snap_fine_out_radius { 0.0 }

private

80{ 0.0 };

Referenced by dragging_grabber_rotation(), and update_bb().

◆ m_snap_radii

GLModel Slic3r::GUI::GLGizmoCut3D::m_snap_radii

private

Referenced by init_rendering_items(), render_rotation_snapping(), and update_bb().

◆ m_snap_space_proportion

float Slic3r::GUI::GLGizmoCut3D::m_snap_space_proportion { 0.3f }

private

147{ 0.3f };

Referenced by get_connector_mesh(), and render_connectors_input_window().

◆ m_snap_step

double Slic3r::GUI::GLGizmoCut3D::m_snap_step { 1.0 }

private

54{ 1.0 };

Referenced by dragging_grabber_move().

◆ m_sphere

PickingModel Slic3r::GUI::GLGizmoCut3D::m_sphere

private

Referenced by init_picking_models(), on_register_raycasters_for_picking(), on_render(), render_cut_plane_grabbers(), and update_bb().

◆ m_sprite_id

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

protectedinherited

Referenced by GLGizmoBase(), and get_sprite_id().

◆ m_start_dragging_m

Transform3d Slic3r::GUI::GLGizmoCut3D::m_start_dragging_m { Transform3d::Identity() }

private

59{ Transform3d::Identity() };

Referenced by dragging_grabber_rotation(), flip_cut_plane(), mouse_position_in_local_plane(), on_load(), on_save(), on_set_state(), on_start_dragging(), on_stop_dragging(), process_cut_line(), render_rotation_snapping(), and reset_cut_plane().

◆ m_state

EState Slic3r::GUI::GLGizmoBase::m_state

protectedinherited

◆ m_transformed_bounding_box

BoundingBoxf3 Slic3r::GUI::GLGizmoCut3D::m_transformed_bounding_box

private

Referenced by dragging_grabber_rotation(), flip_cut_plane(), get_tooltip(), on_load(), on_set_state(), process_cut_line(), render_build_size(), reset_cut_plane(), set_center_pos(), and update_bb().

◆ m_was_contour_selected

bool Slic3r::GUI::GLGizmoCut3D::m_was_contour_selected { false }

private

175{ false };

Referenced by on_mouse().

◆ m_was_cut_plane_dragged

bool Slic3r::GUI::GLGizmoCut3D::m_was_cut_plane_dragged { false }

private

174{ false };

Referenced by dragging_grabber_move(), on_mouse(), and on_stop_dragging().

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

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

	OrcaSlicer latest OrcaSlicer

Classes

Public Types

Public Member Functions

Static Public Member Functions

Static Public Attributes

Protected Member Functions

Protected Attributes

Private Types

Private Member Functions

Static Private Member Functions

Private Attributes

Detailed Description

Member Enumeration Documentation

◆ CutConnectorMode

◆ CutMode

◆ EGrabberExtension

◆ EState

◆ GrabberID

Constructor & Destructor Documentation

◆ GLGizmoCut3D()

Member Function Documentation

◆ add_connector()

◆ add_horizontal_scaled_interval()

◆ add_horizontal_shift()

◆ add_vertical_scaled_interval()

◆ apply_clipping_plane()

◆ apply_color_clip_plane_colors()

◆ apply_connectors_in_model()

◆ apply_cut_connectors()

◆ apply_selected_connectors()

◆ bounding_box()

◆ can_perform_cut()

◆ check_and_update_connectors_state()

◆ clear_selection()

◆ cut_line_processing()

◆ data_changed()

◆ delete_selected_connectors()

◆ discard_cut_line_processing()

◆ do_stop_dragging()

◆ dragging_connector()

◆ dragging_grabber_move()

◆ dragging_grabber_rotation()

◆ flip_cut_plane()

◆ format()

◆ get_action_snapshot_name()

◆ get_connector_mesh()

◆ get_count()

◆ get_cut_matrix()

◆ get_gizmo_entering_text()

◆ get_gizmo_leaving_text()

◆ get_gizmo_name()

◆ get_hover_id()

◆ get_icon_filename()

◆ get_name()

◆ get_requirements()

◆ get_sprite_id()

◆ get_state()

◆ get_tooltip()

◆ gizmo_event()

◆ GizmoImguiBegin()

◆ GizmoImguiEnd()

◆ GizmoImguiSetNextWIndowPos() [1/2]

◆ GizmoImguiSetNextWIndowPos() [2/2]

◆ has_valid_contour()

◆ has_valid_groove()

◆ init()

◆ init_connector_shapes()

◆ init_input_window_data()

◆ init_picking_models()

◆ init_rendering_items()

◆ invalidate_cut_plane()

◆ is_activable()

◆ is_conflict_for_connector()

◆ is_dragging()

◆ is_in_editing_mode()

◆ is_looking_forward()

◆ is_outside_of_cut_contour()

◆ is_selectable()

◆ is_selection_changed()

◆ is_selection_rectangle_dragging()