Slic3r::GUI::GLGizmoFuzzySkin Class Reference

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

Inheritance diagram for Slic3r::GUI::GLGizmoFuzzySkin:

Collaboration diagram for Slic3r::GUI::GLGizmoFuzzySkin:

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
	GLGizmoFuzzySkin (GLCanvas3D &parent, const std::string &icon_filename, unsigned int sprite_id)
void	render_painter_gizmo () override
void	data_changed (bool is_serializing) override
	Is called when data (Selection) is changed.
virtual bool	gizmo_event (SLAGizmoEventType action, const Vec2d &mouse_position, bool shift_down, bool alt_down, bool control_down)
virtual bool	on_tool_shortcut (Shortcut shortcut)
virtual const float	get_cursor_radius_min () const
virtual const float	get_cursor_radius_max () const
virtual const float	get_cursor_radius_step () const
virtual const float	get_cursor_height_min () const
virtual const float	get_cursor_height_max () const
virtual const float	get_cursor_height_step () const
bool	on_mouse (const wxMouseEvent &mouse_event) override
	Implement when want to process mouse events in gizmo Click, Right click, move, drag, ...
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
void	set_common_data_pool (CommonGizmosDataPool *ptr)
virtual bool	apply_clipping_plane ()
unsigned int	get_sprite_id () const
int	get_hover_id () const
void	set_hover_id (int id)
bool	is_dragging () const
bool	update_items_state ()
void	render ()
void	render_input_window (float x, float y, float bottom_limit)
virtual void	on_change_color_mode (bool is_dark)
virtual std::string	get_tooltip () const
	Mouse tooltip text.
int	get_count ()
std::string	get_gizmo_name ()
void	register_raycasters_for_picking ()
void	unregister_raycasters_for_picking ()
virtual bool	is_in_editing_mode () const
virtual bool	is_selection_rectangle_dragging () const

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

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

Protected Types
enum class	ToolType { BRUSH , BUCKET_FILL , SMART_FILL , GAP_FILL }
enum class	Button { None , Left , Right }

Protected Member Functions
void	on_render_input_window (float x, float y, float bottom_limit) override
std::string	on_get_name () const override
void	render_tooltip_button (float x, float y)
wxString	handle_snapshot_action_name (bool shift_down, ButtonButton button_down) 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
EnforcerBlockerType	get_left_button_state_type () const override
EnforcerBlockerType	get_right_button_state_type () const override
virtual void	render_triangles (const Selection &selection, const ModelVolume *skip=nullptr) const
void	render_triangles (const Selection &selection, const std::vector< const ModelVolume * > &skip) const
void	render_cursor ()
void	render_cursor_circle ()
void	render_cursor_sphere (const Transform3d &trafo) const
void	render_cursor_height_range (const Transform3d &trafo) const
virtual ColorRGBA	get_cursor_sphere_left_button_color () const
virtual ColorRGBA	get_cursor_sphere_right_button_color () const
virtual ColorRGBA	get_cursor_hover_color () const
Vec3f	get_tilt_up_direction () const
ClippingPlaneDataWrapper	get_clipping_plane_data () const
TriangleSelector::ClippingPlane	get_clipping_plane_in_volume_coordinates (const Transform3d &trafo) const
bool	is_painting () const
void	on_set_state () override
bool	on_is_activable () const override
bool	render_follows_cursor () const override
bool	on_is_selectable () const override
void	on_load (cereal::BinaryInputArchive &ar) override
void	on_save (cereal::BinaryOutputArchive &ar) const override
CommonGizmosDataID	on_get_requirements () const override
bool	wants_enter_leave_snapshots () const override
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_set_hover_id ()
virtual void	on_enable_grabber (unsigned int id)
virtual void	on_disable_grabber (unsigned int id)
virtual void	on_start_dragging ()
virtual void	on_stop_dragging ()
virtual void	on_dragging (const UpdateData &data)
bool	GizmoImguiBegin (const std::string &name, int flags)
void	GizmoImguiEnd ()
void	GizmoImguiSetNextWIndowPos (float &x, float y, int flag, float pivot_x=0.0f, float pivot_y=0.0f)
void	GizmoImguiSetNextWIndowPos (float &x, float y, float w, float h, int flag, float pivot_x=0.0f, float pivot_y=0.0f)
void	register_grabbers_for_picking ()
void	unregister_grabbers_for_picking ()
virtual void	on_register_raycasters_for_picking ()
virtual void	on_unregister_raycasters_for_picking ()
void	render_grabbers (const BoundingBoxf3 &box) const
void	render_grabbers (float size) const
void	render_grabbers (size_t first, size_t last, float size, bool force_hover) const
std::string	format (float value, unsigned int decimals) const
void	set_dirty ()
bool	use_grabbers (const wxMouseEvent &mouse_event)
	function which Set up m_dragging and call functions on_start_dragging / on_dragging / on_stop_dragging
void	do_stop_dragging (bool perform_mouse_cleanup)

Protected Attributes
wchar_t	m_current_tool = 0
float	m_cursor_radius = 1.f
float	m_cursor_height = 0.2f
std::vector< std::unique_ptr< TriangleSelectorGUI > >	m_triangle_selectors
TriangleSelector::CursorType	m_cursor_type = TriangleSelector::SPHERE
bool	m_triangle_splitting_enabled = true
ToolType	m_tool_type = ToolType::BRUSH
float	m_smart_fill_angle = 30.f
bool	m_paint_on_overhangs_only = false
float	m_highlight_by_angle_threshold_deg = 0.f
GLModel	m_circle
Vec2d	m_old_center { Vec2d::Zero() }
float	m_old_cursor_radius { 0.0f }
bool	m_vertical_only = false
bool	m_horizontal_only = false
int	m_seed_fill_last_mesh_id = -1
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

Static Protected Attributes
static constexpr float	CursorRadiusMin = 0.4f
static constexpr float	CursorRadiusMax = 8.f
static constexpr float	CursorRadiusStep = 0.2f
static constexpr float	CursorHeightMin = 0.1f
static constexpr float	CursorHeightMax = 8.f
static constexpr float	CursorHeightStep = 0.2f
static constexpr float	SmartFillAngleMin = 0.0f
static constexpr float	SmartFillAngleMax = 90.f
static constexpr float	SmartFillAngleStep = 1.f

Private Member Functions
bool	on_init () override
void	update_model_object () override
void	update_from_model_object (bool first_update) override
void	on_opening () override
void	on_shutdown () override
PainterGizmoType	get_painter_type () const override
void	on_render () override
std::vector< std::vector< ProjectedMousePosition > >	get_projected_mouse_positions (const Vec2d &mouse_position, double resolution, const std::vector< Transform3d > &trafo_matrices) const
std::vector< ProjectedHeightRange >	get_projected_height_range (const Vec2d &mouse_position, double resolution, const std::vector< const ModelVolume * > &part_volumes, const std::vector< Transform3d > &trafo_matrices) const
bool	is_mesh_point_clipped (const Vec3d &point, const Transform3d &trafo) const
std::vector< Transform3d >	mesh_trafo_matrices () const
void	update_raycast_cache (const Vec2d &mouse_position, const Camera &camera, const std::vector< Transform3d > &trafo_matrices) const
BoundingBoxf3	bounding_box () const
void	update_contours (int i, const TriangleMesh &vol_mesh, float cursor_z, float max_z, float min_z) const

Private Attributes
std::map< std::string, wxString >	m_desc
std::vector< std::pair< wxString, wxString > >	m_shortcuts_brush
std::vector< std::pair< wxString, wxString > >	m_shortcuts_triangle
std::vector< std::pair< wxString, wxString > >	m_shortcuts_smart_fill
ObjectID	m_old_mo_id
size_t	m_old_volumes_size = 0
bool	m_internal_stack_active = false
bool	m_schedule_update = false
Vec2d	m_last_mouse_click = Vec2d::Zero()
ButtonButton	m_button_down = Button::None
EState	m_old_state = Off
RaycastResult	m_rr = {Vec2d::Zero(), -1, Vec3f::Zero(), 0}
std::vector< CutContours >	m_cut_contours
int	m_volumes_index = 0
float	m_cursor_z {0}
double	m_height_start_z_in_imgui {0}
bool	m_is_set_height_start_z_by_imgui {false}
Vec2i32	m_height_start_pos {0, 0}
bool	m_is_cursor_in_imgui {false}
bool	m_dirty { false }
int	count = 0

Static Private Attributes
static std::shared_ptr< GLModel >	s_sphere = nullptr

Detailed Description

Member Enumeration Documentation

Button

enum class Slic3r::GUI::GLGizmoPainterBase::Button

strongprotectedinherited

Enumerator
None
Left
Right

                      {
        None,
        Left,
        Right
    };

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

ToolType

enum class Slic3r::GUI::GLGizmoPainterBase::ToolType

strongprotectedinherited

Enumerator
BRUSH
BUCKET_FILL
SMART_FILL
GAP_FILL

                        {
        BRUSH,
        BUCKET_FILL,
        SMART_FILL,
        // BBS
        GAP_FILL,
    };

Constructor & Destructor Documentation

GLGizmoFuzzySkin()

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

    : GLGizmoPainterBase(parent, icon_filename, sprite_id), m_current_tool(ImGui::CircleButtonIcon)
{
}

References Slic3r::GUI::GLGizmoPainterBase::GLGizmoPainterBase(), and m_current_tool.

Here is the call graph for this function:

Member Function Documentation

apply_clipping_plane()

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

inlinevirtualinherited

{ return true; }

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

Here is the caller graph for this function:

bounding_box()

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

privateinherited

{
    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);
        if (!volume->is_modifier)
            ret.merge(volume->transformed_convex_hull_bounding_box());
    }
    return ret;
}

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

Referenced by render_cursor_height_range().

Here is the call graph for this function:

Here is the caller graph for this function:

data_changed()

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

overridevirtualinherited

Is called when data (Selection) is changed.

Reimplemented from Slic3r::GUI::GLGizmoBase.

{
    if (m_state != On)
        return;
 
    const ModelObject* mo = m_c->selection_info() ? m_c->selection_info()->model_object() : nullptr;
    const Selection &  selection = m_parent.get_selection();
    if (mo && selection.is_from_single_instance()
     && (m_schedule_update || mo->id() != m_old_mo_id || mo->volumes.size() != m_old_volumes_size))
    {
        //BBS: add logic to distinguish the first_time_update and later_update
        update_from_model_object(!m_schedule_update);
 
        m_old_mo_id = mo->id();
        m_old_volumes_size = mo->volumes.size();
        m_schedule_update = false;
    }
}

References Slic3r::ObjectBase::id(), Slic3r::GUI::Selection::is_from_single_instance(), Slic3r::GUI::GLGizmoBase::m_c, m_old_mo_id, m_old_volumes_size, Slic3r::GUI::GLGizmoBase::m_parent, m_schedule_update, Slic3r::GUI::GLGizmoBase::m_state, Slic3r::GUI::GLGizmoBase::On, update_from_model_object(), and Slic3r::ModelObject::volumes.

Referenced by Slic3r::GUI::GLGizmoMmuSegmentation::data_changed().

Here is the call graph for this function:

Here is the caller graph for this function:

do_stop_dragging()

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

protectedinherited

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

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

Referenced by use_grabbers().

Here is the call graph for this function:

Here is the caller graph for this function:

format()

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

protectedinherited

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

References Slic3r::string_printf().

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

Here is the call graph for this function:

Here is the caller graph for this function:

get_action_snapshot_name()

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

inlineoverrideprotectedvirtual

Reimplemented from Slic3r::GUI::GLGizmoBase.

{ return _u8L("Paint-on fuzzy skin editing"); }

References _u8L.

get_clipping_plane_data()

GLGizmoPainterBase::ClippingPlaneDataWrapper Slic3r::GUI::GLGizmoPainterBase::get_clipping_plane_data ( ) const

protectedinherited

{
    ClippingPlaneDataWrapper clp_data_out{{0.f, 0.f, 1.f, FLT_MAX}, {-FLT_MAX, FLT_MAX}};
    // Take care of the clipping plane. The normal of the clipping plane is
    // saved with opposite sign than we need to pass to OpenGL (FIXME)
    if (bool clipping_plane_active = m_c->object_clipper()->get_position() != 0.; clipping_plane_active) {
        const ClippingPlane *clp = m_c->object_clipper()->get_clipping_plane();
        for (size_t i = 0; i < 3; ++i)
            clp_data_out.clp_dataf[i] = -1.f * float(clp->get_data()[i]);
        clp_data_out.clp_dataf[3] = float(clp->get_data()[3]);
    }
 
    // z_range is calculated in the same way as in GLCanvas3D::_render_objects(GLVolumeCollection::ERenderType type)
    if (m_c->get_canvas()->get_use_clipping_planes()) {
        const std::array<ClippingPlane, 2> &clps = m_c->get_canvas()->get_clipping_planes();
        clp_data_out.z_range                     = {float(-clps[0].get_data()[3]), float(clps[1].get_data()[3])};
    }
 
    return clp_data_out;
}

References Slic3r::GUI::GLGizmoPainterBase::ClippingPlaneDataWrapper::clp_dataf, Slic3r::GUI::ClippingPlane::get_data(), Slic3r::GUI::GLGizmoBase::m_c, and Slic3r::GUI::GLGizmoPainterBase::ClippingPlaneDataWrapper::z_range.

Referenced by Slic3r::GUI::GLGizmoTextureDisplacement::render_painted_colors(), Slic3r::GUI::GLGizmoTextureDisplacement::render_shaded_preview_mesh(), render_triangles(), and Slic3r::GUI::GLGizmoTextureDisplacement::render_uvcheck_mesh().

Here is the call graph for this function:

Here is the caller graph for this function:

get_clipping_plane_in_volume_coordinates()

TriangleSelector::ClippingPlane Slic3r::GUI::GLGizmoPainterBase::get_clipping_plane_in_volume_coordinates ( const Transform3d & trafo ) const

protectedinherited

                                                                                                                         {
    const ::Slic3r::GUI::ClippingPlane *const clipping_plane = m_c->object_clipper()->get_clipping_plane();
    if (clipping_plane == nullptr || !clipping_plane->is_active())
        return {};
 
    const Vec3d  clp_normal = clipping_plane->get_normal();
    const double clp_offset = clipping_plane->get_offset();
 
    const Transform3d trafo_normal = Transform3d(trafo.linear().transpose());
    const Transform3d trafo_inv    = trafo.inverse();
 
    Vec3d point_on_plane             = clp_normal * clp_offset;
    Vec3d point_on_plane_transformed = trafo_inv * point_on_plane;
    Vec3d normal_transformed         = trafo_normal * clp_normal;
    auto offset_transformed          = float(point_on_plane_transformed.dot(normal_transformed));
 
    return TriangleSelector::ClippingPlane({float(normal_transformed.x()), float(normal_transformed.y()), float(normal_transformed.z()), offset_transformed});
}

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

Referenced by gizmo_event().

Here is the caller graph for this function:

get_count()

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

inlineinherited

{ return ++count; }

References count.

get_cursor_height_max()

virtual const float Slic3r::GUI::GLGizmoPainterBase::get_cursor_height_max ( ) const

inlinevirtualinherited

{ return CursorHeightMax; }

References CursorHeightMax.

Referenced by gizmo_event().

Here is the caller graph for this function:

get_cursor_height_min()

virtual const float Slic3r::GUI::GLGizmoPainterBase::get_cursor_height_min ( ) const

inlinevirtualinherited

{ return CursorHeightMin; }

References CursorHeightMin.

Referenced by gizmo_event().

Here is the caller graph for this function:

get_cursor_height_step()

virtual const float Slic3r::GUI::GLGizmoPainterBase::get_cursor_height_step ( ) const

inlinevirtualinherited

{ return CursorHeightStep; }

References CursorHeightStep.

Referenced by gizmo_event().

Here is the caller graph for this function:

get_cursor_hover_color()

virtual ColorRGBA Slic3r::GUI::GLGizmoPainterBase::get_cursor_hover_color ( ) const

inlineprotectedvirtualinherited

Reimplemented in Slic3r::GUI::GLGizmoMmuSegmentation.

{ return { 0.f, 0.f, 0.f, 0.25f }; }

Referenced by render_cursor_circle(), and render_cursor_sphere().

Here is the caller graph for this function:

get_cursor_radius_max()

virtual const float Slic3r::GUI::GLGizmoPainterBase::get_cursor_radius_max ( ) const

inlinevirtualinherited

{ return CursorRadiusMax; }

References CursorRadiusMax.

Referenced by gizmo_event().

Here is the caller graph for this function:

get_cursor_radius_min()

virtual const float Slic3r::GUI::GLGizmoPainterBase::get_cursor_radius_min ( ) const

inlinevirtualinherited

Reimplemented in Slic3r::GUI::GLGizmoMmuSegmentation, and Slic3r::GUI::GLGizmoSeam.

{ return CursorRadiusMin; }

References CursorRadiusMin.

Referenced by gizmo_event().

Here is the caller graph for this function:

get_cursor_radius_step()

virtual const float Slic3r::GUI::GLGizmoPainterBase::get_cursor_radius_step ( ) const

inlinevirtualinherited

{ return CursorRadiusStep; }

References CursorRadiusStep.

Referenced by gizmo_event().

Here is the caller graph for this function:

get_cursor_sphere_left_button_color()

virtual ColorRGBA Slic3r::GUI::GLGizmoPainterBase::get_cursor_sphere_left_button_color ( ) const

inlineprotectedvirtualinherited

{ return { 0.0f, 0.0f, 1.0f, 0.25f }; }

Referenced by render_cursor_circle(), and render_cursor_sphere().

Here is the caller graph for this function:

get_cursor_sphere_right_button_color()

virtual ColorRGBA Slic3r::GUI::GLGizmoPainterBase::get_cursor_sphere_right_button_color ( ) const

