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

Inheritance diagram for Slic3r::GUI::GLGizmoPainterBase:

Collaboration diagram for Slic3r::GUI::GLGizmoPainterBase:

Classes
struct	ProjectedMousePosition
struct	ProjectedHeightRange
struct	ClippingPlaneDataWrapper
struct	RaycastResult
struct	CutContours

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
	GLGizmoPainterBase (GLCanvas3D &parent, const std::string &icon_filename, unsigned int sprite_id)
	~GLGizmoPainterBase () 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 void	render_painter_gizmo ()=0
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
virtual std::string	get_gizmo_entering_text () const
virtual std::string	get_gizmo_leaving_text () const
virtual std::string	get_action_snapshot_name () const
void	set_common_data_pool (CommonGizmosDataPool *ptr)
virtual bool	apply_clipping_plane ()
unsigned int	get_sprite_id () const
int	get_hover_id () const
void	set_hover_id (int id)
bool	is_dragging () const
bool	update_items_state ()
void	render ()
void	render_input_window (float x, float y, float bottom_limit)
virtual void	on_change_color_mode (bool is_dark)
virtual std::string	get_tooltip () const
	Mouse tooltip text.
int	get_count ()
std::string	get_gizmo_name ()
void	register_raycasters_for_picking ()
void	unregister_raycasters_for_picking ()
virtual bool	is_in_editing_mode () const
virtual bool	is_selection_rectangle_dragging () const

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

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

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

Protected Member Functions
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 void	update_model_object ()=0
virtual void	update_from_model_object (bool first_update)=0
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
virtual EnforcerBlockerType	get_left_button_state_type () const
virtual EnforcerBlockerType	get_right_button_state_type () 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
virtual void	on_opening ()=0
virtual void	on_shutdown ()=0
virtual PainterGizmoType	get_painter_type () const =0
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
virtual wxString	handle_snapshot_action_name (bool shift_down, Button Button button_down) const =0
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 bool	on_init ()=0
virtual std::string	on_get_name () const =0
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)
virtual void	on_render_input_window (float x, float y, float bottom_limit)
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
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
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
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()
Button Button	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

Friends
class	::Slic3r::GUI::GLGizmoMmuSegmentation

Detailed Description

Class Documentation

◆ Slic3r::GUI::GLGizmoPainterBase::ProjectedMousePosition

struct Slic3r::GUI::GLGizmoPainterBase::ProjectedMousePosition

Class Members
size_t	facet_idx
Vec3f	mesh_hit
int	mesh_idx

◆ Slic3r::GUI::GLGizmoPainterBase::ProjectedHeightRange

struct Slic3r::GUI::GLGizmoPainterBase::ProjectedHeightRange

Class Members
size_t	first_facet_idx
int	mesh_idx
float	z_world

◆ Slic3r::GUI::GLGizmoPainterBase::ClippingPlaneDataWrapper

struct Slic3r::GUI::GLGizmoPainterBase::ClippingPlaneDataWrapper

Collaboration diagram for Slic3r::GUI::GLGizmoPainterBase::ClippingPlaneDataWrapper:

Class Members
array< float, 4 >	clp_dataf
array< float, 2 >	z_range

◆ Slic3r::GUI::GLGizmoPainterBase::RaycastResult

struct Slic3r::GUI::GLGizmoPainterBase::RaycastResult

Class Members
size_t	facet
Vec3f	hit
int	mesh_id
Vec2d	mouse_position

◆ Slic3r::GUI::GLGizmoPainterBase::CutContours

struct Slic3r::GUI::GLGizmoPainterBase::CutContours

Collaboration diagram for Slic3r::GUI::GLGizmoPainterBase::CutContours:

Class Members
GLModel	contours
double	cut_z { 0.0 }
int	instance_idx { -1 }
TriangleMesh	mesh
ObjectID	object_id
Vec3d	position { Vec3d::Zero() }
Vec3d	shift { Vec3d::Zero() }

Member Enumeration Documentation

◆ Button

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

strongprotected

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

strongprotected

Enumerator
BRUSH
BUCKET_FILL
SMART_FILL
GAP_FILL

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

Constructor & Destructor Documentation

◆ GLGizmoPainterBase()

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

    : GLGizmoBase(parent, icon_filename, sprite_id)
{
    m_vertical_only = false;
    m_horizontal_only = false;
}

References Slic3r::GUI::GLGizmoBase::GLGizmoBase(), m_horizontal_only, and m_vertical_only.

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

