Slic3r::GUI::GLGizmoBrimEars Class Reference

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

Inheritance diagram for Slic3r::GUI::GLGizmoBrimEars:

Collaboration diagram for Slic3r::GUI::GLGizmoBrimEars:

Classes
class	CacheEntry

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
	GLGizmoBrimEars (GLCanvas3D &parent, const std::string &icon_filename, unsigned int sprite_id)
virtual	~GLGizmoBrimEars ()=default
void	data_changed (bool is_serializing) override
	Is called when data (Selection) is changed.
void	set_brim_data ()
bool	on_mouse (const wxMouseEvent &mouse_event) override
	Implement when want to process mouse events in gizmo Click, Right click, move, drag, ...
bool	gizmo_event (SLAGizmoEventType action, const Vec2d &mouse_position, bool shift_down, bool alt_down, bool control_down)
void	delete_selected_points ()
bool	has_selected_points () const
void	update_model_object ()
bool	is_selection_rectangle_dragging () const override
bool	wants_enter_leave_snapshots () const override
std::string	get_gizmo_entering_text () const override
std::string	get_gizmo_leaving_text () const override
bool	init ()
void	load (cereal::BinaryInputArchive &ar)
void	save (cereal::BinaryOutputArchive &ar) const
std::string	get_name (bool include_shortcut=true) const
EState	get_state () const
void	set_state (EState state)
std::optional< Shortcut >	shortcut () const
const std::string &	get_icon_filename () const
void	set_icon_filename (const std::string &filename)
bool	is_activable () const
bool	is_selectable () const
CommonGizmosDataID	get_requirements () const
virtual std::string	get_action_snapshot_name () const
void	set_common_data_pool (CommonGizmosDataPool *ptr)
virtual bool	apply_clipping_plane ()
unsigned int	get_sprite_id () const
int	get_hover_id () const
void	set_hover_id (int id)
bool	is_dragging () const
bool	update_items_state ()
void	render ()
void	render_input_window (float x, float y, float bottom_limit)
virtual void	on_change_color_mode (bool is_dark)
virtual std::string	get_tooltip () const
	Mouse tooltip text.
int	get_count ()
std::string	get_gizmo_name ()
void	register_raycasters_for_picking ()
void	unregister_raycasters_for_picking ()
virtual bool	is_in_editing_mode () const

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

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

Protected Member Functions
void	on_set_state () override
void	on_set_hover_id () override
void	on_start_dragging () override
void	on_stop_dragging () override
void	on_render_input_window (float x, float y, float bottom_limit) override
std::string	on_get_name () const override
bool	on_is_activable () const override
bool	render_follows_cursor () const override
virtual CommonGizmosDataID	on_get_requirements () const override
void	on_load (cereal::BinaryInputArchive &ar) override
void	on_save (cereal::BinaryOutputArchive &ar) const override
virtual void	on_register_raycasters_for_picking () override
virtual void	on_unregister_raycasters_for_picking () override
void	register_single_mesh_pick ()
void	reset_all_pick ()
bool	add_point_to_cache (Vec3f pos, float head_radius, bool selected, Vec3f normal)
float	get_brim_default_radius () const
ExPolygon	make_polygon (BrimPoint point, const Geometry::Transformation &trsf)
void	find_single ()
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_is_selectable () const
virtual void	on_enable_grabber (unsigned int id)
virtual void	on_disable_grabber (unsigned int id)
bool	GizmoImguiBegin (const std::string &name, int flags)
void	GizmoImguiEnd ()
void	GizmoImguiSetNextWIndowPos (float &x, float y, int flag, float pivot_x=0.0f, float pivot_y=0.0f)
void	GizmoImguiSetNextWIndowPos (float &x, float y, float w, float h, int flag, float pivot_x=0.0f, float pivot_y=0.0f)
void	register_grabbers_for_picking ()
void	unregister_grabbers_for_picking ()
void	render_grabbers (const BoundingBoxf3 &box) const
void	render_grabbers (float size) const
void	render_grabbers (size_t first, size_t last, float size, bool force_hover) const
std::string	format (float value, unsigned int decimals) const
void	set_dirty ()
bool	use_grabbers (const wxMouseEvent &mouse_event)
	function which Set up m_dragging and call functions on_start_dragging / on_dragging / on_stop_dragging
void	do_stop_dragging (bool perform_mouse_cleanup)

Protected Attributes
GLCanvas3D &	m_parent
int	m_group_id
EState	m_state
std::optional< Shortcut >	m_shortcut
std::string	m_icon_filename
unsigned int	m_sprite_id
int	m_hover_id { -1 }
bool	m_dragging { false }
std::vector< Grabber >	m_grabbers
ImGuiWrapper *	m_imgui
bool	m_first_input_window_render { true }
CommonGizmosDataPool *	m_c { nullptr }
bool	m_is_dark_mode = false
float	last_input_window_width = 0

Private Types
enum	{ AllPoints = -2 , NoPoints }
using	PickRaycaster = SceneRaycasterItem

Private Member Functions
bool	unproject_on_mesh (const Vec2d &mouse_pos, std::pair< Vec3f, Vec3f > &pos_and_normal)
bool	unproject_on_mesh2 (const Vec2d &mouse_pos, std::pair< Vec3f, Vec3f > &pos_and_normal)
bool	on_init () override
void	on_dragging (const UpdateData &data) override
void	on_render () override
void	render_points (const Selection &selection)
std::vector< const ConfigOption * >	get_config_options (const std::vector< std::string > &keys) const
bool	is_mesh_point_clipped (const Vec3d &point) const
void	select_point (int i)
void	unselect_point (int i)
void	reload_cache ()
Points	generate_points (Polygon &obj_polygon, float ear_detection_length, float brim_ears_max_angle, bool is_outer)
void	auto_generate ()
void	first_layer_slicer ()
void	get_detection_radius_max ()
void	update_raycasters ()
void	begin_radius_change (float initial_value)
void	update_cache_radius ()
void	apply_radius_change ()

Private Attributes
const float	RenderPointScale = 1.f
float	m_new_point_head_radius
float	m_max_angle = 125.f
float	m_detection_radius = 1.f
double	m_detection_radius_max = .0f
CacheEntry	m_point_before_drag
float	m_old_point_head_radius = 0.
std::vector< CacheEntry >	m_editing_cache
std::map< int, CacheEntry >	m_single_brim
ObjectID	m_old_mo_id
const Vec3d	m_world_normal = {0, 0, 1}
std::map< GLVolume *, std::shared_ptr< PickRaycaster > >	m_mesh_raycaster_map
GLVolume *	m_last_hit_volume
std::optional< CacheEntry >	render_hover_point
bool	m_link_text_hover = false
PickingModel	m_cylinder
std::map< std::string, wxString >	m_desc
std::vector< std::pair< wxString, wxString > >	m_shortcuts
GLSelectionRectangle	m_selection_rectangle
ExPolygons	m_first_layer
bool	m_wait_for_up_event = false
bool	m_selection_empty = true
EState	m_old_state = Off
bool	m_dirty { false }
int	count = 0

Detailed Description

Member Typedef Documentation

PickRaycaster

using Slic3r::GUI::GLGizmoBrimEars::PickRaycaster = SceneRaycasterItem

private

Member Enumeration Documentation

anonymous enum

anonymous enum

private

Enumerator
AllPoints
NoPoints

         {
        AllPoints = -2,
        NoPoints,
    };

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

Constructor & Destructor Documentation

GLGizmoBrimEars()

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

                                                                                                           : GLGizmoBase(parent, icon_filename, sprite_id)
{
    GLModel::Geometry cylinder_geometry = smooth_cylinder(16, 1.0f, 1.0f);
    m_cylinder.mesh_raycaster = std::make_unique<MeshRaycaster>(std::make_shared<const TriangleMesh>(cylinder_geometry.get_as_indexed_triangle_set()));
    m_cylinder.model.init_from(std::move(cylinder_geometry));
}

References Slic3r::GUI::GLGizmoBase::GLGizmoBase(), Slic3r::GUI::GLModel::Geometry::get_as_indexed_triangle_set(), m_cylinder, and Slic3r::GUI::smooth_cylinder().

Here is the call graph for this function:

~GLGizmoBrimEars()

virtual Slic3r::GUI::GLGizmoBrimEars::~GLGizmoBrimEars ( )

virtualdefault

References Slic3r::GUI::wxMouseEvent.

Member Function Documentation

add_point_to_cache()

bool Slic3r::GUI::GLGizmoBrimEars::add_point_to_cache ( Vec3f pos, float head_radius, bool selected, Vec3f normal )

protected

{
    BrimPoint point(pos, head_radius);
    for (int i = 0; i < m_editing_cache.size(); i++) {
        if (m_editing_cache[i].brim_point == point) { return false; }
    }
    m_editing_cache.emplace_back(point, selected, normal);
    update_model_object();
    return true;
}

References m_editing_cache, Slic3r::normal(), and update_model_object().

Referenced by auto_generate(), and gizmo_event().

Here is the call graph for this function:

Here is the caller graph for this function:

apply_clipping_plane()

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

inlinevirtualinherited

{ return true; }

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

Here is the caller graph for this function:

apply_radius_change()

void Slic3r::GUI::GLGizmoBrimEars::apply_radius_change ( )

private

{
    if (m_old_point_head_radius == 0.f) return;
 
    // momentarily restore the old value to take snapshot
    for (auto& cache_entry : m_editing_cache)
        if (cache_entry.selected)
            cache_entry.brim_point.head_front_radius = m_old_point_head_radius;
    float backup            = m_new_point_head_radius;
    m_new_point_head_radius = m_old_point_head_radius;
    Plater::TakeSnapshot snapshot(wxGetApp().plater(), "Change brim ear radius");
    m_new_point_head_radius = backup;
    update_cache_radius();
    m_old_point_head_radius = 0.f;
}

References m_editing_cache, m_new_point_head_radius, m_old_point_head_radius, Slic3r::GUI::plater(), and update_cache_radius().

Referenced by gizmo_event(), and on_render_input_window().

Here is the call graph for this function:

Here is the caller graph for this function:

auto_generate()

void Slic3r::GUI::GLGizmoBrimEars::auto_generate ( )

private