inlineprotectedvirtualinherited

{ return { 1.0f, 0.0f, 0.0f, 0.25f }; }

Referenced by render_cursor_circle(), and render_cursor_sphere().

Here is the caller graph for this function:

get_gizmo_entering_text()

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

inlineoverrideprotectedvirtual

Reimplemented from Slic3r::GUI::GLGizmoBase.

{ return _u8L("Entering Paint-on fuzzy skin"); }

References _u8L.

get_gizmo_leaving_text()

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

inlineoverrideprotectedvirtual

Reimplemented from Slic3r::GUI::GLGizmoBase.

{ return _u8L("Leaving Paint-on fuzzy skin"); }

References _u8L.

get_gizmo_name()

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

inlineinherited

{ return on_get_name(); }

References on_get_name().

Here is the call graph for this function:

get_hover_id()

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

inlineinherited

{ return m_hover_id; }

References m_hover_id.

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

Here is the caller graph for this function:

get_icon_filename()

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

inlineinherited

{ return m_icon_filename; }

References m_icon_filename.

get_left_button_state_type()

EnforcerBlockerType Slic3r::GUI::GLGizmoFuzzySkin::get_left_button_state_type ( ) const

inlineoverrideprotectedvirtual

Reimplemented from Slic3r::GUI::GLGizmoPainterBase.

{ return EnforcerBlockerType::FUZZY_SKIN; }

References Slic3r::FUZZY_SKIN.

get_name()

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

inherited

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

References m_shortcut, and on_get_name().

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

Here is the call graph for this function:

Here is the caller graph for this function:

get_painter_type()

PainterGizmoType Slic3r::GUI::GLGizmoFuzzySkin::get_painter_type ( ) const

overrideprivatevirtual

Implements Slic3r::GUI::GLGizmoPainterBase.

{
    return PainterGizmoType::FUZZY_SKIN;
}

References Slic3r::GUI::FUZZY_SKIN.

get_projected_height_range()

std::vector< GLGizmoPainterBase::ProjectedHeightRange > Slic3r::GUI::GLGizmoPainterBase::get_projected_height_range ( const Vec2d & mouse_position, double resolution, const std::vector< const ModelVolume * > & part_volumes, const std::vector< Transform3d > & trafo_matrices ) const

privateinherited

{
    std::vector<GLGizmoPainterBase::ProjectedHeightRange> hit_triangles_by_mesh;
 
    const Camera& camera = wxGetApp().plater()->get_camera();
 
    // In mesh_hit_points only the last item could have mesh_id == -1, any other items mustn't.
    update_raycast_cache(mouse_position, camera, trafo_matrices);
    if (m_rr.mesh_id == -1)
        return hit_triangles_by_mesh;
 
    ProjectedMousePosition mesh_hit_point = { m_rr.hit, m_rr.mesh_id, m_rr.facet };
    float z_bot_world= (trafo_matrices[m_rr.mesh_id] * Vec3d(m_rr.hit(0), m_rr.hit(1), m_rr.hit(2))).z();
    float z_top_world = z_bot_world+ m_cursor_height;
    hit_triangles_by_mesh.push_back({ z_bot_world, m_rr.mesh_id, size_t(m_rr.facet) });
 
    const Selection& selection = m_parent.get_selection();
    const ModelObject* mo = m_c->selection_info()->model_object();
    const ModelInstance* mi = mo->instances[selection.get_instance_idx()];
    const Transform3d   instance_trafo = m_parent.get_canvas_type() == GLCanvas3D::CanvasAssembleView ?
        mi->get_assemble_transformation().get_matrix() :
        mi->get_transformation().get_matrix();
    const Transform3d   instance_trafo_not_translate = m_parent.get_canvas_type() == GLCanvas3D::CanvasAssembleView ?
        mi->get_assemble_transformation().get_matrix_no_offset() :
        mi->get_transformation().get_matrix_no_offset();
 
    for (int mesh_idx = 0; mesh_idx < part_volumes.size(); mesh_idx++) {
        if (mesh_idx == m_rr.mesh_id)
            continue;
 
        const Transform3d& trafo = trafo_matrices[mesh_idx];
        const indexed_triangle_set& its = part_volumes[mesh_idx]->mesh().its;
 
        int first_hit_facet_idx = -1;
        for (int facet_idx = 0; facet_idx < its.indices.size(); facet_idx++) {
            stl_vertex v0 = its.vertices[its.indices[facet_idx].x()];
            stl_vertex v1 = its.vertices[its.indices[facet_idx].y()];
            stl_vertex v2 = its.vertices[its.indices[facet_idx].z()];
 
            float v0_z = (trafo * Vec3d(v0(0), v0(1), v0(2))).z();
            float v1_z = (trafo * Vec3d(v1(0), v1(1), v1(2))).z();
            float v2_z = (trafo * Vec3d(v2(0), v2(1), v2(2))).z();
            bool outside_range = (v0_z < z_bot_world&& v1_z < z_bot_world&& v2_z < z_bot_world) ||
                                 (v0_z > z_top_world && v1_z > z_top_world && v2_z > z_top_world);
            if (!outside_range) {
                first_hit_facet_idx = facet_idx;
                break;
            }
        }
 
        if (first_hit_facet_idx != -1) {
            hit_triangles_by_mesh.push_back({ z_bot_world, mesh_idx, (size_t)first_hit_facet_idx });
        }
    }
 
    return hit_triangles_by_mesh;
}

References Slic3r::GUI::GLCanvas3D::CanvasAssembleView, Slic3r::ModelInstance::get_assemble_transformation(), Slic3r::GUI::Selection::get_instance_idx(), Slic3r::Geometry::Transformation::get_matrix(), Slic3r::Geometry::Transformation::get_matrix_no_offset(), Slic3r::ModelInstance::get_transformation(), Slic3r::ModelObject::instances, Slic3r::GUI::GLGizmoBase::m_c, m_cursor_height, Slic3r::GUI::GLGizmoBase::m_parent, m_rr, Slic3r::resolution(), and update_raycast_cache().

Referenced by gizmo_event().

Here is the call graph for this function:

Here is the caller graph for this function:

get_projected_mouse_positions()

std::vector< std::vector< GLGizmoPainterBase::ProjectedMousePosition > > Slic3r::GUI::GLGizmoPainterBase::get_projected_mouse_positions ( const Vec2d & mouse_position, double resolution, const std::vector< Transform3d > & trafo_matrices ) const

privateinherited

{
    // List of mouse positions that will be used as seeds for painting.
    std::vector<Vec2d> mouse_positions{mouse_position};
    if (m_last_mouse_click != Vec2d::Zero()) {
        // In case current mouse position is far from the last one,
        // add several positions from between into the list, so there
        // are no gaps in the painted region.
        if (size_t patches_in_between = size_t((mouse_position - m_last_mouse_click).norm() / resolution); patches_in_between > 0) {
            const Vec2d diff = (m_last_mouse_click - mouse_position) / (patches_in_between + 1);
            for (size_t patch_idx = 1; patch_idx <= patches_in_between; ++patch_idx)
                mouse_positions.emplace_back(mouse_position + patch_idx * diff);
            mouse_positions.emplace_back(m_last_mouse_click);
        }
    }
 
    const Camera                       &camera = wxGetApp().plater()->get_camera();
    std::vector<ProjectedMousePosition> mesh_hit_points;
    mesh_hit_points.reserve(mouse_positions.size());
 
    // In mesh_hit_points only the last item could have mesh_id == -1, any other items mustn't.
    for (const Vec2d &mp : mouse_positions) {
        update_raycast_cache(mp, camera, trafo_matrices);
        mesh_hit_points.push_back({m_rr.hit, m_rr.mesh_id, m_rr.facet});
        if (m_rr.mesh_id == -1)
            break;
    }
 
    // Divide mesh_hit_points into groups with the same mesh_idx. It may contain multiple groups with the same mesh_idx.
    std::vector<std::vector<ProjectedMousePosition>> mesh_hit_points_by_mesh;
    for (size_t prev_mesh_hit_point = 0, curr_mesh_hit_point = 0; curr_mesh_hit_point < mesh_hit_points.size(); ++curr_mesh_hit_point) {
        size_t next_mesh_hit_point = curr_mesh_hit_point + 1;
        if (next_mesh_hit_point >= mesh_hit_points.size() || mesh_hit_points[curr_mesh_hit_point].mesh_idx != mesh_hit_points[next_mesh_hit_point].mesh_idx) {
            mesh_hit_points_by_mesh.emplace_back();
            mesh_hit_points_by_mesh.back().insert(mesh_hit_points_by_mesh.back().end(), mesh_hit_points.begin() + int(prev_mesh_hit_point), mesh_hit_points.begin() + int(next_mesh_hit_point));
            prev_mesh_hit_point = next_mesh_hit_point;
        }
    }
 
    auto on_same_facet = [](std::vector<ProjectedMousePosition> &hit_points) -> bool {
        for (const ProjectedMousePosition &mesh_hit_point : hit_points)
            if (mesh_hit_point.facet_idx != hit_points.front().facet_idx)
                return false;
        return true;
    };
 
    struct Plane
    {
        Vec3d origin;
        Vec3d first_axis;
        Vec3d second_axis;
    };
    auto find_plane = [](std::vector<ProjectedMousePosition> &hit_points) -> std::optional<Plane> {
        assert(hit_points.size() >= 3);
        for (size_t third_idx = 2; third_idx < hit_points.size(); ++third_idx) {
            const Vec3d &first_point  = hit_points[third_idx - 2].mesh_hit.cast<double>();
            const Vec3d &second_point = hit_points[third_idx - 1].mesh_hit.cast<double>();
            const Vec3d &third_point  = hit_points[third_idx].mesh_hit.cast<double>();
 
            const Vec3d  first_vec    = first_point - second_point;
            const Vec3d  second_vec   = third_point - second_point;
 
            // If three points aren't collinear, then there exists only one plane going through all points.
            if (first_vec.cross(second_vec).squaredNorm() > sqr(EPSILON)) {
                const Vec3d first_axis_vec_n = first_vec.normalized();
                // Make second_vec perpendicular to first_axis_vec_n using Gram–Schmidt orthogonalization process
                const Vec3d second_axis_vec_n = (second_vec - (first_vec.dot(second_vec) / first_vec.dot(first_vec)) * first_vec).normalized();
                return Plane{second_point, first_axis_vec_n, second_axis_vec_n};
            }
        }
 
        return std::nullopt;
    };
 
    for(std::vector<ProjectedMousePosition> &hit_points : mesh_hit_points_by_mesh) {
        assert(!hit_points.empty());
        if (hit_points.back().mesh_idx == -1)
            break;
 
        if (hit_points.size() <= 2)
            continue;
 
        if (on_same_facet(hit_points)) {
            hit_points = {hit_points.front(), hit_points.back()};
        } else if (std::optional<Plane> plane = find_plane(hit_points); plane) {
            Polyline polyline;
            polyline.points.reserve(hit_points.size());
            // Project hit_points into its plane to simplified them in the next step.
            for (auto &hit_point : hit_points) {
                const Vec3d &point  = hit_point.mesh_hit.cast<double>();
                const double x_cord = plane->first_axis.dot(point - plane->origin);
                const double y_cord = plane->second_axis.dot(point - plane->origin);
                polyline.points.emplace_back(scale_(x_cord), scale_(y_cord));
            }
 
            polyline.simplify(scale_(m_cursor_radius) / 10.);
 
            const int                           mesh_idx = hit_points.front().mesh_idx;
            std::vector<ProjectedMousePosition> new_hit_points;
            new_hit_points.reserve(polyline.points.size());
            // Project 2D simplified hit_points beck to 3D.
            for (const Point &point : polyline.points) {
                const double x_cord        = unscale<double>(point.x());
                const double y_cord        = unscale<double>(point.y());
                const Vec3d  new_hit_point = plane->origin + x_cord * plane->first_axis + y_cord * plane->second_axis;
                const int    facet_idx     = m_c->raycaster()->raycasters()[mesh_idx]->get_closest_facet(new_hit_point.cast<float>());
                new_hit_points.push_back({new_hit_point.cast<float>(), mesh_idx, size_t(facet_idx)});
            }
 
            hit_points = new_hit_points;
        } else {
            hit_points = {hit_points.front(), hit_points.back()};
        }
    }
 
    return mesh_hit_points_by_mesh;
}

References Slic3r::diff(), EPSILON, Slic3r::GUI::GLGizmoBase::m_c, m_cursor_radius, m_last_mouse_click, m_rr, Slic3r::Plane, Slic3r::MultiPoint::points, Slic3r::resolution(), scale_, Slic3r::Polyline::simplify(), Slic3r::sqr(), Slic3r::unscale(), and update_raycast_cache().

Referenced by gizmo_event().

Here is the call graph for this function:

Here is the caller graph for this function:

get_requirements()

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

inlineinherited

{ return on_get_requirements(); }

References on_get_requirements().

Here is the call graph for this function:

get_right_button_state_type()

EnforcerBlockerType Slic3r::GUI::GLGizmoFuzzySkin::get_right_button_state_type ( ) const

inlineoverrideprotectedvirtual

Reimplemented from Slic3r::GUI::GLGizmoPainterBase.

{ return EnforcerBlockerType::NONE; }

References Slic3r::NONE.

get_sprite_id()

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

inlineinherited

{ return m_sprite_id; }

References m_sprite_id.

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

Here is the caller graph for this function:

get_state()

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

inlineinherited

{ return m_state; }

References m_state.

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

Here is the caller graph for this function:

get_tilt_up_direction()

Vec3f Slic3r::GUI::GLGizmoPainterBase::get_tilt_up_direction ( ) const

protectedinherited

{
    return build_plate_tilt_up_direction().cast<float>();
}

References Slic3r::GUI::build_plate_tilt_up_direction().

Referenced by gizmo_event(), Slic3r::GUI::GLGizmoTextureDisplacement::render_painted_colors(), and render_triangles().

Here is the call graph for this function:

Here is the caller graph for this function:

get_tooltip()

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

inlinevirtualinherited

Mouse tooltip text.

Returns

Text to be visible in mouse tooltip

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

{ return ""; }

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

Here is the caller graph for this function:

gizmo_event()

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

virtualinherited