Here is the call graph for this function:

Here is the caller graph for this function:

◆ ~GLGizmoPainterBase()

Slic3r::GUI::GLGizmoPainterBase::~GLGizmoPainterBase ( )

override

{
    if (s_sphere != nullptr)
        s_sphere.reset();
}

References s_sphere.

Member Function Documentation

◆ apply_clipping_plane()

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

inlinevirtualinherited

195{ return true; }

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

Here is the caller graph for this function:

◆ bounding_box()

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

private

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

overridevirtual

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

Here is the call graph for this function:

Here is the caller graph for this function:

◆ get_action_snapshot_name()

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

virtualinherited

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

{
    return "Gizmo action";
}

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

Here is the caller graph for this function:

◆ get_clipping_plane_data()

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

protected

{
    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

protected

                                                                                                                         {
    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

224{ return ++count; }

Slic3r::GUI::GLGizmoBase::count

int count

Definition GLGizmoBase.hpp:294

References count.

◆ get_cursor_height_max()

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

inlinevirtual

223{ return CursorHeightMax; }

Slic3r::GUI::GLGizmoPainterBase::CursorHeightMax

static constexpr float CursorHeightMax

Definition GLGizmoPainterBase.hpp:266

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

inlinevirtual

222{ return CursorHeightMin; }

Slic3r::GUI::GLGizmoPainterBase::CursorHeightMin

static constexpr float CursorHeightMin

Definition GLGizmoPainterBase.hpp:265

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

inlinevirtual

224{ return CursorHeightStep; }

Slic3r::GUI::GLGizmoPainterBase::CursorHeightStep

static constexpr float CursorHeightStep

Definition GLGizmoPainterBase.hpp:267

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

inlineprotectedvirtual

Reimplemented in Slic3r::GUI::GLGizmoMmuSegmentation.

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

inlinevirtual

218{ return CursorRadiusMax; }

Slic3r::GUI::GLGizmoPainterBase::CursorRadiusMax

static constexpr float CursorRadiusMax

Definition GLGizmoPainterBase.hpp:263

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

inlinevirtual

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

217{ return CursorRadiusMin; }

Slic3r::GUI::GLGizmoPainterBase::CursorRadiusMin

static constexpr float CursorRadiusMin

Definition GLGizmoPainterBase.hpp:262

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

inlinevirtual

219{ return CursorRadiusStep; }

Slic3r::GUI::GLGizmoPainterBase::CursorRadiusStep

static constexpr float CursorRadiusStep

Definition GLGizmoPainterBase.hpp:264

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

inlineprotectedvirtual

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

inlineprotectedvirtual

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

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

inlinevirtualinherited

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

190{ assert(false); return ""; }

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

Here is the caller graph for this function:

◆ get_gizmo_leaving_text()

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

inlinevirtualinherited

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

191{ assert(false); return ""; }

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

Here is the caller graph for this function:

◆ get_gizmo_name()

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

inlineinherited

225{ return on_get_name(); }

Slic3r::GUI::GLGizmoBase::on_get_name

virtual std::string on_get_name() const =0

References on_get_name().

Here is the call graph for this function:

◆ get_hover_id()

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

inlineinherited

206{ return m_hover_id; }

Slic3r::GUI::GLGizmoBase::m_hover_id

int m_hover_id

Definition GLGizmoBase.hpp:150

References m_hover_id.

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

Here is the caller graph for this function:

◆ get_icon_filename()

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

inlineinherited

180{ return m_icon_filename; }

Slic3r::GUI::GLGizmoBase::m_icon_filename

std::string m_icon_filename

Definition GLGizmoBase.hpp:148

References m_icon_filename.

◆ get_left_button_state_type()

virtual EnforcerBlockerType Slic3r::GUI::GLGizmoPainterBase::get_left_button_state_type ( ) const

inlineprotectedvirtual

Reimplemented in Slic3r::GUI::GLGizmoFuzzySkin, Slic3r::GUI::GLGizmoMmuSegmentation, and Slic3r::GUI::GLGizmoTextureDisplacement.

256{ return EnforcerBlockerType::ENFORCER; }

Slic3r::EnforcerBlockerType::ENFORCER

@ ENFORCER

Definition TriangleSelector.hpp:27

References Slic3r::ENFORCER.

Referenced by gizmo_event().

Here is the caller graph for this function:

◆ get_name()

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

inherited

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

References m_shortcut, and on_get_name().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ get_painter_type()

virtual PainterGizmoType Slic3r::GUI::GLGizmoPainterBase::get_painter_type ( ) const

protectedpure virtual

Implemented in Slic3r::GUI::GLGizmoFdmSupports, Slic3r::GUI::GLGizmoFuzzySkin, Slic3r::GUI::GLGizmoMmuSegmentation, Slic3r::GUI::GLGizmoSeam, and Slic3r::GUI::GLGizmoTextureDisplacement.

◆ 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

private

{
    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

private

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

186{ return on_get_requirements(); }

Slic3r::GUI::GLGizmoBase::on_get_requirements

virtual CommonGizmosDataID on_get_requirements() const

Definition GLGizmoBase.hpp:248

References on_get_requirements().

Here is the call graph for this function:

◆ get_right_button_state_type()

virtual EnforcerBlockerType Slic3r::GUI::GLGizmoPainterBase::get_right_button_state_type ( ) const

inlineprotectedvirtual

Reimplemented in Slic3r::GUI::GLGizmoFuzzySkin, Slic3r::GUI::GLGizmoMmuSegmentation, and Slic3r::GUI::GLGizmoTextureDisplacement.

257{ return EnforcerBlockerType::BLOCKER; }

Slic3r::EnforcerBlockerType::BLOCKER

@ BLOCKER

Definition TriangleSelector.hpp:28

References Slic3r::BLOCKER.

Referenced by gizmo_event().

Here is the caller graph for this function:

◆ get_sprite_id()

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

inlineinherited

204{ return m_sprite_id; }

Slic3r::GUI::GLGizmoBase::m_sprite_id

unsigned int m_sprite_id

Definition GLGizmoBase.hpp:149

References m_sprite_id.

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

Here is the caller graph for this function:

◆ get_state()

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

inlineinherited

175{ return m_state; }

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

protected

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

222{ 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 )

virtual

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

Here is the caller graph for this function:

◆ GizmoImguiEnd()

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

protectedinherited

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

References last_input_window_width, and m_imgui.

Here is the caller graph for this function:

◆ GizmoImguiSetNextWIndowPos() [1/2]

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

protectedinherited

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

References m_imgui, and m_parent.

◆ GizmoImguiSetNextWIndowPos() [2/2]

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

protectedinherited

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

References GizmoImguiSetNextWIndowPos(), and last_input_window_width.

Here is the call graph for this function:

Here is the caller graph for this function:

◆ handle_snapshot_action_name()

virtual wxString Slic3r::GUI::GLGizmoPainterBase::handle_snapshot_action_name	(	bool	shift_down,
		Button Button	button_down ) const

protectedpure virtual

Implemented in Slic3r::GUI::GLGizmoFdmSupports, Slic3r::GUI::GLGizmoFuzzySkin, Slic3r::GUI::GLGizmoMmuSegmentation, Slic3r::GUI::GLGizmoSeam, and Slic3r::GUI::GLGizmoTextureDisplacement.

Referenced by gizmo_event().

Here is the caller graph for this function:

◆ init()

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

inlineinherited

168{ return on_init(); }

Slic3r::GUI::GLGizmoBase::on_init

virtual bool on_init()=0

References on_init().

Here is the call graph for this function:

◆ is_activable()

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

inlineinherited

184{ return on_is_activable(); }

Slic3r::GUI::GLGizmoBase::on_is_activable

virtual bool on_is_activable() const

Definition GLGizmoBase.hpp:246

References on_is_activable().

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

Here is the call graph for this function:

Here is the caller graph for this function:

◆ is_dragging()

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

inlineinherited

209{ return m_dragging; }

References m_dragging.

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

Here is the caller graph for this function:

◆ is_in_editing_mode()

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

inlinevirtualinherited

Reimplemented in Slic3r::GUI::GLGizmoCut3D.

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

private

{
    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

inlineprotected

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

185{ return on_is_selectable(); }

Slic3r::GUI::GLGizmoBase::on_is_selectable

virtual bool on_is_selectable() const

Definition GLGizmoBase.hpp:247

References on_is_selectable().

Here is the call graph for this function:

◆ is_selection_rectangle_dragging()

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

inlinevirtualinherited

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

236{ return false; }

◆ load()

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

inlineinherited

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

Slic3r::GUI::GLGizmoBase::on_load

virtual void on_load(cereal::BinaryInputArchive &ar)

Definition GLGizmoBase.hpp:241

References m_state, On, and on_load().

Here is the call graph for this function:

◆ load_render_colors()

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

staticinherited

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

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

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

Here is the call graph for this function:

Here is the caller graph for this function:

◆ mesh_trafo_matrices()

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

private

{
    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

216{ m_is_dark_mode = is_dark; }

is_dark

static bool is_dark()

Definition TextureImportDialog.cpp:85

Slic3r::GUI::GLGizmoBase::m_is_dark_mode

bool m_is_dark_mode

Definition GLGizmoBase.hpp:157

References is_dark(), and m_is_dark_mode.

Here is the call graph for this function:

◆ on_disable_grabber()

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

inlineprotectedvirtualinherited

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

250{}

◆ on_dragging()

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.

255{}

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.

249{}

◆ on_get_name()

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

protectedpure virtualinherited

Referenced by get_gizmo_name(), and get_name().

Here is the caller graph for this function:

◆ on_get_requirements()

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

overrideprotectedvirtual

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

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

protectedpure virtualinherited

Referenced by init().

Here is the caller graph for this function:

◆ on_is_activable()

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

overrideprotectedvirtual

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

overrideprotectedvirtual

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 )

overrideprotectedvirtual

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 )

overridevirtual

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

virtual void Slic3r::GUI::GLGizmoPainterBase::on_opening ( )

protectedpure virtual

Implemented in Slic3r::GUI::GLGizmoFdmSupports, Slic3r::GUI::GLGizmoFuzzySkin, Slic3r::GUI::GLGizmoMmuSegmentation, Slic3r::GUI::GLGizmoSeam, and Slic3r::GUI::GLGizmoTextureDisplacement.

Referenced by on_set_state().

Here is the caller graph for this function:

◆ on_register_raycasters_for_picking()

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

inlineprotectedvirtualinherited

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

267{}

Referenced by register_raycasters_for_picking().

Here is the caller graph for this function:

◆ on_render()

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

inlineoverrideprivatevirtual

Implements Slic3r::GUI::GLGizmoBase.

201{}

◆ on_render_input_window()

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

inlineprotectedvirtualinherited

258{}

Referenced by render_input_window().

Here is the caller graph for this function:

◆ on_save()

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

inlineoverrideprotectedvirtual

Reimplemented from Slic3r::GUI::GLGizmoBase.

404{}

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

245{}

Referenced by set_hover_id().

Here is the caller graph for this function:

◆ on_set_state()

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

overrideprotectedvirtual

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

virtual void Slic3r::GUI::GLGizmoPainterBase::on_shutdown ( )

protectedpure virtual

Implemented in Slic3r::GUI::GLGizmoFdmSupports, Slic3r::GUI::GLGizmoFuzzySkin, Slic3r::GUI::GLGizmoMmuSegmentation, Slic3r::GUI::GLGizmoSeam, and Slic3r::GUI::GLGizmoTextureDisplacement.

Referenced by on_set_state().

Here is the caller graph for this function:

◆ on_start_dragging()

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

inlineprotectedvirtualinherited

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

253{}

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.

254{}

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 )

inlinevirtual

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

209{ 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.

268{}

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

232{ register_grabbers_for_picking(); on_register_raycasters_for_picking(); }

Slic3r::GUI::GLGizmoBase::register_grabbers_for_picking

void register_grabbers_for_picking()

Definition GLGizmoBase.cpp:398

Slic3r::GUI::GLGizmoBase::on_register_raycasters_for_picking

virtual void on_register_raycasters_for_picking()

Definition GLGizmoBase.hpp:267

References on_register_raycasters_for_picking(), and register_grabbers_for_picking().

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

Here is the call graph for this function:

Here is the caller graph for this function:

◆ render()

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

inlineinherited

214{ on_render(); }

Slic3r::GUI::GLGizmoBase::on_render

virtual void on_render()=0

References on_render().

Here is the call graph for this function:

◆ render_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
    }
}

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

protected

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

protected

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

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

protected

{
    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

protected

{
    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

overrideprotectedvirtual

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

virtual void Slic3r::GUI::GLGizmoPainterBase::render_painter_gizmo ( )

pure virtual

Implemented in Slic3r::GUI::GLGizmoFdmSupports, Slic3r::GUI::GLGizmoFuzzySkin, Slic3r::GUI::GLGizmoMmuSegmentation, Slic3r::GUI::GLGizmoSeam, and Slic3r::GUI::GLGizmoTextureDisplacement.

◆ render_triangles() [1/2]

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

protectedvirtual

{
    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

protected

{
    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

171{ on_save(ar); }

Slic3r::GUI::GLGizmoBase::on_save

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

Definition GLGizmoBase.hpp:242

References on_save().

Here is the call graph for this function:

◆ set_common_data_pool()

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

inlineinherited

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

176{ m_state = state; on_set_state(); }

Slic3r::GUI::GLGizmoBase::on_set_state

virtual void on_set_state()

Definition GLGizmoBase.hpp:244

References m_state, and on_set_state().

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

Here is the call graph for this function:

Here is the caller graph for this function:

◆ shortcut()

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

inlineinherited

178{ return m_shortcut; }

References m_shortcut.

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

Here is the caller graph for this function:

◆ unregister_grabbers_for_picking()

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

protectedinherited

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

References m_grabbers.

Referenced by unregister_raycasters_for_picking().

Here is the caller graph for this function:

◆ unregister_raycasters_for_picking()

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

inlineinherited

233{ unregister_grabbers_for_picking(); on_unregister_raycasters_for_picking(); }

Slic3r::GUI::GLGizmoBase::on_unregister_raycasters_for_picking

virtual void on_unregister_raycasters_for_picking()

Definition GLGizmoBase.hpp:268

Slic3r::GUI::GLGizmoBase::unregister_grabbers_for_picking

void unregister_grabbers_for_picking()

Definition GLGizmoBase.cpp:405

References on_unregister_raycasters_for_picking(), and unregister_grabbers_for_picking().

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

Here is the call graph for this function:

Here is the caller graph for this function:

◆ update_contours()

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

private

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

virtual void Slic3r::GUI::GLGizmoPainterBase::update_from_model_object ( bool first_update )

protectedpure virtual

Implemented in Slic3r::GUI::GLGizmoFdmSupports, Slic3r::GUI::GLGizmoFuzzySkin, Slic3r::GUI::GLGizmoMmuSegmentation, Slic3r::GUI::GLGizmoSeam, and Slic3r::GUI::GLGizmoTextureDisplacement.

Referenced by data_changed().

Here is the caller graph for this function:

◆ update_items_state()

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

inherited

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

References m_dirty.

◆ update_model_object()

virtual void Slic3r::GUI::GLGizmoPainterBase::update_model_object ( )

protectedpure virtual

Implemented in Slic3r::GUI::GLGizmoFdmSupports, Slic3r::GUI::GLGizmoFuzzySkin, Slic3r::GUI::GLGizmoMmuSegmentation, Slic3r::GUI::GLGizmoSeam, and Slic3r::GUI::GLGizmoTextureDisplacement.

Referenced by gizmo_event().

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

private

{
    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

inlineoverrideprotectedvirtual

Reimplemented from Slic3r::GUI::GLGizmoBase.

406{ return true; }

◆ ::Slic3r::GUI::GLGizmoMmuSegmentation

friend class ::Slic3r::GUI::GLGizmoMmuSegmentation

friend

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

staticconstexprprotected

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

◆ CursorHeightMin

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

staticconstexprprotected

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

◆ CursorHeightStep

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

staticconstexprprotected

Referenced by get_cursor_height_step().

◆ CursorRadiusMax

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

staticconstexprprotected

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

staticconstexprprotected

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

staticconstexprprotected

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

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

private

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

155{ nullptr };

◆ m_circle

GLModel Slic3r::GUI::GLGizmoPainterBase::m_circle

protected

Referenced by render_cursor_circle().

◆ m_cursor_height

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

protected

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

protected

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

protected

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}

mutableprivate

386{0};

◆ m_cut_contours

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

mutableprivate

Referenced by render_cursor_height_range(), and update_contours().

◆ m_dirty

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

privateinherited

293{ false };

Referenced by set_dirty(), and update_items_state().

◆ m_dragging

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

protectedinherited

151{ false };

◆ m_first_input_window_render

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

protectedinherited

154{ true };

Referenced by render_input_window().

◆ m_grabbers

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

mutableprotectedinherited

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

mutableprivate

389{0, 0};

◆ m_height_start_z_in_imgui

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

mutableprivate

387{0};

◆ m_highlight_by_angle_threshold_deg

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

protected

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

protected

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

150{ -1 };

◆ m_icon_filename

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

protectedinherited

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

◆ m_imgui

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

protectedinherited

◆ m_internal_stack_active

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

private

◆ m_is_cursor_in_imgui

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

mutableprivate

390{false};

◆ m_is_dark_mode

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

protectedinherited

◆ m_is_set_height_start_z_by_imgui

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

mutableprivate

388{false};

◆ m_last_mouse_click

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

private

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

◆ m_old_center

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

protected

308{ Vec2d::Zero() };

Referenced by render_cursor_circle().

◆ m_old_cursor_radius

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

protected

309{ 0.0f };

Referenced by render_cursor_circle().

◆ m_old_mo_id

ObjectID Slic3r::GUI::GLGizmoPainterBase::m_old_mo_id

private

Referenced by data_changed(), and on_set_state().

◆ m_old_state

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

private

Referenced by on_set_state().

◆ m_old_volumes_size

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

private

Referenced by data_changed().

◆ m_paint_on_overhangs_only

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

protected

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

◆ m_parent

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

protectedinherited

◆ m_rr

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

mutableprivate

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

private

Referenced by data_changed(), and on_load().

◆ m_seed_fill_last_mesh_id

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

protected

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

◆ m_smart_fill_angle

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

protected

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

◆ m_tool_type

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

protected

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

protected

◆ m_triangle_splitting_enabled

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

protected

Referenced by gizmo_event().

◆ m_vertical_only

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

protected

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

mutableprivate

Referenced by render_cursor_height_range().

◆ s_sphere

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

staticprivate

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

◆ SmartFillAngleMax

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

staticconstexprprotected

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

staticconstexprprotected

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

staticconstexprprotected

Referenced by gizmo_event().

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

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

	OrcaSlicer latest OrcaSlicer

Classes

Public Types

Public Member Functions

Static Public Member Functions

Static Public Attributes

Protected Types

Protected Member Functions

Protected Attributes

Static Protected Attributes

Private Member Functions

Private Attributes

Static Private Attributes

Friends

Detailed Description

Class Documentation

◆ Slic3r::GUI::GLGizmoPainterBase::ProjectedMousePosition

◆ Slic3r::GUI::GLGizmoPainterBase::ProjectedHeightRange

◆ Slic3r::GUI::GLGizmoPainterBase::ClippingPlaneDataWrapper

◆ Slic3r::GUI::GLGizmoPainterBase::RaycastResult

◆ Slic3r::GUI::GLGizmoPainterBase::CutContours

Member Enumeration Documentation

◆ Button

◆ EGrabberExtension

◆ EState

◆ ToolType

Constructor & Destructor Documentation

◆ GLGizmoPainterBase()

◆ ~GLGizmoPainterBase()

Member Function Documentation

◆ apply_clipping_plane()

◆ bounding_box()

◆ data_changed()

◆ do_stop_dragging()

◆ format()

◆ get_action_snapshot_name()

◆ get_clipping_plane_data()

◆ get_clipping_plane_in_volume_coordinates()

◆ get_count()

◆ get_cursor_height_max()

◆ get_cursor_height_min()

◆ get_cursor_height_step()

◆ get_cursor_hover_color()

◆ get_cursor_radius_max()

◆ get_cursor_radius_min()

◆ get_cursor_radius_step()

◆ get_cursor_sphere_left_button_color()

◆ get_cursor_sphere_right_button_color()

◆ get_gizmo_entering_text()

◆ get_gizmo_leaving_text()

◆ get_gizmo_name()

◆ get_hover_id()

◆ get_icon_filename()

◆ get_left_button_state_type()

◆ get_name()

◆ get_painter_type()

◆ get_projected_height_range()

◆ get_projected_mouse_positions()

◆ get_requirements()

◆ get_right_button_state_type()

◆ get_sprite_id()

◆ get_state()

◆ get_tilt_up_direction()

◆ get_tooltip()

◆ gizmo_event()

◆ GizmoImguiBegin()

◆ GizmoImguiEnd()

◆ GizmoImguiSetNextWIndowPos() [1/2]

◆ GizmoImguiSetNextWIndowPos() [2/2]

◆ handle_snapshot_action_name()

◆ init()

◆ is_activable()

◆ is_dragging()

◆ is_in_editing_mode()

◆ is_mesh_point_clipped()

◆ is_painting()

◆ is_selectable()

◆ is_selection_rectangle_dragging()

◆ load()

◆ load_render_colors()

◆ mesh_trafo_matrices()