{
    const Selection &selection = m_parent.get_selection();
    const GLVolume  *volume    = selection.get_volume(*selection.get_volume_idxs().begin());
    Transform3d      trsf      = volume->get_instance_transformation().get_matrix();
    Vec3f            normal    = (volume->get_instance_transformation().get_matrix_no_offset().inverse() * m_world_normal).cast<float>();
    auto             add_point = [this, &trsf, &normal](const Point &p) {
        Vec3d world_pos  = {float(p.x() * SCALING_FACTOR), float(p.y() * SCALING_FACTOR), -0.0001};
        Vec3d object_pos = trsf.inverse() * world_pos;
        add_point_to_cache(object_pos.cast<float>(), m_new_point_head_radius, false, normal);
    };
    for (const ExPolygon &ex_poly : m_first_layer) {
        Polygon  out_poly   = ex_poly.contour;
        Polygons inner_poly = ex_poly.holes;
        polygons_reverse(inner_poly);
        Plater::TakeSnapshot snapshot(wxGetApp().plater(), "Auto generate brim ear");
        Points               out_points = generate_points(out_poly, m_detection_radius, m_max_angle, true);
        for (Point &p : out_points) { add_point(p); }
        for (Polygon &pl : inner_poly) {
            Points inner_points = generate_points(pl, m_detection_radius, m_max_angle, false);
            for (Point &p : inner_points) { add_point(p); }
        }
    }
    find_single();
}

References add_point_to_cache(), find_single(), generate_points(), Slic3r::GLVolume::get_instance_transformation(), Slic3r::Geometry::Transformation::get_matrix(), Slic3r::GUI::Selection::get_volume(), Slic3r::GUI::Selection::get_volume_idxs(), m_detection_radius, m_first_layer, m_max_angle, m_new_point_head_radius, Slic3r::GUI::GLGizmoBase::m_parent, m_world_normal, Slic3r::normal(), Slic3r::GUI::plater(), Slic3r::polygons_reverse(), and SCALING_FACTOR.

Referenced by on_render_input_window().

Here is the call graph for this function:

Here is the caller graph for this function:

begin_radius_change()

void Slic3r::GUI::GLGizmoBrimEars::begin_radius_change ( float initial_value )

private

{
    if (m_old_point_head_radius == 0.f)
        m_old_point_head_radius = initial_value;
}

References m_old_point_head_radius.

Referenced by gizmo_event(), and on_render_input_window().

Here is the caller graph for this function:

data_changed()

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

overridevirtual

Is called when data (Selection) is changed.

Reimplemented from Slic3r::GUI::GLGizmoBase.

{
    if (!m_c->selection_info()) return;
 
    ModelObject *mo = m_c->selection_info()->model_object();
    if (mo) {
        reset_all_pick();
        register_single_mesh_pick();
    }
 
    set_brim_data();
}

References Slic3r::GUI::GLGizmoBase::m_c, register_single_mesh_pick(), reset_all_pick(), and set_brim_data().

Here is the call graph for this function:

delete_selected_points()

void Slic3r::GUI::GLGizmoBrimEars::delete_selected_points

(

)

{
    Plater::TakeSnapshot snapshot(wxGetApp().plater(), "Delete brim ear");
 
    for (unsigned int idx = 0; idx < m_editing_cache.size(); ++idx) {
        if (m_editing_cache[idx].selected) { m_editing_cache.erase(m_editing_cache.begin() + (idx--)); }
    }
 
    select_point(NoPoints);
    find_single();
    update_model_object();
}

References find_single(), m_editing_cache, NoPoints, Slic3r::GUI::plater(), select_point(), and update_model_object().

Referenced by gizmo_event(), and on_render_input_window().

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:

find_single()

void Slic3r::GUI::GLGizmoBrimEars::find_single ( )

protected

{
    update_raycasters();
 
    if (m_editing_cache.size() == 0) {
        m_single_brim.clear();
        return;
    }
    const Selection         &selection = m_parent.get_selection();
    const GLVolume          *volume    = selection.get_volume(*selection.get_volume_idxs().begin());
    Geometry::Transformation trsf      = volume->get_instance_transformation();
    ExPolygons               model_pl  = m_first_layer;
 
    m_single_brim.clear();
    for (int i = 0; i < m_editing_cache.size(); i++)
        m_single_brim[i] = m_editing_cache[i];
    unsigned int index = 0;
    bool cyc = true;
    while (cyc) {
        index++;
        if (index > 99999999) break; // cycle protection
        if (m_single_brim.empty()) {
            break;
        }
        auto end = --m_single_brim.end();
        for (auto it = m_single_brim.begin(); it != m_single_brim.end(); ++it) {
            ExPolygon point_pl = make_polygon(it->second.brim_point, trsf);
            if (overlaps(model_pl, point_pl)) {
                model_pl.emplace_back(point_pl);
                model_pl = union_ex(model_pl);
                it = m_single_brim.erase(it);
                break;
            } else {
                if (it == end) cyc = false;
            }
        }
    }
    for (auto& it : m_editing_cache) {
        it.is_error = false;
    }
    for (auto &it : m_single_brim) {
        m_editing_cache[it.first].is_error = true;
    }
}

References Slic3r::GLVolume::get_instance_transformation(), Slic3r::GUI::Selection::get_volume(), Slic3r::GUI::Selection::get_volume_idxs(), m_editing_cache, m_first_layer, Slic3r::GUI::GLGizmoBase::m_parent, m_single_brim, make_polygon(), Slic3r::overlaps(), Slic3r::union_ex(), and update_raycasters().

Referenced by auto_generate(), delete_selected_points(), gizmo_event(), on_dragging(), reload_cache(), and update_cache_radius().

Here is the call graph for this function:

Here is the caller graph for this function:

first_layer_slicer()

void Slic3r::GUI::GLGizmoBrimEars::first_layer_slicer ( )

private

{
    const Selection              &selection = m_parent.get_selection();
    const Selection::IndicesList &idxs      = selection.get_volume_idxs();
    if (idxs.size() <= 0) return;
    std::vector<float>  slice_height(1, 0.1);
    MeshSlicingParamsEx params;
    params.mode           = MeshSlicingParams::SlicingMode::Regular;
    params.closing_radius = 0.1f;
    params.extra_offset   = 0.05f;
    params.resolution     = 0.01;
    ExPolygons part_ex;
    ExPolygons negative_ex;
    for (auto idx : idxs) {
        const GLVolume    *volume       = selection.get_volume(idx);
        const ModelVolume *model_volume = get_model_volume(*volume, wxGetApp().model());
        if (model_volume == nullptr) continue;
        if (model_volume->type() == ModelVolumeType::MODEL_PART || model_volume->type() == ModelVolumeType::NEGATIVE_VOLUME) {
            indexed_triangle_set volume_its = model_volume->mesh().its;
            if (volume_its.indices.size() <= 0) continue;
            Transform3d         trsf = volume->get_instance_transformation().get_matrix() * volume->get_volume_transformation().get_matrix();
            MeshSlicingParamsEx params_ex(params);
            params_ex.trafo = params_ex.trafo * trsf;
            if (params_ex.trafo.rotation().determinant() < 0.) its_flip_triangles(volume_its);
            ExPolygons sliced_layer = slice_mesh_ex(volume_its, slice_height, params_ex).front();
            if (model_volume->type() == ModelVolumeType::MODEL_PART) {
                part_ex = union_ex(part_ex, sliced_layer);
            } else {
                negative_ex = union_ex(negative_ex, sliced_layer);
            }
        }
    }
    m_first_layer = diff_ex(part_ex, negative_ex);
    get_detection_radius_max();
}

References Slic3r::MeshSlicingParamsEx::closing_radius, Slic3r::diff_ex(), Slic3r::MeshSlicingParamsEx::extra_offset, get_detection_radius_max(), Slic3r::GLVolume::get_instance_transformation(), Slic3r::Geometry::Transformation::get_matrix(), Slic3r::GUI::get_model_volume(), Slic3r::GUI::Selection::get_volume(), Slic3r::GUI::Selection::get_volume_idxs(), Slic3r::GLVolume::get_volume_transformation(), Slic3r::TriangleMesh::its, Slic3r::its_flip_triangles(), m_first_layer, Slic3r::GUI::GLGizmoBase::m_parent, Slic3r::ModelVolume::mesh(), Slic3r::MeshSlicingParams::mode, Slic3r::MODEL_PART, Slic3r::NEGATIVE_VOLUME, Slic3r::MeshSlicingParams::Regular, Slic3r::MeshSlicingParamsEx::resolution, Slic3r::slice_mesh_ex(), Slic3r::MeshSlicingParams::trafo, Slic3r::ModelVolume::type(), and Slic3r::union_ex().

Referenced by on_set_state().

Here is the call graph for this function:

Here is the caller graph for this function:

format()

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

protectedinherited

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

References Slic3r::string_printf().

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

Here is the call graph for this function:

Here is the caller graph for this function:

generate_points()

Points Slic3r::GUI::GLGizmoBrimEars::generate_points ( Polygon & obj_polygon, float ear_detection_length, float brim_ears_max_angle, bool is_outer )

private

{
    const coordf_t angle_threshold = (180 - brim_ears_max_angle) * PI / 180.0;
    Points         pt_ears;
    if (ear_detection_length > 0) {
        double detect_length = ear_detection_length / SCALING_FACTOR;
        Points points = obj_polygon.points;
        points.push_back(points.front());
        points = MultiPoint::_douglas_peucker(points, detect_length);
        if (points.size() > 4) {
            points.erase(points.end() - 1);
        }
        obj_polygon.points = points;
    }
    append(pt_ears, is_outer ? obj_polygon.convex_points(angle_threshold) : obj_polygon.concave_points(angle_threshold));
    return pt_ears;
}

References Slic3r::MultiPoint::_douglas_peucker(), Slic3r::append(), Slic3r::Polygon::concave_points(), Slic3r::Polygon::convex_points(), PI, Slic3r::MultiPoint::points, and SCALING_FACTOR.

Referenced by auto_generate().

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

float Slic3r::GUI::GLGizmoBrimEars::get_brim_default_radius ( ) const

protected

{
    const double              nozzle_diameter = wxGetApp().preset_bundle->printers.get_edited_preset().config.option<ConfigOptionFloats>("nozzle_diameter")->get_at(0);
    const DynamicPrintConfig &print_cfg = wxGetApp().preset_bundle->prints.get_edited_preset().config;
    return std::clamp(
        float(print_cfg.get_abs_value("initial_layer_line_width", nozzle_diameter) * 8.0),
        BRIM_EAR_RADIUS_MIN,
        BRIM_EAR_RADIUS_MAX);
}

References Slic3r::GUI::BRIM_EAR_RADIUS_MAX, Slic3r::GUI::BRIM_EAR_RADIUS_MIN, Slic3r::ConfigBase::get_abs_value(), and Slic3r::nozzle_diameter().

Referenced by on_init().

Here is the call graph for this function:

Here is the caller graph for this function:

get_config_options()

std::vector< const ConfigOption * > Slic3r::GUI::GLGizmoBrimEars::get_config_options ( const std::vector< std::string > & keys ) const

private