{
    Vec2d _mouse_position = mouse_position;
    if (action == SLAGizmoEventType::MouseWheelUp
     || action == SLAGizmoEventType::MouseWheelDown) {
        if (control_down) {
            //BBS
            if (m_tool_type == ToolType::BRUSH && m_cursor_type == TriangleSelector::CursorType::HEIGHT_RANGE) {
                m_cursor_height = action == SLAGizmoEventType::MouseWheelDown ? std::max(m_cursor_height - this->get_cursor_height_step(), this->get_cursor_height_min()) :
                                                                                std::min(m_cursor_height + this->get_cursor_height_step(), this->get_cursor_height_max());
                m_parent.set_as_dirty();
                return true;
            }
 
            if (m_tool_type == ToolType::BRUSH && (m_cursor_type == TriangleSelector::CursorType::SPHERE || m_cursor_type == TriangleSelector::CursorType::CIRCLE)) {
                m_cursor_radius = action == SLAGizmoEventType::MouseWheelDown ? std::max(m_cursor_radius - this->get_cursor_radius_step(), this->get_cursor_radius_min()) :
                                                                                std::min(m_cursor_radius + this->get_cursor_radius_step(), this->get_cursor_radius_max());
                m_parent.set_as_dirty();
                return true;
            }
 
            if (m_tool_type == ToolType::BUCKET_FILL || m_tool_type == ToolType::SMART_FILL) {
                m_smart_fill_angle = action == SLAGizmoEventType::MouseWheelDown ? std::max(m_smart_fill_angle - SmartFillAngleStep, SmartFillAngleMin)
                                                                                : std::min(m_smart_fill_angle + SmartFillAngleStep, SmartFillAngleMax);
                m_parent.set_as_dirty();
                if (m_rr.mesh_id != -1) {
                    const Selection     &selection                 = m_parent.get_selection();
                    const ModelObject   *mo                        = m_c->selection_info()->model_object();
                    const ModelInstance *mi                        = mo->instances[selection.get_instance_idx()];
                    const Transform3d   trafo_matrix_not_translate = m_parent.get_canvas_type() == GLCanvas3D::CanvasAssembleView ?
                        mi->get_assemble_transformation().get_matrix_no_offset() * mo->volumes[m_rr.mesh_id]->get_matrix_no_offset() :
                        mi->get_transformation().get_matrix_no_offset() * mo->volumes[m_rr.mesh_id]->get_matrix_no_offset();
                    const Transform3d   trafo_matrix = m_parent.get_canvas_type() == GLCanvas3D::CanvasAssembleView ?
                        mi->get_assemble_transformation().get_matrix() * mo->volumes[m_rr.mesh_id]->get_matrix() :
                        mi->get_transformation().get_matrix() * mo->volumes[m_rr.mesh_id]->get_matrix();
                    m_triangle_selectors[m_rr.mesh_id]->seed_fill_select_triangles(m_rr.hit, int(m_rr.facet), trafo_matrix_not_translate, this->get_clipping_plane_in_volume_coordinates(trafo_matrix), m_smart_fill_angle,
                                                                                   m_paint_on_overhangs_only ? m_highlight_by_angle_threshold_deg : 0.f, get_tilt_up_direction(), true);
                    m_triangle_selectors[m_rr.mesh_id]->request_update_render_data();
                    m_seed_fill_last_mesh_id = m_rr.mesh_id;
                }
                return true;
            }
 
            if (m_tool_type == ToolType::GAP_FILL) {
                TriangleSelectorPatch::gap_area = action == SLAGizmoEventType::MouseWheelDown ?
                    std::max(TriangleSelectorPatch::gap_area - TriangleSelectorPatch::GapAreaStep, TriangleSelectorPatch::GapAreaMin) :
                    std::min(TriangleSelectorPatch::gap_area + TriangleSelectorPatch::GapAreaStep, TriangleSelectorPatch::GapAreaMax);
                m_parent.set_as_dirty();
                return true;
            }
        }
    }
 
    if (action == SLAGizmoEventType::LeftDown
     || action == SLAGizmoEventType::RightDown
    || (action == SLAGizmoEventType::Dragging && m_button_down != Button::None)) {
 
        if (m_triangle_selectors.empty())
            return false;
 
        EnforcerBlockerType new_state = EnforcerBlockerType::NONE;
        // BBS
        if (action == SLAGizmoEventType::Dragging) {
            if (m_button_down == Button::Right && this->get_right_button_state_type() == EnforcerBlockerType(-1))
                return false;
        }
        else {
            if (action == SLAGizmoEventType::RightDown && this->get_right_button_state_type() == EnforcerBlockerType(-1))
                return false;
        }
 
        if (! shift_down) {
            if (action == SLAGizmoEventType::Dragging)
                new_state = m_button_down == Button::Left ? this->get_left_button_state_type() : this->get_right_button_state_type();
            else
                new_state = action == SLAGizmoEventType::LeftDown ? this->get_left_button_state_type() : this->get_right_button_state_type();
        }
 
        const Camera        &camera                      = wxGetApp().plater()->get_camera();
        const Selection     &selection                   = m_parent.get_selection();
        const ModelObject   *mo                          = m_c->selection_info()->model_object();
        const ModelInstance *mi                          = mo->instances[selection.get_instance_idx()];
        Transform3d   instance_trafo = m_parent.get_canvas_type() == GLCanvas3D::CanvasAssembleView ?
            mi->get_assemble_transformation().get_matrix() :
            mi->get_transformation().get_matrix();
        Transform3d   instance_trafo_not_translate = m_parent.get_canvas_type() == GLCanvas3D::CanvasAssembleView ?
            mi->get_assemble_transformation().get_matrix_no_offset() :
            mi->get_transformation().get_matrix_no_offset();
        std::vector<const ModelVolume*> part_volumes;
 
        // Precalculate transformations of individual meshes.
        std::vector<Transform3d> trafo_matrices;
        std::vector<Transform3d> trafo_matrices_not_translate;
        for (const ModelVolume *mv : mo->volumes)
            if (mv->is_model_part()) {
                if (m_parent.get_canvas_type() == GLCanvas3D::CanvasAssembleView) {
                    Transform3d temp = instance_trafo * mv->get_matrix();
                    temp.translate(mv->get_transformation().get_offset() * (GLVolume::explosion_ratio - 1.0) + mi->get_offset_to_assembly() * (GLVolume::explosion_ratio - 1.0));
                    trafo_matrices.emplace_back(temp);
                }
                else {
                    trafo_matrices.emplace_back(instance_trafo* mv->get_matrix());
                }
                trafo_matrices_not_translate.emplace_back(instance_trafo_not_translate * mv->get_matrix_no_offset());
                part_volumes.push_back(mv);
            }
 
        // BBS
        if (m_tool_type == ToolType::BRUSH && m_cursor_type == TriangleSelector::CursorType::HEIGHT_RANGE)
        {
            std::vector<ProjectedHeightRange> projected_height_range_by_mesh = get_projected_height_range(_mouse_position, 1., part_volumes, trafo_matrices);
            m_last_mouse_click = Vec2d::Zero();
 
            for (int i = 0; i < projected_height_range_by_mesh.size(); i++) {
                const ProjectedHeightRange& phr = projected_height_range_by_mesh[i];
                int mesh_idx = phr.mesh_idx;
 
                // The mouse button click detection is enabled when there is a valid hit.
                // Missing the object entirely
                // shall not capture the mouse.
                const bool dragging_while_painting = (action == SLAGizmoEventType::Dragging && m_button_down != Button::None);
                if (mesh_idx != -1 && m_button_down == Button::None)
                    m_button_down = ((action == SLAGizmoEventType::LeftDown) ? Button::Left : Button::Right);
 
                const Transform3d& trafo_matrix = trafo_matrices[mesh_idx];
                const Transform3d& trafo_matrix_not_translate = trafo_matrices_not_translate[mesh_idx];
 
                // Calculate direction from camera to the hit (in mesh coords):
                Vec3f camera_pos = (trafo_matrix.inverse() * camera.get_position()).cast<float>();
                const TriangleSelector::ClippingPlane& clp = this->get_clipping_plane_in_volume_coordinates(trafo_matrix);
 
                std::unique_ptr<TriangleSelector::Cursor> cursor = TriangleSelector::SinglePointCursor::cursor_factory(phr.z_world,
                    camera_pos, m_cursor_height, trafo_matrix, clp);
                m_triangle_selectors[mesh_idx]->select_patch(int(phr.first_facet_idx), std::move(cursor), new_state, trafo_matrix_not_translate,
                    m_triangle_splitting_enabled, m_paint_on_overhangs_only ? m_highlight_by_angle_threshold_deg : 0.f, get_tilt_up_direction());
 
                m_triangle_selectors[mesh_idx]->request_update_render_data(true);
                m_last_mouse_click = _mouse_position;
            }
 
            return true;
        }
 
        if (action == SLAGizmoEventType::Dragging && m_tool_type == ToolType::BRUSH ){
            if(m_vertical_only)
                _mouse_position.x() = m_last_mouse_click.x();
            else if(m_horizontal_only)
                _mouse_position.y() = m_last_mouse_click.y();
        }
        
        std::vector<std::vector<ProjectedMousePosition>> projected_mouse_positions_by_mesh = get_projected_mouse_positions(_mouse_position, 1., trafo_matrices);
        m_last_mouse_click = Vec2d::Zero(); // only actual hits should be saved
 
        for (const std::vector<ProjectedMousePosition> &projected_mouse_positions : projected_mouse_positions_by_mesh) {
            assert(!projected_mouse_positions.empty());
            const int  mesh_idx                = projected_mouse_positions.front().mesh_idx;
            const bool dragging_while_painting = (action == SLAGizmoEventType::Dragging && m_button_down != Button::None);
 
            // The mouse button click detection is enabled when there is a valid hit.
            // Missing the object entirely
            // shall not capture the mouse.
            if (mesh_idx != -1)
                if (m_button_down == Button::None)
                    m_button_down = ((action == SLAGizmoEventType::LeftDown) ? Button::Left : Button::Right);
 
            // In case we have no valid hit, we can return. The event will be stopped when
            // dragging while painting (to prevent scene rotations and moving the object)
            if (mesh_idx == -1)
                return dragging_while_painting;
 
            const Transform3d &trafo_matrix               = trafo_matrices[mesh_idx];
            const Transform3d &trafo_matrix_not_translate = trafo_matrices_not_translate[mesh_idx];
 
            // Calculate direction from camera to the hit (in mesh coords):
            Vec3f camera_pos = (trafo_matrix.inverse() * camera.get_position()).cast<float>();
 
            assert(mesh_idx < int(m_triangle_selectors.size()));
            const TriangleSelector::ClippingPlane &clp = this->get_clipping_plane_in_volume_coordinates(trafo_matrix);
            if (m_tool_type == ToolType::SMART_FILL || m_tool_type == ToolType::BUCKET_FILL || (m_tool_type == ToolType::BRUSH && m_cursor_type == TriangleSelector::CursorType::POINTER)) {
                for(const ProjectedMousePosition &projected_mouse_position : projected_mouse_positions) {
                    assert(projected_mouse_position.mesh_idx == mesh_idx);
                    const Vec3f mesh_hit = projected_mouse_position.mesh_hit;
                    const int facet_idx = int(projected_mouse_position.facet_idx);
                    m_triangle_selectors[mesh_idx]->seed_fill_apply_on_triangles(new_state);
                    if (m_tool_type == ToolType::SMART_FILL)
                        m_triangle_selectors[mesh_idx]->seed_fill_select_triangles(mesh_hit, facet_idx, trafo_matrix_not_translate, clp, m_smart_fill_angle,
                                                                                       m_paint_on_overhangs_only ? m_highlight_by_angle_threshold_deg : 0.f, get_tilt_up_direction(), true);
                    else if (m_tool_type == ToolType::BRUSH && m_cursor_type == TriangleSelector::CursorType::POINTER)
                        // BBS: add infill_angle parameter
                        m_triangle_selectors[mesh_idx]->bucket_fill_select_triangles(mesh_hit, facet_idx, clp, -1.f, false, true);
                    else if (m_tool_type == ToolType::BUCKET_FILL)
                        // BBS: add infill_angle parameter
                        m_triangle_selectors[mesh_idx]->bucket_fill_select_triangles(mesh_hit, facet_idx, clp, m_smart_fill_angle, true, true);
 
                    m_seed_fill_last_mesh_id = -1;
                }
            } else if (m_tool_type == ToolType::BRUSH) {
                assert(m_cursor_type == TriangleSelector::CursorType::CIRCLE || m_cursor_type == TriangleSelector::CursorType::SPHERE);
 
                if (projected_mouse_positions.size() == 1) {
                    const ProjectedMousePosition             &first_position = projected_mouse_positions.front();
                    std::unique_ptr<TriangleSelector::Cursor> cursor         = TriangleSelector::SinglePointCursor::cursor_factory(first_position.mesh_hit,
                                                                                                                                   camera_pos, m_cursor_radius,
                                                                                                                                   m_cursor_type, trafo_matrix, clp);
                    m_triangle_selectors[mesh_idx]->select_patch(int(first_position.facet_idx), std::move(cursor), new_state, trafo_matrix_not_translate,
                                                                 m_triangle_splitting_enabled, m_paint_on_overhangs_only ? m_highlight_by_angle_threshold_deg : 0.f, get_tilt_up_direction());
                } else {
                    for (auto first_position_it = projected_mouse_positions.cbegin(); first_position_it != projected_mouse_positions.cend() - 1; ++first_position_it) {
                        auto second_position_it = first_position_it + 1;
                        std::unique_ptr<TriangleSelector::Cursor> cursor = TriangleSelector::DoublePointCursor::cursor_factory(first_position_it->mesh_hit, second_position_it->mesh_hit, camera_pos, m_cursor_radius, m_cursor_type, trafo_matrix, clp);
                        m_triangle_selectors[mesh_idx]->select_patch(int(first_position_it->facet_idx), std::move(cursor), new_state, trafo_matrix_not_translate, m_triangle_splitting_enabled, m_paint_on_overhangs_only ? m_highlight_by_angle_threshold_deg : 0.f, get_tilt_up_direction());
                    }
                }
            }
 
            m_triangle_selectors[mesh_idx]->request_update_render_data(true);
 
            m_last_mouse_click = _mouse_position;
        }
 
        return true;
    }
 
    if (action == SLAGizmoEventType::Moving && (m_tool_type == ToolType::SMART_FILL || m_tool_type == ToolType::BUCKET_FILL || (m_tool_type == ToolType::BRUSH && m_cursor_type == TriangleSelector::CursorType::POINTER))) {
        if (m_triangle_selectors.empty())
            return false;
 
        const Camera        &camera                       = wxGetApp().plater()->get_camera();
        const Selection     &selection                    = m_parent.get_selection();
        const ModelObject   *mo                           = m_c->selection_info()->model_object();
        const ModelInstance *mi                           = mo->instances[selection.get_instance_idx()];
        const Transform3d    instance_trafo = m_parent.get_canvas_type() == GLCanvas3D::CanvasAssembleView ?
            mi->get_assemble_transformation().get_matrix() :
            mi->get_transformation().get_matrix();
        const Transform3d    instance_trafo_not_translate = m_parent.get_canvas_type() == GLCanvas3D::CanvasAssembleView ?
            mi->get_assemble_transformation().get_matrix_no_offset() :
            mi->get_transformation().get_matrix_no_offset();
 
        // Precalculate transformations of individual meshes.
        std::vector<Transform3d> trafo_matrices;
        std::vector<Transform3d> trafo_matrices_not_translate;
        for (const ModelVolume *mv : mo->volumes)
            if (mv->is_model_part()) {
                if (m_parent.get_canvas_type() == GLCanvas3D::CanvasAssembleView) {
                    Transform3d temp = instance_trafo * mv->get_matrix();
                    temp.translate(mv->get_transformation().get_offset() * (GLVolume::explosion_ratio - 1.0) + mi->get_offset_to_assembly() * (GLVolume::explosion_ratio - 1.0));
                    trafo_matrices.emplace_back(temp);
                }
                else {
                    trafo_matrices.emplace_back(instance_trafo * mv->get_matrix());
                }
                trafo_matrices_not_translate.emplace_back(instance_trafo_not_translate * mv->get_matrix_no_offset());
            }
 
        // Now "click" into all the prepared points and spill paint around them.
        update_raycast_cache(_mouse_position, camera, trafo_matrices);
 
        auto seed_fill_unselect_all = [this]() {
            for (auto &triangle_selector : m_triangle_selectors) {
                triangle_selector->seed_fill_unselect_all_triangles();
                triangle_selector->request_update_render_data();
            }
        };
 
        if (m_rr.mesh_id == -1) {
            // Clean selected by seed fill for all triangles in all meshes when a mouse isn't pointing on any mesh.
            seed_fill_unselect_all();
            m_seed_fill_last_mesh_id = -1;
 
            // In case we have no valid hit, we can return.
            return false;
        }
 
        // The mouse moved from one object's volume to another one. So it is needed to unselect all triangles selected by seed fill.
        if(m_rr.mesh_id != m_seed_fill_last_mesh_id)
            seed_fill_unselect_all();
 
        const Transform3d &trafo_matrix = trafo_matrices[m_rr.mesh_id];
        const Transform3d &trafo_matrix_not_translate = trafo_matrices_not_translate[m_rr.mesh_id];
 
        assert(m_rr.mesh_id < int(m_triangle_selectors.size()));
        const TriangleSelector::ClippingPlane &clp = this->get_clipping_plane_in_volume_coordinates(trafo_matrix);
        if (m_tool_type == ToolType::SMART_FILL)
            m_triangle_selectors[m_rr.mesh_id]->seed_fill_select_triangles(m_rr.hit, int(m_rr.facet), trafo_matrix_not_translate, clp, m_smart_fill_angle,
                                                                           m_paint_on_overhangs_only ? m_highlight_by_angle_threshold_deg : 0.f, get_tilt_up_direction(), false);
        else if (m_tool_type == ToolType::BRUSH && m_cursor_type == TriangleSelector::CursorType::POINTER)
            // BBS: add infill_angle parameter
            m_triangle_selectors[m_rr.mesh_id]->bucket_fill_select_triangles(m_rr.hit, int(m_rr.facet), clp, -1.f, false);
        else if (m_tool_type == ToolType::BUCKET_FILL)
            // BBS: add infill_angle parameter
            m_triangle_selectors[m_rr.mesh_id]->bucket_fill_select_triangles(m_rr.hit, int(m_rr.facet), clp, m_smart_fill_angle, true);
        m_triangle_selectors[m_rr.mesh_id]->request_update_render_data();
        m_seed_fill_last_mesh_id = m_rr.mesh_id;
        return true;
    }
 
    if ((action == SLAGizmoEventType::LeftUp || action == SLAGizmoEventType::RightUp)
      && m_button_down != Button::None) {
        // Take snapshot and update ModelVolume data.
        wxString action_name = this->handle_snapshot_action_name(shift_down, m_button_down);
        Plater::TakeSnapshot snapshot(wxGetApp().plater(), std::string(action_name.ToUTF8().data()), UndoRedo::SnapshotType::GizmoAction);
        update_model_object();
 
        m_button_down = Button::None;
        m_last_mouse_click = Vec2d::Zero();
        return true;
    }
 
    return false;
}

References BRUSH, BUCKET_FILL, Slic3r::GUI::GLCanvas3D::CanvasAssembleView, Slic3r::TriangleSelector::CIRCLE, Slic3r::TriangleSelector::DoublePointCursor::cursor_factory(), Slic3r::TriangleSelector::SinglePointCursor::cursor_factory(), Slic3r::GUI::Dragging, Slic3r::GLVolume::explosion_ratio, Slic3r::GUI::GLGizmoPainterBase::ProjectedMousePosition::facet_idx, Slic3r::GUI::GLGizmoPainterBase::ProjectedHeightRange::first_facet_idx, Slic3r::GUI::TriangleSelectorPatch::gap_area, GAP_FILL, Slic3r::GUI::TriangleSelectorPatch::GapAreaMax, Slic3r::GUI::TriangleSelectorPatch::GapAreaMin, Slic3r::GUI::TriangleSelectorPatch::GapAreaStep, Slic3r::ModelInstance::get_assemble_transformation(), get_clipping_plane_in_volume_coordinates(), get_cursor_height_max(), get_cursor_height_min(), get_cursor_height_step(), get_cursor_radius_max(), get_cursor_radius_min(), get_cursor_radius_step(), Slic3r::GUI::Selection::get_instance_idx(), get_left_button_state_type(), Slic3r::Geometry::Transformation::get_matrix(), Slic3r::ModelVolume::get_matrix(), Slic3r::Geometry::Transformation::get_matrix_no_offset(), Slic3r::ModelVolume::get_matrix_no_offset(), Slic3r::Geometry::Transformation::get_offset(), Slic3r::ModelInstance::get_offset_to_assembly(), Slic3r::GUI::Camera::get_position(), get_projected_height_range(), get_projected_mouse_positions(), get_right_button_state_type(), get_tilt_up_direction(), Slic3r::ModelInstance::get_transformation(), Slic3r::ModelVolume::get_transformation(), Slic3r::UndoRedo::GizmoAction, handle_snapshot_action_name(), Slic3r::TriangleSelector::HEIGHT_RANGE, Slic3r::ModelObject::instances, Slic3r::ModelVolume::is_model_part(), Left, Slic3r::GUI::LeftDown, Slic3r::GUI::LeftUp, m_button_down, Slic3r::GUI::GLGizmoBase::m_c, m_cursor_height, m_cursor_radius, m_cursor_type, m_highlight_by_angle_threshold_deg, m_horizontal_only, m_last_mouse_click, m_paint_on_overhangs_only, Slic3r::GUI::GLGizmoBase::m_parent, m_rr, m_seed_fill_last_mesh_id, m_smart_fill_angle, m_tool_type, m_triangle_selectors, m_triangle_splitting_enabled, m_vertical_only, Slic3r::GUI::GLGizmoPainterBase::ProjectedMousePosition::mesh_hit, Slic3r::GUI::GLGizmoPainterBase::ProjectedHeightRange::mesh_idx, Slic3r::GUI::MouseWheelDown, Slic3r::GUI::MouseWheelUp, Slic3r::GUI::Moving, Slic3r::NONE, None, Slic3r::GUI::plater(), Slic3r::TriangleSelector::POINTER, Right, Slic3r::GUI::RightDown, Slic3r::GUI::RightUp, SMART_FILL, SmartFillAngleMax, SmartFillAngleMin, SmartFillAngleStep, Slic3r::TriangleSelector::SPHERE, update_model_object(), update_raycast_cache(), Slic3r::ModelObject::volumes, and Slic3r::GUI::GLGizmoPainterBase::ProjectedHeightRange::z_world.

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.

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