{
    std::vector<const ConfigOption *> out;
    const ModelObject                *mo = m_c->selection_info()->model_object();
 
    if (!mo) return out;
 
    const DynamicPrintConfig           &object_cfg  = mo->config.get();
    const DynamicPrintConfig           &print_cfg   = wxGetApp().preset_bundle->sla_prints.get_edited_preset().config;
    std::unique_ptr<DynamicPrintConfig> default_cfg = nullptr;
 
    for (const std::string &key : keys) {
        if (object_cfg.has(key))
            out.push_back(object_cfg.option(key));
        else if (print_cfg.has(key))
            out.push_back(print_cfg.option(key));
        else { // we must get it from defaults
            if (default_cfg == nullptr) default_cfg.reset(DynamicPrintConfig::new_from_defaults_keys(keys));
            out.push_back(default_cfg->option(key));
        }
    }
 
    return out;
}

References Slic3r::ModelObject::config, Slic3r::ModelConfig::get(), Slic3r::ConfigOptionResolver::has(), Slic3r::GUI::GLGizmoBase::m_c, Slic3r::DynamicPrintConfig::new_from_defaults_keys(), and Slic3r::ConfigBase::option().

Here is the call graph for this function:

get_count()

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

inlineinherited

{ return ++count; }

References count.

get_detection_radius_max()

void Slic3r::GUI::GLGizmoBrimEars::get_detection_radius_max ( )

private

{
    double max_dist = 0.0;
    int    min_points_num = 0;
    for (const ExPolygon &ex_poly : m_first_layer) {
        Polygon  out_poly   = ex_poly.contour;
        Polygons inner_poly = ex_poly.holes;
        polygons_reverse(inner_poly);
 
        Points out_points = out_poly.points;
        out_points.push_back(out_points.front());
        double tolerance = 0.0;
        min_points_num   = MultiPoint::_douglas_peucker(out_points, 0).size();
        int repeat       = 0;
        int loop_protect = 0;
        for (;;) {
            loop_protect++;
            tolerance += 10;
            int num = MultiPoint::_douglas_peucker(out_points, tolerance / SCALING_FACTOR).size();
            if (num == min_points_num) {
                repeat++;
                if (repeat > 1)
                    break;
            }
            min_points_num = num;
            if (loop_protect > 100) break;
        }
        loop_protect = 0;
        for (;;) {
            loop_protect++;
            tolerance -= 1;
            int num = MultiPoint::_douglas_peucker(out_points, tolerance / SCALING_FACTOR).size();
            if (num <= min_points_num) {
                min_points_num = num;
            }else{
                break;
            }
            if (loop_protect > 100) break;
        }
        tolerance += 1;
        if (tolerance > max_dist)
            max_dist = tolerance;
    }
    if (max_dist > 100 || max_dist <= 0) {
        m_detection_radius_max = 100;
    } else {
        m_detection_radius_max = max_dist;
    }
}

References Slic3r::MultiPoint::_douglas_peucker(), m_detection_radius_max, m_first_layer, Slic3r::MultiPoint::points, Slic3r::polygons_reverse(), and SCALING_FACTOR.

Referenced by first_layer_slicer().

Here is the call graph for this function:

Here is the caller graph for this function:

get_gizmo_entering_text()

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

inlineoverridevirtual

Reimplemented from Slic3r::GUI::GLGizmoBase.

{ return _u8L("Entering Brim Ears"); }

References _u8L.

get_gizmo_leaving_text()

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

inlineoverridevirtual

Reimplemented from Slic3r::GUI::GLGizmoBase.

{ return _u8L("Leaving Brim Ears"); }

References _u8L.

get_gizmo_name()

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

inlineinherited

{ return on_get_name(); }

References on_get_name().

Here is the call graph for this function:

get_hover_id()

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

inlineinherited

{ return m_hover_id; }

References m_hover_id.

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

Here is the caller graph for this function:

get_icon_filename()

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

inlineinherited

{ return m_icon_filename; }

References m_icon_filename.

get_name()

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

inherited

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

References m_shortcut, and on_get_name().

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

Here is the call graph for this function:

Here is the caller graph for this function:

get_requirements()

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

inlineinherited

{ return on_get_requirements(); }

References on_get_requirements().

Here is the call graph for this function:

get_sprite_id()

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

inlineinherited

{ return m_sprite_id; }

References m_sprite_id.

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

Here is the caller graph for this function:

get_state()

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

inlineinherited

{ return m_state; }

References m_state.

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

Here is the caller graph for this function:

get_tooltip()

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

inlinevirtualinherited

Mouse tooltip text.

Returns

Text to be visible in mouse tooltip

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

{ return ""; }

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

Here is the caller graph for this function:

gizmo_event()

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

{
    if (action != SLAGizmoEventType::MouseWheelDown && action != SLAGizmoEventType::MouseWheelUp && action != SLAGizmoEventType::Moving) {
        apply_radius_change();
    }
 
    ModelObject *mo          = m_c->selection_info()->model_object();
    int          active_inst = m_c->selection_info()->get_active_instance();
 
    if (action == SLAGizmoEventType::Moving) {
        // First check that the mouse pointer is on an object.
        const Selection     &selection = m_parent.get_selection();
        const ModelInstance *mi        = mo->instances[0];
        Plater              *plater    = wxGetApp().plater();
        if (!plater) return false;
        const Camera           &camera       = wxGetApp().plater()->get_camera();
        const GLVolume         *volume       = selection.get_volume(*selection.get_volume_idxs().begin());
        Transform3d             inverse_trsf = volume->get_instance_transformation().get_matrix_no_offset().inverse();
        std::pair<Vec3f, Vec3f> pos_and_normal;
        if (unproject_on_mesh2(mouse_position, pos_and_normal)) {
            render_hover_point = CacheEntry(BrimPoint(pos_and_normal.first, m_new_point_head_radius), false, (inverse_trsf * m_world_normal).cast<float>(), true);
        } else {
            render_hover_point.reset();
        }
    } else if (action == SLAGizmoEventType::LeftDown && (shift_down || alt_down || control_down)) {
        // left down with shift - show the selection rectangle:
        if (m_hover_id == -1) {
            if (shift_down || alt_down) { m_selection_rectangle.start_dragging(mouse_position, shift_down ? GLSelectionRectangle::Select : GLSelectionRectangle::Deselect); }
        } else {
            if (m_editing_cache[m_hover_id].selected)
                unselect_point(m_hover_id);
            else {
                if (!alt_down) select_point(m_hover_id);
            }
        }
 
        return true;
    }
 
    // left down without selection rectangle - place point on the mesh:
    if (action == SLAGizmoEventType::LeftDown && !m_selection_rectangle.is_dragging() && !shift_down) {
        // If any point is in hover state, this should initiate its move - return control back to GLCanvas:
        if (m_hover_id != -1) return false;
 
        // If there is some selection, don't add new point and deselect everything instead.
        if (m_selection_empty) {
            std::pair<Vec3f, Vec3f> pos_and_normal;
            if (unproject_on_mesh2(mouse_position, pos_and_normal)) {
                // we got an intersection
                const Selection &selection    = m_parent.get_selection();
                const GLVolume  *volume       = selection.get_volume(*selection.get_volume_idxs().begin());
                Transform3d      trsf         = volume->get_instance_transformation().get_matrix();
                Transform3d      inverse_trsf = volume->get_instance_transformation().get_matrix_no_offset().inverse();
                // BBS brim ear postion is placed on the bottom side
                Vec3d world_pos  = trsf * pos_and_normal.first.cast<double>();
                world_pos[2]     = -0.0001;
                Vec3d object_pos = trsf.inverse() * world_pos;
                // brim ear always face up
                Plater::TakeSnapshot snapshot(wxGetApp().plater(), "Add brim ear");
                add_point_to_cache(object_pos.cast<float>(), m_new_point_head_radius, false, (inverse_trsf * m_world_normal).cast<float>());
                m_parent.set_as_dirty();
                m_wait_for_up_event = true;
                find_single();
            } else
                return false;
        } else
            select_point(NoPoints);
 
        return true;
    }
 
    // left up with selection rectangle - select points inside the rectangle:
    if ((action == SLAGizmoEventType::LeftUp || action == SLAGizmoEventType::ShiftUp || action == SLAGizmoEventType::AltUp) && m_selection_rectangle.is_dragging()) {
        // Is this a selection or deselection rectangle?
        GLSelectionRectangle::EState rectangle_status = m_selection_rectangle.get_state();
 
        // First collect positions of all the points in world coordinates.
        Geometry::Transformation trafo = mo->instances[active_inst]->get_transformation();
        // trafo.set_offset(trafo.get_offset() + Vec3d(0., 0., m_c->selection_info()->get_sla_shift()));
        std::vector<Vec3d> points;
        for (unsigned int i = 0; i < m_editing_cache.size(); ++i) points.push_back(trafo.get_matrix() * m_editing_cache[i].brim_point.pos.cast<double>());
 
        // Now ask the rectangle which of the points are inside.
        std::vector<Vec3f>        points_inside;
        std::vector<unsigned int> points_idxs = m_selection_rectangle.contains(points);
        m_selection_rectangle.stop_dragging();
        for (size_t idx : points_idxs) points_inside.push_back(points[idx].cast<float>());
 
        // Only select/deselect points that are actually visible. We want to check not only
        // the point itself, but also the center of base of its cone, so the points don't hide
        // under every miniature irregularity on the model. Remember the actual number and
        // append the cone bases.
        size_t orig_pts_num = points_inside.size();
        for (size_t idx : points_idxs)
            points_inside.emplace_back((trafo.get_matrix().cast<float>() * (m_editing_cache[idx].brim_point.pos + m_editing_cache[idx].normal)).cast<float>());
 
        for (size_t idx :
             m_c->raycaster()->raycaster()->get_unobscured_idxs(trafo, wxGetApp().plater()->get_camera(), points_inside, m_c->object_clipper()->get_clipping_plane())) {
            if (idx >= orig_pts_num) // this is a cone-base, get index of point it belongs to
                idx -= orig_pts_num;
            if (rectangle_status == GLSelectionRectangle::Deselect)
                unselect_point(points_idxs[idx]);
            else
                select_point(points_idxs[idx]);
        }
        return true;
    }
 
    // left up with no selection rectangle
    if (action == SLAGizmoEventType::LeftUp) {
        if (m_wait_for_up_event) { m_wait_for_up_event = false; }
        return true;
    }
 
    // dragging the selection rectangle:
    if (action == SLAGizmoEventType::Dragging) {
        if (m_wait_for_up_event)
            return true; // point has been placed and the button not released yet
                         // this prevents GLCanvas from starting scene rotation
 
        if (m_selection_rectangle.is_dragging()) {
            m_selection_rectangle.dragging(mouse_position);
            return true;
        }
 
        return false;
    }
 
    if (action == SLAGizmoEventType::Delete) {
        // delete key pressed
        delete_selected_points();
        return true;
    }
 
    if (action == SLAGizmoEventType::RightDown) {
        if (m_hover_id != -1) {
            select_point(NoPoints);
            select_point(m_hover_id);
            delete_selected_points();
            return true;
        }
        return false;
    }
 
    if (action == SLAGizmoEventType::SelectAll) {
        select_point(AllPoints);
        return true;
    }
 
    // mouse wheel up
    if (action == SLAGizmoEventType::MouseWheelUp) {
        if (control_down) {
            float initial_value = m_new_point_head_radius;
            begin_radius_change(initial_value);
            m_new_point_head_radius = std::min(BRIM_EAR_RADIUS_MAX, initial_value + 0.1f);
            update_cache_radius();
            return true;
        }
 
        apply_radius_change();
    }
 
    if (action == SLAGizmoEventType::MouseWheelDown) {
        if (control_down) {
            float initial_value = m_new_point_head_radius;
            begin_radius_change(initial_value);
            m_new_point_head_radius = std::max(BRIM_EAR_RADIUS_MIN, initial_value - 0.1f);
            update_cache_radius();
            return true;
        }
 
        apply_radius_change();
    }
 
    return false;
}

References add_point_to_cache(), AllPoints, Slic3r::GUI::AltUp, apply_radius_change(), begin_radius_change(), Slic3r::GUI::BRIM_EAR_RADIUS_MAX, Slic3r::GUI::BRIM_EAR_RADIUS_MIN, Slic3r::cast(), Slic3r::GUI::Delete, delete_selected_points(), Slic3r::GUI::GLSelectionRectangle::Deselect, Slic3r::GUI::Dragging, find_single(), Slic3r::GLVolume::get_instance_transformation(), Slic3r::Geometry::Transformation::get_matrix(), Slic3r::Geometry::Transformation::get_matrix_no_offset(), Slic3r::GUI::Selection::get_volume(), Slic3r::GUI::Selection::get_volume_idxs(), Slic3r::ModelObject::instances, Slic3r::GUI::LeftDown, Slic3r::GUI::LeftUp, Slic3r::GUI::GLGizmoBase::m_c, m_editing_cache, Slic3r::GUI::GLGizmoBase::m_hover_id, m_new_point_head_radius, Slic3r::GUI::GLGizmoBase::m_parent, m_selection_empty, m_selection_rectangle, m_wait_for_up_event, m_world_normal, Slic3r::GUI::MouseWheelDown, Slic3r::GUI::MouseWheelUp, Slic3r::GUI::Moving, NoPoints, Slic3r::GUI::plater(), Slic3r::points_inside(), render_hover_point, Slic3r::GUI::RightDown, Slic3r::GUI::GLSelectionRectangle::Select, select_point(), Slic3r::GUI::SelectAll, Slic3r::GUI::ShiftUp, unproject_on_mesh2(), unselect_point(), and update_cache_radius().

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

Here is the call graph for this function:

Here is the caller graph for this function:

GizmoImguiBegin()

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

protectedinherited

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

References m_imgui.

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

Here is the caller graph for this function:

GizmoImguiEnd()

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

protectedinherited

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

References last_input_window_width, and m_imgui.

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

Here is the caller graph for this function:

GizmoImguiSetNextWIndowPos() [1/2]

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

protectedinherited

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

References m_imgui, and m_parent.

GizmoImguiSetNextWIndowPos() [2/2]

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

protectedinherited

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

References GizmoImguiSetNextWIndowPos(), and last_input_window_width.

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

Here is the call graph for this function:

Here is the caller graph for this function:

has_selected_points()

bool Slic3r::GUI::GLGizmoBrimEars::has_selected_points

(

)

const

{
    for (const auto& entry : m_editing_cache) {
        if (entry.selected)
            return true;
    }
    return false;
}

References m_editing_cache.

Referenced by on_render_input_window().

Here is the caller graph for this function:

init()

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

inlineinherited

{ return on_init(); }

References on_init().

Here is the call graph for this function:

is_activable()

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

inlineinherited

{ return on_is_activable(); }

References on_is_activable().

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

Here is the call graph for this function:

Here is the caller graph for this function:

is_dragging()

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

inlineinherited

{ return m_dragging; }

References m_dragging.

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

Here is the caller graph for this function:

is_in_editing_mode()

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

inlinevirtualinherited

Reimplemented in Slic3r::GUI::GLGizmoCut3D.

{ return false; }

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

Here is the caller graph for this function:

is_mesh_point_clipped()

bool Slic3r::GUI::GLGizmoBrimEars::is_mesh_point_clipped ( const Vec3d & point ) const

private