Here is the caller graph for this function:

GizmoImguiEnd()

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

protectedinherited

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

References last_input_window_width, and m_imgui.

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

Here is the caller graph for this function:

GizmoImguiSetNextWIndowPos() [1/2]

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

protectedinherited

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

References m_imgui, and m_parent.

GizmoImguiSetNextWIndowPos() [2/2]

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

protectedinherited

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

References GizmoImguiSetNextWIndowPos(), and last_input_window_width.

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

Here is the call graph for this function:

Here is the caller graph for this function:

handle_snapshot_action_name()

wxString Slic3r::GUI::GLGizmoFuzzySkin::handle_snapshot_action_name ( bool shift_down, ButtonButton button_down ) const

overrideprotectedvirtual

Implements Slic3r::GUI::GLGizmoPainterBase.

{
    return shift_down ? _L("Remove fuzzy skin") : _L("Add fuzzy skin");
}

References _L.

init()

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

inlineinherited

{ return on_init(); }

References on_init().

Here is the call graph for this function:

is_activable()

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

inlineinherited

{ return on_is_activable(); }

References on_is_activable().

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

Here is the call graph for this function:

Here is the caller graph for this function:

is_dragging()

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

inlineinherited

{ return m_dragging; }

References m_dragging.

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

Here is the caller graph for this function:

is_in_editing_mode()

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

inlinevirtualinherited

Reimplemented in Slic3r::GUI::GLGizmoCut3D.

{ return false; }

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

Here is the caller graph for this function:

is_mesh_point_clipped()

bool Slic3r::GUI::GLGizmoPainterBase::is_mesh_point_clipped ( const Vec3d & point, const Transform3d & trafo ) const

privateinherited

{
    if (m_c->object_clipper()->get_position() == 0.)
        return false;
 
    auto sel_info = m_c->selection_info();
    Vec3d transformed_point =  trafo * point;
    transformed_point(2) += sel_info->get_sla_shift();
    return m_c->object_clipper()->get_clipping_plane()->is_point_clipped(transformed_point);
}

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

Referenced by update_raycast_cache().

Here is the caller graph for this function:

is_painting()

bool Slic3r::GUI::GLGizmoPainterBase::is_painting ( ) const

inlineprotectedinherited

{ return m_button_down != Button::None; }

References m_button_down, and None.

Referenced by Slic3r::GUI::GLGizmoTextureDisplacement::render_painter_gizmo().

Here is the caller graph for this function:

is_selectable()

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

inlineinherited

{ return on_is_selectable(); }

References on_is_selectable().

Here is the call graph for this function:

is_selection_rectangle_dragging()

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

inlinevirtualinherited

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

{ return false; }

load()

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

inlineinherited

{ m_state = On; on_load(ar); }

References m_state, On, and on_load().

Here is the call graph for this function:

load_render_colors()

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

staticinherited

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

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

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

Here is the call graph for this function:

Here is the caller graph for this function:

mesh_trafo_matrices()

std::vector< Transform3d > Slic3r::GUI::GLGizmoPainterBase::mesh_trafo_matrices ( ) const

privateinherited

{
    const ModelObject* mo = m_c->selection_info()->model_object();
    const Selection& selection = m_parent.get_selection();
    const ModelInstance* mi = mo->instances[selection.get_instance_idx()];
 
    std::vector<Transform3d> trafo_matrices;
    for (const ModelVolume* mv : mo->volumes) {
        if (mv->is_model_part())
        {
            if (m_parent.get_canvas_type() == GLCanvas3D::CanvasAssembleView) {
                Transform3d temp = mi->get_assemble_transformation().get_matrix() * mv->get_matrix();
                temp.translate(mv->get_transformation().get_offset() * (GLVolume::explosion_ratio - 1.0) + mi->get_offset_to_assembly() * (GLVolume::explosion_ratio - 1.0));
                trafo_matrices.emplace_back(temp);
            }
            else {
                trafo_matrices.emplace_back(mi->get_transformation().get_matrix() * mv->get_matrix());
            }
        }
    }
    return trafo_matrices;
}

References Slic3r::GUI::GLCanvas3D::CanvasAssembleView, Slic3r::GLVolume::explosion_ratio, Slic3r::ModelInstance::get_assemble_transformation(), Slic3r::GUI::Selection::get_instance_idx(), Slic3r::Geometry::Transformation::get_matrix(), Slic3r::ModelVolume::get_matrix(), Slic3r::Geometry::Transformation::get_offset(), Slic3r::ModelInstance::get_offset_to_assembly(), Slic3r::ModelInstance::get_transformation(), Slic3r::ModelVolume::get_transformation(), Slic3r::ModelObject::instances, Slic3r::ModelVolume::is_model_part(), Slic3r::GUI::GLGizmoBase::m_c, Slic3r::GUI::GLGizmoBase::m_parent, and Slic3r::ModelObject::volumes.

Referenced by render_cursor(), and render_follows_cursor().

Here is the call graph for this function:

Here is the caller graph for this function:

on_change_color_mode()

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

inlinevirtualinherited

{  m_is_dark_mode = is_dark; }

References is_dark(), and m_is_dark_mode.

Here is the call graph for this function:

on_disable_grabber()

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

inlineprotectedvirtualinherited

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

{}

on_dragging()

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

inlineprotectedvirtualinherited

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

{}

Referenced by use_grabbers().

Here is the caller graph for this function:

on_enable_grabber()

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

inlineprotectedvirtualinherited

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

{}

on_get_name()

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

overrideprotectedvirtual

Implements Slic3r::GUI::GLGizmoBase.

{
    return _u8L("Paint-on fuzzy skin");
}

References _u8L.

on_get_requirements()

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

overrideprotectedvirtualinherited

Reimplemented from Slic3r::GUI::GLGizmoBase.

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

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

on_init()

bool Slic3r::GUI::GLGizmoFuzzySkin::on_init ( )

overrideprivatevirtual

Implements Slic3r::GUI::GLGizmoBase.

{
    m_shortcut = Shortcut::GizmoFuzzySkin;
 
    const wxString ctrl  = GUI::shortkey_ctrl_prefix();
    const wxString shift = GUI::shortkey_shift_prefix();
 
    m_desc["remove_all"]        = _L("Erase all");
    m_desc["circle"]            = _L("Circle");
    m_desc["sphere"]            = _L("Sphere");
    m_desc["pointer"]           = _L("Triangles");
    m_desc["tool_type"]         = _L("Tool type");
    m_desc["tool_brush"]        = _L("Brush");
    m_desc["tool_smart_fill"]   = _L("Smart fill");
    m_desc["cursor_size"]       = _L("Brush size");
    m_desc["add_fuzzy_skin"]    = _L("Add fuzzy skin");
    m_desc["remove_fuzzy_skin"] = _L("Remove fuzzy skin");
    m_desc["smart_fill_angle"]  = _L("Smart fill angle");
 
    std::pair<wxString, wxString> add_fuzzy_skin_shortcut    = {_L("Left mouse button"),         m_desc["add_fuzzy_skin"]};
    std::pair<wxString, wxString> remove_fuzzy_skin_shortcut = {shift + _L("Left mouse button"), m_desc["remove_fuzzy_skin"]};
 
    m_shortcuts_brush = {
        add_fuzzy_skin_shortcut,
        remove_fuzzy_skin_shortcut,
        {ctrl + _L("Mouse wheel"), m_desc["cursor_size"]}
    };
 
    m_shortcuts_triangle = {
        add_fuzzy_skin_shortcut, 
        remove_fuzzy_skin_shortcut
    };
 
    m_shortcuts_smart_fill = {
        add_fuzzy_skin_shortcut,
        remove_fuzzy_skin_shortcut,
        {ctrl + _L("Mouse wheel"), m_desc["smart_fill_angle"]}
    };
 
    return true;
}

References _L, Slic3r::GUI::GizmoFuzzySkin, m_desc, Slic3r::GUI::GLGizmoBase::m_shortcut, m_shortcuts_brush, m_shortcuts_smart_fill, m_shortcuts_triangle, 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::GLGizmoPainterBase::on_is_activable ( ) const

overrideprotectedvirtualinherited

Reimplemented from Slic3r::GUI::GLGizmoBase.

Reimplemented in Slic3r::GUI::GLGizmoTextureDisplacement.

{
    const Selection& selection = m_parent.get_selection();
 
    if (wxGetApp().preset_bundle->printers.get_edited_preset().printer_technology() != ptFFF
        || !selection.is_single_full_instance()/* || wxGetApp().get_mode() == comSimple*/)
        return false;
 
    // BBS
#if 0
    // Check that none of the selected volumes is outside. Only SLA auxiliaries (supports) are allowed outside.
    const Selection::IndicesList& list = selection.get_volume_idxs();
    return std::all_of(list.cbegin(), list.cend(), [&selection](unsigned int idx) { return !selection.get_volume(idx)->is_outside; });
#else
    return true;
#endif
}

References Slic3r::GUI::Selection::get_volume_idxs(), Slic3r::GUI::Selection::is_single_full_instance(), Slic3r::GUI::GLGizmoBase::m_parent, and Slic3r::ptFFF.

Referenced by Slic3r::GUI::GLGizmoTextureDisplacement::on_is_activable().

Here is the call graph for this function:

Here is the caller graph for this function:

on_is_selectable()

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

overrideprotectedvirtualinherited

Reimplemented from Slic3r::GUI::GLGizmoBase.

{
    //BBS
    /*return (wxGetApp().preset_bundle->printers.get_edited_preset().printer_technology() == ptFFF
         && wxGetApp().get_mode() != comSimple );*/
    return (wxGetApp().preset_bundle->printers.get_edited_preset().printer_technology() == ptFFF);
}

References Slic3r::ptFFF.

on_load()

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

overrideprotectedvirtualinherited

Reimplemented from Slic3r::GUI::GLGizmoBase.

{
    // We should update the gizmo from current ModelObject, but it is not
    // possible at this point. That would require having updated selection and
    // common gizmos data, which is not done at this point. Instead, save
    // a flag to do the update in set_painter_gizmo_data, which will be called
    // soon after.
    m_schedule_update = true;
}

References m_schedule_update.

on_mouse()

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

overridevirtualinherited

Implement when want to process mouse events in gizmo Click, Right click, move, drag, ...

Parameters

mouse_event

Keep information about mouse click

Returns

Return True when use the information and don't want to propagate it otherwise False.

Reimplemented from Slic3r::GUI::GLGizmoBase.

Reimplemented in Slic3r::GUI::GLGizmoTextureDisplacement.

{
    // wxCoord == int --> wx/types.h
    Vec2i32 mouse_coord(mouse_event.GetX(), mouse_event.GetY());
    Vec2d mouse_pos = mouse_coord.cast<double>();
 
    if (mouse_event.Moving()) {
        // No button is down, yet a stroke is still open: its release went elsewhere, as a paint drag does not
        // capture the mouse. End the stroke as that release would have.
        if (m_button_down != Button::None)
            gizmo_event(m_button_down == Button::Left ? SLAGizmoEventType::LeftUp : SLAGizmoEventType::RightUp, mouse_pos,
                        mouse_event.ShiftDown(), mouse_event.AltDown(), false);
        gizmo_event(SLAGizmoEventType::Moving, mouse_pos, mouse_event.ShiftDown(), mouse_event.AltDown(), false);
        return false;
    }
 
    // when control is down we allow scene pan and rotation even when clicking
    // over some object
    bool control_down           = mouse_event.CmdDown();
    bool grabber_contains_mouse = (get_hover_id() != -1);
 
    const Selection &selection = m_parent.get_selection();
    int selected_object_idx = selection.get_object_idx();
    if (mouse_event.LeftDown()) {
        if ((!control_down || grabber_contains_mouse) &&            
            gizmo_event(SLAGizmoEventType::LeftDown, mouse_pos, mouse_event.ShiftDown(), mouse_event.AltDown(), false))
            // the gizmo got the event and took some action, there is no need
            // to do anything more
            return true;
    } else if (mouse_event.RightDown()){
        if (!control_down && selected_object_idx != -1 &&
            gizmo_event(SLAGizmoEventType::RightDown, mouse_pos, false, false, false)) 
            // event was taken care of
            return true;
    } else if (mouse_event.Dragging()) {
        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())
                gizmo_event(SLAGizmoEventType::RightUp, mouse_pos, mouse_event.ShiftDown(), mouse_event.AltDown(), true);
            return false;
        }
    } else if (mouse_event.LeftUp()) {
        if (!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(), control_down);
            return true;
        }
    } else if (mouse_event.RightUp()) {
        if (!m_parent.is_mouse_dragging()) {
            gizmo_event(SLAGizmoEventType::RightUp, mouse_pos, mouse_event.ShiftDown(), mouse_event.AltDown(), control_down);
            return true;
        }
    }
    return false;
}

References Slic3r::GUI::Dragging, Slic3r::GUI::GLGizmoBase::get_hover_id(), Slic3r::GUI::Selection::get_object_idx(), gizmo_event(), Left, Slic3r::GUI::LeftDown, Slic3r::GUI::LeftUp, m_button_down, Slic3r::GUI::GLGizmoBase::m_parent, Slic3r::GUI::Moving, None, Slic3r::GUI::RightDown, Slic3r::GUI::RightUp, and Slic3r::GUI::wxMouseEvent.

Referenced by Slic3r::GUI::GLGizmoTextureDisplacement::on_mouse().

Here is the call graph for this function:

Here is the caller graph for this function:

on_opening()

void Slic3r::GUI::GLGizmoFuzzySkin::on_opening ( )

inlineoverrideprivatevirtual

Implements Slic3r::GUI::GLGizmoPainterBase.

{}

on_register_raycasters_for_picking()

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

inlineprotectedvirtualinherited

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

{}

Referenced by register_raycasters_for_picking().

Here is the caller graph for this function:

on_render()

void Slic3r::GUI::GLGizmoPainterBase::on_render ( )

inlineoverrideprivatevirtualinherited

Implements Slic3r::GUI::GLGizmoBase.

{}

on_render_input_window()

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

overrideprotectedvirtual

Reimplemented from Slic3r::GUI::GLGizmoBase.