{
    if (m_c->object_clipper()->get_position() == 0.) return false;
 
    auto                 sel_info    = m_c->selection_info();
    int                  active_inst = m_c->selection_info()->get_active_instance();
    const ModelInstance *mi          = sel_info->model_object()->instances[active_inst];
    const Transform3d   &trafo       = mi->get_transformation().get_matrix();
 
    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::Geometry::Transformation::get_matrix(), Slic3r::ModelInstance::get_transformation(), and Slic3r::GUI::GLGizmoBase::m_c.

Here is the call graph for this function:

is_selectable()

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

inlineinherited

{ return on_is_selectable(); }

References on_is_selectable().

Here is the call graph for this function:

is_selection_rectangle_dragging()

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

inlineoverridevirtual

Reimplemented from Slic3r::GUI::GLGizmoBase.

{ return m_selection_rectangle.is_dragging(); }

References m_selection_rectangle.

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

Here is the caller graph for this function:

load()

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

inlineinherited

{ m_state = On; on_load(ar); }

References m_state, On, and on_load().

Here is the call graph for this function:

load_render_colors()

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

staticinherited

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

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

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

Here is the call graph for this function:

Here is the caller graph for this function:

make_polygon()

ExPolygon Slic3r::GUI::GLGizmoBrimEars::make_polygon ( BrimPoint point, const Geometry::Transformation & trsf )

protected

{
    ExPolygon   point_round;
    Transform3d model_trsf = trsf.get_matrix();
    Vec3f       world_pos  = point.transform(trsf.get_matrix());
    coord_t     size_ear   = scale_(point.head_front_radius);
    for (size_t i = 0; i < POLY_SIDE_COUNT; i++) {
        double angle = (2.0 * PI * i) / POLY_SIDE_COUNT;
        point_round.contour.points.emplace_back(size_ear * cos(angle), size_ear * sin(angle));
    }
    Vec3f   pos  = point.transform(model_trsf);
    int32_t pt_x = scale_(pos.x());
    int32_t pt_y = scale_(pos.y());
    point_round.translate(Point(pt_x, pt_y));
    return point_round;
}

References Slic3r::angle(), Slic3r::ExPolygon::contour, Slic3r::Geometry::Transformation::get_matrix(), Slic3r::BrimPoint::head_front_radius, PI, Slic3r::MultiPoint::points, POLY_SIDE_COUNT, scale_, Slic3r::BrimPoint::transform(), and Slic3r::ExPolygon::translate().

Referenced by find_single().

Here is the call graph for this function:

Here is the caller graph for this function:

on_change_color_mode()

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

inlinevirtualinherited

{  m_is_dark_mode = is_dark; }

References is_dark(), and m_is_dark_mode.

Here is the call graph for this function:

on_disable_grabber()

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

inlineprotectedvirtualinherited

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

{}

on_dragging()

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

overrideprivatevirtual

Reimplemented from Slic3r::GUI::GLGizmoBase.

{
    if (m_hover_id != -1) {
        std::pair<Vec3f, Vec3f> pos_and_normal;
        if (!unproject_on_mesh2(data.mouse_pos.cast<double>(), pos_and_normal)) return;
        m_editing_cache[m_hover_id].brim_point.pos[0] = pos_and_normal.first.x();
        m_editing_cache[m_hover_id].brim_point.pos[1] = pos_and_normal.first.y();
        //m_editing_cache[m_hover_id].normal            = pos_and_normal.second;
        m_editing_cache[m_hover_id].normal = Vec3f(0, 0, 1);
        find_single();
    }
}

References find_single(), m_editing_cache, Slic3r::GUI::GLGizmoBase::m_hover_id, Slic3r::GUI::GLGizmoBase::UpdateData::mouse_pos, and unproject_on_mesh2().

Here is the call graph for this function:

on_enable_grabber()

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

inlineprotectedvirtualinherited

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

{}

on_get_name()

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

overrideprotectedvirtual

Implements Slic3r::GUI::GLGizmoBase.

{
    if (!on_is_activable() && m_state == EState::Off) {
        return _u8L("Brim Ears") + ":\n" + _u8L("Please select single object.");
    } else {
        return _u8L("Brim Ears");
    }
}

References _u8L, Slic3r::GUI::GLGizmoBase::m_state, Slic3r::GUI::GLGizmoBase::Off, and on_is_activable().

Here is the call graph for this function:

on_get_requirements()

CommonGizmosDataID Slic3r::GUI::GLGizmoBrimEars::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()

bool Slic3r::GUI::GLGizmoBrimEars::on_init ( )

overrideprivatevirtual

Implements Slic3r::GUI::GLGizmoBase.

{
    m_new_point_head_radius = get_brim_default_radius();
 
    m_shortcut = Shortcut::GizmoBrimEars;
 
    const wxString ctrl = GUI::shortkey_ctrl_prefix();
 
    m_desc["brim_ear_radius"]       = _L("Brim ear radius");
    m_desc["max_angle"]             = _L("Max angle");
    m_desc["detection_radius"]      = _L("Detection radius");
    m_desc["remove"]                = _L("Remove");
    m_desc["remove_selected"]       = _L("Selected");
    m_desc["remove_all"]            = _L("All");
    m_desc["create"]                = _L("Create");
    m_desc["auto_generate"]         = _L("Auto-generate");
    m_desc["auto-generate-tooltip"] = _L("Generate brim ears using Max angle and Detection radius");
 
    m_shortcuts = {
        {_L("Left mouse button"),   _L("Add or Select")},
        {_L("Right mouse button"),  _L("Remove")},
        {ctrl + _L("Mouse wheel"),  m_desc["brim_ear_radius"]},
    };
 
    return true;
}

References _L, get_brim_default_radius(), Slic3r::GUI::GizmoBrimEars, m_desc, m_new_point_head_radius, Slic3r::GUI::GLGizmoBase::m_shortcut, m_shortcuts, and Slic3r::GUI::shortkey_ctrl_prefix().

Here is the call graph for this function:

on_is_activable()

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

overrideprotectedvirtual

Reimplemented from Slic3r::GUI::GLGizmoBase.

{
    const Selection &selection = m_parent.get_selection();
 
    if (!selection.is_single_full_instance()) return false;
 
    // Check that none of the selected volumes is outside. Only SLA auxiliaries (supports) are allowed outside.
    // const Selection::IndicesList &list = selection.get_volume_idxs();
    // for (const auto &idx : list)
    //     if (selection.get_volume(idx)->is_outside && selection.get_volume(idx)->composite_id.volume_id >= 0) return false;
 
    return true;
}

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

Referenced by on_get_name().

Here is the call graph for this function:

Here is the caller graph for this function:

on_is_selectable()

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

inlineprotectedvirtualinherited

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

{ return true; }

Referenced by is_selectable().

Here is the caller graph for this function:

on_load()

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

overrideprotectedvirtual

Reimplemented from Slic3r::GUI::GLGizmoBase.

{ ar(m_new_point_head_radius, m_editing_cache, m_selection_empty); }

References m_editing_cache, m_new_point_head_radius, and m_selection_empty.

on_mouse()

bool Slic3r::GUI::GLGizmoBrimEars::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.

{
    // 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()) {
        gizmo_event(SLAGizmoEventType::Moving, mouse_pos, mouse_event.ShiftDown(), mouse_event.AltDown(), 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 (gizmo_event(SLAGizmoEventType::LeftUp, mouse_pos, mouse_event.ShiftDown(), mouse_event.AltDown(), control_down)
            && !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
            return true;
        }
    }
    return use_grabbers(mouse_event);
}

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

Here is the call graph for this function:

on_register_raycasters_for_picking()

void Slic3r::GUI::GLGizmoBrimEars::on_register_raycasters_for_picking ( )

overrideprotectedvirtual

Reimplemented from Slic3r::GUI::GLGizmoBase.

                                                         {
    update_raycasters();
}

References update_raycasters().

Here is the call graph for this function:

on_render()

void Slic3r::GUI::GLGizmoBrimEars::on_render ( )

overrideprivatevirtual

Implements Slic3r::GUI::GLGizmoBase.

{
    ModelObject     *mo        = m_c->selection_info()->model_object();
    const Selection &selection = m_parent.get_selection();
 
    // If current m_c->m_model_object does not match selection, ask GLCanvas3D to turn us off
    if (m_state == On && (mo != selection.get_model()->objects[selection.get_object_idx()] || m_c->selection_info()->get_active_instance() != selection.get_instance_idx())) {
        m_parent.post_event(SimpleEvent(EVT_GLCANVAS_RESETGIZMOS));
        return;
    }
 
    glsafe(::glEnable(GL_BLEND));
    glsafe(::glEnable(GL_DEPTH_TEST));
 
    if (selection.is_from_single_instance()) render_points(selection);
 
    m_selection_rectangle.render(m_parent);
    m_c->object_clipper()->render_cut();
 
    glsafe(::glDisable(GL_BLEND));
}

References Slic3r::GUI::Selection::get_instance_idx(), Slic3r::GUI::Selection::get_model(), Slic3r::GUI::Selection::get_object_idx(), GL_BLEND, GL_DEPTH_TEST, glDisable, glEnable, glsafe, Slic3r::GUI::Selection::is_from_single_instance(), Slic3r::GUI::GLGizmoBase::m_c, Slic3r::GUI::GLGizmoBase::m_parent, m_selection_rectangle, Slic3r::GUI::GLGizmoBase::m_state, Slic3r::Model::objects, Slic3r::GUI::GLGizmoBase::On, and render_points().

Here is the call graph for this function:

on_render_input_window()

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

overrideprotectedvirtual

Reimplemented from Slic3r::GUI::GLGizmoBase.

{
    static float last_y = 0.0f;
    static float last_h = 0.0f;
 
    ModelObject *mo = m_c->selection_info()->model_object();
 
    if (!mo) return;
 
    const DynamicPrintConfig& obj_cfg = mo->config.get();
    const DynamicPrintConfig& glb_cfg = wxGetApp().preset_bundle->prints.get_edited_preset().config;
    const float win_h = ImGui::GetWindowHeight();
    y                 = std::min(y, bottom_limit - win_h);
    GizmoImguiSetNextWIndowPos(x, y, ImGuiCond_Always, 0.0f, 0.0f);
 
    const float f_scale = m_parent.get_scale();
    ImGuiWrapper::push_toolbar_style(f_scale);
    ImGui::PushStyleVar(ImGuiStyleVar_FramePadding, ImVec2(6.0f, 4.0f * f_scale));
    GizmoImguiBegin(get_name(),
                    ImGuiWindowFlags_AlwaysAutoResize | ImGuiWindowFlags_NoMove | ImGuiWindowFlags_NoResize | ImGuiWindowFlags_NoCollapse | ImGuiWindowFlags_NoTitleBar);
 
    float                 space_size      = m_imgui->get_style_scaling() * 8;
    std::vector<wxString> text_list       = {m_desc["brim_ear_radius"], m_desc["max_angle"], m_desc["detection_radius"], m_desc["create"],
                                             m_desc["remove"]};
    float                 widest_text     = m_imgui->find_widest_text(text_list);
    float                 caption_size    = widest_text + space_size + ImGui::GetStyle().WindowPadding.x;
    float                 input_text_size = m_imgui->scaled(10.0f);
    float                 button_size     = ImGui::GetFrameHeight();
 
    float list_width      = input_text_size + ImGui::GetStyle().ScrollbarSize + 2 * f_scale;
 
    const float slider_icon_width = m_imgui->get_slider_icon_size().x;
    const float slider_width      = list_width - space_size;
    const float drag_left_width   = caption_size + slider_width + space_size;
 
    // adjust window position to avoid overlap the view toolbar
    if (last_h != win_h || last_y != y) {
        // ask canvas for another frame to render the window in the correct position
        m_imgui->set_requires_extra_frame();
        if (last_h != win_h) last_h = win_h;
        if (last_y != y) last_y = y;
    }
 
 
    // Following is a nasty way to:
    //  - save the initial value of the slider before one starts messing with it
    //  - keep updating the head radius during sliding so it is continuosly refreshed in 3D scene
    //  - take correct undo/redo snapshot after the user is done with moving the slider
    ImGui::AlignTextToFramePadding();
    float initial_value = m_new_point_head_radius;
    m_imgui->text(m_desc["brim_ear_radius"]);
    ImGui::SameLine(caption_size);
    ImGui::PushItemWidth(slider_width);
    m_imgui->bbl_slider_float_style("##brim_ear_radius", &m_new_point_head_radius, BRIM_EAR_RADIUS_MIN, BRIM_EAR_RADIUS_MAX, "%.1f", 1.0f, true);
    if (m_imgui->get_last_slider_status().clicked) {
        begin_radius_change(initial_value);
    }
    if (m_imgui->get_last_slider_status().edited)
        update_cache_radius();
    if (m_imgui->get_last_slider_status().deactivated_after_edit) {
        apply_radius_change();
    }
    ImGui::SameLine(drag_left_width);
    ImGui::PushItemWidth(1.5 * slider_icon_width);
    ImGui::BBLDragFloat("##brim_ear_radius_input", &m_new_point_head_radius, 0.05f, BRIM_EAR_RADIUS_MIN, BRIM_EAR_RADIUS_MAX, "%.1f");
 
    ImGui::Separator();
 
    ImGui::AlignTextToFramePadding();
    m_imgui->text(m_desc["max_angle"]);
    ImGui::SameLine(caption_size);
    ImGui::PushItemWidth(slider_width);
    m_imgui->bbl_slider_float_style("##max_angle", &m_max_angle, 0, 180, "%.1f", 1.0f, true);
    ImGui::SameLine(drag_left_width);
    ImGui::PushItemWidth(1.5 * slider_icon_width);
    ImGui::BBLDragFloat("##max_angle_input", &m_max_angle, 0.05f, 0.0f, 180.0f, "%.1f");
 
    ImGui::AlignTextToFramePadding();
    m_imgui->text(m_desc["detection_radius"]);
    ImGui::SameLine(caption_size);
    ImGui::PushItemWidth(slider_width);
    m_imgui->bbl_slider_float_style("##detection_radius", &m_detection_radius, 0, static_cast<int>(m_detection_radius_max), "%.1f", 1.0f, true);
    ImGui::SameLine(drag_left_width);
    ImGui::PushItemWidth(1.5 * slider_icon_width);
    ImGui::BBLDragFloat("##detection_radius_input", &m_detection_radius, 0.05f, 0.0f, static_cast<float>(m_detection_radius_max), "%.1f");
        
    ImGui::Separator();
 
    ImGui::AlignTextToFramePadding();
    m_imgui->text(m_desc["create"]);
    ImGui::SameLine(caption_size);
    if (m_imgui->button(m_desc["auto_generate"], m_desc["auto-generate-tooltip"])) {
        auto_generate();
    }
 
    ImGui::AlignTextToFramePadding();
    m_imgui->text(m_desc["remove"]);
    ImGui::SameLine(caption_size);
    m_imgui->disabled_begin(has_selected_points() == false);
    if (m_imgui->button(m_desc["remove_selected"])) {
        delete_selected_points();
    }
    m_imgui->disabled_end();
    ImGui::SameLine();
    m_imgui->disabled_begin(m_editing_cache.empty());
    if (m_imgui->button(m_desc["remove_all"])) {
        if (m_editing_cache.size() > 0) {
            select_point(AllPoints);
            delete_selected_points();
        }
    }
    m_imgui->disabled_end();
 
    ImGui::Separator();
 
    GLGizmoUtils::render_tooltip_button(m_imgui, m_parent, m_shortcuts, x, y);
 
    ImGui::SameLine();
    GLGizmoUtils::begin_right_aligned_buttons({_L("Done")});
    if (m_imgui->button(_L("Done"))) {
        m_parent.reset_all_gizmos();
    }
 
    bool brim_not_painted = (obj_cfg.option("brim_type")) ? (obj_cfg.opt_enum<BrimType>("brim_type") != btPainted) :
                                                            (glb_cfg.opt_enum<BrimType>("brim_type") != btPainted);
    bool has_invalid_ears = !m_single_brim.empty();
 
    if (brim_not_painted || has_invalid_ears) {
        ImGui::Separator();
        ImGui::PushStyleColor(ImGuiCol_Text, ImGuiWrapper::COL_WARNING);
 
        float parent_width = ImGui::GetContentRegionAvail().x;
        float font_size    = ImGui::GetFontSize();
 
        if (brim_not_painted) {
            m_imgui->text_wrapped(_L("Warning: The brim type is not set to \"painted\", the brim ears will not take effect!"), parent_width);
 
            ImColor HyperColor = ImGuiWrapper::COL_ORCA;
            ImGui::PushStyleColor(ImGuiCol_Text, HyperColor.Value);
 
            ImGui::Dummy(ImVec2(font_size * 1.8f, 0.0f)); // Horizontal indent
            ImGui::SameLine();
            m_imgui->bold_text(_u8L("Set the brim type of this object to \"painted\""));
 
            ImVec2 min = ImGui::GetItemRectMin();
            ImVec2 max = ImGui::GetItemRectMax();
            ImGui::GetWindowDrawList()->AddLine(ImVec2(min.x, max.y - 2.0f), ImVec2(max.x, max.y - 2.0f), HyperColor);
 
            if (ImGui::IsMouseHoveringRect(min, max)) {
                m_link_text_hover = true;
                ImGui::SetMouseCursor(ImGuiMouseCursor_Hand);
                if (ImGui::IsMouseClicked(ImGuiMouseButton_Left)) {
                    DynamicPrintConfig new_conf = obj_cfg;
                    new_conf.set_key_value("brim_type", new ConfigOptionEnum<BrimType>(btPainted));
                    mo->config.assign_config(new_conf);
                }
            } else {
                m_link_text_hover = false;
            }
            ImGui::PopStyleColor(1); // Pop HyperColor
        }
 
        if (has_invalid_ears) {
            const int n_invalid = int(m_single_brim.size());
            wxString out = _L("Warning") + ": " + wxString::Format(_L_PLURAL("%d invalid brim ear", "%d invalid brim ears", n_invalid), n_invalid);
            m_imgui->text_wrapped(out, parent_width);
        }
 
        ImGui::PopStyleColor(1); // Pop Warning Color
    } else {
        // Reset hover state if no warnings are active
        m_link_text_hover = false;
    }
 
    GizmoImguiEnd();
    ImGui::PopStyleVar(1); // ImGuiStyleVar_FramePadding
    ImGuiWrapper::pop_toolbar_style();
}

References _L, _L_PLURAL, _u8L, AllPoints, apply_radius_change(), Slic3r::ModelConfig::assign_config(), auto_generate(), begin_radius_change(), Slic3r::GUI::GLGizmoUtils::begin_right_aligned_buttons(), Slic3r::GUI::BRIM_EAR_RADIUS_MAX, Slic3r::GUI::BRIM_EAR_RADIUS_MIN, Slic3r::btPainted, Slic3r::GUI::ImGuiWrapper::COL_ORCA, Slic3r::GUI::ImGuiWrapper::COL_WARNING, Slic3r::ModelObject::config, delete_selected_points(), Slic3r::ModelConfig::get(), Slic3r::GUI::GLGizmoBase::get_name(), Slic3r::GUI::GLGizmoBase::GizmoImguiBegin(), Slic3r::GUI::GLGizmoBase::GizmoImguiEnd(), Slic3r::GUI::GLGizmoBase::GizmoImguiSetNextWIndowPos(), has_selected_points(), Slic3r::GUI::GLGizmoBase::m_c, m_desc, m_detection_radius, m_detection_radius_max, m_editing_cache, Slic3r::GUI::GLGizmoBase::m_imgui, m_link_text_hover, m_max_angle, m_new_point_head_radius, Slic3r::GUI::GLGizmoBase::m_parent, m_shortcuts, m_single_brim, Slic3r::DynamicConfig::opt_enum(), Slic3r::ConfigBase::option(), Slic3r::GUI::ImGuiWrapper::pop_toolbar_style(), Slic3r::GUI::ImGuiWrapper::push_toolbar_style(), Slic3r::GUI::GLGizmoUtils::render_tooltip_button(), select_point(), Slic3r::DynamicConfig::set_key_value(), and update_cache_radius().

Here is the call graph for this function:

on_save()

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

overrideprotectedvirtual

Reimplemented from Slic3r::GUI::GLGizmoBase.

{ ar(m_new_point_head_radius, m_editing_cache, m_selection_empty); }

References m_editing_cache, m_new_point_head_radius, and m_selection_empty.

on_set_hover_id()

void Slic3r::GUI::GLGizmoBrimEars::on_set_hover_id ( )

inlineoverrideprotectedvirtual

Reimplemented from Slic3r::GUI::GLGizmoBase.

    {
        if ((int)m_editing_cache.size() <= m_hover_id)
            m_hover_id = -1;
    }

References m_editing_cache, and Slic3r::GUI::GLGizmoBase::m_hover_id.

on_set_state()

void Slic3r::GUI::GLGizmoBrimEars::on_set_state ( )

overrideprotectedvirtual

Reimplemented from Slic3r::GUI::GLGizmoBase.

{
    if (m_state == m_old_state) return;
 
    if (m_state == On && m_old_state != On) {
        // the gizmo was just turned on
        wxGetApp().plater()->enter_gizmos_stack();
        first_layer_slicer();
    }
    if (m_state == Off && m_old_state != Off) {
        // the gizmo was just turned Off
        Plater::TakeSnapshot snapshot(wxGetApp().plater(), "Brim ears edit");
        update_model_object();
        wxGetApp().plater()->leave_gizmos_stack();
        // wxGetApp().mainframe->update_slice_print_status(MainFrame::SlicePrintEventType::eEventSliceUpdate, true, true);
    }
    m_old_state = m_state;
}

References first_layer_slicer(), m_old_state, Slic3r::GUI::GLGizmoBase::m_state, Slic3r::GUI::GLGizmoBase::Off, Slic3r::GUI::GLGizmoBase::On, Slic3r::GUI::plater(), and update_model_object().

Here is the call graph for this function:

on_start_dragging()

void Slic3r::GUI::GLGizmoBrimEars::on_start_dragging ( )

overrideprotectedvirtual

Reimplemented from Slic3r::GUI::GLGizmoBase.

{
    if (m_hover_id != -1) {
        select_point(NoPoints);
        select_point(m_hover_id);
        m_point_before_drag = m_editing_cache[m_hover_id];
    } else
        m_point_before_drag = CacheEntry();
}

References m_editing_cache, Slic3r::GUI::GLGizmoBase::m_hover_id, m_point_before_drag, NoPoints, and select_point().

Here is the call graph for this function:

on_stop_dragging()

void Slic3r::GUI::GLGizmoBrimEars::on_stop_dragging ( )

overrideprotectedvirtual

Reimplemented from Slic3r::GUI::GLGizmoBase.

{
    if (m_hover_id != -1) {
        CacheEntry backup = m_editing_cache[m_hover_id];
 
        if (m_point_before_drag.brim_point.pos != Vec3f::Zero()             // some point was touched
            && backup.brim_point.pos != m_point_before_drag.brim_point.pos) // and it was moved, not just selected
        {
            m_editing_cache[m_hover_id] = m_point_before_drag;
            Plater::TakeSnapshot snapshot(wxGetApp().plater(), "Move support point");
            m_editing_cache[m_hover_id] = backup;
        }
    }
    m_point_before_drag = CacheEntry();
}

References Slic3r::GUI::GLGizmoBrimEars::CacheEntry::brim_point, m_editing_cache, Slic3r::GUI::GLGizmoBase::m_hover_id, m_point_before_drag, Slic3r::GUI::plater(), and Slic3r::BrimPoint::pos.

Here is the call graph for this function:

on_unregister_raycasters_for_picking()

void Slic3r::GUI::GLGizmoBrimEars::on_unregister_raycasters_for_picking ( )

overrideprotectedvirtual

Reimplemented from Slic3r::GUI::GLGizmoBase.

{
    m_parent.remove_raycasters_for_picking(SceneRaycaster::EType::Gizmo);
    m_grabbers.clear();
}

References Slic3r::GUI::SceneRaycaster::Gizmo, Slic3r::GUI::GLGizmoBase::m_grabbers, and Slic3r::GUI::GLGizmoBase::m_parent.

register_grabbers_for_picking()

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

protectedinherited

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

References m_grabbers, and m_group_id.

Referenced by register_raycasters_for_picking().

Here is the caller graph for this function:

register_raycasters_for_picking()

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

inlineinherited

{ register_grabbers_for_picking(); on_register_raycasters_for_picking(); }

References on_register_raycasters_for_picking(), and register_grabbers_for_picking().

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

Here is the call graph for this function:

Here is the caller graph for this function:

register_single_mesh_pick()

void Slic3r::GUI::GLGizmoBrimEars::register_single_mesh_pick ( )

protected

{
    Selection                    &selection = m_parent.get_selection();
    const Selection::IndicesList &idxs      = selection.get_volume_idxs();
    if (idxs.size() > 0) {
        for (unsigned int idx : idxs) {
            GLVolume *v          = const_cast<GLVolume *>(selection.get_volume(idx));
            const ModelVolume* mv = get_model_volume(*v, wxGetApp().model());
            if (!mv->is_model_part()) continue;
            auto      world_tran = v->get_instance_transformation() * v->get_volume_transformation();
            if (m_mesh_raycaster_map.find(v) != m_mesh_raycaster_map.end()) {
                m_mesh_raycaster_map[v]->set_transform(world_tran.get_matrix());
            } else {
                auto mesh               = mv->mesh_ptr();
                m_mesh_raycaster_map[v] = std::make_shared<PickRaycaster>(-1, *v->mesh_raycaster, world_tran.get_matrix());
                m_mesh_raycaster_map[v]->set_transform(world_tran.get_matrix());
            }
        }
    }
}

References Slic3r::GLVolume::get_instance_transformation(), Slic3r::GUI::get_model_volume(), Slic3r::GUI::Selection::get_volume(), Slic3r::GUI::Selection::get_volume_idxs(), Slic3r::GLVolume::get_volume_transformation(), Slic3r::ModelVolume::is_model_part(), m_mesh_raycaster_map, Slic3r::GUI::GLGizmoBase::m_parent, Slic3r::ModelVolume::mesh_ptr(), and Slic3r::GLVolume::mesh_raycaster.

Referenced by data_changed().

Here is the call graph for this function:

Here is the caller graph for this function:

reload_cache()

void Slic3r::GUI::GLGizmoBrimEars::reload_cache ( )

private

{
    const ModelObject *mo = m_c->selection_info()->model_object();
    m_editing_cache.clear();
    for (const BrimPoint &point : mo->brim_points) m_editing_cache.emplace_back(point);
    find_single();
}

References Slic3r::ModelObject::brim_points, find_single(), Slic3r::GUI::GLGizmoBase::m_c, and m_editing_cache.

Referenced by set_brim_data().

Here is the call graph for this function:

Here is the caller graph for this function:

render()

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

inlineinherited

{ on_render(); }

References on_render().

Here is the call graph for this function:

render_combo()

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

protectedinherited

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

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

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

Here is the call graph for this function:

Here is the caller graph for this function:

render_cross_mark()

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

protectedinherited

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

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

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

Here is the call graph for this function:

Here is the caller graph for this function:

render_follows_cursor()

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

inlineoverrideprotectedvirtual

Reimplemented from Slic3r::GUI::GLGizmoBase.

{ return render_hover_point.has_value(); }

References render_hover_point.

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

void Slic3r::GUI::GLGizmoBrimEars::render_points ( const Selection & selection )

private

{
    auto editing_cache = m_editing_cache;
    if (render_hover_point) { editing_cache.push_back(*render_hover_point); }
 
    size_t cache_size = editing_cache.size();
 
    bool has_points = (cache_size != 0);
 
    if (!has_points) return;
 
    const auto shader = wxGetApp().get_shader("gouraud_light");
    if (shader == nullptr)
        return;
    shader->start_using();
    ScopeGuard guard([shader]() {
        shader->stop_using();
    });
 
    const Camera&      camera                          = wxGetApp().plater()->get_camera();
    const Transform3d& view_matrix                     = camera.get_view_matrix();
    const GLVolume    *vol                             = selection.get_volume(*selection.get_volume_idxs().begin());
    const Transform3d &instance_scaling_matrix_inverse = vol->get_instance_transformation().get_scaling_factor_matrix().inverse();
    const Transform3d &instance_matrix                 = vol->get_instance_transformation().get_matrix();
 
    shader->set_uniform("projection_matrix", camera.get_projection_matrix());
 
    ColorRGBA render_color;
    for (size_t i = 0; i < cache_size; ++i) {
        const BrimPoint &brim_point     = editing_cache[i].brim_point;
        const bool      &point_selected = editing_cache[i].selected;
        const bool      &hover          = editing_cache[i].is_hover;
        const bool      &error          = editing_cache[i].is_error;
        // keep show brim ear
        // if (is_mesh_point_clipped(brim_point.pos.cast<double>()))
        //     continue;
 
        // First decide about the color of the point.
        if (hover) {
            render_color = HOVER_COLOR;
        } else {
            if (size_t(m_hover_id) == i) // ignore hover state unless editing mode is active
                render_color = {0.f, 1.f, 1.f, 1.f};
            else { // neigher hover nor picking
                if (point_selected)
                    render_color = SELECTED_COLOR;
                else {
                    if (error)
                        render_color = ERR_COLOR;
                    else
                        render_color = DEF_COLOR;
                }
            }
        }
 
        m_cylinder.model.set_color(render_color);
        shader->set_uniform("emission_factor", 0.5f);
 
        if (vol->is_left_handed()) glFrontFace(GL_CW);
 
        // Matrices set, we can render the point mark now.
        // If in editing mode, we'll also render a cone pointing to the sphere.
        if (editing_cache[i].normal == Vec3f::Zero()) m_c->raycaster()->raycaster()->get_closest_point(editing_cache[i].brim_point.pos, &editing_cache[i].normal);
 
        Eigen::Quaterniond q;
        q.setFromTwoVectors(Vec3d{0., 0., 1.}, instance_scaling_matrix_inverse * editing_cache[i].normal.cast<double>());
 
        double radius = (double) brim_point.head_front_radius * RenderPointScale;
        const Transform3d center_matrix =
            instance_matrix
            * Geometry::translation_transform(brim_point.pos.cast<double>())
            // Inverse matrix of the instance scaling is applied so that the mark does not scale with the object.
            * instance_scaling_matrix_inverse
            * q
            * Geometry::scale_transform(Vec3d{radius, radius, .2});
        if (i < m_grabbers.size()) {
            m_grabbers[i].raycasters[0]->set_transform(center_matrix);
        }
        shader->set_uniform("view_model_matrix", view_matrix * center_matrix);
        m_cylinder.model.render();
 
        if (vol->is_left_handed()) glFrontFace(GL_CCW);
    }
}

References Slic3r::GUI::DEF_COLOR, Slic3r::GUI::ERR_COLOR, Slic3r::GLVolume::get_instance_transformation(), Slic3r::Geometry::Transformation::get_matrix(), Slic3r::Geometry::Transformation::get_scaling_factor_matrix(), Slic3r::GUI::Selection::get_volume(), Slic3r::GUI::Selection::get_volume_idxs(), GL_CCW, GL_CW, glFrontFace, Slic3r::BrimPoint::head_front_radius, Slic3r::GUI::HOVER_COLOR, Slic3r::GLVolume::is_left_handed(), Slic3r::GUI::GLGizmoBase::m_c, m_cylinder, m_editing_cache, Slic3r::GUI::GLGizmoBase::m_grabbers, Slic3r::GUI::GLGizmoBase::m_hover_id, Slic3r::normal(), Slic3r::BrimPoint::pos, render_hover_point, RenderPointScale, Slic3r::Geometry::scale_transform(), Slic3r::GUI::SELECTED_COLOR, and Slic3r::Geometry::translation_transform().

Referenced by on_render().

Here is the call graph for this function:

Here is the caller graph for this function:

reset_all_pick()

void Slic3r::GUI::GLGizmoBrimEars::reset_all_pick ( )

protected

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

References m_mesh_raycaster_map.

Referenced by data_changed().

Here is the caller graph for this function:

save()

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

inlineinherited

{ on_save(ar); }

References on_save().

Here is the call graph for this function:

select_point()

void Slic3r::GUI::GLGizmoBrimEars::select_point ( int i )

private

{
    if (i == AllPoints || i == NoPoints) {
        for (auto &point_and_selection : m_editing_cache) point_and_selection.selected = (i == AllPoints);
        m_selection_empty = (i == NoPoints);
 
        if (i == AllPoints) m_new_point_head_radius = m_editing_cache[0].brim_point.head_front_radius;
    } else {
        m_editing_cache[i].selected = true;
        m_selection_empty           = false;
        m_new_point_head_radius     = m_editing_cache[i].brim_point.head_front_radius;
    }
}

References AllPoints, m_editing_cache, m_new_point_head_radius, m_selection_empty, and NoPoints.

Referenced by delete_selected_points(), gizmo_event(), on_render_input_window(), and on_start_dragging().

Here is the caller graph for this function:

set_brim_data()

void Slic3r::GUI::GLGizmoBrimEars::set_brim_data

(

)

{
    if (!m_c->selection_info()) return;
 
    ModelObject *mo = m_c->selection_info()->model_object();
 
    if (m_state == On && mo && mo->id() != m_old_mo_id) {
        reload_cache();
        m_old_mo_id = mo->id();
    }
}

References Slic3r::ObjectBase::id(), Slic3r::GUI::GLGizmoBase::m_c, m_old_mo_id, Slic3r::GUI::GLGizmoBase::m_state, Slic3r::GUI::GLGizmoBase::On, and reload_cache().

Referenced by data_changed().

Here is the call graph for this function:

Here is the caller graph for this function:

set_common_data_pool()

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

inlineinherited

{ m_c = ptr; }

References m_c.

set_dirty()

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

protectedinherited

                            {
    m_dirty = true;
}

References m_dirty.

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

Here is the caller graph for this function:

set_hover_id()

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

inherited

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

References m_dragging, m_hover_id, and on_set_hover_id().

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

Here is the call graph for this function:

Here is the caller graph for this function:

set_icon_filename()

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

inherited

                                                             {
    m_icon_filename = filename;
}

References m_icon_filename.

set_state()

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

inlineinherited

{ m_state = state; on_set_state(); }

References m_state, and on_set_state().

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

Here is the call graph for this function:

Here is the caller graph for this function:

shortcut()

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

inlineinherited

{ return m_shortcut; }

References m_shortcut.

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

Here is the caller graph for this function:

unproject_on_mesh()

bool Slic3r::GUI::GLGizmoBrimEars::unproject_on_mesh ( const Vec2d & mouse_pos, std::pair< Vec3f, Vec3f > & pos_and_normal )

private

{
    if (m_c->raycaster()->raycasters().size() != 1) return false;
    if (!m_c->raycaster()->raycaster()) return false;
 
    const Camera            &camera    = wxGetApp().plater()->get_camera();
    const Selection         &selection = m_parent.get_selection();
    const GLVolume          *volume    = selection.get_volume(*selection.get_volume_idxs().begin());
    Geometry::Transformation trafo     = volume->get_instance_transformation();
    // trafo.set_offset(trafo.get_offset() + Vec3d(0., 0., m_c->selection_info()->get_sla_shift()));//sla shift看起来可以删掉
 
    double               clp_dist = m_c->object_clipper()->get_position();
    const ClippingPlane *clp      = m_c->object_clipper()->get_clipping_plane();
 
    // The raycaster query
    Vec3f hit;
    Vec3f normal;
    if (m_c->raycaster()->raycaster()->unproject_on_mesh(mouse_pos, trafo.get_matrix(), camera, hit, normal, clp_dist != 0. ? clp : nullptr)) {
        pos_and_normal = std::make_pair(hit, normal);
        return true;
    }
 
    return false;
}

References Slic3r::GLVolume::get_instance_transformation(), Slic3r::Geometry::Transformation::get_matrix(), Slic3r::GUI::Selection::get_volume(), Slic3r::GUI::Selection::get_volume_idxs(), Slic3r::GUI::GLGizmoBase::m_c, Slic3r::GUI::GLGizmoBase::m_parent, and Slic3r::normal().

Here is the call graph for this function:

unproject_on_mesh2()

bool Slic3r::GUI::GLGizmoBrimEars::unproject_on_mesh2 ( const Vec2d & mouse_pos, std::pair< Vec3f, Vec3f > & pos_and_normal )

private

{
    const Camera        &camera          = wxGetApp().plater()->get_camera();
    double               clp_dist        = m_c->object_clipper()->get_position();
    const ClippingPlane *clp             = m_c->object_clipper()->get_clipping_plane();
    bool                 mouse_on_object = false;
    Vec3f                position_on_model {};
    Vec3f                normal_on_model {};
    double               closest_hit_distance = std::numeric_limits<double>::max();
 
    for (auto item : m_mesh_raycaster_map) {
        auto raycaster  = item.second->get_raycaster();
        auto& world_tran = item.second->get_transform();
        Vec3f normal     = Vec3f::Zero();
        Vec3f hit        = Vec3f::Zero();
        if (raycaster->unproject_on_mesh(mouse_pos, world_tran, camera, hit, normal, clp_dist != 0. ? clp : nullptr)) {
            double hit_squared_distance = (camera.get_position() - world_tran * hit.cast<double>()).norm();
            if (hit_squared_distance < closest_hit_distance) {
                closest_hit_distance = hit_squared_distance;
                mouse_on_object      = true;
                m_last_hit_volume    = item.first;
                auto volum_trsf      = m_last_hit_volume->get_volume_transformation().get_matrix();
                position_on_model    = (m_last_hit_volume->get_volume_transformation().get_matrix() * hit.cast<double>()).cast<float>();
                normal_on_model      = normal;
            }
        }
    }
    pos_and_normal = std::make_pair(position_on_model, normal_on_model);
    return mouse_on_object;
}

References Slic3r::GUI::Camera::get_position(), Slic3r::GUI::GLGizmoBase::m_c, m_last_hit_volume, m_mesh_raycaster_map, and Slic3r::normal().

Referenced by gizmo_event(), and on_dragging().

Here is the call graph for this function:

Here is the caller graph for this function:

unregister_grabbers_for_picking()

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

protectedinherited

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

References m_grabbers.

Referenced by unregister_raycasters_for_picking().

Here is the caller graph for this function:

unregister_raycasters_for_picking()

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

inlineinherited

{ unregister_grabbers_for_picking(); on_unregister_raycasters_for_picking(); }

References on_unregister_raycasters_for_picking(), and unregister_grabbers_for_picking().

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

Here is the call graph for this function:

Here is the caller graph for this function:

unselect_point()

void Slic3r::GUI::GLGizmoBrimEars::unselect_point ( int i )

private

{
    m_editing_cache[i].selected = false;
    m_selection_empty           = true;
    for (const CacheEntry &ce : m_editing_cache) {
        if (ce.selected) {
            m_selection_empty = false;
            break;
        }
    }
}

References m_editing_cache, and m_selection_empty.

Referenced by gizmo_event().

Here is the caller graph for this function:

update_cache_radius()

void Slic3r::GUI::GLGizmoBrimEars::update_cache_radius ( )

private

{
    if (render_hover_point)
        render_hover_point->brim_point.head_front_radius = m_new_point_head_radius;
 
    for (auto &cache_entry : m_editing_cache)
        if (cache_entry.selected) {
            cache_entry.brim_point.head_front_radius = m_new_point_head_radius;
            find_single();
            update_model_object();
        }
    m_parent.set_as_dirty();
}

References find_single(), m_editing_cache, m_new_point_head_radius, Slic3r::GUI::GLGizmoBase::m_parent, render_hover_point, and update_model_object().

Referenced by apply_radius_change(), gizmo_event(), and on_render_input_window().

Here is the call graph for this function:

Here is the caller graph for this function:

update_items_state()

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

inherited

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

References m_dirty.

update_model_object()

void Slic3r::GUI::GLGizmoBrimEars::update_model_object

(

)

{
    ModelObject* mo = m_c->selection_info()->model_object();
    if (mo) {
        mo->brim_points.clear();
        for (const CacheEntry& ce : m_editing_cache) mo->brim_points.emplace_back(ce.brim_point);
        wxGetApp().plater()->set_plater_dirty(true);
    }
    m_parent.post_event(SimpleEvent(EVT_GLCANVAS_SCHEDULE_BACKGROUND_PROCESS));
}

References Slic3r::ModelObject::brim_points, Slic3r::GUI::GLGizmoBase::m_c, m_editing_cache, and Slic3r::GUI::GLGizmoBase::m_parent.

Referenced by add_point_to_cache(), delete_selected_points(), on_set_state(), and update_cache_radius().

Here is the caller graph for this function:

update_raycasters()

void Slic3r::GUI::GLGizmoBrimEars::update_raycasters ( )

private

{
    // Remove extra raycasters
    if (m_editing_cache.size() < m_grabbers.size()) {
        for (auto it = m_grabbers.begin() + m_editing_cache.size(); it != m_grabbers.end(); ++it) {
            if (it->picking_id >= 0) {
                it->unregister_raycasters_for_picking();
            }
        }
        m_grabbers.erase(m_grabbers.begin() + m_editing_cache.size(), m_grabbers.end());
    } else if (m_editing_cache.size() > m_grabbers.size()) {
        auto remaining = m_editing_cache.size() - m_grabbers.size();
        while (remaining > 0) {
            const auto id   = m_grabbers.size();
            auto& g = m_grabbers.emplace_back();
            g.register_raycasters_for_picking(id);
            g.raycasters[0] = m_parent.add_raycaster_for_picking(SceneRaycaster::EType::Gizmo, id,
                                                                 *m_cylinder.mesh_raycaster, Transform3d::Identity());
            remaining--;
        }
    }
}

References Slic3r::GUI::SceneRaycaster::Gizmo, m_cylinder, m_editing_cache, Slic3r::GUI::GLGizmoBase::m_grabbers, and Slic3r::GUI::GLGizmoBase::m_parent.

Referenced by find_single(), and on_register_raycasters_for_picking().

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::GLGizmoBrimEars::wants_enter_leave_snapshots ( ) const

inlineoverridevirtual

Reimplemented from Slic3r::GUI::GLGizmoBase.

{ return true; }

Member Data Documentation

AXES_COLOR

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

staticinherited

Initial value:

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

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

AXES_HOVER_COLOR

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

staticinherited

Initial value:

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

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

BASE_ID

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

staticinherited

CONSTRAINED_COLOR

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

staticinherited

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

count

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

privateinherited

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

DEFAULT_BASE_COLOR

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

staticinherited

DEFAULT_DRAG_COLOR

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

staticinherited

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

DEFAULT_HIGHLIGHT_COLOR

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

staticinherited

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

FLATTEN_COLOR

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

staticinherited

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

FLATTEN_HOVER_COLOR

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

staticinherited

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

GRABBER_ELEMENTS_MAX_COUNT

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

staticinherited

GRABBER_HOVER_COL

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

staticinherited

GRABBER_NORMAL_COL

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

staticinherited

GRABBER_UNIFORM_COL

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

staticinherited

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

GRABBER_UNIFORM_HOVER_COL

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

staticinherited

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

INV_ZOOM

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

staticinherited

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

last_input_window_width

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

protectedinherited

Referenced by GizmoImguiEnd(), and GizmoImguiSetNextWIndowPos().

m_c

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

protectedinherited

{ nullptr };

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

m_cylinder

PickingModel Slic3r::GUI::GLGizmoBrimEars::m_cylinder

private

Referenced by GLGizmoBrimEars(), render_points(), and update_raycasters().

m_desc

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

private

Referenced by on_init(), and on_render_input_window().

m_detection_radius

float Slic3r::GUI::GLGizmoBrimEars::m_detection_radius = 1.f

private

Referenced by auto_generate(), and on_render_input_window().

m_detection_radius_max

double Slic3r::GUI::GLGizmoBrimEars::m_detection_radius_max = .0f

private

Referenced by get_detection_radius_max(), and on_render_input_window().

m_dirty

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

privateinherited

{ false };

Referenced by set_dirty(), and update_items_state().

m_dragging

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

protectedinherited

{ false };

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

m_editing_cache

std::vector<CacheEntry> Slic3r::GUI::GLGizmoBrimEars::m_editing_cache

mutableprivate

Referenced by add_point_to_cache(), apply_radius_change(), delete_selected_points(), find_single(), gizmo_event(), has_selected_points(), on_dragging(), on_load(), on_render_input_window(), on_save(), on_set_hover_id(), on_start_dragging(), on_stop_dragging(), reload_cache(), render_points(), select_point(), unselect_point(), update_cache_radius(), update_model_object(), and update_raycasters().

m_first_input_window_render

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

protectedinherited

{ true };

Referenced by render_input_window().

m_first_layer

ExPolygons Slic3r::GUI::GLGizmoBrimEars::m_first_layer

private

Referenced by auto_generate(), find_single(), first_layer_slicer(), and get_detection_radius_max().

m_grabbers

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

mutableprotectedinherited

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

m_group_id

int Slic3r::GUI::GLGizmoBase::m_group_id

protectedinherited

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

m_hover_id

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

protectedinherited

{ -1 };

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

m_icon_filename

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

protectedinherited

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

m_imgui

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

protectedinherited

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

m_is_dark_mode

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

protectedinherited

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

m_last_hit_volume

GLVolume* Slic3r::GUI::GLGizmoBrimEars::m_last_hit_volume

private

Referenced by unproject_on_mesh2().

m_link_text_hover

bool Slic3r::GUI::GLGizmoBrimEars::m_link_text_hover = false

private

Referenced by on_render_input_window().

m_max_angle

float Slic3r::GUI::GLGizmoBrimEars::m_max_angle = 125.f

private

Referenced by auto_generate(), and on_render_input_window().

m_mesh_raycaster_map

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

private

Referenced by register_single_mesh_pick(), reset_all_pick(), and unproject_on_mesh2().

m_new_point_head_radius

float Slic3r::GUI::GLGizmoBrimEars::m_new_point_head_radius

private

Referenced by apply_radius_change(), auto_generate(), gizmo_event(), on_init(), on_load(), on_render_input_window(), on_save(), select_point(), and update_cache_radius().

m_old_mo_id

ObjectID Slic3r::GUI::GLGizmoBrimEars::m_old_mo_id

private

Referenced by set_brim_data().

m_old_point_head_radius

float Slic3r::GUI::GLGizmoBrimEars::m_old_point_head_radius = 0.

private

Referenced by apply_radius_change(), and begin_radius_change().

m_old_state

EState Slic3r::GUI::GLGizmoBrimEars::m_old_state = Off

private

Referenced by on_set_state().

m_parent

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

protectedinherited

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

m_point_before_drag

CacheEntry Slic3r::GUI::GLGizmoBrimEars::m_point_before_drag

private

Referenced by on_start_dragging(), and on_stop_dragging().

m_selection_empty

bool Slic3r::GUI::GLGizmoBrimEars::m_selection_empty = true

private

Referenced by gizmo_event(), on_load(), on_save(), select_point(), and unselect_point().

m_selection_rectangle

GLSelectionRectangle Slic3r::GUI::GLGizmoBrimEars::m_selection_rectangle

private

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

m_shortcut

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

protectedinherited

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

m_shortcuts

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

private

Referenced by on_init(), and on_render_input_window().

m_single_brim

std::map<int, CacheEntry> Slic3r::GUI::GLGizmoBrimEars::m_single_brim

private

Referenced by find_single(), and on_render_input_window().

m_sprite_id

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

protectedinherited

Referenced by GLGizmoBase(), and get_sprite_id().

m_state

EState Slic3r::GUI::GLGizmoBase::m_state

protectedinherited

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

m_wait_for_up_event

bool Slic3r::GUI::GLGizmoBrimEars::m_wait_for_up_event = false

private

Referenced by gizmo_event().

m_world_normal

const Vec3d Slic3r::GUI::GLGizmoBrimEars::m_world_normal = {0, 0, 1}

private

{0, 0, 1};

Referenced by auto_generate(), and gizmo_event().

render_hover_point

std::optional<CacheEntry> Slic3r::GUI::GLGizmoBrimEars::render_hover_point

private

Referenced by gizmo_event(), render_follows_cursor(), render_points(), and update_cache_radius().

RenderPointScale

const float Slic3r::GUI::GLGizmoBrimEars::RenderPointScale = 1.f

private

Referenced by render_points().

---

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

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