{
    ModelObject *mo = m_c->selection_info()->model_object();
    if (!mo)
        return;
 
    float  scale       = m_parent.get_scale();
    #ifdef WIN32
        int dpi = get_dpi_for_window(wxGetApp().GetTopWindow());
        scale *= (float) dpi / (float) DPI_DEFAULT;
    #endif // WIN32
 
    const DynamicPrintConfig &obj_cfg = mo->config.get();
 
    const float approx_height = m_imgui->scaled(22.f);
    y = std::min(y, bottom_limit - approx_height);
    //BBS: GUI refactor: move gizmo to the right
#if BBS_TOOLBAR_ON_TOP
    GizmoImguiSetNextWIndowPos(x, y, ImGuiCond_Always, 0.0f, 0.0f);
#else
    GizmoImguiSetNextWIndowPos(x, y, ImGuiCond_Always, 1.0f, 0.0f);
#endif
    //m_imgui->set_next_window_pos(x, y, ImGuiCond_Always);
 
    // BBS
    ImGuiWrapper::push_toolbar_style(m_parent.get_scale());
    float f_scale = m_parent.get_gizmos_manager().get_layout_scale();
    ImGui::PushStyleVar(ImGuiStyleVar_FramePadding, ImVec2(6.0f, 4.0f * f_scale));
 
    GizmoImguiBegin(get_name(), ImGuiWindowFlags_NoMove | ImGuiWindowFlags_AlwaysAutoResize | ImGuiWindowFlags_NoCollapse | ImGuiWindowFlags_NoTitleBar);
 
    // First calculate width of all the texts that are could possibly be shown. We will decide set the dialog width based on that:
    const float space_size = m_imgui->get_style_scaling() * 8;
    const float cursor_slider_left     = m_imgui->calc_text_size(m_desc.at("cursor_size")).x + m_imgui->scaled(1.5f);
    const float smart_fill_slider_left = m_imgui->calc_text_size(m_desc.at("smart_fill_angle")).x + m_imgui->scaled(1.5f);
 
    const float cursor_type_radio_circle  = m_imgui->calc_text_size(m_desc["circle"]).x + m_imgui->scaled(2.5f);
    const float cursor_type_radio_sphere  = m_imgui->calc_text_size(m_desc["sphere"]).x + m_imgui->scaled(2.5f);
    const float cursor_type_radio_pointer = m_imgui->calc_text_size(m_desc["pointer"]).x + m_imgui->scaled(2.5f);
 
    const float buttons_width        = m_imgui->scaled(0.5f);
    const float minimal_slider_width = m_imgui->scaled(4.f);
 
    const float tool_type_radio_left       = m_imgui->calc_text_size(m_desc["tool_type"]).x + m_imgui->scaled(1.f);
    const float tool_type_radio_brush      = m_imgui->calc_text_size(m_desc["tool_brush"]).x + m_imgui->scaled(2.5f);
    const float tool_type_radio_smart_fill = m_imgui->calc_text_size(m_desc["tool_smart_fill"]).x + m_imgui->scaled(2.5f);
 
    float caption_max    = 0.f;
    float total_text_max = 0.f;
    for (const std::string t : {"add_fuzzy_skin", "remove_fuzzy_skin"}) {
        caption_max    = std::max(caption_max, m_imgui->calc_text_size(m_desc[t + "_caption"]).x);
        total_text_max = std::max(total_text_max, m_imgui->calc_text_size(m_desc[t]).x);
    }
    total_text_max += caption_max + m_imgui->scaled(1.f);
    caption_max    += m_imgui->scaled(1.f);
 
    const float sliders_left_width = std::max(smart_fill_slider_left, cursor_slider_left);
    const float slider_icon_width  = m_imgui->get_slider_icon_size().x;
    float window_width = minimal_slider_width + sliders_left_width + slider_icon_width;
    const float empty_button_width = m_imgui->calc_button_size("").x;
 
    window_width                   = std::max(window_width, total_text_max);
    window_width                   = std::max(window_width, cursor_type_radio_circle + cursor_type_radio_sphere + cursor_type_radio_pointer);
    window_width                   = std::max(window_width, tool_type_radio_left + tool_type_radio_brush + tool_type_radio_smart_fill);
    window_width                   = std::max(window_width, 2.f * buttons_width + m_imgui->scaled(1.f));
    
    const float sliders_width = m_imgui->scaled(7.0f);
    const float drag_left_width = ImGui::GetStyle().WindowPadding.x + sliders_width - space_size;
 
    const float max_tooltip_width = ImGui::GetFontSize() * 20.0f;
 
    ImGui::AlignTextToFramePadding();
    m_imgui->text(m_desc["tool_type"]);
 
    std::array<wchar_t, 4> tool_ids;
    tool_ids = { ImGui::CircleButtonIcon, ImGui::SphereButtonIcon, ImGui::TriangleButtonIcon, ImGui::FillButtonIcon };
    std::array<wchar_t, 4> icons;
    if (m_is_dark_mode)
        icons = { ImGui::CircleButtonDarkIcon, ImGui::SphereButtonDarkIcon, ImGui::TriangleButtonDarkIcon, ImGui::FillButtonDarkIcon };
    else
        icons = { ImGui::CircleButtonIcon, ImGui::SphereButtonIcon, ImGui::TriangleButtonIcon, ImGui::FillButtonIcon };
    std::array<wxString, 4> tool_tips = { _L("Circle"), _L("Sphere"), _L("Triangle"), _L("Fill") };
    for (int i = 0; i < tool_ids.size(); i++) {
        //std::string  str_label = std::string("");
        //std::wstring btn_name  = icons[i] + boost::nowide::widen(str_label);
 
        if (i != 0) ImGui::SameLine((empty_button_width + m_imgui->scaled(1.75f)) * i + m_imgui->scaled(1.5f));
 
        bool is_active = m_current_tool == tool_ids[i];
        ImGui::PushStyleVar(ImGuiStyleVar_FrameBorderSize, 1.f);
        ImGui::PushStyleVar(ImGuiStyleVar_FrameRounding  , 3.f * scale);
        ImGui::PushStyleVar(ImGuiStyleVar_FramePadding   , ImVec2(4.f * scale, 4.f * scale));
        ImGui::PushStyleColor(ImGuiCol_Text         , ImVec4(1,1,1,1)); // ORCA Fixes icon rendered without colors while using Light theme
        ImGui::PushStyleColor(ImGuiCol_Button       , is_active ? ImVec4(0.f, .59f, .53f, .25f) : ImVec4(0,0,0,0));         // ORCA
        ImGui::PushStyleColor(ImGuiCol_ButtonHovered, is_active ? ImVec4(0.f, .59f, .53f, .25f) : ImVec4(.6f,.6f,.6f,.2f)); // ORCA
        ImGui::PushStyleColor(ImGuiCol_ButtonActive , is_active ? ImVec4(0.f, .59f, .53f, .30f) : ImVec4(0,0,0,0));         // ORCA
        ImGui::PushStyleColor(ImGuiCol_Border       , is_active ? ImGuiWrapper::COL_ORCA        : ImVec4(0,0,0,0));         // ORCA
        ImGui::PushStyleColor(ImGuiCol_BorderActive , is_active ? ImGuiWrapper::COL_ORCA        : ImVec4(0,0,0,0));         // ORCA matched color for fixing flicker on click
        bool btn_clicked = m_imgui->glyph_button(icons[i], ImVec2(16.f  * scale, 16.f  * scale)); // ORCA glyph_button for fixing unequal paddings
        ImGui::PopStyleColor(6);
        ImGui::PopStyleVar(3);
 
        if (btn_clicked && m_current_tool != tool_ids[i]) {
            m_current_tool = tool_ids[i];
            for (auto &triangle_selector : m_triangle_selectors) {
                triangle_selector->seed_fill_unselect_all_triangles();
                triangle_selector->request_update_render_data();
            }
        }
 
        if (ImGui::IsItemHovered()) {
            m_imgui->tooltip(tool_tips[i], max_tooltip_width);
        }
    }
 
    ImGui::Dummy(ImVec2(0.0f, ImGui::GetFontSize() * 0.1));
 
    if (m_current_tool == ImGui::CircleButtonIcon || m_current_tool == ImGui::SphereButtonIcon) {
        if (m_current_tool == ImGui::CircleButtonIcon)
            m_cursor_type = TriangleSelector::CursorType::CIRCLE;
        else
            m_cursor_type = TriangleSelector::CursorType::SPHERE;
        m_tool_type = ToolType::BRUSH;
 
        ImGui::AlignTextToFramePadding();
        m_imgui->text(m_desc.at("cursor_size"));
        ImGui::SameLine(cursor_slider_left);
        ImGui::PushItemWidth(sliders_width);
        m_imgui->bbl_slider_float_style("##cursor_radius", &m_cursor_radius, CursorRadiusMin, CursorRadiusMax, "%.2f", 1.0f, true);
        ImGui::SameLine(drag_left_width + cursor_slider_left);
        ImGui::PushItemWidth(1.5 * slider_icon_width);
        ImGui::BBLDragFloat("##cursor_radius_input", &m_cursor_radius, 0.05f, 0.0f, 0.0f, "%.2f");
    } else if (m_current_tool == ImGui::TriangleButtonIcon) {
        m_cursor_type = TriangleSelector::CursorType::POINTER;
        m_tool_type   = ToolType::BRUSH;
    } else {
        assert(m_current_tool == ImGui::FillButtonIcon);
        m_cursor_type = TriangleSelector::CursorType::POINTER;
        m_tool_type = ToolType::SMART_FILL;
 
        ImGui::AlignTextToFramePadding();
        m_imgui->text(m_desc["smart_fill_angle"]);
        std::string format_str = std::string("%.f") + I18N::translate_utf8("°",
                                                                            "Face angle threshold,"
                                                                            "placed after the number with no whitespace in between.");
        ImGui::SameLine(sliders_left_width);
        ImGui::PushItemWidth(sliders_width);
        if (m_imgui->bbl_slider_float_style("##smart_fill_angle", &m_smart_fill_angle, SmartFillAngleMin, SmartFillAngleMax,
                                            format_str.data(), 1.0f, true))
            for (auto& triangle_selector : m_triangle_selectors) {
                triangle_selector->seed_fill_unselect_all_triangles();
                triangle_selector->request_update_render_data();
            }
        ImGui::SameLine(drag_left_width + sliders_left_width);
        ImGui::PushItemWidth(1.5 * slider_icon_width);
        ImGui::BBLDragFloat("##smart_fill_angle_input", &m_smart_fill_angle, 0.05f, 0.0f, 0.0f, "%.2f");
    }
 
    ImGui::Separator();
 
    render_tooltip_button(x, y);
 
    ImGui::SameLine();
    m_imgui->disabled_begin(mo->is_fuzzy_skin_painted() == false);
    if (m_imgui->button(m_desc.at("remove_all"))) {
        Plater::TakeSnapshot snapshot(wxGetApp().plater(), _u8L("Reset selection"), UndoRedo::SnapshotType::GizmoAction);
        int                  idx = -1;
        for (ModelVolume *mv : mo->volumes)
            if (mv->is_model_part()) {
                ++idx;
                m_triangle_selectors[idx]->reset();
                m_triangle_selectors[idx]->request_update_render_data(true);
            }
 
        update_model_object();
        m_parent.set_as_dirty();
    }
    m_imgui->disabled_end();
 
    ImGui::SameLine();
    GLGizmoUtils::begin_right_aligned_buttons({_L("Done")});
    if (m_imgui->button(_L("Done"))) {
        m_parent.reset_all_gizmos();
    }
 
    const DynamicPrintConfig &glb_cfg                    = wxGetApp().preset_bundle->prints.get_edited_preset().config;
    const bool                has_object_fuzzy_override  = obj_cfg.option("fuzzy_skin");
    const FuzzySkinType       effective_fuzzy_skin_state = has_object_fuzzy_override ? obj_cfg.opt_enum<FuzzySkinType>("fuzzy_skin")
                                                                                     : glb_cfg.opt_enum<FuzzySkinType>("fuzzy_skin");
    if (effective_fuzzy_skin_state == FuzzySkinType::Disabled_fuzzy) {
        float font_size = ImGui::GetFontSize();
        auto link_text = [&]() {
            ImColor HyperColor = ImGuiWrapper::COL_ORCA;
            ImGui::PushStyleColor(ImGuiCol_Text, ImGuiWrapper::COL_WARNING);
            float parent_width = ImGui::GetContentRegionAvail().x;
            m_imgui->text_wrapped(_L("Warning: Fuzzy skin is disabled, painted fuzzy skin will not take effect!"), parent_width);
            ImGui::PopStyleColor();
            ImGui::PushStyleColor(ImGuiCol_Text, HyperColor.Value);
            ImGui::Dummy(ImVec2(font_size * 1.8f, font_size * 1.3f));
            ImGui::SameLine();
            m_imgui->bold_text(_u8L("Enable painted fuzzy skin for this object"));
            ImGui::PopStyleColor();
            ImVec2 line_end = ImGui::GetItemRectMax();
            line_end.y -= 2.0f;
            ImVec2 line_start = line_end;
            line_start.x = ImGui::GetItemRectMin().x;
            ImGui::GetWindowDrawList()->AddLine(line_start, line_end, HyperColor);
            if (ImGui::IsMouseHoveringRect(ImGui::GetItemRectMin(), ImGui::GetItemRectMax(), true)
                && ImGui::IsMouseClicked(ImGuiMouseButton_Left)) {
                DynamicPrintConfig new_conf = obj_cfg;
                new_conf.set_key_value("fuzzy_skin", new ConfigOptionEnum<FuzzySkinType>(FuzzySkinType::None));
                mo->config.assign_config(new_conf);
            }
        };
        ImGui::Separator();
 
        link_text();
    }
    ImGui::PopStyleVar(1); // ImGuiStyleVar_FramePadding
    GizmoImguiEnd();
 
    // BBS
    ImGuiWrapper::pop_toolbar_style();
}

References _L, _u8L, Slic3r::ModelConfig::assign_config(), Slic3r::GUI::GLGizmoUtils::begin_right_aligned_buttons(), Slic3r::GUI::GLGizmoPainterBase::BRUSH, Slic3r::TriangleSelector::CIRCLE, Slic3r::GUI::ImGuiWrapper::COL_ORCA, Slic3r::GUI::ImGuiWrapper::COL_WARNING, Slic3r::ModelObject::config, Slic3r::GUI::GLGizmoPainterBase::CursorRadiusMax, Slic3r::GUI::GLGizmoPainterBase::CursorRadiusMin, Slic3r::Disabled_fuzzy, Slic3r::GUI::DPI_DEFAULT, Slic3r::ModelConfig::get(), Slic3r::GUI::get_dpi_for_window(), Slic3r::GUI::GLGizmoBase::get_name(), Slic3r::UndoRedo::GizmoAction, Slic3r::GUI::GLGizmoBase::GizmoImguiBegin(), Slic3r::GUI::GLGizmoBase::GizmoImguiEnd(), Slic3r::GUI::GLGizmoBase::GizmoImguiSetNextWIndowPos(), Slic3r::ModelObject::is_fuzzy_skin_painted(), Slic3r::ModelVolume::is_model_part(), Slic3r::GUI::GLGizmoBase::m_c, m_current_tool, Slic3r::GUI::GLGizmoPainterBase::m_cursor_radius, Slic3r::GUI::GLGizmoPainterBase::m_cursor_type, m_desc, Slic3r::GUI::GLGizmoBase::m_imgui, Slic3r::GUI::GLGizmoBase::m_is_dark_mode, Slic3r::GUI::GLGizmoBase::m_parent, Slic3r::GUI::GLGizmoPainterBase::m_smart_fill_angle, Slic3r::GUI::GLGizmoPainterBase::m_tool_type, Slic3r::GUI::GLGizmoPainterBase::m_triangle_selectors, Slic3r::None, Slic3r::DynamicConfig::opt_enum(), Slic3r::ConfigBase::option(), Slic3r::GUI::plater(), Slic3r::TriangleSelector::POINTER, Slic3r::GUI::ImGuiWrapper::pop_toolbar_style(), Slic3r::GUI::ImGuiWrapper::push_toolbar_style(), render_tooltip_button(), scale(), Slic3r::DynamicConfig::set_key_value(), Slic3r::GUI::GLGizmoPainterBase::SMART_FILL, Slic3r::GUI::GLGizmoPainterBase::SmartFillAngleMax, Slic3r::GUI::GLGizmoPainterBase::SmartFillAngleMin, Slic3r::TriangleSelector::SPHERE, Slic3r::GUI::I18N::translate_utf8(), update_model_object(), and Slic3r::ModelObject::volumes.

Here is the call graph for this function:

on_save()

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

inlineoverrideprotectedvirtualinherited

Reimplemented from Slic3r::GUI::GLGizmoBase.

{}

on_set_hover_id()

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

inlineprotectedvirtualinherited

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

{}

Referenced by set_hover_id().

Here is the caller graph for this function:

on_set_state()

void Slic3r::GUI::GLGizmoPainterBase::on_set_state ( )

overrideprotectedvirtualinherited

Reimplemented from Slic3r::GUI::GLGizmoBase.

Reimplemented in Slic3r::GUI::GLGizmoSeam.

{
    if (m_state == m_old_state)
        return;
 
    if (m_state == On && m_old_state != On) { // the gizmo was just turned on
        m_parent.enable_picking(false);
        on_opening();
 
        const Selection& selection = m_parent.get_selection();
        //Camera& camera = wxGetApp().plater()->get_camera();
        //Vec3d rotate_target = selection.get_bounding_box().center();
        //rotate_target(2) = 0.f;
        //Vec3d position = camera.get_position();
        //camera.set_target(rotate_target);
        //camera.look_at(position, rotate_target, Vec3d::UnitZ());
    }
    if (m_state == Off && m_old_state != Off) { // the gizmo was just turned Off
        m_parent.enable_picking(true);
        // we are actually shutting down
        on_shutdown();
        m_old_mo_id = -1;
        //m_iva.release_geometry();
        m_triangle_selectors.clear();
        // A stroke still open goes with the selectors. Its state must not carry into the next session, where the
        // first move would end it as if released and the first press would paint a line from its last position.
        m_button_down      = Button::None;
        m_last_mouse_click = Vec2d::Zero();
 
        //Camera& camera = wxGetApp().plater()->get_camera();
        //camera.look_at(camera.get_position(), m_previous_target, Vec3d::UnitZ());
        //camera.set_target(m_previous_target);
        //camera.recover_from_free_camera();
    }
    m_old_state = m_state;
}

References m_button_down, m_last_mouse_click, m_old_mo_id, m_old_state, Slic3r::GUI::GLGizmoBase::m_parent, Slic3r::GUI::GLGizmoBase::m_state, m_triangle_selectors, None, Slic3r::GUI::GLGizmoBase::Off, Slic3r::GUI::GLGizmoBase::On, on_opening(), and on_shutdown().

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

Here is the call graph for this function:

Here is the caller graph for this function:

on_shutdown()

void Slic3r::GUI::GLGizmoFuzzySkin::on_shutdown ( )

overrideprivatevirtual

Implements Slic3r::GUI::GLGizmoPainterBase.

{
    m_parent.use_slope(false);
    m_parent.toggle_model_objects_visibility(true);
}

References Slic3r::GUI::GLGizmoBase::m_parent.

on_start_dragging()

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

inlineprotectedvirtualinherited

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

{}

Referenced by use_grabbers().

Here is the caller graph for this function:

on_stop_dragging()

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

inlineprotectedvirtualinherited

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

{}

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

Here is the caller graph for this function:

on_tool_shortcut()

virtual bool Slic3r::GUI::GLGizmoPainterBase::on_tool_shortcut ( Shortcut shortcut )

inlinevirtualinherited

Reimplemented in Slic3r::GUI::GLGizmoFdmSupports, Slic3r::GUI::GLGizmoMmuSegmentation, and Slic3r::GUI::GLGizmoSeam.

{ return false; }

References Slic3r::GUI::GLGizmoBase::shortcut().

Here is the call graph for this function:

on_unregister_raycasters_for_picking()

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

inlineprotectedvirtualinherited

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

{}

Referenced by unregister_raycasters_for_picking().

Here is the caller graph for this function:

register_grabbers_for_picking()

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

protectedinherited

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

References m_grabbers, and m_group_id.

Referenced by register_raycasters_for_picking().

Here is the caller graph for this function:

register_raycasters_for_picking()

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

inlineinherited

{ register_grabbers_for_picking(); on_register_raycasters_for_picking(); }

References on_register_raycasters_for_picking(), and register_grabbers_for_picking().

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

Here is the call graph for this function:

Here is the caller graph for this function:

render()

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

inlineinherited

{ on_render(); }

References on_render().

Here is the call graph for this function:

render_combo()

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

protectedinherited

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

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

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

Here is the call graph for this function:

Here is the caller graph for this function:

render_cross_mark()

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

protectedinherited

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

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

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

Here is the call graph for this function:

Here is the caller graph for this function:

render_cursor()

void Slic3r::GUI::GLGizmoPainterBase::render_cursor ( )

protectedinherited

{
    // First check that the mouse pointer is on an object.
    const Camera& camera = wxGetApp().plater()->get_camera();
 
    // Precalculate transformations of individual meshes.
    const std::vector<Transform3d> trafo_matrices = mesh_trafo_matrices();
    // Raycast and return if there's no hit.
    update_raycast_cache(m_parent.get_local_mouse_position(), camera, trafo_matrices);
    if (m_rr.mesh_id == -1)
        return;
 
    if (m_tool_type == ToolType::BRUSH) {
        if (m_cursor_type == TriangleSelector::SPHERE)
            render_cursor_sphere(trafo_matrices[m_rr.mesh_id]);
        else if (m_cursor_type == TriangleSelector::CIRCLE)
            render_cursor_circle();
        else if (m_cursor_type == TriangleSelector::HEIGHT_RANGE)
            render_cursor_height_range(trafo_matrices[m_rr.mesh_id]);
    }
}

References BRUSH, Slic3r::TriangleSelector::CIRCLE, Slic3r::TriangleSelector::HEIGHT_RANGE, m_cursor_type, Slic3r::GUI::GLGizmoBase::m_parent, m_rr, m_tool_type, mesh_trafo_matrices(), render_cursor_circle(), render_cursor_height_range(), render_cursor_sphere(), Slic3r::TriangleSelector::SPHERE, and update_raycast_cache().

Referenced by Slic3r::GUI::GLGizmoFdmSupports::render_painter_gizmo(), Slic3r::GUI::GLGizmoFuzzySkin::render_painter_gizmo(), Slic3r::GUI::GLGizmoMmuSegmentation::render_painter_gizmo(), Slic3r::GUI::GLGizmoSeam::render_painter_gizmo(), and Slic3r::GUI::GLGizmoTextureDisplacement::render_painter_gizmo().

Here is the call graph for this function:

Here is the caller graph for this function:

render_cursor_circle()

void Slic3r::GUI::GLGizmoPainterBase::render_cursor_circle ( )

protectedinherited

{
    const Size cnv_size = m_parent.get_canvas_size();
    const float cnv_width  = float(cnv_size.get_width());
    const float cnv_height = float(cnv_size.get_height());
    if (cnv_width == 0.0f || cnv_height == 0.0f)
        return;
 
    const float cnv_inv_width  = 1.0f / cnv_width;
    const float cnv_inv_height = 1.0f / cnv_height;
 
    const Vec2d center = m_parent.get_local_mouse_position();
    const float zoom = float(wxGetApp().plater()->get_camera().get_zoom());
    const float radius = m_cursor_radius * float(wxGetApp().plater()->get_camera().get_zoom());
 
#if !SLIC3R_OPENGL_ES
    if (!OpenGLManager::get_gl_info().is_core_profile())
        glsafe(::glLineWidth(1.5f));
#endif // !SLIC3R_OPENGL_ES
 
    glsafe(::glDisable(GL_DEPTH_TEST));
 
#if !SLIC3R_OPENGL_ES
    if (!OpenGLManager::get_gl_info().is_core_profile()) {
        glsafe(::glPushAttrib(GL_ENABLE_BIT));
        glsafe(::glLineStipple(4, 0xAAAA));
        glsafe(::glEnable(GL_LINE_STIPPLE));
    }
#endif // !SLIC3R_OPENGL_ES
 
    if (!m_circle.is_initialized() || !m_old_center.isApprox(center) || std::abs(m_old_cursor_radius - radius) > EPSILON) {
        m_old_cursor_radius = radius;
        m_old_center = center;
        m_circle.reset();
 
        GLModel::Geometry init_data;
        unsigned int steps_count = 0;
#if !SLIC3R_OPENGL_ES
        if (OpenGLManager::get_gl_info().is_core_profile()) {
#endif // !SLIC3R_OPENGL_ES
            steps_count = (unsigned int)(2 * (4 + int(252 * (zoom - 1.0f) / (250.0f - 1.0f))));
            init_data.format = { GLModel::Geometry::EPrimitiveType::Lines, GLModel::Geometry::EVertexLayout::P2 };
#if !SLIC3R_OPENGL_ES
        }
        else {
            steps_count = 32;
            init_data.format = { GLModel::Geometry::EPrimitiveType::LineLoop, GLModel::Geometry::EVertexLayout::P2 };
        }
#endif // !SLIC3R_OPENGL_ES
        const float step_size = 2.0f * float(PI) / float(steps_count);
        init_data.color  = { 0.0f, 1.0f, 0.3f, 1.0f };
        init_data.reserve_vertices(steps_count);
        init_data.reserve_indices(steps_count);
 
        // vertices + indices
        for (unsigned int i = 0; i < steps_count; ++i) {
#if !SLIC3R_OPENGL_ES
            if (OpenGLManager::get_gl_info().is_core_profile()) {
#endif // !SLIC3R_OPENGL_ES
                if (i % 2 != 0) continue;
 
                const float angle_i = float(i) * step_size;
                const unsigned int j = (i + 1) % steps_count;
                const float angle_j = float(j) * step_size;
                const Vec2d v_i(::cos(angle_i), ::sin(angle_i));
                const Vec2d v_j(::cos(angle_j), ::sin(angle_j));
                init_data.add_vertex(Vec2f(v_i.x(), v_i.y()));
                init_data.add_vertex(Vec2f(v_j.x(), v_j.y()));
                const size_t vcount = init_data.vertices_count();
                init_data.add_line(vcount - 2, vcount - 1);
#if !SLIC3R_OPENGL_ES
            }
            else {
                const float angle = float(i) * step_size;
                init_data.add_vertex(Vec2f(2.0f * ((center.x() + ::cos(angle) * radius) * cnv_inv_width - 0.5f),
                  -2.0f * ((center.y() + ::sin(angle) * radius) * cnv_inv_height - 0.5f)));
                init_data.add_index(i);
            }
#endif // !SLIC3R_OPENGL_ES
        }
 
        m_circle.init_from(std::move(init_data));
    }
 
    // BBS
    ColorRGBA render_color = this->get_cursor_hover_color();
    if (m_button_down == Button::Left)
        render_color = this->get_cursor_sphere_left_button_color();
    else if (m_button_down == Button::Right)
        render_color = this->get_cursor_sphere_right_button_color();
 
    m_circle.set_color(render_color);
 
#if SLIC3R_OPENGL_ES
    GLShaderProgram* shader = wxGetApp().get_shader("dashed_lines");
#else
    GLShaderProgram* shader = OpenGLManager::get_gl_info().is_core_profile() ? wxGetApp().get_shader("dashed_thick_lines") : wxGetApp().get_shader("flat");
#endif // SLIC3R_OPENGL_ES
    if (shader != nullptr) {
        shader->start_using();
#if !SLIC3R_OPENGL_ES
        if (OpenGLManager::get_gl_info().is_core_profile()) {
#endif // !SLIC3R_OPENGL_ES
            const Transform3d view_model_matrix = Geometry::translation_transform(Vec3d(2.0f * (center.x() * cnv_inv_width - 0.5f), -2.0f * (center.y() * cnv_inv_height - 0.5f), 0.0)) *
                Geometry::scale_transform(Vec3d(2.0f * radius * cnv_inv_width, 2.0f * radius * cnv_inv_height, 1.0f));
            shader->set_uniform("view_model_matrix", view_model_matrix);
#if !SLIC3R_OPENGL_ES
        }
        else
            shader->set_uniform("view_model_matrix", Transform3d::Identity());
#endif // !SLIC3R_OPENGL_ES
        shader->set_uniform("projection_matrix", Transform3d::Identity());
#if !SLIC3R_OPENGL_ES
        if (OpenGLManager::get_gl_info().is_core_profile()) {
#endif // !SLIC3R_OPENGL_ES
            const std::array<int, 4>& viewport = wxGetApp().plater()->get_camera().get_viewport();
            shader->set_uniform("viewport_size", Vec2d(double(viewport[2]), double(viewport[3])));
            shader->set_uniform("width", 0.25f);
            shader->set_uniform("gap_size", 0.0f);
#if !SLIC3R_OPENGL_ES
        }
#endif // !SLIC3R_OPENGL_ES
        m_circle.render();
        shader->stop_using();
    }
 
#if !SLIC3R_OPENGL_ES
    if (!OpenGLManager::get_gl_info().is_core_profile())
        glsafe(::glPopAttrib());
#endif // !SLIC3R_OPENGL_ES
    glsafe(::glEnable(GL_DEPTH_TEST));
}

References Slic3r::GUI::GLModel::Geometry::add_index(), Slic3r::GUI::GLModel::Geometry::add_line(), Slic3r::GUI::GLModel::Geometry::add_vertex(), Slic3r::angle(), Slic3r::center(), Slic3r::GUI::GLModel::Geometry::color, EPSILON, Slic3r::GUI::GLModel::Geometry::format, get_cursor_hover_color(), get_cursor_sphere_left_button_color(), get_cursor_sphere_right_button_color(), Slic3r::GUI::OpenGLManager::get_gl_info(), Slic3r::GUI::Size::get_height(), Slic3r::GUI::Size::get_width(), GL_DEPTH_TEST, GL_ENABLE_BIT, GL_LINE_STIPPLE, glDisable, glEnable, glLineStipple, glLineWidth, glPopAttrib, glPushAttrib, glsafe, Slic3r::GUI::OpenGLManager::GLInfo::is_core_profile(), Left, Slic3r::GUI::GLModel::Geometry::LineLoop, Slic3r::GUI::GLModel::Geometry::Lines, m_button_down, m_circle, m_cursor_radius, m_old_center, m_old_cursor_radius, Slic3r::GUI::GLGizmoBase::m_parent, Slic3r::GUI::GLModel::Geometry::P2, PI, Slic3r::GUI::plater(), Slic3r::GUI::GLModel::Geometry::reserve_indices(), Slic3r::GUI::GLModel::Geometry::reserve_vertices(), Right, Slic3r::Geometry::scale_transform(), Slic3r::GLShaderProgram::set_uniform(), Slic3r::GLShaderProgram::start_using(), Slic3r::GLShaderProgram::stop_using(), Slic3r::Geometry::translation_transform(), and Slic3r::GUI::GLModel::Geometry::vertices_count().

Referenced by render_cursor().

Here is the call graph for this function:

Here is the caller graph for this function:

render_cursor_height_range()

void Slic3r::GUI::GLGizmoPainterBase::render_cursor_height_range ( const Transform3d & trafo ) const

protectedinherited

{
    GLShaderProgram *shader = wxGetApp().get_shader("flat");
    if (shader == nullptr)
        return;
 
    shader->start_using();
 
    const BoundingBoxf3 box = bounding_box();
    Vec3d hit_world = trafo * Vec3d(m_rr.hit(0), m_rr.hit(1), m_rr.hit(2));
    float max_z = (float)box.max.z();
    float min_z = (float)box.min.z();
 
    float cursor_z = std::clamp((float)hit_world.z(), min_z, max_z);
    std::array<float, 2> zs = { cursor_z, std::clamp(cursor_z + m_cursor_height, min_z, max_z) };
 
    const Selection& selection = m_parent.get_selection();
    const ModelObject* model_object = wxGetApp().model().objects[selection.get_object_idx()];
    const ModelInstance* mi = model_object->instances[selection.get_instance_idx()];
 
    int volumes_count = model_object->volumes.size();
    if (m_cut_contours.size() != volumes_count * 2) {
        m_cut_contours.resize(volumes_count * 2);
    }
    m_volumes_index = 0;
    for (const ModelVolume* mv : model_object->volumes) {
        TriangleMesh vol_mesh = mv->mesh();
        if (m_parent.get_canvas_type() == GLCanvas3D::CanvasAssembleView) {
            Transform3d temp = mi->get_assemble_transformation().get_matrix() * mv->get_matrix();
            temp.translate(mv->get_transformation().get_offset() * (GLVolume::explosion_ratio - 1.0) + mi->get_offset_to_assembly() * (GLVolume::explosion_ratio - 1.0));
            vol_mesh.transform(temp);
        }
        else {
            vol_mesh.transform(mi->get_transformation().get_matrix() * mv->get_matrix());
        }
 
        for (int i = 0; i < zs.size(); i++) {
            update_contours(m_volumes_index, vol_mesh, zs[i], max_z, min_z);
 
            const Camera& camera = wxGetApp().plater()->get_camera();
            Transform3d view_model_matrix = camera.get_view_matrix()  * Geometry::assemble_transform(m_cut_contours[m_volumes_index].shift);
 
            shader->set_uniform("view_model_matrix", view_model_matrix);
            shader->set_uniform("projection_matrix", camera.get_projection_matrix());
            // ORCA: OpenGL Core Profile
#if !SLIC3R_OPENGL_ES
            if (!OpenGLManager::get_gl_info().is_core_profile())
                glsafe(::glLineWidth(2.0f));
#endif // !SLIC3R_OPENGL_ES
            m_cut_contours[m_volumes_index].contours.render();
            m_volumes_index++;
        }
 
    }
 
    shader->stop_using();
}

References Slic3r::Geometry::assemble_transform(), bounding_box(), Slic3r::GUI::GLCanvas3D::CanvasAssembleView, Slic3r::GLVolume::explosion_ratio, Slic3r::ModelInstance::get_assemble_transformation(), Slic3r::GUI::OpenGLManager::get_gl_info(), Slic3r::GUI::Selection::get_instance_idx(), Slic3r::Geometry::Transformation::get_matrix(), Slic3r::ModelVolume::get_matrix(), Slic3r::GUI::Selection::get_object_idx(), Slic3r::Geometry::Transformation::get_offset(), Slic3r::ModelInstance::get_offset_to_assembly(), Slic3r::GUI::Camera::get_projection_matrix(), Slic3r::ModelInstance::get_transformation(), Slic3r::ModelVolume::get_transformation(), Slic3r::GUI::Camera::get_view_matrix(), glLineWidth, glsafe, Slic3r::ModelObject::instances, m_cursor_height, m_cut_contours, Slic3r::GUI::GLGizmoBase::m_parent, m_rr, m_volumes_index, Slic3r::BoundingBoxBase< PointType, std::vector< PointType > >::max, Slic3r::ModelVolume::mesh(), Slic3r::BoundingBoxBase< PointType, std::vector< PointType > >::min, Slic3r::GLShaderProgram::set_uniform(), Slic3r::GLShaderProgram::start_using(), Slic3r::GLShaderProgram::stop_using(), Slic3r::TriangleMesh::transform(), update_contours(), and Slic3r::ModelObject::volumes.

Referenced by render_cursor().

Here is the call graph for this function:

Here is the caller graph for this function:

render_cursor_sphere()

void Slic3r::GUI::GLGizmoPainterBase::render_cursor_sphere ( const Transform3d & trafo ) const

protectedinherited

{
    if (s_sphere == nullptr) {
        s_sphere = std::make_shared<GLModel>();
        s_sphere->init_from(its_make_sphere(1.0, double(PI) / 12.0));
    }
 
    GLShaderProgram* shader = wxGetApp().get_shader("flat");
    if (shader == nullptr)
        return;
 
    const Transform3d complete_scaling_matrix_inverse = Geometry::Transformation(trafo).get_scaling_factor_matrix().inverse();
 
    // BBS
    ColorRGBA render_color = this->get_cursor_hover_color();
    if (m_button_down == Button::Left)
        render_color = this->get_cursor_sphere_left_button_color();
    else if (m_button_down == Button::Right)
        render_color = this->get_cursor_sphere_right_button_color();
 
    shader->start_using();
 
    const Camera& camera = wxGetApp().plater()->get_camera();
    Transform3d view_model_matrix = camera.get_view_matrix() * trafo *
        Geometry::assemble_transform(m_rr.hit.cast<double>()) * complete_scaling_matrix_inverse *
        Geometry::assemble_transform(Vec3d::Zero(), Vec3d::Zero(), m_cursor_radius * Vec3d::Ones());
 
    shader->set_uniform("view_model_matrix", view_model_matrix);
    shader->set_uniform("projection_matrix", camera.get_projection_matrix());
 
    const bool is_left_handed = Geometry::Transformation(view_model_matrix).is_left_handed();
    if (is_left_handed)
        glsafe(::glFrontFace(GL_CW));
 
    assert(s_sphere != nullptr);
    s_sphere->set_color(render_color);
    s_sphere->render();
 
    if (is_left_handed)
        glsafe(::glFrontFace(GL_CCW));
 
    shader->stop_using();
}

References Slic3r::Geometry::assemble_transform(), get_cursor_hover_color(), get_cursor_sphere_left_button_color(), get_cursor_sphere_right_button_color(), Slic3r::GUI::Camera::get_projection_matrix(), Slic3r::Geometry::Transformation::get_scaling_factor_matrix(), Slic3r::GUI::Camera::get_view_matrix(), GL_CCW, GL_CW, glFrontFace, glsafe, Slic3r::Geometry::Transformation::is_left_handed(), Slic3r::GUI::is_left_handed(), Slic3r::its_make_sphere(), Left, m_button_down, m_cursor_radius, m_rr, PI, Right, s_sphere, Slic3r::GLShaderProgram::set_uniform(), Slic3r::GLShaderProgram::start_using(), and Slic3r::GLShaderProgram::stop_using().

Referenced by render_cursor().

Here is the call graph for this function:

Here is the caller graph for this function:

render_follows_cursor()

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

overrideprotectedvirtualinherited

Reimplemented from Slic3r::GUI::GLGizmoBase.

{
    // The brush is drawn only where the cursor meets the model. update_raycast_cache() keeps the
    // answer for render_cursor().
    if (m_c->selection_info() == nullptr || m_c->selection_info()->model_object() == nullptr)
        return false;
    update_raycast_cache(m_parent.get_local_mouse_position(), wxGetApp().plater()->get_camera(), mesh_trafo_matrices());
    return m_rr.mesh_id != -1;
}

References Slic3r::GUI::GLGizmoBase::m_c, Slic3r::GUI::GLGizmoBase::m_parent, m_rr, mesh_trafo_matrices(), Slic3r::GUI::plater(), and update_raycast_cache().

Here is the call graph for this function:

render_grabbers() [1/3]

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

protectedinherited

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

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

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

Here is the call graph for this function:

Here is the caller graph for this function:

render_grabbers() [2/3]

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

protectedinherited

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

References m_grabbers, and render_grabbers().

Here is the call graph for this function:

render_grabbers() [3/3]

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

protectedinherited

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

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

Here is the call graph for this function:

render_input_window()

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

inherited

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

References m_first_input_window_render, m_parent, and on_render_input_window().

Here is the call graph for this function:

render_painter_gizmo()

void Slic3r::GUI::GLGizmoFuzzySkin::render_painter_gizmo ( )

overridevirtual

Implements Slic3r::GUI::GLGizmoPainterBase.

{
    const Selection &selection = m_parent.get_selection();
 
    glsafe(::glEnable(GL_BLEND));
    glsafe(::glEnable(GL_DEPTH_TEST));
 
    render_triangles(selection);
    m_c->object_clipper()->render_cut();
    m_c->instances_hider()->render_cut();
    render_cursor();
 
    glsafe(::glDisable(GL_BLEND));
}

References GL_BLEND, GL_DEPTH_TEST, glDisable, glEnable, glsafe, Slic3r::GUI::GLGizmoBase::m_c, Slic3r::GUI::GLGizmoBase::m_parent, Slic3r::GUI::GLGizmoPainterBase::render_cursor(), and Slic3r::GUI::GLGizmoPainterBase::render_triangles().

Here is the call graph for this function:

render_tooltip_button()

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

protected

{
    auto get_shortcuts = [this]() -> std::vector<std::pair<wxString, wxString>> {
        switch (m_tool_type) {
        case ToolType::BRUSH: return m_cursor_type == TriangleSelector::POINTER ? m_shortcuts_triangle : m_shortcuts_brush;
 
        case ToolType::SMART_FILL: return m_shortcuts_smart_fill;
        default: return {};
        }
    };
 
    GLGizmoUtils::render_tooltip_button(m_imgui, m_parent, get_shortcuts(), x, y);
}

References Slic3r::GUI::GLGizmoPainterBase::BRUSH, Slic3r::GUI::GLGizmoPainterBase::m_cursor_type, Slic3r::GUI::GLGizmoBase::m_imgui, Slic3r::GUI::GLGizmoBase::m_parent, m_shortcuts_brush, m_shortcuts_smart_fill, m_shortcuts_triangle, Slic3r::GUI::GLGizmoPainterBase::m_tool_type, Slic3r::TriangleSelector::POINTER, Slic3r::GUI::GLGizmoUtils::render_tooltip_button(), and Slic3r::GUI::GLGizmoPainterBase::SMART_FILL.

Referenced by on_render_input_window().

Here is the call graph for this function:

Here is the caller graph for this function:

render_triangles() [1/2]

void Slic3r::GUI::GLGizmoPainterBase::render_triangles ( const Selection & selection, const ModelVolume * skip = nullptr ) const

protectedvirtualinherited

{
    render_triangles(selection, skip == nullptr ? std::vector<const ModelVolume*>{} : std::vector<const ModelVolume*>{skip});
}

References render_triangles().

Referenced by Slic3r::GUI::GLGizmoFdmSupports::render_painter_gizmo(), Slic3r::GUI::GLGizmoFuzzySkin::render_painter_gizmo(), Slic3r::GUI::GLGizmoMmuSegmentation::render_painter_gizmo(), Slic3r::GUI::GLGizmoSeam::render_painter_gizmo(), Slic3r::GUI::GLGizmoTextureDisplacement::render_painter_gizmo(), and render_triangles().

Here is the call graph for this function:

Here is the caller graph for this function:

render_triangles() [2/2]

void Slic3r::GUI::GLGizmoPainterBase::render_triangles ( const Selection & selection, const std::vector< const ModelVolume * > & skip ) const

protectedinherited

{
    auto* shader = wxGetApp().get_shader("mm_gouraud");
    if (!shader)
        return;
    shader->start_using();
    ScopeGuard guard([shader]() { if (shader) shader->stop_using(); });
 
    ClippingPlaneDataWrapper clp_data = this->get_clipping_plane_data();
    shader->set_uniform("clipping_plane", clp_data.clp_dataf);
    shader->set_uniform("z_range", clp_data.z_range);
 
    // BBS: to improve the random white pixel issue
    glsafe(::glDisable(GL_CULL_FACE));
 
    const ModelObject* mo = m_c->selection_info()->model_object();
    int                mesh_id = -1;
    for (const ModelVolume* mv : mo->volumes) {
        if (!mv->is_model_part())
            continue;
 
        ++mesh_id;
        if (std::find(skip.begin(), skip.end(), mv) != skip.end())
            continue;
 
        Transform3d trafo_matrix;
        if (m_parent.get_canvas_type() == GLCanvas3D::CanvasAssembleView) {
            trafo_matrix = mo->instances[selection.get_instance_idx()]->get_assemble_transformation().get_matrix() * mv->get_matrix();
            trafo_matrix.translate(mv->get_transformation().get_offset() * (GLVolume::explosion_ratio - 1.0) + mo->instances[selection.get_instance_idx()]->get_offset_to_assembly() * (GLVolume::explosion_ratio - 1.0));
        }
        else {
            trafo_matrix = mo->instances[selection.get_instance_idx()]->get_transformation().get_matrix()* mv->get_matrix();
        }
 
        bool is_left_handed = trafo_matrix.matrix().determinant() < 0.;
        if (is_left_handed)
            glsafe(::glFrontFace(GL_CW));
 
        const Camera& camera = wxGetApp().plater()->get_camera();
        const Transform3d& view_matrix = camera.get_view_matrix();
        shader->set_uniform("view_model_matrix", view_matrix * trafo_matrix);
        shader->set_uniform("projection_matrix", camera.get_projection_matrix());
        const Matrix3d view_normal_matrix = view_matrix.matrix().block(0, 0, 3, 3) * trafo_matrix.matrix().block(0, 0, 3, 3).inverse().transpose();
        shader->set_uniform("view_normal_matrix", view_normal_matrix);
 
        float normal_z = -::cos(Geometry::deg2rad(m_highlight_by_angle_threshold_deg));
        Matrix3f normal_matrix = static_cast<Matrix3f>(trafo_matrix.matrix().block(0, 0, 3, 3).inverse().transpose().cast<float>());
 
        // Compute up direction accounting for build plate tilt
        Vec3f up_direction = get_tilt_up_direction();
 
        shader->set_uniform("volume_world_matrix", trafo_matrix);
        shader->set_uniform("volume_mirrored", is_left_handed);
        shader->set_uniform("slope.actived", m_parent.is_using_slope());
        shader->set_uniform("slope.volume_world_normal_matrix", normal_matrix);
        shader->set_uniform("slope.normal_z", normal_z);
        shader->set_uniform("slope.up_direction", up_direction);
        m_triangle_selectors[mesh_id]->render(m_imgui, trafo_matrix);
 
        if (is_left_handed)
            glsafe(::glFrontFace(GL_CCW));
    }
}

References Slic3r::GUI::GLCanvas3D::CanvasAssembleView, Slic3r::cast(), Slic3r::Geometry::deg2rad(), Slic3r::GLVolume::explosion_ratio, get_clipping_plane_data(), Slic3r::GUI::Selection::get_instance_idx(), Slic3r::ModelVolume::get_matrix(), Slic3r::Geometry::Transformation::get_offset(), Slic3r::GUI::Camera::get_projection_matrix(), get_tilt_up_direction(), Slic3r::ModelVolume::get_transformation(), Slic3r::GUI::Camera::get_view_matrix(), GL_CCW, GL_CULL_FACE, GL_CW, glDisable, glFrontFace, glsafe, Slic3r::ModelObject::instances, Slic3r::GUI::is_left_handed(), Slic3r::ModelVolume::is_model_part(), Slic3r::GUI::GLGizmoBase::m_c, m_highlight_by_angle_threshold_deg, Slic3r::GUI::GLGizmoBase::m_imgui, Slic3r::GUI::GLGizmoBase::m_parent, m_triangle_selectors, and Slic3r::ModelObject::volumes.

Here is the call graph for this function:

save()

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

inlineinherited

{ on_save(ar); }

References on_save().

Here is the call graph for this function:

set_common_data_pool()

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

inlineinherited

{ m_c = ptr; }

References m_c.

set_dirty()

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

protectedinherited

                            {
    m_dirty = true;
}

References m_dirty.

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

Here is the caller graph for this function:

set_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

{ m_state = state; on_set_state(); }

References m_state, and on_set_state().

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

Here is the call graph for this function:

Here is the caller graph for this function:

shortcut()

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

inlineinherited

{ return m_shortcut; }

References m_shortcut.

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

Here is the caller graph for this function:

unregister_grabbers_for_picking()

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

protectedinherited

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

References m_grabbers.

Referenced by unregister_raycasters_for_picking().

Here is the caller graph for this function:

unregister_raycasters_for_picking()

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

inlineinherited

{ unregister_grabbers_for_picking(); on_unregister_raycasters_for_picking(); }

References on_unregister_raycasters_for_picking(), and unregister_grabbers_for_picking().

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

Here is the call graph for this function:

Here is the caller graph for this function:

update_contours()

void Slic3r::GUI::GLGizmoPainterBase::update_contours ( int i, const TriangleMesh & vol_mesh, float cursor_z, float max_z, float min_z ) const

privateinherited

{
    const Selection& selection = m_parent.get_selection();
    const GLVolume* first_glvolume = selection.get_first_volume();
    const BoundingBoxf3& box = first_glvolume->transformed_convex_hull_bounding_box();
 
    const ModelObject* model_object = wxGetApp().model().objects[selection.get_object_idx()];
    const int instance_idx = selection.get_instance_idx();
 
        if (min_z < cursor_z && cursor_z < max_z) {
            if (m_cut_contours[i].cut_z != cursor_z || m_cut_contours[i].object_id != model_object->id() || m_cut_contours[i].instance_idx != instance_idx) {
                m_cut_contours[i].cut_z = cursor_z;
 
                m_cut_contours[i].mesh = vol_mesh;
 
                m_cut_contours[i].position = box.center();
                m_cut_contours[i].shift = Vec3d::Zero();
                m_cut_contours[i].object_id = model_object->id();
                m_cut_contours[i].instance_idx = instance_idx;
                m_cut_contours[i].contours.reset();
 
                MeshSlicingParams slicing_params;
                slicing_params.trafo = Transform3d::Identity().matrix();
                const Polygons polys = slice_mesh(m_cut_contours[i].mesh.its, cursor_z, slicing_params);
                if (!polys.empty()) {
                    m_cut_contours[i].contours.init_from(polys, static_cast<float>(cursor_z));
                    m_cut_contours[i].contours.set_color({ 1.0f, 1.0f, 1.0f, 1.0f });
                }
            }
            else if (box.center() != m_cut_contours[i].position) {
                m_cut_contours[i].shift = box.center() - m_cut_contours[i].position;
            }
        }
        else
            m_cut_contours[i].contours.reset();
}

References Slic3r::BoundingBox3Base< PointType >::center(), Slic3r::GUI::Selection::get_first_volume(), Slic3r::GUI::Selection::get_instance_idx(), Slic3r::GUI::Selection::get_object_idx(), Slic3r::ObjectBase::id(), m_cut_contours, Slic3r::GUI::GLGizmoBase::m_parent, Slic3r::slice_mesh(), Slic3r::MeshSlicingParams::trafo, and Slic3r::GLVolume::transformed_convex_hull_bounding_box().

Referenced by render_cursor_height_range().

Here is the call graph for this function:

Here is the caller graph for this function:

update_from_model_object()

void Slic3r::GUI::GLGizmoFuzzySkin::update_from_model_object ( bool first_update )

overrideprivatevirtual

Implements Slic3r::GUI::GLGizmoPainterBase.

{
    wxBusyCursor wait;
 
    const ModelObject *mo = m_c->selection_info()->model_object();
    m_triangle_selectors.clear();
 
    int volume_id = -1;
    std::vector<ColorRGBA> ebt_colors;
    ebt_colors.push_back(GLVolume::NEUTRAL_COLOR);
    ebt_colors.push_back(TriangleSelectorGUI::enforcers_color);
    ebt_colors.push_back(TriangleSelectorGUI::blockers_color);
    for (const ModelVolume *mv : mo->volumes) {
        if (!mv->is_model_part())
            continue;
 
        ++volume_id;
 
        // This mesh does not account for the possible Z up SLA offset.
        const TriangleMesh* mesh = &mv->mesh();
        m_triangle_selectors.emplace_back(std::make_unique<TriangleSelectorPatch>(*mesh, ebt_colors));
        // Reset of TriangleSelector is done inside TriangleSelectorGUI's constructor, so we don't need it to perform it again in deserialize().
        // Fuzzy skin paints a single state (FUZZY_SKIN): a higher state in the file is reset to NONE.
        m_triangle_selectors.back()->deserialize(mv->fuzzy_skin_facets.get_data(), false, EnforcerBlockerType::FUZZY_SKIN);
        m_triangle_selectors.back()->request_update_render_data();
    }
}

References Slic3r::GUI::TriangleSelectorGUI::blockers_color, Slic3r::GUI::TriangleSelectorGUI::enforcers_color, Slic3r::FUZZY_SKIN, Slic3r::ModelVolume::fuzzy_skin_facets, Slic3r::FacetsAnnotation::get_data(), Slic3r::ModelVolume::is_model_part(), Slic3r::GUI::GLGizmoBase::m_c, Slic3r::GUI::GLGizmoPainterBase::m_triangle_selectors, Slic3r::ModelVolume::mesh(), Slic3r::GLVolume::NEUTRAL_COLOR, and Slic3r::ModelObject::volumes.

Here is the call 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_model_object()

void Slic3r::GUI::GLGizmoFuzzySkin::update_model_object ( )

overrideprivatevirtual

Implements Slic3r::GUI::GLGizmoPainterBase.

{
    bool         updated = false;
    ModelObject *mo      = m_c->selection_info()->model_object();
    int          idx     = -1;
    for (ModelVolume *mv : mo->volumes) {
        if (!mv->is_model_part())
            continue;
 
        ++idx;
        updated |= mv->fuzzy_skin_facets.set(*m_triangle_selectors[idx]);
    }
 
    if (updated) {
        const ModelObjectPtrs &mos = wxGetApp().model().objects;
        wxGetApp().obj_list()->update_info_items(std::find(mos.begin(), mos.end(), mo) - mos.begin());
 
        m_parent.post_event(SimpleEvent(EVT_GLCANVAS_SCHEDULE_BACKGROUND_PROCESS));
    }
}

References Slic3r::ModelVolume::fuzzy_skin_facets, Slic3r::ModelVolume::is_model_part(), Slic3r::GUI::GLGizmoBase::m_c, Slic3r::GUI::GLGizmoBase::m_parent, Slic3r::GUI::GLGizmoPainterBase::m_triangle_selectors, Slic3r::FacetsAnnotation::set(), and Slic3r::ModelObject::volumes.

Referenced by on_render_input_window().

Here is the call graph for this function:

Here is the caller graph for this function:

update_raycast_cache()

void Slic3r::GUI::GLGizmoPainterBase::update_raycast_cache ( const Vec2d & mouse_position, const Camera & camera, const std::vector< Transform3d > & trafo_matrices ) const

privateinherited

{
    if (m_rr.mouse_position == mouse_position) {
        // Same query as last time - the answer is already in the cache.
        return;
    }
 
    Vec3f normal =  Vec3f::Zero();
    Vec3f hit = Vec3f::Zero();
    size_t facet = 0;
    Vec3f closest_hit = Vec3f::Zero();
    double closest_hit_squared_distance = std::numeric_limits<double>::max();
    size_t closest_facet = 0;
    int closest_hit_mesh_id = -1;
 
    // Cast a ray on all meshes, pick the closest hit and save it for the respective mesh
    for (int mesh_id = 0; mesh_id < int(trafo_matrices.size()); ++mesh_id) {
 
        if (m_c->raycaster()->raycasters()[mesh_id]->unproject_on_mesh(
                   mouse_position,
                   trafo_matrices[mesh_id],
                   camera,
                   hit,
                   normal,
                   m_c->object_clipper()->get_clipping_plane(),
                   &facet,
                   m_parent.get_canvas_type() != GLCanvas3D::CanvasAssembleView))
        {
            // In case this hit is clipped, skip it.
            if (is_mesh_point_clipped(hit.cast<double>(), trafo_matrices[mesh_id]))
                continue;
 
            // Is this hit the closest to the camera so far?
            double hit_squared_distance = (camera.get_position()-trafo_matrices[mesh_id]*hit.cast<double>()).squaredNorm();
            if (hit_squared_distance < closest_hit_squared_distance) {
                closest_hit_squared_distance = hit_squared_distance;
                closest_facet = facet;
                closest_hit_mesh_id = mesh_id;
                closest_hit = hit;
            }
        }
    }
 
    m_rr = {mouse_position, closest_hit_mesh_id, closest_hit, closest_facet};
}

References Slic3r::GUI::GLCanvas3D::CanvasAssembleView, Slic3r::GUI::Camera::get_position(), is_mesh_point_clipped(), Slic3r::GUI::GLGizmoBase::m_c, Slic3r::GUI::GLGizmoBase::m_parent, m_rr, and Slic3r::normal().

Referenced by get_projected_height_range(), get_projected_mouse_positions(), gizmo_event(), render_cursor(), and render_follows_cursor().

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:

wants_enter_leave_snapshots()

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

inlineoverrideprotectedvirtualinherited

Reimplemented from Slic3r::GUI::GLGizmoBase.

{ return true; }

Member Data Documentation

AXES_COLOR

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

staticinherited

Initial value:

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

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

AXES_HOVER_COLOR

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

staticinherited

Initial value:

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

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

BASE_ID

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

staticinherited

CONSTRAINED_COLOR

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

staticinherited

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

count

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

privateinherited

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

CursorHeightMax

float Slic3r::GUI::GLGizmoPainterBase::CursorHeightMax = 8.f

staticconstexprprotectedinherited

Referenced by get_cursor_height_max(), and Slic3r::GUI::GLGizmoMmuSegmentation::on_render_input_window().

CursorHeightMin

float Slic3r::GUI::GLGizmoPainterBase::CursorHeightMin = 0.1f

staticconstexprprotectedinherited

Referenced by get_cursor_height_min(), and Slic3r::GUI::GLGizmoMmuSegmentation::on_render_input_window().

CursorHeightStep

float Slic3r::GUI::GLGizmoPainterBase::CursorHeightStep = 0.2f

staticconstexprprotectedinherited

Referenced by get_cursor_height_step().

CursorRadiusMax

float Slic3r::GUI::GLGizmoPainterBase::CursorRadiusMax = 8.f

staticconstexprprotectedinherited

Referenced by get_cursor_radius_max(), Slic3r::GUI::GLGizmoFdmSupports::on_render_input_window(), Slic3r::GUI::GLGizmoFuzzySkin::on_render_input_window(), Slic3r::GUI::GLGizmoMmuSegmentation::on_render_input_window(), Slic3r::GUI::GLGizmoSeam::on_render_input_window(), and Slic3r::GUI::GLGizmoTextureDisplacement::on_render_input_window().

CursorRadiusMin

float Slic3r::GUI::GLGizmoPainterBase::CursorRadiusMin = 0.4f

staticconstexprprotectedinherited

Referenced by get_cursor_radius_min(), Slic3r::GUI::GLGizmoFdmSupports::on_render_input_window(), Slic3r::GUI::GLGizmoFuzzySkin::on_render_input_window(), and Slic3r::GUI::GLGizmoTextureDisplacement::on_render_input_window().

CursorRadiusStep

float Slic3r::GUI::GLGizmoPainterBase::CursorRadiusStep = 0.2f

staticconstexprprotectedinherited

Referenced by get_cursor_radius_step().

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_button_down

ButtonButton Slic3r::GUI::GLGizmoPainterBase::m_button_down = Button::None

privateinherited

Referenced by gizmo_event(), is_painting(), on_mouse(), on_set_state(), render_cursor_circle(), and render_cursor_sphere().

m_c

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

protectedinherited

{ nullptr };

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

m_circle

GLModel Slic3r::GUI::GLGizmoPainterBase::m_circle

protectedinherited

Referenced by render_cursor_circle().

m_current_tool

wchar_t Slic3r::GUI::GLGizmoFuzzySkin::m_current_tool = 0

protected

Referenced by GLGizmoFuzzySkin(), and on_render_input_window().

m_cursor_height

float Slic3r::GUI::GLGizmoPainterBase::m_cursor_height = 0.2f

protectedinherited

Referenced by get_projected_height_range(), gizmo_event(), Slic3r::GUI::GLGizmoMmuSegmentation::on_render_input_window(), and render_cursor_height_range().

m_cursor_radius

float Slic3r::GUI::GLGizmoPainterBase::m_cursor_radius = 1.f

protectedinherited

Referenced by get_projected_mouse_positions(), gizmo_event(), Slic3r::GUI::GLGizmoFdmSupports::on_render_input_window(), Slic3r::GUI::GLGizmoFuzzySkin::on_render_input_window(), Slic3r::GUI::GLGizmoMmuSegmentation::on_render_input_window(), Slic3r::GUI::GLGizmoSeam::on_render_input_window(), Slic3r::GUI::GLGizmoTextureDisplacement::on_render_input_window(), render_cursor_circle(), and render_cursor_sphere().

m_cursor_type

TriangleSelector::CursorType Slic3r::GUI::GLGizmoPainterBase::m_cursor_type = TriangleSelector::SPHERE

protectedinherited

Referenced by Slic3r::GUI::GLGizmoFdmSupports::GLGizmoFdmSupports(), gizmo_event(), Slic3r::GUI::GLGizmoFdmSupports::on_render_input_window(), Slic3r::GUI::GLGizmoFuzzySkin::on_render_input_window(), Slic3r::GUI::GLGizmoMmuSegmentation::on_render_input_window(), Slic3r::GUI::GLGizmoSeam::on_render_input_window(), Slic3r::GUI::GLGizmoTextureDisplacement::on_render_input_window(), render_cursor(), Slic3r::GUI::GLGizmoTextureDisplacement::render_painter_gizmo(), and Slic3r::GUI::GLGizmoFuzzySkin::render_tooltip_button().

m_cursor_z

float Slic3r::GUI::GLGizmoPainterBase::m_cursor_z {0}

mutableprivateinherited

{0};

m_cut_contours

std::vector<CutContours> Slic3r::GUI::GLGizmoPainterBase::m_cut_contours

mutableprivateinherited

Referenced by render_cursor_height_range(), and update_contours().

m_desc

std::map<std::string, wxString> Slic3r::GUI::GLGizmoFuzzySkin::m_desc

private

Referenced by on_init(), and on_render_input_window().

m_dirty

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

privateinherited

{ false };

Referenced by set_dirty(), and update_items_state().

m_dragging

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

protectedinherited

{ false };

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

m_first_input_window_render

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

protectedinherited

{ true };

Referenced by render_input_window().

m_grabbers

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

mutableprotectedinherited

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

m_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_height_start_pos

Vec2i32 Slic3r::GUI::GLGizmoPainterBase::m_height_start_pos {0, 0}

mutableprivateinherited

{0, 0};

m_height_start_z_in_imgui

double Slic3r::GUI::GLGizmoPainterBase::m_height_start_z_in_imgui {0}

mutableprivateinherited

{0};

m_highlight_by_angle_threshold_deg

float Slic3r::GUI::GLGizmoPainterBase::m_highlight_by_angle_threshold_deg = 0.f

protectedinherited

Referenced by gizmo_event(), Slic3r::GUI::GLGizmoFdmSupports::on_render_input_window(), Slic3r::GUI::GLGizmoFdmSupports::on_shutdown(), Slic3r::GUI::GLGizmoTextureDisplacement::render_painted_colors(), and render_triangles().

m_horizontal_only

bool Slic3r::GUI::GLGizmoPainterBase::m_horizontal_only = false

protectedinherited

Referenced by GLGizmoPainterBase(), gizmo_event(), Slic3r::GUI::GLGizmoFdmSupports::on_render_input_window(), and Slic3r::GUI::GLGizmoMmuSegmentation::on_render_input_window().

m_hover_id

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

protectedinherited

{ -1 };

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

m_icon_filename

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

protectedinherited

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

m_imgui

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

protectedinherited

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

m_internal_stack_active

bool Slic3r::GUI::GLGizmoPainterBase::m_internal_stack_active = false

privateinherited

m_is_cursor_in_imgui

bool Slic3r::GUI::GLGizmoPainterBase::m_is_cursor_in_imgui {false}

mutableprivateinherited

{false};

m_is_dark_mode

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

protectedinherited

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

m_is_set_height_start_z_by_imgui

bool Slic3r::GUI::GLGizmoPainterBase::m_is_set_height_start_z_by_imgui {false}

mutableprivateinherited

{false};

m_last_mouse_click

Vec2d Slic3r::GUI::GLGizmoPainterBase::m_last_mouse_click = Vec2d::Zero()

privateinherited

Referenced by get_projected_mouse_positions(), gizmo_event(), and on_set_state().

m_old_center

Vec2d Slic3r::GUI::GLGizmoPainterBase::m_old_center { Vec2d::Zero() }

protectedinherited

{ Vec2d::Zero() };

Referenced by render_cursor_circle().

m_old_cursor_radius

float Slic3r::GUI::GLGizmoPainterBase::m_old_cursor_radius { 0.0f }

protectedinherited

{ 0.0f };

Referenced by render_cursor_circle().

m_old_mo_id

ObjectID Slic3r::GUI::GLGizmoPainterBase::m_old_mo_id

privateinherited

Referenced by data_changed(), and on_set_state().

m_old_state

EState Slic3r::GUI::GLGizmoPainterBase::m_old_state = Off

privateinherited

Referenced by on_set_state().

m_old_volumes_size

size_t Slic3r::GUI::GLGizmoPainterBase::m_old_volumes_size = 0

privateinherited

Referenced by data_changed().

m_paint_on_overhangs_only

bool Slic3r::GUI::GLGizmoPainterBase::m_paint_on_overhangs_only = false

protectedinherited

Referenced by gizmo_event(), and Slic3r::GUI::GLGizmoFdmSupports::on_render_input_window().

m_parent

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

protectedinherited

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

m_rr

RaycastResult Slic3r::GUI::GLGizmoPainterBase::m_rr = {Vec2d::Zero(), -1, Vec3f::Zero(), 0}

mutableprivateinherited

{Vec2d::Zero(), -1, Vec3f::Zero(), 0};

Referenced by get_projected_height_range(), get_projected_mouse_positions(), gizmo_event(), render_cursor(), render_cursor_height_range(), render_cursor_sphere(), render_follows_cursor(), and update_raycast_cache().

m_schedule_update

bool Slic3r::GUI::GLGizmoPainterBase::m_schedule_update = false

privateinherited

Referenced by data_changed(), and on_load().

m_seed_fill_last_mesh_id

int Slic3r::GUI::GLGizmoPainterBase::m_seed_fill_last_mesh_id = -1

protectedinherited

Referenced by gizmo_event(), Slic3r::GUI::GLGizmoTextureDisplacement::on_shutdown(), Slic3r::GUI::GLGizmoTextureDisplacement::render_painter_gizmo(), and Slic3r::GUI::GLGizmoTextureDisplacement::update_from_model_object().

m_shortcut

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

protectedinherited

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

m_shortcuts_brush

std::vector<std::pair<wxString, wxString> > Slic3r::GUI::GLGizmoFuzzySkin::m_shortcuts_brush

private

Referenced by on_init(), and render_tooltip_button().

m_shortcuts_smart_fill

std::vector<std::pair<wxString, wxString> > Slic3r::GUI::GLGizmoFuzzySkin::m_shortcuts_smart_fill

private

Referenced by on_init(), and render_tooltip_button().

m_shortcuts_triangle

std::vector<std::pair<wxString, wxString> > Slic3r::GUI::GLGizmoFuzzySkin::m_shortcuts_triangle

private

Referenced by on_init(), and render_tooltip_button().

m_smart_fill_angle

float Slic3r::GUI::GLGizmoPainterBase::m_smart_fill_angle = 30.f

protectedinherited

Referenced by gizmo_event(), Slic3r::GUI::GLGizmoFdmSupports::on_render_input_window(), Slic3r::GUI::GLGizmoFuzzySkin::on_render_input_window(), Slic3r::GUI::GLGizmoMmuSegmentation::on_render_input_window(), and Slic3r::GUI::GLGizmoTextureDisplacement::on_render_input_window().

m_sprite_id

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

protectedinherited

Referenced by GLGizmoBase(), and get_sprite_id().

m_state

EState Slic3r::GUI::GLGizmoBase::m_state

protectedinherited

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

m_tool_type

ToolType Slic3r::GUI::GLGizmoPainterBase::m_tool_type = ToolType::BRUSH

protectedinherited

Referenced by Slic3r::GUI::GLGizmoFdmSupports::GLGizmoFdmSupports(), gizmo_event(), Slic3r::GUI::GLGizmoFdmSupports::on_render_input_window(), Slic3r::GUI::GLGizmoFuzzySkin::on_render_input_window(), Slic3r::GUI::GLGizmoMmuSegmentation::on_render_input_window(), Slic3r::GUI::GLGizmoSeam::on_render_input_window(), Slic3r::GUI::GLGizmoTextureDisplacement::on_render_input_window(), render_cursor(), Slic3r::GUI::GLGizmoTextureDisplacement::render_painter_gizmo(), Slic3r::GUI::GLGizmoFuzzySkin::render_tooltip_button(), and Slic3r::GUI::GLGizmoMmuSegmentation::render_tooltip_button().

m_triangle_selectors

std::vector<std::unique_ptr<TriangleSelectorGUI> > Slic3r::GUI::GLGizmoPainterBase::m_triangle_selectors

protectedinherited

Referenced by gizmo_event(), Slic3r::GUI::GLGizmoMmuSegmentation::init_model_triangle_selectors(), Slic3r::GUI::GLGizmoFdmSupports::on_render_input_window(), Slic3r::GUI::GLGizmoFuzzySkin::on_render_input_window(), Slic3r::GUI::GLGizmoMmuSegmentation::on_render_input_window(), Slic3r::GUI::GLGizmoSeam::on_render_input_window(), Slic3r::GUI::GLGizmoTextureDisplacement::on_render_input_window(), on_set_state(), Slic3r::GUI::GLGizmoTextureDisplacement::rebuild_paint_overlay(), Slic3r::GUI::GLGizmoTextureDisplacement::rebuild_shaded_preview_mesh(), Slic3r::GUI::GLGizmoTextureDisplacement::rebuild_uvcheck_mesh(), Slic3r::GUI::GLGizmoMmuSegmentation::remap_filament_assignments(), Slic3r::GUI::GLGizmoTextureDisplacement::render_painter_gizmo(), render_triangles(), Slic3r::GUI::GLGizmoFdmSupports::select_facets_by_angle(), Slic3r::GUI::GLGizmoTextureDisplacement::select_visible_faces(), Slic3r::GUI::GLGizmoTextureDisplacement::select_whole_model(), Slic3r::GUI::GLGizmoFdmSupports::tool_changed(), Slic3r::GUI::GLGizmoMmuSegmentation::tool_changed(), Slic3r::GUI::GLGizmoSeam::tool_changed(), Slic3r::GUI::GLGizmoFdmSupports::update_from_model_object(), Slic3r::GUI::GLGizmoFuzzySkin::update_from_model_object(), Slic3r::GUI::GLGizmoSeam::update_from_model_object(), Slic3r::GUI::GLGizmoTextureDisplacement::update_from_model_object(), Slic3r::GUI::GLGizmoFdmSupports::update_model_object(), Slic3r::GUI::GLGizmoFuzzySkin::update_model_object(), Slic3r::GUI::GLGizmoMmuSegmentation::update_model_object(), Slic3r::GUI::GLGizmoSeam::update_model_object(), Slic3r::GUI::GLGizmoTextureDisplacement::update_model_object(), Slic3r::GUI::GLGizmoMmuSegmentation::update_triangle_selectors_colors(), and Slic3r::GUI::GLGizmoMmuSegmentation::update_used_filaments().

m_triangle_splitting_enabled

bool Slic3r::GUI::GLGizmoPainterBase::m_triangle_splitting_enabled = true

protectedinherited

Referenced by gizmo_event().

m_vertical_only

bool Slic3r::GUI::GLGizmoPainterBase::m_vertical_only = false

protectedinherited

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

m_volumes_index

int Slic3r::GUI::GLGizmoPainterBase::m_volumes_index = 0

mutableprivateinherited

Referenced by render_cursor_height_range().

s_sphere

std::shared_ptr< GLModel > Slic3r::GUI::GLGizmoPainterBase::s_sphere = nullptr

staticprivateinherited

Referenced by ~GLGizmoPainterBase(), and render_cursor_sphere().

SmartFillAngleMax

float Slic3r::GUI::GLGizmoPainterBase::SmartFillAngleMax = 90.f

staticconstexprprotectedinherited

Referenced by gizmo_event(), Slic3r::GUI::GLGizmoFdmSupports::on_render_input_window(), Slic3r::GUI::GLGizmoFuzzySkin::on_render_input_window(), Slic3r::GUI::GLGizmoMmuSegmentation::on_render_input_window(), and Slic3r::GUI::GLGizmoTextureDisplacement::on_render_input_window().

SmartFillAngleMin

float Slic3r::GUI::GLGizmoPainterBase::SmartFillAngleMin = 0.0f

staticconstexprprotectedinherited

Referenced by gizmo_event(), Slic3r::GUI::GLGizmoFdmSupports::on_render_input_window(), Slic3r::GUI::GLGizmoFuzzySkin::on_render_input_window(), Slic3r::GUI::GLGizmoMmuSegmentation::on_render_input_window(), and Slic3r::GUI::GLGizmoTextureDisplacement::on_render_input_window().

SmartFillAngleStep

float Slic3r::GUI::GLGizmoPainterBase::SmartFillAngleStep = 1.f

staticconstexprprotectedinherited

Referenced by gizmo_event().

---

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

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