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

Collaboration diagram for Slic3r::GUI::Selection:

Classes
struct	VolumeCache
class	Clipboard
struct	Cache
struct	Planes

Public Types
enum	EMode : unsigned char { Volume , Instance }
enum	EType : unsigned char { Invalid , Empty , WipeTower , SingleModifier , MultipleModifier , SingleVolume , MultipleVolume , SingleFullObject , MultipleFullObject , SingleFullInstance , MultipleFullInstance , Mixed }
enum class	SyncRotationType { NONE = 0 , GENERAL = 1 , RESET = 2 }
typedef std::set< unsigned int >	IndicesList
typedef std::map< unsigned int, VolumeCache >	VolumesCache
typedef std::set< int >	InstanceIdxsList
typedef std::map< int, InstanceIdxsList >	ObjectIdxsToInstanceIdxsMap

Public Member Functions
	Selection ()
void	set_volumes (GLVolumePtrs *volumes)
bool	init ()
bool	is_enabled () const
void	set_enabled (bool enable)
Model *	get_model () const
void	set_model (Model *model)
EMode	get_mode () const
void	set_mode (EMode mode)
int	query_real_volume_idx_from_other_view (unsigned int object_idx, unsigned int instance_idx, unsigned int model_volume_idx)
void	add (unsigned int volume_idx, bool as_single_selection=true, bool check_for_already_contained=false)
void	remove (unsigned int volume_idx)
void	add_object (unsigned int object_idx, bool as_single_selection=true)
void	remove_object (unsigned int object_idx)
void	add_instance (unsigned int object_idx, unsigned int instance_idx, bool as_single_selection=true)
void	remove_instance (unsigned int object_idx, unsigned int instance_idx)
void	add_volume (unsigned int object_idx, unsigned int volume_idx, int instance_idx, bool as_single_selection=true)
void	remove_volume (unsigned int object_idx, unsigned int volume_idx)
void	add_volumes (EMode mode, const std::vector< unsigned int > &volume_idxs, bool as_single_selection=true)
void	remove_volumes (EMode mode, const std::vector< unsigned int > &volume_idxs)
ModelVolume *	get_selected_single_volume (int &out_object_idx, int &out_volume_idx) const
ModelObject *	get_selected_single_object (int &out_object_idx) const
const ModelInstance *	get_selected_single_intance () const
void	add_curr_plate ()
void	add_object_from_idx (std::vector< int > &object_idxs)
void	remove_curr_plate ()
void	clone (int numbers=1)
void	center ()
void	drop ()
bool	can_drop () const
double	get_drop_min_z () const
void	center_plate (const int plate_idx)
void	set_printable (bool printable)
bool	get_auto_drop () const
void	set_auto_drop (bool enabled)
void	add_all ()
void	remove_all ()
void	set_deserialized (EMode mode, const std::vector< std::pair< size_t, size_t > > &volumes_and_instances)
void	instances_changed (const std::vector< size_t > &instance_ids_selected)
void	volumes_changed (const std::vector< size_t > &map_volume_old_to_new)
void	clear ()
bool	is_empty () const
bool	is_wipe_tower () const
bool	is_any_modifier () const
bool	is_single_modifier () const
bool	is_multiple_modifier () const
bool	is_single_full_instance () const
bool	is_multiple_full_instance () const
bool	is_single_full_object () const
bool	is_multiple_full_object () const
bool	is_single_volume () const
bool	is_multiple_volume () const
bool	is_any_volume () const
bool	is_any_connector () const
bool	is_any_cut_volume () const
bool	is_mixed () const
bool	is_from_single_instance () const
bool	is_from_single_object () const
bool	is_sla_compliant () const
bool	is_instance_mode () const
bool	is_single_volume_or_modifier () const
bool	is_single_volume_instance () const
bool	is_single_text () const
bool	contains_volume (unsigned int volume_idx) const
bool	contains_all_volumes (const std::vector< unsigned int > &volume_idxs) const
bool	contains_any_volume (const std::vector< unsigned int > &volume_idxs) const
bool	contains_sinking_volumes (bool ignore_modifiers=true) const
bool	matches (const std::vector< unsigned int > &volume_idxs) const
bool	requires_uniform_scale () const
int	get_object_idx () const
int	get_instance_idx () const
const InstanceIdxsList &	get_instance_idxs () const
const IndicesList &	get_volume_idxs () const
const GLVolume *	get_volume (unsigned int volume_idx) const
const GLVolume *	get_first_volume () const
GLVolume *	get_volume (unsigned int volume_idx)
const ObjectIdxsToInstanceIdxsMap &	get_content () const
unsigned int	volumes_count () const
const BoundingBoxf3 &	get_bounding_box () const
const BoundingBoxf3 &	get_unscaled_instance_bounding_box () const
const BoundingBoxf3 &	get_scaled_instance_bounding_box () const
const BoundingBoxf3 &	get_full_unscaled_instance_bounding_box () const
const BoundingBoxf3 &	get_full_scaled_instance_bounding_box () const
const BoundingBoxf3 &	get_full_unscaled_instance_local_bounding_box () const
const std::pair< BoundingBoxf3, Transform3d > &	get_bounding_box_in_current_reference_system () const
std::pair< BoundingBoxf3, Transform3d >	get_bounding_box_in_reference_system (ECoordinatesType type) const
const std::pair< Vec3d, double >	get_bounding_sphere () const
void	setup_cache ()
void	translate (const Vec3d &displacement, TransformationType transformation_type)
void	move_to_center (const Vec3d &displacement, bool local=false)
void	rotate (const Vec3d &rotation, TransformationType transformation_type)
void	flattening_rotate (const Vec3d &normal)
void	scale (const Vec3d &scale, TransformationType transformation_type)
void	scale_to_fit_print_volume (const DynamicPrintConfig &config)
void	scale_and_translate (const Vec3d &scale, const Vec3d &world_translation, TransformationType transformation_type)
void	mirror (Axis axis, TransformationType transformation_type)
void	translate (unsigned int object_idx, const Vec3d &displacement)
void	translate (unsigned int object_idx, unsigned int instance_idx, const Vec3d &displacement)
void	translate (unsigned int object_idx, unsigned int instance_idx, unsigned int volume_idx, const Vec3d &displacement, bool local=true)
void	rotate (unsigned int object_idx, unsigned int instance_idx, const Transform3d &overwrite_tran)
void	rotate (unsigned int object_idx, unsigned int instance_idx, unsigned int volume_idx, const Transform3d &overwrite_tran)
void	notify_instance_update (int object_idx, int instance_idx)
EMode	get_volume_selection_mode ()
void	set_volume_selection_mode (EMode mode)
void	lock_volume_selection_mode ()
void	unlock_volume_selection_mode ()
void	erase ()
void	render (float scale_factor=1.0)
void	render_sidebar_hints (const std::string &sidebar_field, bool uniform_scale)
bool	requires_local_axes () const
void	render_bounding_box (const BoundingBoxf3 &box, const ColorRGB &color, float scale)
void	render_bounding_box (const BoundingBoxf3 &box, const Transform3d &trafo, const ColorRGB &color, float scale)
void	cut_to_clipboard ()
void	copy_to_clipboard ()
void	paste_from_clipboard ()
std::set< std::pair< int, int > >	get_selected_object_instances ()
const Clipboard &	get_clipboard () const
void	fill_color (int extruder_id)
std::vector< unsigned int >	get_volume_idxs_from_object (unsigned int object_idx) const
std::vector< unsigned int >	get_volume_idxs_from_instance (unsigned int object_idx, unsigned int instance_idx) const
std::vector< unsigned int >	get_volume_idxs_from_volume (unsigned int object_idx, unsigned int instance_idx, unsigned int volume_idx) const
std::vector< unsigned int >	get_volume_idxs_from_plate (const int plate_idx) const
std::vector< unsigned int >	get_missing_volume_idxs_from (const std::vector< unsigned int > &volume_idxs) const
std::vector< unsigned int >	get_unselected_volume_idxs_from (const std::vector< unsigned int > &volume_idxs) const
void	synchronize_unselected_instances (SyncRotationType sync_rotation_type)
void	synchronize_unselected_volumes ()

Private Member Functions
void	update_valid ()
void	update_type ()
void	set_caches ()
void	do_add_volume (unsigned int volume_idx)
void	do_add_volumes (const std::vector< unsigned int > &volume_idxs)
void	do_remove_volume (unsigned int volume_idx)
void	do_remove_instance (unsigned int object_idx, unsigned int instance_idx)
void	do_remove_object (unsigned int object_idx)
void	set_bounding_boxes_dirty ()
void	render_synchronized_volumes ()
void	render_bounding_box (const BoundingBoxf3 &box, const Transform3d &trafo, const bool auto_drop, const ColorRGB &color)
void	render_sidebar_position_hints (const std::string &sidebar_field, GLShaderProgram &shader, const Transform3d &matrix)
void	render_sidebar_rotation_hints (const std::string &sidebar_field, GLShaderProgram &shader, const Transform3d &matrix)
void	render_sidebar_scale_hints (const std::string &sidebar_field, bool gizmo_uniform_scale, GLShaderProgram &shader, const Transform3d &matrix)
void	render_sidebar_layers_hints (const std::string &sidebar_field, GLShaderProgram &shader)
void	ensure_on_bed ()
void	ensure_not_below_bed ()
bool	is_from_fully_selected_instance (unsigned int volume_idx) const
void	paste_volumes_from_clipboard ()
void	paste_objects_from_clipboard ()
void	transform_instance_relative (GLVolume &volume, const VolumeCache &volume_data, TransformationType transformation_type, const Transform3d &transform, const Vec3d &world_pivot)
void	transform_volume_relative (GLVolume &volume, const VolumeCache &volume_data, TransformationType transformation_type, const Transform3d &transform, const Vec3d &world_pivot)

Private Attributes
GLVolumePtrs *	m_volumes
Model *	m_model
bool	m_enabled
bool	m_valid
EMode	m_mode
EType	m_type
IndicesList	m_list
Cache	m_cache
Clipboard	m_clipboard
std::optional< BoundingBoxf3 >	m_bounding_box
std::optional< BoundingBoxf3 >	m_unscaled_instance_bounding_box
std::optional< BoundingBoxf3 >	m_scaled_instance_bounding_box
std::optional< BoundingBoxf3 >	m_full_unscaled_instance_bounding_box
std::optional< BoundingBoxf3 >	m_full_scaled_instance_bounding_box
std::optional< BoundingBoxf3 >	m_full_unscaled_instance_local_bounding_box
std::optional< std::pair< BoundingBoxf3, Transform3d > >	m_bounding_box_in_current_reference_system
std::optional< std::pair< Vec3d, double > >	m_bounding_sphere
GLModel	m_arrow
GLModel	m_curved_arrow
GLModel	m_box
bool	m_auto_drop = true
Planes	m_planes
float	m_scale_factor
EMode	m_volume_selection_mode { Instance }
bool	m_volume_selection_locked { false }

Detailed Description

Class Documentation

◆ Slic3r::GUI::Selection::Cache

struct Slic3r::GUI::Selection::Cache

Collaboration diagram for Slic3r::GUI::Selection::Cache:

Class Members
ObjectIdxsToInstanceIdxsMap	content
Vec3d	dragging_center
Vec3d	rotation_pivot
vector< unsigned int >	sinking_volumes
VolumesCache	volumes_data

◆ Slic3r::GUI::Selection::Planes

struct Slic3r::GUI::Selection::Planes

Collaboration diagram for Slic3r::GUI::Selection::Planes:

Class Members
array< Vec3f, 2 >	check_points { Vec3f::Zero(), Vec3f::Zero() }
array< GLModel, 2 >	models

Member Typedef Documentation

◆ IndicesList

typedef std::set<unsigned int> Slic3r::GUI::Selection::IndicesList

◆ InstanceIdxsList

typedef std::set<int> Slic3r::GUI::Selection::InstanceIdxsList

◆ ObjectIdxsToInstanceIdxsMap

typedef std::map<int, InstanceIdxsList> Slic3r::GUI::Selection::ObjectIdxsToInstanceIdxsMap

◆ VolumesCache

typedef std::map<unsigned int, VolumeCache> Slic3r::GUI::Selection::VolumesCache

Member Enumeration Documentation

◆ EMode

enum Slic3r::GUI::Selection::EMode : unsigned char

Enumerator
Volume
Instance

    {
        Volume,
        Instance
    };

◆ EType

enum Slic3r::GUI::Selection::EType : unsigned char

Enumerator
Invalid
Empty
WipeTower
SingleModifier
MultipleModifier
SingleVolume
MultipleVolume
SingleFullObject
MultipleFullObject
SingleFullInstance
MultipleFullInstance
Mixed

    {
        Invalid,
        Empty,
        WipeTower,
        SingleModifier,
        MultipleModifier,
        SingleVolume,
        MultipleVolume,
        SingleFullObject,
        MultipleFullObject,
        SingleFullInstance,
        MultipleFullInstance,
        Mixed
    };

◆ SyncRotationType

enum class Slic3r::GUI::Selection::SyncRotationType

strong

Enumerator
NONE
GENERAL
RESET

                                {
        // Do not synchronize rotation. Either not rotating at all, or rotating by world Z axis.
        NONE = 0,
        // Synchronize after rotation by an axis not parallel with Z.
        GENERAL = 1,
        // Synchronize after rotation reset.
        RESET = 2
    };

Constructor & Destructor Documentation

◆ Selection()

Slic3r::GUI::Selection::Selection ( )

    : m_volumes(nullptr)
    , m_model(nullptr)
    , m_enabled(false)
    , m_mode(Instance)
    , m_type(Empty)
    , m_valid(false)
    , m_scale_factor(1.0f)
{
    this->set_bounding_boxes_dirty();
}

References Empty, Instance, m_enabled, m_mode, m_model, m_scale_factor, m_type, m_valid, m_volumes, and set_bounding_boxes_dirty().

Here is the call graph for this function:

Member Function Documentation

◆ add()

void Slic3r::GUI::Selection::add	(	unsigned int	volume_idx,
		bool	as_single_selection = true,
		bool	check_for_already_contained = false )

{
    if (!m_valid || (unsigned int)m_volumes->size() <= volume_idx)
        return;
 
    const GLVolume* volume = (*m_volumes)[volume_idx];
    //BBS: multiple wipe tower case should be considered
    // wipe tower is already selected
    //if (is_wipe_tower() && volume->is_wipe_tower)
    //    return;
    if (!m_list.empty() && !is_wipe_tower() && volume->is_wipe_tower && !as_single_selection)
        return;
 
    bool keep_instance_mode = (m_mode == Instance) && !as_single_selection;
    bool already_contained = check_for_already_contained && contains_volume(volume_idx);
 
    // resets the current list if needed
    bool needs_reset = as_single_selection && !already_contained;
    needs_reset |= volume->is_wipe_tower;
    needs_reset |= is_wipe_tower() && !volume->is_wipe_tower;
    needs_reset |= as_single_selection && !is_any_modifier() && volume->is_modifier;
    needs_reset |= is_any_modifier() && !volume->is_modifier;
    if (!needs_reset && (is_any_modifier() || is_any_volume())) {
        int obj_index = volume->object_idx();
        int inst_index = volume->instance_idx();
        int first = *(m_list.begin());
        if (first < m_volumes->size()) {
            const GLVolume* volume = (*m_volumes)[first];
            if ((volume->object_idx() != obj_index) || (volume->instance_idx() != inst_index))
                needs_reset = true;
        }
    }
 
    if (!already_contained || needs_reset) {
        wxGetApp().plater()->take_snapshot(std::string("Selection-Add!"), UndoRedo::SnapshotType::Selection);
 
        if (needs_reset)
            clear();
 
        // BBS
        if (!keep_instance_mode)
            m_mode = volume->is_modifier ? Volume : m_volume_selection_mode;
    }
    else
      // keep current mode
      return;
 
    switch (m_mode)
    {
    case Volume:
    {
        if (volume->volume_idx() >= 0 && (is_empty() || volume->instance_idx() == get_instance_idx()))
            do_add_volume(volume_idx);
 
        break;
    }
    case Instance:
    {
        Plater::SuppressSnapshots suppress(wxGetApp().plater());
        add_instance(volume->object_idx(), volume->instance_idx(), as_single_selection);
        break;
    }
    }
 
    update_type();
    this->set_bounding_boxes_dirty();
}

References add_instance(), clear(), contains_volume(), do_add_volume(), get_instance_idx(), Instance, Slic3r::GLVolume::instance_idx(), is_any_modifier(), is_any_volume(), is_empty(), is_wipe_tower(), m_list, m_mode, m_valid, m_volume_selection_mode, m_volumes, Slic3r::GLVolume::object_idx(), Slic3r::GUI::plater(), Slic3r::UndoRedo::Selection, set_bounding_boxes_dirty(), update_type(), Volume, and Slic3r::GLVolume::volume_idx().

Referenced by Slic3r::GUI::Plater::priv::reload_all_from_disk(), and Slic3r::GUI::Plater::priv::set_current_panel().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ add_all()

void Slic3r::GUI::Selection::add_all ( )

{
    if (!m_valid)
        return;
 
    unsigned int count = 0;
    for (unsigned int i = 0; i < (unsigned int)m_volumes->size(); ++i) {
        if (!(*m_volumes)[i]->is_wipe_tower)
            ++count;
    }
 
    if ((unsigned int)m_list.size() == count)
        return;
 
    wxGetApp().plater()->take_snapshot(std::string("Selection-Add All!"), UndoRedo::SnapshotType::Selection);
 
    m_mode = Instance;
    clear();
 
    for (unsigned int i = 0; i < (unsigned int)m_volumes->size(); ++i) {
        if (!(*m_volumes)[i]->is_wipe_tower)
            do_add_volume(i);
    }
 
    update_type();
    this->set_bounding_boxes_dirty();
}

References clear(), count, do_add_volume(), Instance, is_wipe_tower(), m_list, m_mode, m_valid, m_volumes, Slic3r::UndoRedo::Selection, set_bounding_boxes_dirty(), and update_type().

Here is the call graph for this function:

◆ add_curr_plate()

void Slic3r::GUI::Selection::add_curr_plate ( )

{
    if (!m_valid)
        return;
 
    std::vector<unsigned int> volume_idxs = get_volume_idxs_from_plate(wxGetApp().plater()->get_partplate_list().get_curr_plate_index());
    if (volume_idxs.empty())
        return;
 
    wxGetApp().plater()->take_snapshot(std::string("Selection-Add Curr Plate All!"));
    m_mode = Instance;
    clear();
    do_add_volumes(volume_idxs);
 
    update_type();
    this->set_bounding_boxes_dirty();
}

References clear(), do_add_volumes(), get_volume_idxs_from_plate(), Instance, m_mode, m_valid, Slic3r::GUI::plater(), set_bounding_boxes_dirty(), and update_type().

Here is the call graph for this function:

◆ add_instance()

void Slic3r::GUI::Selection::add_instance	(	unsigned int	object_idx,
		unsigned int	instance_idx,
		bool	as_single_selection = true )

{
    if (!m_valid)
        return;
 
    const std::vector<unsigned int> volume_idxs = get_volume_idxs_from_instance(object_idx, instance_idx);
    if ((!as_single_selection && contains_all_volumes(volume_idxs)) ||
        (as_single_selection && matches(volume_idxs)))
        return;
 
    wxGetApp().plater()->take_snapshot(std::string("Selection-Add Instance"), UndoRedo::SnapshotType::Selection);
 
    // resets the current list if needed
    if (as_single_selection)
        clear();
 
    m_mode = Instance;
 
    do_add_volumes(volume_idxs);
 
    update_type();
    this->set_bounding_boxes_dirty();
}

References clear(), contains_all_volumes(), do_add_volumes(), get_volume_idxs_from_instance(), Instance, m_mode, m_valid, matches(), Slic3r::UndoRedo::Selection, set_bounding_boxes_dirty(), and update_type().

Referenced by add().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ add_object()

void Slic3r::GUI::Selection::add_object	(	unsigned int	object_idx,
		bool	as_single_selection = true )

{
    if (!m_valid)
        return;
 
    std::vector<unsigned int> volume_idxs = get_volume_idxs_from_object(object_idx);
    if ((!as_single_selection && contains_all_volumes(volume_idxs)) ||
        (as_single_selection && matches(volume_idxs)))
        return;
 
    wxGetApp().plater()->take_snapshot(std::string("Selection-Add Object"), UndoRedo::SnapshotType::Selection);
 
    // resets the current list if needed
    if (as_single_selection)
        clear();
 
    m_mode = Instance;
 
    do_add_volumes(volume_idxs);
 
    update_type();
    this->set_bounding_boxes_dirty();
}

References clear(), contains_all_volumes(), do_add_volumes(), get_volume_idxs_from_object(), Instance, m_mode, m_valid, matches(), Slic3r::UndoRedo::Selection, set_bounding_boxes_dirty(), and update_type().

Referenced by Slic3r::GUI::Plater::_calib_pa_select_added_objects(), Slic3r::GUI::GLGizmoSimplify::add_simplify_suggestion_notification(), Slic3r::GUI::Plater::apply_cut_object_to_model(), Slic3r::GUI::Plater::convert_unit(), and Slic3r::GUI::Plater::priv::split_object().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ add_object_from_idx()

void Slic3r::GUI::Selection::add_object_from_idx ( std::vector< int > & object_idxs )

                                                               {
    if (!m_valid)
        return;
 
    m_mode = Instance;
    clear();
 
    for (int obj_idx = 0; obj_idx < object_idxs.size(); obj_idx++) {
        std::vector<unsigned int> volume_idxs = get_volume_idxs_from_object(object_idxs[obj_idx]);
        do_add_volumes(volume_idxs);
    }
 
    update_type();
    this->set_bounding_boxes_dirty();
}

References clear(), do_add_volumes(), get_volume_idxs_from_object(), Instance, m_mode, m_valid, set_bounding_boxes_dirty(), and update_type().

Here is the call graph for this function:

◆ add_volume()

void Slic3r::GUI::Selection::add_volume	(	unsigned int	object_idx,
		unsigned int	volume_idx,
		int	instance_idx,
		bool	as_single_selection = true )

{
    if (!m_valid)
        return;
 
    std::vector<unsigned int> volume_idxs = get_volume_idxs_from_volume(object_idx, instance_idx, volume_idx);
    if ((!as_single_selection && contains_all_volumes(volume_idxs)) ||
        (as_single_selection && matches(volume_idxs)))
        return;
 
    // resets the current list if needed
    if (as_single_selection)
        clear();
 
    m_mode = Volume;
 
    do_add_volumes(volume_idxs);
 
    update_type();
    this->set_bounding_boxes_dirty();
}

References clear(), contains_all_volumes(), do_add_volumes(), get_volume_idxs_from_volume(), m_mode, m_valid, matches(), set_bounding_boxes_dirty(), update_type(), and Volume.

Referenced by Slic3r::GUI::Plater::convert_unit().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ add_volumes()

void Slic3r::GUI::Selection::add_volumes	(	EMode	mode,
		const std::vector< unsigned int > &	volume_idxs,
		bool	as_single_selection = true )

{
    if (!m_valid)
        return;
 
    if ((!as_single_selection && contains_all_volumes(volume_idxs)) ||
        (as_single_selection && matches(volume_idxs)))
        return;
 
    // resets the current list if needed
    if (as_single_selection)
        clear();
 
    m_mode = mode;
    for (unsigned int i : volume_idxs) {
        if (i < (unsigned int)m_volumes->size())
            do_add_volume(i);
    }
 
    update_type();
    this->set_bounding_boxes_dirty();
}

References clear(), contains_all_volumes(), do_add_volume(), m_mode, m_valid, m_volumes, matches(), set_bounding_boxes_dirty(), and update_type().

Referenced by Slic3r::GUI::ObjectList::update_selections_on_canvas().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ can_drop()

bool Slic3r::GUI::Selection::can_drop ( ) const

{
    return std::abs(get_drop_min_z()) > -SINKING_Z_THRESHOLD;
}

References get_drop_min_z(), and Slic3r::SINKING_Z_THRESHOLD.

Referenced by Slic3r::GUI::anonymous_namespace{NativeCommands.cpp}::build_command_catalog(), and Slic3r::GUI::GizmoObjectManipulation::update_reset_buttons_visibility().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ center()

void Slic3r::GUI::Selection::center ( )

{
    PartPlate* plate = wxGetApp().plater()->get_partplate_list().get_selected_plate();
 
    // calc distance
    Vec3d src_pos = this->get_bounding_box().center();
    Vec3d tar_pos = plate->get_center_origin();
    Vec3d distance = Vec3d(tar_pos.x() - src_pos.x(), tar_pos.y() - src_pos.y(), 0);
 
    this->move_to_center(distance);
    wxGetApp().plater()->get_view3D_canvas3D()->do_move(L("Move object"));
    return;
}

References Slic3r::BoundingBox3Base< PointType >::center(), get_bounding_box(), Slic3r::GUI::PartPlate::get_center_origin(), L, and move_to_center().

Referenced by get_bounding_box_in_reference_system(), render_sidebar_hints(), and scale_to_fit_print_volume().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ center_plate()

void Slic3r::GUI::Selection::center_plate ( const int plate_idx )

                                                {
 
    PartPlate* plate = wxGetApp().plater()->get_partplate_list().get_plate(plate_idx);
 
 
    Vec3d src_pos = this->get_bounding_box().center();
    Vec3d tar_pos = plate->get_center_origin();
    Vec3d distance = Vec3d(tar_pos.x() - src_pos.x(), tar_pos.y() - src_pos.y(), 0);
 
    this->move_to_center(distance);
    wxGetApp().plater()->get_view3D_canvas3D()->do_move(L("Move object"));
    return;
}

References Slic3r::BoundingBox3Base< PointType >::center(), get_bounding_box(), Slic3r::GUI::PartPlate::get_center_origin(), L, and move_to_center().

Here is the call graph for this function:

◆ clear()

void Slic3r::GUI::Selection::clear ( )

{
    if (!m_valid)
        return;
 
    if (m_list.empty())
        return;
 
#if ENABLE_MODIFIERS_ALWAYS_TRANSPARENT
    // ensure that the volumes get the proper color before next call to render (expecially needed for transparent volumes)
    for (unsigned int i : m_list) {
        GLVolume& volume = *(*m_volumes)[i];
        volume.selected = false;
        bool is_transparent = volume.color.is_transparent();
        if (is_transparent)
            volume.force_transparent = true;
        volume.set_render_color();
        if (is_transparent)
            volume.force_transparent = false;
    }
#else
    for (unsigned int i : m_list) {
        (*m_volumes)[i]->selected = false;
        // ensure the volume gets the proper color before next call to render (expecially needed for transparent volumes)
        (*m_volumes)[i]->set_render_color();
    }
#endif // ENABLE_MODIFIERS_ALWAYS_TRANSPARENT
 
    m_list.clear();
 
    update_type();
    set_bounding_boxes_dirty();
 
    // BBS
#if 0
    // this happens while the application is closing
    if (wxGetApp().obj_manipul() == nullptr)
        return;
 
    // resets the cache in the sidebar
    wxGetApp().obj_manipul()->reset_cache();
#endif
 
    // #et_FIXME fake KillFocus from sidebar
    // Skip on shutdown: Plater's pImpl is already freed, so plater()->canvas3D() would use-after-free.
    if (wxGetApp().is_closing())
        return;
    wxGetApp().plater()->canvas3D()->handle_sidebar_focus_event("", false);
}

References Slic3r::GLVolume::color, Slic3r::ColorRGBA::is_transparent(), m_list, m_valid, set_bounding_boxes_dirty(), Slic3r::GLVolume::set_render_color(), and update_type().

Referenced by Slic3r::GUI::Plater::_calib_pa_select_added_objects(), add(), add_all(), add_curr_plate(), add_instance(), add_object(), add_object_from_idx(), Slic3r::GUI::GLGizmoSimplify::add_simplify_suggestion_notification(), add_volume(), add_volumes(), Slic3r::GUI::Plater::priv::reload_all_from_disk(), remove_all(), remove_curr_plate(), Slic3r::GUI::Plater::priv::set_current_panel(), Slic3r::GUI::Plater::priv::update_after_undo_redo(), and Slic3r::GUI::ObjectList::update_selections_on_canvas().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ clone()

void Slic3r::GUI::Selection::clone ( int numbers = 1 )

{
    if (numbers <= 0)
        return;
 
    wxGetApp().plater()->take_snapshot(std::string("Selection-clone"));
    copy_to_clipboard();
    for (int i = 0; i < numbers; i++) {
        paste_from_clipboard();
    }
}

References copy_to_clipboard(), and paste_from_clipboard().

Here is the call graph for this function:

◆ contains_all_volumes()

bool Slic3r::GUI::Selection::contains_all_volumes ( const std::vector< unsigned int > & volume_idxs ) const

{
    for (unsigned int i : volume_idxs) {
        if (m_list.find(i) == m_list.end())
            return false;
    }
 
    return true;
}

References m_list.

Referenced by add_instance(), add_object(), add_volume(), add_volumes(), and Slic3r::GUI::ObjectList::update_selections_on_canvas().

Here is the caller graph for this function:

◆ contains_any_volume()

bool Slic3r::GUI::Selection::contains_any_volume ( const std::vector< unsigned int > & volume_idxs ) const

{
    for (unsigned int i : volume_idxs) {
        if (m_list.find(i) != m_list.end())
            return true;
    }
 
    return false;
}

References m_list.

◆ contains_sinking_volumes()

bool Slic3r::GUI::Selection::contains_sinking_volumes ( bool ignore_modifiers = true ) const

{
    for (const GLVolume* v : *m_volumes) {
        if (!ignore_modifiers || !v->is_modifier) {
            if (v->is_sinking())
                return true;
        }
    }
    return false;
}

References m_volumes.

◆ contains_volume()

bool Slic3r::GUI::Selection::contains_volume ( unsigned int volume_idx ) const

inline

295{ return m_list.find(volume_idx) != m_list.end(); }

References m_list.

Referenced by add(), and remove().

Here is the caller graph for this function:

◆ copy_to_clipboard()

void Slic3r::GUI::Selection::copy_to_clipboard ( )

{
    if (!m_valid)
        return;
 
    m_clipboard.reset();
 
    // sort as the object list order
    std::vector<unsigned int> selected_list;
    selected_list.assign(m_list.begin(), m_list.end());
    std::sort(selected_list.begin(), selected_list.end(), [this](unsigned int left, unsigned int right) {
        return (*m_volumes)[left]->volume_idx() < (*m_volumes)[right]->volume_idx();
    });
 
    for (const ObjectIdxsToInstanceIdxsMap::value_type& object : m_cache.content) {
        ModelObject* src_object = m_model->objects[object.first];
        ModelObject* dst_object = m_clipboard.add_object();
        dst_object->name                 = src_object->name;
        dst_object->input_file           = src_object->input_file;
    dst_object->config.assign_config(src_object->config);
        dst_object->sla_support_points   = src_object->sla_support_points;
        dst_object->sla_points_status    = src_object->sla_points_status;
        dst_object->sla_drain_holes      = src_object->sla_drain_holes;
        dst_object->brim_points          = src_object->brim_points;
        dst_object->layer_config_ranges  = src_object->layer_config_ranges;     // #ys_FIXME_experiment
        dst_object->layer_height_profile.assign(src_object->layer_height_profile);
        dst_object->origin_translation   = src_object->origin_translation;
 
        for (int i : object.second) {
            dst_object->add_instance(*src_object->instances[i]);
        }
 
        for (unsigned int i : selected_list) {
            // Copy the ModelVolumes only for the selected GLVolumes of the 1st selected instance.
            const GLVolume* volume = (*m_volumes)[i];
            if (volume->object_idx() == object.first && volume->instance_idx() == *object.second.begin()) {
                int volume_idx = volume->volume_idx();
                if (0 <= volume_idx && volume_idx < (int)src_object->volumes.size()) {
                    ModelVolume* src_volume = src_object->volumes[volume_idx];
                    ModelVolume* dst_volume = dst_object->add_volume(*src_volume);
                    dst_volume->set_new_unique_id();
                }
                else
                    assert(false);
            }
        }
    }
 
    m_clipboard.set_mode(m_mode);
}

Referenced by Slic3r::GUI::CloneDialog::CloneDialog(), clone(), and cut_to_clipboard().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ cut_to_clipboard()

void Slic3r::GUI::Selection::cut_to_clipboard ( )

{
    copy_to_clipboard();
    erase();
}

References copy_to_clipboard(), and erase().

Here is the call graph for this function:

◆ do_add_volume()

void Slic3r::GUI::Selection::do_add_volume ( unsigned int volume_idx )

private

{
    m_list.insert(volume_idx);
    GLVolume* v = (*m_volumes)[volume_idx];
    v->selected = true;
    if (v->hover == GLVolume::HS_Select || v->hover == GLVolume::HS_Deselect)
        v->hover = GLVolume::HS_Hover;
}

References Slic3r::GLVolume::hover, Slic3r::GLVolume::HS_Deselect, Slic3r::GLVolume::HS_Hover, Slic3r::GLVolume::HS_Select, and m_list.

Referenced by add(), add_all(), add_volumes(), do_add_volumes(), instances_changed(), and set_deserialized().

Here is the caller graph for this function:

◆ do_add_volumes()

void Slic3r::GUI::Selection::do_add_volumes ( const std::vector< unsigned int > & volume_idxs )

private

{
    for (unsigned int i : volume_idxs)
    {
        if (i < (unsigned int)m_volumes->size())
            do_add_volume(i);
    }
}

References do_add_volume(), and m_volumes.

Referenced by add_curr_plate(), add_instance(), add_object(), add_object_from_idx(), add_volume(), and remove_curr_plate().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ do_remove_instance()

void Slic3r::GUI::Selection::do_remove_instance	(	unsigned int	object_idx,
		unsigned int	instance_idx )

private

{
    for (unsigned int i = 0; i < (unsigned int)m_volumes->size(); ++i) {
        GLVolume* v = (*m_volumes)[i];
        if (v->object_idx() == (int)object_idx && v->instance_idx() == (int)instance_idx)
            do_remove_volume(i);
    }
}

References do_remove_volume(), Slic3r::GLVolume::instance_idx(), m_volumes, and Slic3r::GLVolume::object_idx().

Referenced by remove(), and remove_instance().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ do_remove_object()

void Slic3r::GUI::Selection::do_remove_object ( unsigned int object_idx )

private

{
    for (unsigned int i = 0; i < (unsigned int)m_volumes->size(); ++i) {
        GLVolume* v = (*m_volumes)[i];
        if (v->object_idx() == (int)object_idx)
            do_remove_volume(i);
    }
}

References do_remove_volume(), m_volumes, and Slic3r::GLVolume::object_idx().

Referenced by remove_object().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ do_remove_volume()

void Slic3r::GUI::Selection::do_remove_volume ( unsigned int volume_idx )

private

{
    IndicesList::iterator v_it = m_list.find(volume_idx);
    if (v_it == m_list.end())
        return;
 
    m_list.erase(v_it);
 
    (*m_volumes)[volume_idx]->selected = false;
}

References m_list.

Referenced by do_remove_instance(), do_remove_object(), remove(), remove_volume(), and remove_volumes().

Here is the caller graph for this function:

◆ drop()

void Slic3r::GUI::Selection::drop ( )

{
    const double min_z = get_drop_min_z();
    if (std::abs(min_z) < -SINKING_Z_THRESHOLD)
        return; // already checked in can_drop()
 
    wxGetApp().plater()->take_snapshot(L("Move object"));
 
    // do_move() writes every volume back to the model and refreshes the view.
    setup_cache();
    TransformationType transformation_type;
    transformation_type.set_relative();
    translate(Vec3d(0, 0, -min_z), transformation_type);
    wxGetApp().plater()->get_view3D_canvas3D()->do_move("");
}

References get_drop_min_z(), L, Slic3r::GUI::TransformationType::set_relative(), setup_cache(), Slic3r::SINKING_Z_THRESHOLD, and translate().

Here is the call graph for this function:

◆ ensure_not_below_bed()

void Slic3r::GUI::Selection::ensure_not_below_bed ( )

private

{
    typedef std::map<std::pair<int, int>, double> InstancesToZMap;
    InstancesToZMap instances_max_z;
 
    for (size_t i = 0; i < m_volumes->size(); ++i) {
        GLVolume* volume = (*m_volumes)[i];
        if (!volume->is_wipe_tower && !volume->is_modifier) {
            const double max_z = volume->transformed_convex_hull_bounding_box().max.z();
            const std::pair<int, int> instance = std::make_pair(volume->object_idx(), volume->instance_idx());
            InstancesToZMap::iterator it = instances_max_z.find(instance);
            if (it == instances_max_z.end())
                it = instances_max_z.insert({ instance, -DBL_MAX }).first;
 
            it->second = std::max(it->second, max_z);
        }
    }
 
    if (is_any_volume()) {
        for (unsigned int i : m_list) {
            GLVolume& volume = *(*m_volumes)[i];
            const std::pair<int, int> instance = std::make_pair(volume.object_idx(), volume.instance_idx());
            InstancesToZMap::const_iterator it = instances_max_z.find(instance);
            const double z_shift = SINKING_MIN_Z_THRESHOLD - it->second;
            if (it != instances_max_z.end() && z_shift > 0.0)
                volume.set_volume_offset(Z, volume.get_volume_offset(Z) + z_shift);
        }
    }
    else {
        for (GLVolume* volume : *m_volumes) {
            const std::pair<int, int> instance = std::make_pair(volume->object_idx(), volume->instance_idx());
            InstancesToZMap::const_iterator it = instances_max_z.find(instance);
            if (it != instances_max_z.end() && it->second < SINKING_MIN_Z_THRESHOLD)
                volume->set_instance_offset(Z, volume->get_instance_offset(Z) + SINKING_MIN_Z_THRESHOLD - it->second);
        }
    }
}

References Slic3r::GLVolume::get_volume_offset(), Slic3r::GLVolume::instance_idx(), is_any_volume(), m_list, m_volumes, Slic3r::BoundingBoxBase< PointType, std::vector< PointType > >::max, Slic3r::GLVolume::object_idx(), Slic3r::GLVolume::set_volume_offset(), Slic3r::SINKING_MIN_Z_THRESHOLD, Slic3r::GLVolume::transformed_convex_hull_bounding_box(), and Slic3r::Z.

Referenced by erase(), and translate().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ ensure_on_bed()

void Slic3r::GUI::Selection::ensure_on_bed ( )

private

{
    typedef std::map<std::pair<int, int>, double> InstancesToZMap;
    InstancesToZMap instances_min_z;
 
    for (size_t i = 0; i < m_volumes->size(); ++i) {
        GLVolume* volume    = (*m_volumes)[i];
        ModelObject*   mo   = m_model->objects[volume->object_idx()];
        if (mo->auto_drop == false
            || volume->is_wipe_tower 
            || volume->is_modifier 
            || std::find(m_cache.sinking_volumes.begin(), m_cache.sinking_volumes.end(), i) != m_cache.sinking_volumes.end()) 
        {
            continue;
        }
 
        const double min_z = volume->transformed_convex_hull_bounding_box().min.z();
        std::pair<int, int> instance = std::make_pair(volume->object_idx(), volume->instance_idx());
        InstancesToZMap::iterator it = instances_min_z.find(instance);
        if (it == instances_min_z.end())
            it = instances_min_z.insert(InstancesToZMap::value_type(instance, DBL_MAX)).first;
 
        it->second = std::min(it->second, min_z);
    }
 
    for (GLVolume* volume : *m_volumes) {
        std::pair<int, int> instance = std::make_pair(volume->object_idx(), volume->instance_idx());
        InstancesToZMap::iterator it = instances_min_z.find(instance);
        if (it != instances_min_z.end())
            volume->set_instance_offset(Z, volume->get_instance_offset(Z) - it->second);
    }
}

References Slic3r::ModelObject::auto_drop, Slic3r::GLVolume::instance_idx(), m_cache, m_model, m_volumes, Slic3r::BoundingBoxBase< PointType, std::vector< PointType > >::min, Slic3r::GLVolume::object_idx(), Slic3r::GLVolume::transformed_convex_hull_bounding_box(), and Slic3r::Z.

Here is the call graph for this function:

◆ erase()

void Slic3r::GUI::Selection::erase ( )

{
    if (!m_valid)
        return;
 
    if (is_single_full_object())
        wxGetApp().obj_list()->delete_from_model_and_list(ItemType::itObject, get_object_idx(), 0);
    else if (is_multiple_full_object()) {
        std::vector<ItemForDelete> items;
        items.reserve(m_cache.content.size());
        for (ObjectIdxsToInstanceIdxsMap::iterator it = m_cache.content.begin(); it != m_cache.content.end(); ++it) {
            items.emplace_back(ItemType::itObject, it->first, 0);
        }
        wxGetApp().obj_list()->delete_from_model_and_list(items);
    }
    else if (is_multiple_full_instance()) {
        std::set<std::pair<int, int>> instances_idxs;
        for (ObjectIdxsToInstanceIdxsMap::iterator obj_it = m_cache.content.begin(); obj_it != m_cache.content.end(); ++obj_it) {
            for (InstanceIdxsList::reverse_iterator inst_it = obj_it->second.rbegin(); inst_it != obj_it->second.rend(); ++inst_it) {
                instances_idxs.insert(std::make_pair(obj_it->first, *inst_it));
            }
        }
 
        std::vector<ItemForDelete> items;
        items.reserve(instances_idxs.size());
        for (const std::pair<int, int>& i : instances_idxs) {
            items.emplace_back(ItemType::itInstance, i.first, i.second);
        }
        wxGetApp().obj_list()->delete_from_model_and_list(items);
    }
    else if (is_single_full_instance())
        wxGetApp().obj_list()->delete_from_model_and_list(ItemType::itInstance, get_object_idx(), get_instance_idx());
    else if (is_mixed()) {
        std::set<ItemForDelete> items_set;
        std::map<int, int> volumes_in_obj;
 
        for (auto i : m_list) {
            const auto gl_vol = (*m_volumes)[i];
            const auto glv_obj_idx = gl_vol->object_idx();
            const auto model_object = m_model->objects[glv_obj_idx];
 
            if (model_object->instances.size() == 1) {
                if (model_object->volumes.size() == 1)
                    items_set.insert(ItemForDelete(ItemType::itObject, glv_obj_idx, -1));
                else {
                    items_set.insert(ItemForDelete(ItemType::itVolume, glv_obj_idx, gl_vol->volume_idx()));
                    int idx = (volumes_in_obj.find(glv_obj_idx) == volumes_in_obj.end()) ? 0 : volumes_in_obj.at(glv_obj_idx);
                    volumes_in_obj[glv_obj_idx] = ++idx;
                }
                continue;
            }
 
            const auto glv_ins_idx = gl_vol->instance_idx();
 
            for (auto obj_ins : m_cache.content) {
                if (obj_ins.first == glv_obj_idx) {
                    if (obj_ins.second.find(glv_ins_idx) != obj_ins.second.end()) {
                        if (obj_ins.second.size() == model_object->instances.size())
                            items_set.insert(ItemForDelete(ItemType::itObject, glv_obj_idx, -1));
                        else
                            items_set.insert(ItemForDelete(ItemType::itInstance, glv_obj_idx, glv_ins_idx));
 
                        break;
                    }
                }
            }
        }
 
        std::vector<ItemForDelete> items;
        items.reserve(items_set.size());
        for (const ItemForDelete& i : items_set) {
            if (i.type == ItemType::itVolume) {
                const int vol_in_obj_cnt = volumes_in_obj.find(i.obj_idx) == volumes_in_obj.end() ? 0 : volumes_in_obj.at(i.obj_idx);
                if (vol_in_obj_cnt == (int)m_model->objects[i.obj_idx]->volumes.size()) {
                    if (i.sub_obj_idx == vol_in_obj_cnt - 1)
                        items.emplace_back(ItemType::itObject, i.obj_idx, 0);
                    continue;
                }
            }
            items.emplace_back(i.type, i.obj_idx, i.sub_obj_idx);
        }
 
        wxGetApp().obj_list()->delete_from_model_and_list(items);
    }
    else {
        std::set<std::pair<int, int>> volumes_idxs;
        for (unsigned int i : m_list) {
            const GLVolume* v = (*m_volumes)[i];
            // Only remove volumes associated with ModelVolumes from the object list.
            // Temporary meshes (SLA supports or pads) are not managed by the object list.
            if (v->volume_idx() >= 0)
                volumes_idxs.insert(std::make_pair(v->object_idx(), v->volume_idx()));
        }
 
        std::vector<ItemForDelete> items;
        items.reserve(volumes_idxs.size());
        for (const std::pair<int, int>& v : volumes_idxs) {
            items.emplace_back(ItemType::itVolume, v.first, v.second);
        }
 
        wxGetApp().obj_list()->delete_from_model_and_list(items);
        ensure_not_below_bed();
    }
}

References ensure_not_below_bed(), get_instance_idx(), get_object_idx(), is_mixed(), is_multiple_full_instance(), is_multiple_full_object(), is_single_full_instance(), is_single_full_object(), Slic3r::GUI::itInstance, Slic3r::GUI::itObject, Slic3r::GUI::itVolume, m_cache, m_list, m_model, m_valid, Slic3r::GLVolume::object_idx(), and Slic3r::GLVolume::volume_idx().

Referenced by cut_to_clipboard(), and remove_curr_plate().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ fill_color()

void Slic3r::GUI::Selection::fill_color ( int extruder_id )

{
    wxGetApp().obj_list()->set_extruder_for_selected_items(extruder_id);
}

◆ flattening_rotate()

void Slic3r::GUI::Selection::flattening_rotate ( const Vec3d & normal )

{
    // We get the normal in untransformed coordinates. We must transform it using the instance matrix, find out
    // how to rotate the instance so it faces downwards and do the rotation. All that for all selected instances.
    // The function assumes that is_from_single_object() holds.
    assert(Slic3r::is_approx(normal.norm(), 1.));
 
    if (!m_valid)
        return;
 
    for (unsigned int i : m_list) {
        GLVolume& v = *(*m_volumes)[i];
        // Additional rotation to align the face normal with the down vector in the world coordinate space.
        const Geometry::Transformation& old_inst_trafo = v.get_instance_transformation();
        const Transform3d rotation_matrix = lay_on_face_rotation(normal, old_inst_trafo.get_matrix_no_offset());
        v.set_instance_transformation(old_inst_trafo.get_offset_matrix() * rotation_matrix * old_inst_trafo.get_matrix_no_offset());
    }
 
#if !DISABLE_INSTANCES_SYNCH
    // Apply the same transformation also to other instances,
    // but respect their possibly diffrent z-rotation.
    if (m_mode == Instance)
        synchronize_unselected_instances(SyncRotationType::GENERAL);
#endif // !DISABLE_INSTANCES_SYNCH
 
    this->set_bounding_boxes_dirty();
}

References GENERAL, Slic3r::GLVolume::get_instance_transformation(), Slic3r::Geometry::Transformation::get_matrix_no_offset(), Slic3r::Geometry::Transformation::get_offset_matrix(), Instance, Slic3r::is_approx(), Slic3r::lay_on_face_rotation(), m_list, m_mode, m_valid, Slic3r::normal(), set_bounding_boxes_dirty(), Slic3r::GLVolume::set_instance_transformation(), and synchronize_unselected_instances().

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

Here is the call graph for this function:

Here is the caller graph for this function:

◆ get_auto_drop()

bool Slic3r::GUI::Selection::get_auto_drop ( ) const

                                    {
    // The wipe tower is not a ModelObject and has no auto_drop state;
    // return the default to avoid indexing m_model->objects with its synthetic id.
    if (!m_valid || is_wipe_tower())
        return true;
 
    std::set<int> object_idxs;
    for (const auto& [obj_idx, inst_list] : m_cache.content) {
        object_idxs.insert(obj_idx);
    }
 
    // Return false if one selected object has auto_drop disabled.
    for (int obj_idx : object_idxs) {
        ModelObject* object = m_model->objects[obj_idx];
        if (!object->auto_drop)
            return false;
    }
 
    return true;
}

References Slic3r::ModelObject::auto_drop, is_wipe_tower(), m_cache, m_model, and m_valid.

Referenced by Slic3r::GUI::MenuFactory::append_menu_item_set_auto_drop(), render(), render_bounding_box(), render_bounding_box(), and render_synchronized_volumes().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ get_bounding_box()

const BoundingBoxf3 & Slic3r::GUI::Selection::get_bounding_box ( ) const

{
    if (!m_bounding_box.has_value()) {
        std::optional<BoundingBoxf3>* bbox = const_cast<std::optional<BoundingBoxf3>*>(&m_bounding_box);
        *bbox = BoundingBoxf3();
        if (m_valid) {
            for (unsigned int i : m_list) {
                (*bbox)->merge((*m_volumes)[i]->transformed_convex_hull_bounding_box());
            }
        }
    }
    return *m_bounding_box;
}

References m_bounding_box, m_list, m_valid, and m_volumes.

Referenced by Slic3r::GUI::MenuFactory::append_menu_item_center(), Slic3r::GUI::MenuFactory::append_menu_items_flush_options(), center(), center_plate(), get_drop_min_z(), Slic3r::GUI::GLGizmoMove3D::get_tooltip(), render_sidebar_hints(), render_sidebar_layers_hints(), scale_to_fit_print_volume(), set_caches(), and Slic3r::GUI::GizmoObjectManipulation::update_settings_value().

Here is the caller graph for this function:

◆ get_bounding_box_in_current_reference_system()

const std::pair< BoundingBoxf3, Transform3d > & Slic3r::GUI::Selection::get_bounding_box_in_current_reference_system ( ) const

{
    static int last_coordinates_type = -1;
 
    assert(!is_empty());
 
    ECoordinatesType coordinates_type = wxGetApp().obj_manipul()->get_coordinates_type();
    if (m_mode == Instance && coordinates_type == ECoordinatesType::Local) coordinates_type = ECoordinatesType::World;
 
    if (last_coordinates_type != int(coordinates_type)) const_cast<std::optional<std::pair<BoundingBoxf3, Transform3d>> *>(&m_bounding_box_in_current_reference_system)->reset();
 
    if (!m_bounding_box_in_current_reference_system.has_value()) {
        last_coordinates_type                                                                                            = int(coordinates_type);
        *const_cast<std::optional<std::pair<BoundingBoxf3, Transform3d>> *>(&m_bounding_box_in_current_reference_system) = get_bounding_box_in_reference_system(coordinates_type);
    }
 
    return *m_bounding_box_in_current_reference_system;
}

References get_bounding_box_in_reference_system(), Instance, is_empty(), Slic3r::GUI::Local, m_bounding_box_in_current_reference_system, m_mode, and Slic3r::GUI::World.

Referenced by Slic3r::GUI::GLGizmoRotate::init_data_from_selection(), Slic3r::GUI::GLGizmoMove3D::on_render(), render(), render_sidebar_hints(), scale_and_translate(), Slic3r::GUI::GLGizmoScale3D::update_grabbers_data(), and Slic3r::GUI::GizmoObjectManipulation::update_settings_value().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ get_bounding_box_in_reference_system()

std::pair< BoundingBoxf3, Transform3d > Slic3r::GUI::Selection::get_bounding_box_in_reference_system ( ECoordinatesType type ) const

{
    //
    // trafo to current reference system
    //
    Transform3d trafo;
    switch (type) {
    case ECoordinatesType::World: {
        trafo = Transform3d::Identity();
        break;
    }
    case ECoordinatesType::Instance: {
        trafo = get_first_volume()->get_instance_transformation().get_matrix();
        break;
    }
    case ECoordinatesType::Local: {
        trafo = get_first_volume()->world_matrix();
        break;
    }
    }
 
    //
    // trafo basis in world coordinates
    //
    Geometry::Transformation t(trafo);
    t.reset_scaling_factor();
    const Transform3d  basis_trafo = t.get_matrix_no_offset();
    std::vector<Vec3d> axes        = {Vec3d::UnitX(), Vec3d::UnitY(), Vec3d::UnitZ()};
    for (size_t i = 0; i < axes.size(); ++i) { axes[i] = basis_trafo * axes[i]; }
 
    //
    // calculate bounding box aligned to trafo basis
    //
    Vec3d min = {DBL_MAX, DBL_MAX, DBL_MAX};
    Vec3d max = {-DBL_MAX, -DBL_MAX, -DBL_MAX};
    for (unsigned int id : m_list) {
        const GLVolume &    vol            = *get_volume(id);
        const Transform3d   vol_world_rafo = vol.world_matrix();
        const TriangleMesh *mesh           = vol.convex_hull();
        if (mesh == nullptr)
            mesh = &m_model->objects[vol.object_idx()]->volumes[vol.volume_idx()]->mesh();
        assert(mesh != nullptr);
        for (const stl_vertex &v : mesh->its.vertices) {
            const Vec3d world_v = vol_world_rafo * v.cast<double>();
            for (int i = 0; i < 3; ++i) {
                const double i_comp = world_v.dot(axes[i]);
                min(i)              = std::min(min(i), i_comp);
                max(i)              = std::max(max(i), i_comp);
            }
        }
    }
 
    const Vec3d              box_size      = max - min;
    Vec3d                    half_box_size = 0.5 * box_size;
    Geometry::Transformation out_trafo(trafo);
    Vec3d                    center = 0.5 * (min + max);
 
    // Fix for non centered volume
    // by move with calculated center(to volume center) and extend half box size
    // e.g. for right aligned embossed text
    if (m_list.size() == 1 && type == ECoordinatesType::Local) {
        const GLVolume &  vol             = *get_volume(*m_list.begin());
        const Transform3d vol_world_trafo = vol.world_matrix();
        Vec3d             world_zero      = vol_world_trafo * Vec3d::Zero();
        for (size_t i = 0; i < 3; i++) {
            // move center to local volume zero
            center[i] = world_zero.dot(axes[i]);
            // extend half size to bigger distance from center
            half_box_size[i] = std::max(abs(center[i] - min[i]), abs(center[i] - max[i]));
        }
    }
 
    const BoundingBoxf3 out_box(-half_box_size, half_box_size);
    out_trafo.set_offset(basis_trafo * center);
    return {out_box, out_trafo.get_matrix_no_scaling_factor()};
}

References center(), Slic3r::GLVolume::convex_hull(), get_first_volume(), Slic3r::GLVolume::get_instance_transformation(), Slic3r::Geometry::Transformation::get_matrix(), Slic3r::Geometry::Transformation::get_matrix_no_offset(), Slic3r::Geometry::Transformation::get_matrix_no_scaling_factor(), get_volume(), Slic3r::GUI::Instance, Slic3r::TriangleMesh::its, Slic3r::GUI::Local, m_list, m_model, Slic3r::GLVolume::object_idx(), Slic3r::Geometry::Transformation::reset_scaling_factor(), Slic3r::Geometry::Transformation::set_offset(), Slic3r::GLVolume::volume_idx(), Slic3r::GUI::World, and Slic3r::GLVolume::world_matrix().

Referenced by get_bounding_box_in_current_reference_system(), and Slic3r::GUI::GLGizmoRotate::init_data_from_selection().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ get_bounding_sphere()

const std::pair< Vec3d, double > Slic3r::GUI::Selection::get_bounding_sphere ( ) const

{
    if (!m_bounding_sphere.has_value()) {
        std::optional<std::pair<Vec3d, double>>* sphere = const_cast<std::optional<std::pair<Vec3d, double>>*>(&m_bounding_sphere);
        *sphere = { Vec3d::Zero(), 0.0 };
 
        using K = CGAL::Simple_cartesian<float>;
        using Traits = CGAL::Min_sphere_of_points_d_traits_3<K, float>;
        using Min_sphere = CGAL::Min_sphere_of_spheres_d<Traits>;
        using Point = K::Point_3;
 
        if (m_valid && !m_list.empty()) {
            std::vector<Point> points;
            for (unsigned int i : m_list) {
                const GLVolume& volume = *(*m_volumes)[i];
                const TriangleMesh* hull = volume.convex_hull();
                const indexed_triangle_set& its = (hull != nullptr) ?
                    hull->its : m_model->objects[volume.object_idx()]->volumes[volume.volume_idx()]->mesh().its;
                const Transform3d& matrix = volume.world_matrix();
                for (const Vec3f& v : its.vertices) {
                    const Vec3d vv = matrix * v.cast<double>();
                    points.push_back(Point(vv.x(), vv.y(), vv.z()));
                }
            }
 
            Min_sphere ms(points.begin(), points.end());
            const float* center_x = ms.center_cartesian_begin();
            (*sphere)->first = { *center_x, *(center_x + 1), *(center_x + 2) };
            (*sphere)->second = ms.radius();
        }
    }
 
    return *m_bounding_sphere;
}

References Slic3r::GLVolume::convex_hull(), Slic3r::TriangleMesh::its, Slic3r::GUI::K, m_bounding_sphere, m_list, m_model, m_valid, Slic3r::GLVolume::object_idx(), Slic3r::GLVolume::volume_idx(), and Slic3r::GLVolume::world_matrix().

Referenced by Slic3r::GUI::GLGizmoRotate::init_data_from_selection(), and set_caches().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ get_clipboard()

const Clipboard & Slic3r::GUI::Selection::get_clipboard ( ) const

inline

411{ return m_clipboard; }

References m_clipboard.

Referenced by Slic3r::GUI::Plater::can_paste_from_clipboard().

Here is the caller graph for this function:

◆ get_content()

const ObjectIdxsToInstanceIdxsMap & Slic3r::GUI::Selection::get_content ( ) const

inline

320{ return m_cache.content; }

References m_cache.

Referenced by Slic3r::GUI::GLGizmoAlignment::get_items_count(), Slic3r::GUI::GLGizmoAlignment::get_parent_box(), Slic3r::GUI::GLGizmoAlignment::get_selected_objects_info(), Slic3r::GUI::GLGizmoAlignment::is_parts_selection(), Slic3r::GUI::Plater::show_object_info(), and Slic3r::GUI::ObjectList::update_selections().

Here is the caller graph for this function:

◆ get_drop_min_z()

double Slic3r::GUI::Selection::get_drop_min_z ( ) const

{
    if (!m_valid)
        return 0.;
    if (m_mode == Volume)
        return get_bounding_box().min.z();
 
    double min_z = DBL_MAX;
    for (const auto& [obj_idx, inst_idxs] : m_cache.content) {
        if (obj_idx >= (int)m_model->objects.size())
            continue; // wipe tower
        for (int inst_idx : inst_idxs)
            min_z = std::min(min_z, m_model->objects[obj_idx]->get_instance_min_z(inst_idx));
    }
    return min_z == DBL_MAX ? 0. : min_z;
}

References get_bounding_box(), m_cache, m_mode, m_model, m_valid, Slic3r::BoundingBoxBase< PointType, std::vector< PointType > >::min, and Volume.

Referenced by can_drop(), and drop().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ get_first_volume()

const GLVolume * Slic3r::GUI::Selection::get_first_volume ( ) const

inline

317{ return get_volume(*m_list.begin()); }

References get_volume(), and m_list.

Here is the call graph for this function:

Here is the caller graph for this function:

◆ get_full_scaled_instance_bounding_box()

const BoundingBoxf3 & Slic3r::GUI::Selection::get_full_scaled_instance_bounding_box ( ) const

{
    assert(is_single_full_instance());
 
    if (!m_full_scaled_instance_bounding_box.has_value()) {
        std::optional<BoundingBoxf3> *bbox = const_cast<std::optional<BoundingBoxf3> *>(&m_full_scaled_instance_bounding_box);
        *bbox                              = BoundingBoxf3();
        if (m_valid) {
            for (unsigned int i : m_list) {
                const GLVolume &volume = *(*m_volumes)[i];
                Transform3d     trafo  = volume.get_instance_transformation().get_matrix() * volume.get_volume_transformation().get_matrix();
                trafo.translation().z() += volume.get_sla_shift_z();
                (*bbox)->merge(volume.transformed_convex_hull_bounding_box(trafo));
            }
        }
    }
    return *m_full_scaled_instance_bounding_box;
}

References Slic3r::GLVolume::get_instance_transformation(), Slic3r::Geometry::Transformation::get_matrix(), Slic3r::GLVolume::get_sla_shift_z(), Slic3r::GLVolume::get_volume_transformation(), is_single_full_instance(), m_full_scaled_instance_bounding_box, m_list, m_valid, and Slic3r::GLVolume::transformed_convex_hull_bounding_box().

Here is the call graph for this function:

◆ get_full_unscaled_instance_bounding_box()

const BoundingBoxf3 & Slic3r::GUI::Selection::get_full_unscaled_instance_bounding_box ( ) const

{
    assert(is_single_full_instance());
 
    if (!m_full_unscaled_instance_bounding_box.has_value()) {
        std::optional<BoundingBoxf3> *bbox = const_cast<std::optional<BoundingBoxf3> *>(&m_full_unscaled_instance_bounding_box);
        *bbox                              = BoundingBoxf3();
        if (m_valid) {
            for (unsigned int i : m_list) {
                const GLVolume &volume = *(*m_volumes)[i];
                Transform3d     trafo  = volume.get_instance_transformation().get_matrix_no_scaling_factor() * volume.get_volume_transformation().get_matrix();
                trafo.translation().z() += volume.get_sla_shift_z();
                (*bbox)->merge(volume.transformed_convex_hull_bounding_box(trafo));
            }
        }
    }
    return *m_full_unscaled_instance_bounding_box;
}

References Slic3r::GLVolume::get_instance_transformation(), Slic3r::Geometry::Transformation::get_matrix(), Slic3r::Geometry::Transformation::get_matrix_no_scaling_factor(), Slic3r::GLVolume::get_sla_shift_z(), Slic3r::GLVolume::get_volume_transformation(), is_single_full_instance(), m_full_unscaled_instance_bounding_box, m_list, m_valid, and Slic3r::GLVolume::transformed_convex_hull_bounding_box().

Referenced by Slic3r::GUI::GizmoObjectManipulation::change_size_value(), and scale_and_translate().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ get_full_unscaled_instance_local_bounding_box()

const BoundingBoxf3 & Slic3r::GUI::Selection::get_full_unscaled_instance_local_bounding_box ( ) const

{
    assert(is_single_full_instance());
 
    if (!m_full_unscaled_instance_local_bounding_box.has_value()) {
        std::optional<BoundingBoxf3> *bbox = const_cast<std::optional<BoundingBoxf3> *>(&m_full_unscaled_instance_local_bounding_box);
        *bbox                              = BoundingBoxf3();
        if (m_valid) {
            for (unsigned int i : m_list) {
                const GLVolume &volume = *(*m_volumes)[i];
                Transform3d     trafo  = volume.get_volume_transformation().get_matrix();
                trafo.translation().z() += volume.get_sla_shift_z();
                (*bbox)->merge(volume.transformed_convex_hull_bounding_box(trafo));
            }
        }
    }
    return *m_full_unscaled_instance_local_bounding_box;
}

References Slic3r::Geometry::Transformation::get_matrix(), Slic3r::GLVolume::get_sla_shift_z(), Slic3r::GLVolume::get_volume_transformation(), is_single_full_instance(), m_full_unscaled_instance_local_bounding_box, m_list, m_valid, and Slic3r::GLVolume::transformed_convex_hull_bounding_box().

Referenced by Slic3r::GUI::GizmoObjectManipulation::change_size_value(), scale_and_translate(), and Slic3r::GUI::GizmoObjectManipulation::update_settings_value().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ get_instance_idx()

int Slic3r::GUI::Selection::get_instance_idx ( ) const

{
    if (m_cache.content.size() == 1) {
        const InstanceIdxsList& idxs = m_cache.content.begin()->second;
        if (idxs.size() == 1)
            return *idxs.begin();
    }
 
    return -1;
}

References m_cache.

Here is the caller graph for this function:

◆ get_instance_idxs()

const Selection::InstanceIdxsList & Slic3r::GUI::Selection::get_instance_idxs ( ) const

{
    assert(m_cache.content.size() == 1);
    return m_cache.content.begin()->second;
}

References m_cache.

Referenced by Slic3r::GUI::ObjectList::load_generic_subobject(), Slic3r::GUI::ObjectList::load_modifier(), Slic3r::GUI::ObjectList::split_instances(), and Slic3r::GUI::ObjectList::update_selections().

Here is the caller graph for this function:

◆ get_missing_volume_idxs_from()

std::vector< unsigned int > Slic3r::GUI::Selection::get_missing_volume_idxs_from ( const std::vector< unsigned int > & volume_idxs ) const

{
    std::vector<unsigned int> idxs;
 
    for (unsigned int i : m_list)
    {
        std::vector<unsigned int>::const_iterator it = std::find(volume_idxs.begin(), volume_idxs.end(), i);
        if (it == volume_idxs.end())
            idxs.push_back(i);
    }
 
    return idxs;
}

References m_list.

Referenced by Slic3r::GUI::ObjectList::update_selections_on_canvas().

Here is the caller graph for this function:

◆ get_mode()

EMode Slic3r::GUI::Selection::get_mode ( ) const

inline

222{ return m_mode; }

References m_mode.

Referenced by Slic3r::GUI::Plater::can_paste_from_clipboard(), Slic3r::GUI::Plater::export_stl(), Slic3r::GUI::GLGizmoAlignment::get_items_count(), Slic3r::GUI::GLGizmoAlignment::get_selected_part_volumes(), Slic3r::GUI::GLGizmoAlignment::is_parts_selection(), Slic3r::GUI::Plater::show_object_info(), Slic3r::UndoRedo::StackImpl::take_snapshot(), and Slic3r::GUI::ObjectList::update_selections_on_canvas().

Here is the caller graph for this function:

◆ get_model()

Model * Slic3r::GUI::Selection::get_model ( ) const

inline

219{ return m_model; }

References m_model.

Here is the caller graph for this function:

◆ get_object_idx()

int Slic3r::GUI::Selection::get_object_idx ( ) const

{
    return (m_cache.content.size() == 1) ? m_cache.content.begin()->first : -1;
}

References m_cache.

Here is the caller graph for this function:

◆ get_scaled_instance_bounding_box()

const BoundingBoxf3 & Slic3r::GUI::Selection::get_scaled_instance_bounding_box ( ) const

{
    assert(is_single_full_instance());
 
    if (!m_scaled_instance_bounding_box.has_value()) {
        std::optional<BoundingBoxf3>* bbox = const_cast<std::optional<BoundingBoxf3>*>(&m_scaled_instance_bounding_box);
        *bbox = BoundingBoxf3();
        if (m_valid) {
            for (unsigned int i : m_list) {
                const GLVolume& volume = *(*m_volumes)[i];
                if (volume.is_modifier)
                    continue;
                Transform3d trafo = volume.get_instance_transformation().get_matrix() * volume.get_volume_transformation().get_matrix();
                trafo.translation().z() += volume.get_sla_shift_z();
                (*bbox)->merge(volume.transformed_convex_hull_bounding_box(trafo));
            }
        }
    }
    return *m_scaled_instance_bounding_box;
}

References Slic3r::GLVolume::get_instance_transformation(), Slic3r::Geometry::Transformation::get_matrix(), Slic3r::GLVolume::get_sla_shift_z(), Slic3r::GLVolume::get_volume_transformation(), is_single_full_instance(), m_list, m_scaled_instance_bounding_box, m_valid, and Slic3r::GLVolume::transformed_convex_hull_bounding_box().

Here is the call graph for this function:

◆ get_selected_object_instances()

std::set< std::pair< int, int > > Slic3r::GUI::Selection::get_selected_object_instances ( )

{
    std::set<std::pair<int, int>> instances_idxs;
    // BBS only support multi full object now
    if (!is_multiple_full_object())
        return instances_idxs;
 
    for (ObjectIdxsToInstanceIdxsMap::iterator obj_it = m_cache.content.begin(); obj_it != m_cache.content.end(); ++obj_it)
    {
        for (InstanceIdxsList::reverse_iterator inst_it = obj_it->second.rbegin(); inst_it != obj_it->second.rend(); ++inst_it)
        {
            instances_idxs.insert(std::make_pair(obj_it->first, *inst_it));
        }
    }
 
    return instances_idxs;
}

References is_multiple_full_object(), and m_cache.

Here is the call graph for this function:

◆ get_selected_single_intance()

const ModelInstance * Slic3r::GUI::Selection::get_selected_single_intance ( ) const

{
    int  object_idx;
    auto mo = get_selected_single_object(object_idx);
    if (mo) {
        return mo->instances[get_instance_idx()];
    }
    return nullptr;
}

References get_instance_idx(), and get_selected_single_object().

Here is the call graph for this function:

◆ get_selected_single_object()

ModelObject * Slic3r::GUI::Selection::get_selected_single_object ( int & out_object_idx ) const

{
    if (is_single_volume() || is_single_modifier() || is_single_full_object()) {
        const GLVolume *gl_volume = get_first_volume();
        out_object_idx            = gl_volume->object_idx();
        return get_model()->objects[out_object_idx];
    }
    return nullptr;
}

References get_first_volume(), get_model(), is_single_full_object(), is_single_modifier(), is_single_volume(), Slic3r::GLVolume::object_idx(), and Slic3r::Model::objects.

Referenced by get_selected_single_intance().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ get_selected_single_volume()

ModelVolume * Slic3r::GUI::Selection::get_selected_single_volume	(	int &	out_object_idx,
		int &	out_volume_idx ) const

{
    if (is_single_volume() || is_single_modifier()) {
        const GLVolume *gl_volume = get_first_volume();
        out_object_idx            = gl_volume->object_idx();
        ModelObject *model_object = get_model()->objects[out_object_idx];
        out_volume_idx            = gl_volume->volume_idx();
        if (out_volume_idx < model_object->volumes.size())
            return model_object->volumes[out_volume_idx];
    }
    return nullptr;
}

References get_first_volume(), get_model(), is_single_modifier(), is_single_volume(), Slic3r::GLVolume::object_idx(), Slic3r::Model::objects, Slic3r::GLVolume::volume_idx(), and Slic3r::ModelObject::volumes.

Here is the call graph for this function:

◆ get_unscaled_instance_bounding_box()

const BoundingBoxf3 & Slic3r::GUI::Selection::get_unscaled_instance_bounding_box ( ) const

{
    assert(is_single_full_instance());
 
    if (!m_unscaled_instance_bounding_box.has_value()) {
        std::optional<BoundingBoxf3>* bbox = const_cast<std::optional<BoundingBoxf3>*>(&m_unscaled_instance_bounding_box);
        *bbox = BoundingBoxf3();
        if (m_valid) {
            for (unsigned int i : m_list) {
                const GLVolume& volume = *(*m_volumes)[i];
                if (volume.is_modifier)
                    continue;
                Transform3d trafo = volume.get_instance_transformation().get_matrix_no_scaling_factor() * volume.get_volume_transformation().get_matrix();
                trafo.translation().z() += volume.get_sla_shift_z();
                (*bbox)->merge(volume.transformed_convex_hull_bounding_box(trafo));
            }
        }
    }
    return *m_unscaled_instance_bounding_box;
}

References Slic3r::GLVolume::get_instance_transformation(), Slic3r::Geometry::Transformation::get_matrix(), Slic3r::Geometry::Transformation::get_matrix_no_scaling_factor(), Slic3r::GLVolume::get_sla_shift_z(), Slic3r::GLVolume::get_volume_transformation(), is_single_full_instance(), m_list, m_unscaled_instance_bounding_box, m_valid, and Slic3r::GLVolume::transformed_convex_hull_bounding_box().

Referenced by Slic3r::GUI::GizmoObjectManipulation::update_settings_value().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ get_unselected_volume_idxs_from()

std::vector< unsigned int > Slic3r::GUI::Selection::get_unselected_volume_idxs_from ( const std::vector< unsigned int > & volume_idxs ) const

{
    std::vector<unsigned int> idxs;
 
    for (unsigned int i : volume_idxs)
    {
        if (m_list.find(i) == m_list.end())
            idxs.push_back(i);
    }
 
    return idxs;
}

References m_list.

Referenced by Slic3r::GUI::ObjectList::update_selections_on_canvas().

Here is the caller graph for this function:

◆ get_volume() [1/2]

GLVolume * Slic3r::GUI::Selection::get_volume ( unsigned int volume_idx )

{
    return (m_valid && (volume_idx < (unsigned int)m_volumes->size())) ? (*m_volumes)[volume_idx] : nullptr;
}

References m_valid, and m_volumes.

◆ get_volume() [2/2]

const GLVolume * Slic3r::GUI::Selection::get_volume ( unsigned int volume_idx ) const

{
    return (m_valid && (volume_idx < (unsigned int)m_volumes->size())) ? (*m_volumes)[volume_idx] : nullptr;
}

References m_valid, and m_volumes.

Here is the caller graph for this function:

◆ get_volume_idxs()

const IndicesList & Slic3r::GUI::Selection::get_volume_idxs ( ) const

inline

315{ return m_list; }

References m_list.

Here is the caller graph for this function:

◆ get_volume_idxs_from_instance()

std::vector< unsigned int > Slic3r::GUI::Selection::get_volume_idxs_from_instance	(	unsigned int	object_idx,
		unsigned int	instance_idx ) const

{
    std::vector<unsigned int> idxs;
 
    for (unsigned int i = 0; i < (unsigned int)m_volumes->size(); ++i)
    {
        const GLVolume* v = (*m_volumes)[i];
        if ((v->object_idx() == (int)object_idx) && (v->instance_idx() == (int)instance_idx))
            idxs.push_back(i);
    }
 
    return idxs;
}

References Slic3r::GLVolume::instance_idx(), m_volumes, and Slic3r::GLVolume::object_idx().

Referenced by add_instance(), get_volume_idxs_from_plate(), and Slic3r::GUI::ObjectList::update_selections_on_canvas().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ get_volume_idxs_from_object()

std::vector< unsigned int > Slic3r::GUI::Selection::get_volume_idxs_from_object ( unsigned int object_idx ) const

{
    std::vector<unsigned int> idxs;
 
    for (unsigned int i = 0; i < (unsigned int)m_volumes->size(); ++i)
    {
        if ((*m_volumes)[i]->object_idx() == (int)object_idx)
            idxs.push_back(i);
    }
 
    return idxs;
}

References m_volumes.

Referenced by add_object(), add_object_from_idx(), Slic3r::GUI::Plater::priv::replace_all_with_stl(), and Slic3r::GUI::ObjectList::update_selections_on_canvas().

Here is the caller graph for this function:

◆ get_volume_idxs_from_plate()

std::vector< unsigned int > Slic3r::GUI::Selection::get_volume_idxs_from_plate ( const int plate_idx ) const

{
    PartPlate* plate = wxGetApp().plater()->get_partplate_list().get_plate(plate_idx);
    std::vector<unsigned int> idxs;
    if (!plate)
        return idxs;
 
    for (int obj_idx = 0; obj_idx < (int)m_model->objects.size(); obj_idx++) {
        const ModelObject* obj = m_model->objects[obj_idx];
        for (int inst_idx = 0; inst_idx < (int)obj->instances.size(); inst_idx++) {
            // on this plate or overlapping it in some way (fully inside, oversized or partly outside)
            if (plate->contain_instance(obj_idx, inst_idx) || plate->intersect_instance(obj_idx, inst_idx)) {
                std::vector<unsigned int> inst_idxs = get_volume_idxs_from_instance(obj_idx, inst_idx);
                idxs.insert(idxs.end(), inst_idxs.begin(), inst_idxs.end());
            }
        }
    }
 
    return idxs;
}

References Slic3r::GUI::PartPlate::contain_instance(), get_volume_idxs_from_instance(), Slic3r::ModelObject::instances, Slic3r::GUI::PartPlate::intersect_instance(), and m_model.

Referenced by add_curr_plate(), and remove_curr_plate().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ get_volume_idxs_from_volume()

std::vector< unsigned int > Slic3r::GUI::Selection::get_volume_idxs_from_volume	(	unsigned int	object_idx,
		unsigned int	instance_idx,
		unsigned int	volume_idx ) const

{
    std::vector<unsigned int> idxs;
 
    for (unsigned int i = 0; i < (unsigned int)m_volumes->size(); ++i)
    {
        const GLVolume* v = (*m_volumes)[i];
        if ((v->object_idx() == (int)object_idx) && (v->volume_idx() == (int)volume_idx))
        {
            if (((int)instance_idx != -1) && (v->instance_idx() == (int)instance_idx))
                idxs.push_back(i);
        }
    }
 
    return idxs;
}

References Slic3r::GLVolume::instance_idx(), m_volumes, Slic3r::GLVolume::object_idx(), and Slic3r::GLVolume::volume_idx().

Referenced by add_volume(), and Slic3r::GUI::ObjectList::update_selections_on_canvas().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ get_volume_selection_mode()

EMode Slic3r::GUI::Selection::get_volume_selection_mode ( )

inline

378{ return m_volume_selection_mode;}

References m_volume_selection_mode.

◆ init()

bool Slic3r::GUI::Selection::init ( )

{
    m_arrow.init_from(straight_arrow(10.0f, 5.0f, 5.0f, 10.0f, 1.0f));
    m_curved_arrow.init_from(circular_arrow(16, 10.0f, 5.0f, 10.0f, 5.0f, 1.0f));
#if ENABLE_RENDER_SELECTION_CENTER
    m_vbo_sphere.init_from(its_make_sphere(0.75, PI / 12.0));
#endif // ENABLE_RENDER_SELECTION_CENTER
 
    return true;
}

References Slic3r::GUI::circular_arrow(), Slic3r::its_make_sphere(), m_arrow, m_curved_arrow, PI, and Slic3r::GUI::straight_arrow().

Here is the call graph for this function:

◆ instances_changed()

void Slic3r::GUI::Selection::instances_changed ( const std::vector< size_t > & instance_ids_selected )

{
    assert(m_valid);
    assert(m_mode == Instance);
    m_list.clear();
    for (unsigned int volume_idx = 0; volume_idx < (unsigned int)m_volumes->size(); ++ volume_idx) {
        const GLVolume *volume = (*m_volumes)[volume_idx];
        auto it = std::lower_bound(instance_ids_selected.begin(), instance_ids_selected.end(), volume->geometry_id.second);
    if (it != instance_ids_selected.end() && *it == volume->geometry_id.second)
            this->do_add_volume(volume_idx);
    }
    update_type();
    this->set_bounding_boxes_dirty();
}

References do_add_volume(), Slic3r::GLVolume::geometry_id, Instance, m_list, m_mode, m_valid, m_volumes, set_bounding_boxes_dirty(), and update_type().

Here is the call graph for this function:

◆ is_any_connector()

bool Slic3r::GUI::Selection::is_any_connector ( ) const

{
    const int obj_idx = get_object_idx();
 
    if ((is_any_volume() || is_any_modifier() || is_mixed()) && // some solid_part AND/OR modifier is selected 
        obj_idx >= 0 && m_model->objects[obj_idx]->is_cut()) {
        const ModelVolumePtrs& obj_volumes = m_model->objects[obj_idx]->volumes;
        for (size_t vol_idx = 0; vol_idx < obj_volumes.size(); vol_idx++)
            if (obj_volumes[vol_idx]->is_cut_connector())
                for (const GLVolume* v  : *m_volumes)
                    if (v->object_idx() == obj_idx && v->volume_idx() == (int)vol_idx && v->selected)
                        return true;
    }
    return false;
}

References get_object_idx(), is_any_modifier(), is_any_volume(), is_mixed(), m_model, and m_volumes.

Here is the call graph for this function:

◆ is_any_cut_volume()

bool Slic3r::GUI::Selection::is_any_cut_volume ( ) const

{
    const int obj_idx = get_object_idx();
    return is_any_volume() && obj_idx >= 0 && m_model->objects[obj_idx]->is_cut();
}

References get_object_idx(), is_any_volume(), and m_model.

Here is the call graph for this function:

◆ is_any_modifier()

bool Slic3r::GUI::Selection::is_any_modifier ( ) const

inline

274{ return is_single_modifier() || is_multiple_modifier(); }

Slic3r::GUI::Selection::is_multiple_modifier

bool is_multiple_modifier() const

Definition Selection.hpp:276

References is_multiple_modifier(), and is_single_modifier().

Referenced by add(), is_any_connector(), Slic3r::GUI::ObjectList::part_selection_changed(), and Slic3r::GUI::ObjectList::update_selections().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ is_any_volume()

bool Slic3r::GUI::Selection::is_any_volume ( ) const

inline

283{ return is_single_volume() || is_multiple_volume(); }

Slic3r::GUI::Selection::is_multiple_volume

bool is_multiple_volume() const

Definition Selection.hpp:282

References is_multiple_volume(), and is_single_volume().

Referenced by add(), ensure_not_below_bed(), is_any_connector(), is_any_cut_volume(), Slic3r::GUI::GLGizmoMmuSegmentation::on_is_activable(), Slic3r::GUI::ObjectList::part_selection_changed(), and Slic3r::GUI::ObjectList::update_selections().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ is_empty()

bool Slic3r::GUI::Selection::is_empty ( ) const

inline

272{ return m_type == Empty; }

References Empty, and m_type.

Referenced by add(), Slic3r::GUI::Plater::priv::can_delete(), Slic3r::GUI::do_local_z_move(), Slic3r::GUI::do_local_z_rotate(), get_bounding_box_in_current_reference_system(), Slic3r::GUI::GLGizmoAlignment::get_selected_objects_info(), Slic3r::GUI::GLGizmoMmuSegmentation::on_is_activable(), Slic3r::GUI::GLGizmoScale3D::on_is_activable(), Slic3r::GUI::GLGizmoEmboss::on_render(), Slic3r::GUI::CommonGizmosDataObjects::SelectionInfo::on_update(), Slic3r::GUI::GLGizmoAlignment::reference_basis(), remove_all(), render(), Slic3r::GUI::Plater::priv::replace_all_with_stl(), scale_to_fit_print_volume(), Slic3r::GUI::Emboss::start_create_volume_without_position(), Slic3r::GUI::GLGizmosManager::update_data(), and Slic3r::GUI::GLGizmoBase::use_grabbers().

Here is the caller graph for this function:

◆ is_enabled()

bool Slic3r::GUI::Selection::is_enabled ( ) const

inline

216{ return m_enabled; }

References m_enabled.

◆ is_from_fully_selected_instance()

bool Slic3r::GUI::Selection::is_from_fully_selected_instance ( unsigned int volume_idx ) const

private

{
    if (m_mode == Instance && wxGetApp().plater()->canvas3D()->get_canvas_type() == GLCanvas3D::ECanvasType::CanvasAssembleView) {
        return true;
    }
    struct SameInstance
    {
        int obj_idx;
        int inst_idx;
        GLVolumePtrs& volumes;
 
        SameInstance(int obj_idx, int inst_idx, GLVolumePtrs& volumes) : obj_idx(obj_idx), inst_idx(inst_idx), volumes(volumes) {}
        bool operator () (unsigned int i) { return (volumes[i]->volume_idx() >= 0) && (volumes[i]->object_idx() == obj_idx) && (volumes[i]->instance_idx() == inst_idx); }
    };
 
    if ((unsigned int)m_volumes->size() <= volume_idx)
        return false;
 
    GLVolume* volume = (*m_volumes)[volume_idx];
    int object_idx = volume->object_idx();
    if ((int)m_model->objects.size() <= object_idx)
        return false;
 
    unsigned int count = (unsigned int)std::count_if(m_list.begin(), m_list.end(), SameInstance(object_idx, volume->instance_idx(), *m_volumes));
    return count == (unsigned int)m_model->objects[object_idx]->volumes.size();
}

References Slic3r::GUI::GLCanvas3D::CanvasAssembleView, count, Instance, Slic3r::GLVolume::instance_idx(), m_list, m_mode, m_model, m_volumes, Slic3r::GLVolume::object_idx(), and Slic3r::GUI::plater().

Referenced by move_to_center(), rotate(), and translate().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ is_from_single_instance()

bool Slic3r::GUI::Selection::is_from_single_instance ( ) const

inline

287{ return get_instance_idx() != -1; }

References get_instance_idx().

Referenced by Slic3r::GUI::Plater::priv::can_mirror(), Slic3r::GUI::Plater::can_paste_from_clipboard(), Slic3r::GUI::GLGizmoPainterBase::data_changed(), Slic3r::GUI::GLGizmoBrimEars::on_render(), paste_from_clipboard(), requires_local_axes(), transform_instance_relative(), and Slic3r::GUI::ObjectList::update_selections().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ is_from_single_object()

bool Slic3r::GUI::Selection::is_from_single_object ( ) const

{
    const int idx = get_object_idx();
    return 0 <= idx && idx < 1000;
}

References get_object_idx().

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

Here is the call graph for this function:

Here is the caller graph for this function:

◆ is_instance_mode()

bool Slic3r::GUI::Selection::is_instance_mode ( ) const

inline

290{ return m_mode == Instance; }

References Instance, and m_mode.

◆ is_mixed()

bool Slic3r::GUI::Selection::is_mixed ( ) const

inline

286{ return m_type == Mixed; }

References m_type, and Mixed.

Referenced by Slic3r::GUI::MenuFactory::append_menu_item_settings(), erase(), is_any_connector(), Slic3r::GUI::ObjectList::part_selection_changed(), and Slic3r::GUI::ObjectList::update_selections().

Here is the caller graph for this function:

◆ is_multiple_full_instance()

bool Slic3r::GUI::Selection::is_multiple_full_instance ( ) const

inline

278{ return m_type == MultipleFullInstance; }

References m_type, and MultipleFullInstance.

Referenced by Slic3r::GUI::MenuFactory::append_menu_item_export_drc(), Slic3r::GUI::MenuFactory::append_menu_item_export_stl(), Slic3r::GUI::MenuFactory::append_menu_item_per_object_process(), Slic3r::GUI::MenuFactory::append_menu_item_settings(), Slic3r::GUI::ObjectList::can_split_instances(), erase(), Slic3r::GUI::Plater::priv::on_right_click(), Slic3r::GUI::ObjectList::part_selection_changed(), and Slic3r::GUI::ObjectList::update_selections().

Here is the caller graph for this function:

◆ is_multiple_full_object()

bool Slic3r::GUI::Selection::is_multiple_full_object ( ) const

inline

280{ return m_type == MultipleFullObject; }

References m_type, and MultipleFullObject.

Referenced by Slic3r::GUI::MenuFactory::append_menu_item_export_drc(), Slic3r::GUI::MenuFactory::append_menu_item_export_stl(), Slic3r::GUI::MenuFactory::append_menu_item_per_object_process(), Slic3r::GUI::GizmoObjectManipulation::do_render_move_window(), Slic3r::GUI::GizmoObjectManipulation::do_render_scale_input_window(), erase(), Slic3r::GUI::Plater::export_stl(), get_selected_object_instances(), Slic3r::GUI::ObjectList::part_selection_changed(), and Slic3r::GUI::ObjectList::update_selections().

Here is the caller graph for this function:

◆ is_multiple_modifier()

bool Slic3r::GUI::Selection::is_multiple_modifier ( ) const

inline

276{ return m_type == MultipleModifier; }

References m_type, and MultipleModifier.

Referenced by is_any_modifier().

Here is the caller graph for this function:

◆ is_multiple_volume()

bool Slic3r::GUI::Selection::is_multiple_volume ( ) const

inline

282{ return m_type == MultipleVolume; }

References m_type, and MultipleVolume.

Referenced by Slic3r::GUI::MenuFactory::append_menu_item_per_object_process(), Slic3r::GUI::MenuFactory::append_menu_item_settings(), and is_any_volume().

Here is the caller graph for this function:

◆ is_single_full_instance()

bool Slic3r::GUI::Selection::is_single_full_instance ( ) const

{
    if (m_type == SingleFullInstance)
        return true;
 
    if (m_type == SingleFullObject)
        return get_instance_idx() != -1;
 
    if (m_list.empty() || m_volumes->empty())
        return false;
 
    int object_idx = m_valid ? get_object_idx() : -1;
    if (object_idx < 0 || (int)m_model->objects.size() <= object_idx)
        return false;
 
    int instance_idx = (*m_volumes)[*m_list.begin()]->instance_idx();
 
    std::set<int> volumes_idxs;
    for (unsigned int i : m_list) {
        const GLVolume* v = (*m_volumes)[i];
        if (object_idx != v->object_idx() || instance_idx != v->instance_idx())
            return false;
 
        int volume_idx = v->volume_idx();
        if (volume_idx >= 0)
            volumes_idxs.insert(volume_idx);
    }
 
    return m_model->objects[object_idx]->volumes.size() == volumes_idxs.size();
}

References get_instance_idx(), get_object_idx(), Slic3r::GLVolume::instance_idx(), m_list, m_model, m_type, m_valid, m_volumes, Slic3r::GLVolume::object_idx(), SingleFullInstance, SingleFullObject, and Slic3r::GLVolume::volume_idx().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ is_single_full_object()

bool Slic3r::GUI::Selection::is_single_full_object ( ) const

inline

279{ return m_type == SingleFullObject; }

References m_type, and SingleFullObject.

Referenced by Slic3r::GUI::MenuFactory::append_menu_item_export_drc(), Slic3r::GUI::MenuFactory::append_menu_item_export_stl(), Slic3r::GUI::MenuFactory::append_menu_item_instance_to_object(), Slic3r::GUI::MenuFactory::append_menu_item_per_object_process(), Slic3r::GUI::MenuFactory::append_menu_item_per_object_settings(), Slic3r::GUI::MenuFactory::append_menu_item_settings(), Slic3r::GUI::GizmoObjectManipulation::do_render_scale_input_window(), erase(), Slic3r::GUI::Plater::export_stl(), Slic3r::GUI::Plater::priv::get_export_file_path(), get_selected_single_object(), anonymous_namespace{SurfaceDrag.cpp}::is_embossed_object(), Slic3r::GUI::ObjectList::is_instance_or_object_selected(), Slic3r::GUI::ObjectList::layers_editing(), Slic3r::GUI::Plater::priv::on_right_click(), Slic3r::GUI::ObjectList::part_selection_changed(), Slic3r::GUI::Plater::show_object_info(), Slic3r::GUI::ObjectList::split_instances(), Slic3r::GUI::ObjectList::update_selections(), and Slic3r::GUI::GizmoObjectManipulation::update_settings_value().

Here is the caller graph for this function:

◆ is_single_modifier()

bool Slic3r::GUI::Selection::is_single_modifier ( ) const

inline

275{ return m_type == SingleModifier; }

References m_type, and SingleModifier.

Referenced by get_selected_single_object(), get_selected_single_volume(), Slic3r::GUI::SceneRaycaster::hit(), is_any_modifier(), is_single_volume_or_modifier(), Slic3r::GUI::Plater::priv::on_right_click(), requires_uniform_scale(), Slic3r::GUI::GizmoObjectManipulation::reset_position_value(), and Slic3r::GUI::GLGizmoScale3D::update_grabbers_data().

Here is the caller graph for this function:

◆ is_single_text()

bool Slic3r::GUI::Selection::is_single_text ( ) const

{
    if (!is_single_volume_or_modifier())
      return false;
 
    const GLVolume* gl_volume = (*m_volumes)[*m_list.begin()];
    const ModelVolume* model_volume = m_model->objects[gl_volume->object_idx()]->volumes[gl_volume->volume_idx()];
    
    return model_volume && model_volume->text_configuration.has_value();
}

References is_single_volume_or_modifier(), m_list, m_model, Slic3r::GLVolume::object_idx(), Slic3r::ModelVolume::text_configuration, and Slic3r::GLVolume::volume_idx().

Here is the call graph for this function:

◆ is_single_volume()

bool Slic3r::GUI::Selection::is_single_volume ( ) const

inline

281{ return m_type == SingleVolume; }

References m_type, and SingleVolume.

Referenced by Slic3r::GUI::MenuFactory::append_menu_item_per_object_process(), Slic3r::GUI::MenuFactory::append_menu_item_per_object_settings(), get_selected_single_object(), get_selected_single_volume(), Slic3r::GUI::SceneRaycaster::hit(), is_any_volume(), is_single_volume_or_modifier(), Slic3r::GUI::Plater::priv::on_right_click(), requires_uniform_scale(), Slic3r::GUI::GizmoObjectManipulation::reset_position_value(), Slic3r::GUI::Plater::show_object_info(), Slic3r::GUI::GLGizmoScale3D::update_grabbers_data(), and Slic3r::GUI::ObjectList::update_selections().

Here is the caller graph for this function:

◆ is_single_volume_instance()

bool Slic3r::GUI::Selection::is_single_volume_instance ( ) const

inline

292{ return is_single_full_instance() && m_list.size() == 1; }

References is_single_full_instance(), and m_list.

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

Here is the call graph for this function:

Here is the caller graph for this function:

◆ is_single_volume_or_modifier()

bool Slic3r::GUI::Selection::is_single_volume_or_modifier ( ) const

inline

291{ return is_single_volume() || is_single_modifier(); }

References is_single_modifier(), and is_single_volume().

Referenced by Slic3r::GUI::MenuFactory::append_menu_item_per_object_process(), Slic3r::GUI::GizmoObjectManipulation::change_scale_value(), Slic3r::GUI::GizmoObjectManipulation::change_size_value(), Slic3r::GUI::GLGizmoScale3D::data_changed(), Slic3r::GUI::GizmoObjectManipulation::do_scale(), Slic3r::GUI::GLGizmoScale3D::get_tooltip(), is_single_text(), Slic3r::GUI::GLGizmoEmboss::on_render(), render_sidebar_hints(), Slic3r::GUI::GizmoObjectManipulation::reset_rotation_value(), rotate(), scale_and_translate(), Slic3r::GUI::GLGizmoScale3D::update_grabbers_data(), Slic3r::GUI::GizmoObjectManipulation::update_reset_buttons_visibility(), and Slic3r::GUI::GizmoObjectManipulation::update_settings_value().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ is_sla_compliant()

bool Slic3r::GUI::Selection::is_sla_compliant ( ) const

{
    if (m_mode == Volume)
        return false;
 
    for (unsigned int i : m_list) {
        if ((*m_volumes)[i]->is_modifier)
            return false;
    }
 
    return true;
}

References m_list, m_mode, m_volumes, and Volume.

Referenced by Slic3r::GUI::Plater::can_copy_to_clipboard().

Here is the caller graph for this function:

◆ is_wipe_tower()

bool Slic3r::GUI::Selection::is_wipe_tower ( ) const

inline

273{ return m_type == WipeTower; }

References m_type, and WipeTower.

Referenced by add(), add_all(), Slic3r::GUI::Plater::priv::can_delete(), Slic3r::GUI::GLGizmoRotate3D::data_changed(), Slic3r::GUI::GizmoObjectManipulation::do_render_move_window(), Slic3r::GUI::Plater::export_stl(), get_auto_drop(), Slic3r::GUI::GLGizmoAssembly::on_is_activable(), Slic3r::GUI::GLGizmoCut3D::on_is_activable(), Slic3r::GUI::GLGizmoMeasure::on_is_activable(), Slic3r::GUI::GLGizmoRotate3D::on_is_activable(), Slic3r::GUI::GLGizmoScale3D::on_is_activable(), Slic3r::GUI::Plater::priv::reload_from_disk(), Slic3r::GUI::Plater::priv::replace_all_with_stl(), Slic3r::GUI::Plater::priv::replace_with_stl(), rotate(), translate(), Slic3r::GUI::GizmoObjectManipulation::update_settings_value(), and update_type().

Here is the caller graph for this function:

◆ lock_volume_selection_mode()

void Slic3r::GUI::Selection::lock_volume_selection_mode ( )

inline

380{ m_volume_selection_locked = true; }

Slic3r::GUI::Selection::m_volume_selection_locked

bool m_volume_selection_locked

Definition Selection.hpp:208

References m_volume_selection_locked.

◆ matches()

bool Slic3r::GUI::Selection::matches ( const std::vector< unsigned int > & volume_idxs ) const

{
    unsigned int count = 0;
 
    for (unsigned int i : volume_idxs) {
        if (m_list.find(i) != m_list.end())
            ++count;
        else
            return false;
    }
 
    return count == (unsigned int)m_list.size();
}

References count, and m_list.

Referenced by add_instance(), add_object(), add_volume(), and add_volumes().

Here is the caller graph for this function:

◆ mirror()

void Slic3r::GUI::Selection::mirror	(	Axis	axis,
		TransformationType	transformation_type )

{
    const Vec3d mirror((axis == X) ? -1.0 : 1.0, (axis == Y) ? -1.0 : 1.0, (axis == Z) ? -1.0 : 1.0);
    scale_and_translate(mirror, Vec3d::Zero(), transformation_type);
}

References mirror(), scale_and_translate(), Slic3r::X, Slic3r::Y, and Slic3r::Z.

Referenced by Slic3r::GUI::GLGizmoEmboss::do_mirror(), Slic3r::GUI::GLGizmoSVG::draw_mirroring(), and mirror().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ move_to_center()

void Slic3r::GUI::Selection::move_to_center	(	const Vec3d &	displacement,
		bool	local = false )

{
    if (!m_valid)
        return;
 
    EMode translation_type = m_mode;
    //BOOST_LOG_TRIVIAL(debug) << __FUNCTION__ << boost::format(": %1%, displacement {%2%, %3%, %4%}") % __LINE__ % displacement(X) % displacement(Y) % displacement(Z);
 
    set_caches();
    for (unsigned int i : m_list) {
        GLVolume& v = *(*m_volumes)[i];
        if (m_mode == Volume) {
            if (local)
                v.set_volume_offset(m_cache.volumes_data[i].get_volume_position() + displacement);
            else {
                const Vec3d local_displacement = (m_cache.volumes_data[i].get_instance_rotation_matrix() * m_cache.volumes_data[i].get_instance_scale_matrix() * m_cache.volumes_data[i].get_instance_mirror_matrix()).inverse() * displacement;
                v.set_volume_offset(m_cache.volumes_data[i].get_volume_position() + local_displacement);
            }
        }
        else if (m_mode == Instance) {
            if (is_from_fully_selected_instance(i)) {
                v.set_instance_offset(m_cache.volumes_data[i].get_instance_position() + displacement);
            }
            else {
                const Vec3d local_displacement = (m_cache.volumes_data[i].get_instance_rotation_matrix() * m_cache.volumes_data[i].get_instance_scale_matrix() * m_cache.volumes_data[i].get_instance_mirror_matrix()).inverse() * displacement;
                v.set_volume_offset(m_cache.volumes_data[i].get_volume_position() + local_displacement);
                translation_type = Volume;
            }
        }
    }
    this->set_bounding_boxes_dirty();
}

References Instance, is_from_fully_selected_instance(), m_cache, m_list, m_mode, m_valid, set_bounding_boxes_dirty(), set_caches(), Slic3r::GLVolume::set_instance_offset(), Slic3r::GLVolume::set_volume_offset(), and Volume.

Referenced by center(), and center_plate().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ notify_instance_update()

void Slic3r::GUI::Selection::notify_instance_update	(	int	object_idx,
		int	instance_idx )

{
    //BBS: notify instance updates to part plater list
    PartPlateList& plate_list = wxGetApp().plater()->get_partplate_list();
 
    if (object_idx == -1)
    {
        std::set<std::pair<int, int>> notify_set;
        for (unsigned int i : m_list)
        {
            int obj_index = (*m_volumes)[i]->object_idx();
            // Skip the wipe tower: its synthetic id (>= 1000) is not an index into m_model->objects.
            if (obj_index >= 1000)
                continue;
            //-1 means all the instance in this object
            if (instance_idx == -1)
            {
                ModelObject* object = m_model->objects[obj_index];
 
                for (int instance_index = 0; instance_index < object->instances.size(); instance_index++)
                {
                    std::pair<int, int> notify_index(obj_index, instance_index);
                    if (notify_set.find(notify_index) == notify_set.end()) {
                        plate_list.notify_instance_update(obj_index, instance_index);
                        notify_set.insert(notify_index);
                    }
                }
            }
            else {
                std::pair<int, int> notify_index(obj_index, instance_idx);
                if (notify_set.find(notify_index) == notify_set.end()) {
                    plate_list.notify_instance_update(obj_index, instance_idx);
                    notify_set.insert(notify_index);
                }
            }
        }
    }
    else
    {
        if (instance_idx == -1)
        {
            ModelObject* object = m_model->objects[object_idx];
 
            for (int index = 0; index < object->instances.size(); index++)
            {
                plate_list.notify_instance_update(object_idx, index);
            }
        }
        else
            plate_list.notify_instance_update(object_idx, instance_idx);
    }
}

References m_list, m_model, and Slic3r::GUI::PartPlateList::notify_instance_update().

Referenced by Slic3r::GUI::Plater::_calib_pa_select_added_objects().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ paste_from_clipboard()

void Slic3r::GUI::Selection::paste_from_clipboard ( )

{
    if (!m_valid || m_clipboard.is_empty())
        return;
 
    switch (m_clipboard.get_mode())
    {
    case Volume:
    {
        if (is_from_single_instance())
            paste_volumes_from_clipboard();
 
        break;
    }
    case Instance:
    {
        if (m_mode == Instance)
            paste_objects_from_clipboard();
 
        break;
    }
    }
}

References Instance, is_from_single_instance(), m_clipboard, m_mode, m_valid, paste_objects_from_clipboard(), paste_volumes_from_clipboard(), and Volume.

Referenced by Slic3r::GUI::CloneDialog::CloneDialog(), and clone().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ paste_objects_from_clipboard()

void Slic3r::GUI::Selection::paste_objects_from_clipboard ( )

private

{
#ifdef _DEBUG
    check_model_ids_validity(*m_model);
#endif /* _DEBUG */
 
    std::vector<size_t> object_idxs;
    const ModelObjectPtrs& src_objects = m_clipboard.get_objects();
    PartPlate *            plate       = wxGetApp().plater()->get_partplate_list().get_curr_plate();
 
    //BBS: if multiple objects are selected, move them as a whole after copy
    Vec2d shift_all = {0, 0};
    Vec2f empty_cell_all = {0, 0};
    if (src_objects.size() > 1) {
        BoundingBoxf3 bbox_all;
        for (const ModelObject *src_object : src_objects) {
            BoundingBoxf3 bbox = src_object->instance_convex_hull_bounding_box(size_t(0));
            bbox_all.merge(bbox);
        }
        auto bsize = bbox_all.size();
        if (bsize.x() < bsize.y())
            shift_all = {bbox_all.size().x(), 0};
        else
            shift_all = {0, bbox_all.size().y()};
    }
 
    for (size_t i=0;i<src_objects.size();i++)
    {
        const ModelObject *src_object = src_objects[i];
        ModelObject* dst_object = m_model->add_object(*src_object);
 
        // BBS: find an empty cell to put the copied object
        BoundingBoxf3 bbox = src_object->instance_convex_hull_bounding_box(size_t(0));
 
        Vec3d displacement;
        bool  in_current  = plate->intersects(bbox);
        auto  start_point = in_current ? bbox.center() : plate->get_build_volume().center();
        auto  start_offset = in_current ? src_object->instances.front()->get_offset() : plate->get_build_volume().center();
        if (shift_all(0) != 0 || shift_all(1) != 0) {
            // BBS: if multiple objects are selected, move them as a whole after copy
            if (i == 0) empty_cell_all = wxGetApp().plater()->canvas3D()->get_nearest_empty_cell({start_point(0), start_point(1)}, {bbox.size()(0)+1,bbox.size()(1)+1});
            auto instance_shift = src_object->instances.front()->get_offset() - src_objects[0]->instances.front()->get_offset();
            displacement        = {shift_all.x() + empty_cell_all.x() + instance_shift.x(), shift_all.y() + empty_cell_all.y() + instance_shift.y(), start_offset(2)};
        } else {
            // BBS: if only one object is copied, find an empty cell to put it
            auto point_offset = start_offset - start_point;
            auto empty_cell   = wxGetApp().plater()->canvas3D()->get_nearest_empty_cell({start_point(0), start_point(1)}, {bbox.size()(0)+1, bbox.size()(1)+1});
            displacement      = {empty_cell.x() + point_offset.x(), empty_cell.y() + point_offset.y(), start_offset(2)};
        }
 
        for (ModelInstance* inst : dst_object->instances) {
            inst->set_offset(displacement);
 
            //BBS init asssmble transformation
            Geometry::Transformation t = inst->get_transformation();
            inst->set_assemble_transformation(t);
        }
 
        object_idxs.push_back(m_model->objects.size() - 1);
#ifdef _DEBUG
      check_model_ids_validity(*m_model);
#endif /* _DEBUG */
    }
 
    wxGetApp().obj_list()->paste_objects_into_list(object_idxs);
 
#ifdef _DEBUG
    check_model_ids_validity(*m_model);
#endif /* _DEBUG */
}

References Slic3r::BoundingBox3Base< PointType >::center(), Slic3r::check_model_ids_validity(), Slic3r::GUI::PartPlate::get_build_volume(), Slic3r::ModelInstance::get_transformation(), Slic3r::ModelObject::instance_convex_hull_bounding_box(), Slic3r::ModelObject::instances, Slic3r::GUI::PartPlate::intersects(), m_clipboard, m_model, Slic3r::BoundingBox3Base< PointType >::merge(), Slic3r::ModelInstance::set_assemble_transformation(), Slic3r::ModelInstance::set_offset(), and Slic3r::BoundingBox3Base< PointType >::size().

Referenced by paste_from_clipboard().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ paste_volumes_from_clipboard()

void Slic3r::GUI::Selection::paste_volumes_from_clipboard ( )

private

{
#ifdef _DEBUG
    check_model_ids_validity(*m_model);
#endif /* _DEBUG */
 
    int dst_obj_idx = get_object_idx();
    if ((dst_obj_idx < 0) || ((int)m_model->objects.size() <= dst_obj_idx))
        return;
 
    ModelObject* dst_object = m_model->objects[dst_obj_idx];
 
    int dst_inst_idx = get_instance_idx();
    if ((dst_inst_idx < 0) || ((int)dst_object->instances.size() <= dst_inst_idx))
        return;
 
    ModelObject* src_object = m_clipboard.get_object(0);
    if (src_object != nullptr)
    {
        ModelInstance* dst_instance = dst_object->instances[dst_inst_idx];
        BoundingBoxf3 dst_instance_bb = dst_object->instance_bounding_box(dst_inst_idx);
        Transform3d src_matrix = src_object->instances[0]->get_transformation().get_matrix_no_offset();
        Transform3d dst_matrix = dst_instance->get_transformation().get_matrix_no_offset();
        bool from_same_object = (src_object->input_file == dst_object->input_file) && src_matrix.isApprox(dst_matrix);
 
        // used to keep relative position of multivolume selections when pasting from another object
        BoundingBoxf3 total_bb;
 
        ModelVolumePtrs volumes;
        for (ModelVolume* src_volume : src_object->volumes)
        {
            ModelVolume* dst_volume = dst_object->add_volume(*src_volume);
            dst_volume->set_new_unique_id();
            if (from_same_object)
            {
//                // if the volume comes from the same object, apply the offset in world system
//                double offset = wxGetApp().plater()->canvas3D()->get_size_proportional_to_max_bed_size(0.05);
//                dst_volume->translate(dst_matrix.inverse() * Vec3d(offset, offset, 0.0));
            }
            else
            {
                // if the volume comes from another object, apply the offset as done when adding modifiers
                // see ObjectList::load_generic_subobject()
                total_bb.merge(dst_volume->mesh().bounding_box().transformed(src_volume->get_matrix()));
            }
 
            volumes.push_back(dst_volume);
#ifdef _DEBUG
        check_model_ids_validity(*m_model);
#endif /* _DEBUG */
        }
 
        // keeps relative position of multivolume selections
        if (!from_same_object)
        {
            for (ModelVolume* v : volumes)
            {
                v->set_offset((v->get_offset() - total_bb.center()) + dst_matrix.inverse() * (Vec3d(dst_instance_bb.max(0), dst_instance_bb.min(1), dst_instance_bb.min(2)) + 0.5 * total_bb.size() - dst_instance->get_transformation().get_offset()));
            }
        }
 
        wxGetApp().obj_list()->paste_volumes_into_list(dst_obj_idx, volumes);
    }
 
#ifdef _DEBUG
    check_model_ids_validity(*m_model);
#endif /* _DEBUG */
}

References Slic3r::ModelObject::add_volume(), Slic3r::TriangleMesh::bounding_box(), Slic3r::BoundingBox3Base< PointType >::center(), Slic3r::check_model_ids_validity(), get_instance_idx(), Slic3r::ModelVolume::get_matrix(), Slic3r::Geometry::Transformation::get_matrix_no_offset(), get_object_idx(), Slic3r::Geometry::Transformation::get_offset(), Slic3r::ModelInstance::get_transformation(), Slic3r::ModelObject::input_file, Slic3r::ModelObject::instance_bounding_box(), Slic3r::ModelObject::instances, m_clipboard, m_model, Slic3r::BoundingBoxBase< PointType, std::vector< PointType > >::max, Slic3r::BoundingBox3Base< PointType >::merge(), Slic3r::ModelVolume::mesh(), Slic3r::BoundingBoxBase< PointType, std::vector< PointType > >::min, Slic3r::ModelVolume::set_new_unique_id(), Slic3r::BoundingBox3Base< PointType >::size(), Slic3r::BoundingBoxf3::transformed(), and Slic3r::ModelObject::volumes.

Referenced by paste_from_clipboard().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ query_real_volume_idx_from_other_view()

int Slic3r::GUI::Selection::query_real_volume_idx_from_other_view	(	unsigned int	object_idx,
		unsigned int	instance_idx,
		unsigned int	model_volume_idx )

{
    for (int i = 0; i < m_volumes->size(); i++) {
        auto v = (*m_volumes)[i];
        if (v->object_idx() == object_idx && instance_idx == v->instance_idx() && model_volume_idx == v->volume_idx()) {
            return i;
        }
    }
    return -1;
}

References m_volumes.

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

Here is the caller graph for this function:

◆ remove()

void Slic3r::GUI::Selection::remove ( unsigned int volume_idx )

{
    if (!m_valid || (unsigned int)m_volumes->size() <= volume_idx)
        return;
 
    if (!contains_volume(volume_idx))
        return;
 
    wxGetApp().plater()->take_snapshot(std::string("Selection-Remove!"), UndoRedo::SnapshotType::Selection);
 
    GLVolume* volume = (*m_volumes)[volume_idx];
 
    switch (m_mode)
    {
    case Volume:
    {
        do_remove_volume(volume_idx);
        break;
    }
    case Instance:
    {
        do_remove_instance(volume->object_idx(), volume->instance_idx());
        break;
    }
    }
 
    update_type();
    this->set_bounding_boxes_dirty();
}

References contains_volume(), do_remove_instance(), do_remove_volume(), Instance, Slic3r::GLVolume::instance_idx(), m_mode, m_valid, m_volumes, Slic3r::GLVolume::object_idx(), Slic3r::UndoRedo::Selection, set_bounding_boxes_dirty(), update_type(), and Volume.

Here is the call graph for this function:

◆ remove_all()

void Slic3r::GUI::Selection::remove_all ( )

{
    if (!m_valid)
        return;
 
    if (is_empty())
        return;
 
// Not taking the snapshot with non-empty Redo stack will likely be more confusing than losing the Redo stack.
// Let's wait for user feedback.
//    if (!wxGetApp().plater()->can_redo())
        wxGetApp().plater()->take_snapshot(std::string("Selection-Remove All!"), UndoRedo::SnapshotType::Selection);
 
    m_mode = Instance;
    clear();
}

References clear(), Instance, is_empty(), m_mode, m_valid, and Slic3r::UndoRedo::Selection.

Referenced by Slic3r::GUI::ObjectList::update_selections_on_canvas().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ remove_curr_plate()

void Slic3r::GUI::Selection::remove_curr_plate ( )

{
    if (!m_valid)
        return;
 
    std::vector<unsigned int> volume_idxs = get_volume_idxs_from_plate(wxGetApp().plater()->get_partplate_list().get_curr_plate_index());
    if (volume_idxs.empty())
        return;
 
    wxGetApp().plater()->take_snapshot(std::string("Selection-Delete Curr Plate All"));
    m_mode = Instance;
    clear();
    do_add_volumes(volume_idxs);
 
    update_type();
    this->set_bounding_boxes_dirty();
 
    erase();
}

References clear(), do_add_volumes(), erase(), get_volume_idxs_from_plate(), Instance, m_mode, m_valid, Slic3r::GUI::plater(), set_bounding_boxes_dirty(), and update_type().

Here is the call graph for this function:

◆ remove_instance()

void Slic3r::GUI::Selection::remove_instance	(	unsigned int	object_idx,
		unsigned int	instance_idx )

{
    if (!m_valid)
        return;
 
    wxGetApp().plater()->take_snapshot(std::string("Selection-Remove Instance"), UndoRedo::SnapshotType::Selection);
 
    do_remove_instance(object_idx, instance_idx);
 
    update_type();
    this->set_bounding_boxes_dirty();
}

References do_remove_instance(), m_valid, Slic3r::UndoRedo::Selection, set_bounding_boxes_dirty(), and update_type().

Here is the call graph for this function:

◆ remove_object()

void Slic3r::GUI::Selection::remove_object ( unsigned int object_idx )

{
    if (!m_valid)
        return;
 
    wxGetApp().plater()->take_snapshot(std::string("Selection-Remove Object"), UndoRedo::SnapshotType::Selection);
 
    do_remove_object(object_idx);
 
    update_type();
    this->set_bounding_boxes_dirty();
}

References do_remove_object(), m_valid, Slic3r::UndoRedo::Selection, set_bounding_boxes_dirty(), and update_type().

Here is the call graph for this function:

◆ remove_volume()

void Slic3r::GUI::Selection::remove_volume	(	unsigned int	object_idx,
		unsigned int	volume_idx )

{
    if (!m_valid)
        return;
 
    for (unsigned int i = 0; i < (unsigned int)m_volumes->size(); ++i) {
        GLVolume* v = (*m_volumes)[i];
        if (v->object_idx() == (int)object_idx && v->volume_idx() == (int)volume_idx)
            do_remove_volume(i);
    }
 
    update_type();
    this->set_bounding_boxes_dirty();
}

References do_remove_volume(), m_valid, m_volumes, Slic3r::GLVolume::object_idx(), set_bounding_boxes_dirty(), update_type(), and Slic3r::GLVolume::volume_idx().

Here is the call graph for this function:

◆ remove_volumes()

void Slic3r::GUI::Selection::remove_volumes	(	EMode	mode,
		const std::vector< unsigned int > &	volume_idxs )

{
    if (!m_valid)
        return;
 
    m_mode = mode;
    for (unsigned int i : volume_idxs) {
        if (i < (unsigned int)m_volumes->size())
            do_remove_volume(i);
    }
 
    update_type();
    this->set_bounding_boxes_dirty();
}

References do_remove_volume(), m_mode, m_valid, m_volumes, set_bounding_boxes_dirty(), and update_type().

Referenced by Slic3r::GUI::ObjectList::update_selections_on_canvas().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ render()

void Slic3r::GUI::Selection::render ( float scale_factor = 1.0 )

{
    if (!m_valid || is_empty())
        return;
 
    m_scale_factor = scale_factor;
    // render cumulative bounding box of selected volumes
    const auto& [box, trafo] = get_bounding_box_in_current_reference_system();
    const bool auto_drop     = get_auto_drop();
    render_bounding_box(box, trafo, auto_drop,
        wxGetApp().plater()->canvas3D()->get_canvas_type() == GLCanvas3D::ECanvasType::CanvasAssembleView ? ColorRGB::YELLOW(): ColorRGB::WHITE());
    render_synchronized_volumes();
}

References Slic3r::GUI::GLCanvas3D::CanvasAssembleView, get_auto_drop(), get_bounding_box_in_current_reference_system(), is_empty(), m_scale_factor, m_valid, Slic3r::GUI::plater(), render_bounding_box(), render_synchronized_volumes(), Slic3r::ColorRGB::WHITE(), and Slic3r::ColorRGB::YELLOW().

Here is the call graph for this function:

◆ render_bounding_box() [1/3]

void Slic3r::GUI::Selection::render_bounding_box	(	const BoundingBoxf3 &	box,
		const ColorRGB &	color,
		float	scale )

inline

                                                                                           {
        m_scale_factor = scale;
        render_bounding_box(box, Transform3d::Identity(), get_auto_drop(), color);
    }

References get_auto_drop(), m_scale_factor, render_bounding_box(), and scale().

Referenced by render(), render_bounding_box(), render_bounding_box(), and render_synchronized_volumes().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ render_bounding_box() [2/3]

void Slic3r::GUI::Selection::render_bounding_box	(	const BoundingBoxf3 &	box,
		const Transform3d &	trafo,
		const bool	auto_drop,
		const ColorRGB &	color )

private

{
    const BoundingBoxf3& curr_box = m_box.get_bounding_box();
    const bool curr_auto_drop = m_auto_drop;
 
    if (!m_box.is_initialized() || !is_approx(box.min, curr_box.min) || !is_approx(box.max, curr_box.max) || curr_auto_drop != auto_drop) {
        m_box.reset();
        m_auto_drop = auto_drop;
 
        const Vec3f b_min = box.min.cast<float>();
        const Vec3f b_max = box.max.cast<float>();
        const Vec3f size = 0.2f * box.size().cast<float>();
 
        // 48 brackets + (24 if auto_drop == false)
        int total_vertices = 48 + (auto_drop ? 0 : 24);
 
        GLModel::Geometry init_data;
        init_data.format = { GLModel::Geometry::EPrimitiveType::Lines, GLModel::Geometry::EVertexLayout::P3 };
        init_data.reserve_vertices(total_vertices);
        init_data.reserve_indices(total_vertices);
 
        // vertices
        init_data.add_vertex(Vec3f(b_min.x(),            b_min.y(),            b_min.z()));
        init_data.add_vertex(Vec3f(b_min.x() + size.x(), b_min.y(),            b_min.z()));
        init_data.add_vertex(Vec3f(b_min.x(),            b_min.y(),            b_min.z()));
        init_data.add_vertex(Vec3f(b_min.x(),            b_min.y() + size.y(), b_min.z()));
        init_data.add_vertex(Vec3f(b_min.x(),            b_min.y(),            b_min.z()));
        init_data.add_vertex(Vec3f(b_min.x(),            b_min.y(),            b_min.z() + size.z()));
                                                                               
        init_data.add_vertex(Vec3f(b_max.x(),            b_min.y(),            b_min.z()));
        init_data.add_vertex(Vec3f(b_max.x() - size.x(), b_min.y(),            b_min.z()));
        init_data.add_vertex(Vec3f(b_max.x(),            b_min.y(),            b_min.z()));
        init_data.add_vertex(Vec3f(b_max.x(),            b_min.y() + size.y(), b_min.z()));
        init_data.add_vertex(Vec3f(b_max.x(),            b_min.y(),            b_min.z()));
        init_data.add_vertex(Vec3f(b_max.x(),            b_min.y(),            b_min.z() + size.z()));
                                                                               
        init_data.add_vertex(Vec3f(b_max.x(),            b_max.y(),            b_min.z()));
        init_data.add_vertex(Vec3f(b_max.x() - size.x(), b_max.y(),            b_min.z()));
        init_data.add_vertex(Vec3f(b_max.x(),            b_max.y(),            b_min.z()));
        init_data.add_vertex(Vec3f(b_max.x(),            b_max.y() - size.y(), b_min.z()));
        init_data.add_vertex(Vec3f(b_max.x(),            b_max.y(),            b_min.z()));
        init_data.add_vertex(Vec3f(b_max.x(),            b_max.y(),            b_min.z() + size.z()));
                                                                               
        init_data.add_vertex(Vec3f(b_min.x(),            b_max.y(),            b_min.z()));
        init_data.add_vertex(Vec3f(b_min.x() + size.x(), b_max.y(),            b_min.z()));
        init_data.add_vertex(Vec3f(b_min.x(),            b_max.y(),            b_min.z()));
        init_data.add_vertex(Vec3f(b_min.x(),            b_max.y() - size.y(), b_min.z()));
        init_data.add_vertex(Vec3f(b_min.x(),            b_max.y(),            b_min.z()));
        init_data.add_vertex(Vec3f(b_min.x(),            b_max.y(),            b_min.z() + size.z()));
                                                                               
        init_data.add_vertex(Vec3f(b_min.x(),            b_min.y(),            b_max.z()));
        init_data.add_vertex(Vec3f(b_min.x() + size.x(), b_min.y(),            b_max.z()));
        init_data.add_vertex(Vec3f(b_min.x(),            b_min.y(),            b_max.z()));
        init_data.add_vertex(Vec3f(b_min.x(),            b_min.y() + size.y(), b_max.z()));
        init_data.add_vertex(Vec3f(b_min.x(),            b_min.y(),            b_max.z()));
        init_data.add_vertex(Vec3f(b_min.x(),            b_min.y(),            b_max.z() - size.z()));
                                                                               
        init_data.add_vertex(Vec3f(b_max.x(),            b_min.y(),            b_max.z()));
        init_data.add_vertex(Vec3f(b_max.x() - size.x(), b_min.y(),            b_max.z()));
        init_data.add_vertex(Vec3f(b_max.x(),            b_min.y(),            b_max.z()));
        init_data.add_vertex(Vec3f(b_max.x(),            b_min.y() + size.y(), b_max.z()));
        init_data.add_vertex(Vec3f(b_max.x(),            b_min.y(),            b_max.z()));
        init_data.add_vertex(Vec3f(b_max.x(),            b_min.y(),            b_max.z() - size.z()));
                                                                               
        init_data.add_vertex(Vec3f(b_max.x(),            b_max.y(),            b_max.z()));
        init_data.add_vertex(Vec3f(b_max.x() - size.x(), b_max.y(),            b_max.z()));
        init_data.add_vertex(Vec3f(b_max.x(),            b_max.y(),            b_max.z()));
        init_data.add_vertex(Vec3f(b_max.x(),            b_max.y() - size.y(), b_max.z()));
        init_data.add_vertex(Vec3f(b_max.x(),            b_max.y(),            b_max.z()));
        init_data.add_vertex(Vec3f(b_max.x(),            b_max.y(),            b_max.z() - size.z()));
                                                                               
        init_data.add_vertex(Vec3f(b_min.x(),            b_max.y(),            b_max.z()));
        init_data.add_vertex(Vec3f(b_min.x() + size.x(), b_max.y(),            b_max.z()));
        init_data.add_vertex(Vec3f(b_min.x(),            b_max.y(),            b_max.z()));
        init_data.add_vertex(Vec3f(b_min.x(),            b_max.y() - size.y(), b_max.z()));
        init_data.add_vertex(Vec3f(b_min.x(),            b_max.y(),            b_max.z()));
        init_data.add_vertex(Vec3f(b_min.x(),            b_max.y(),            b_max.z() - size.z()));
 
        // Indicate that auto_drop == false, by drawing an arrow on bottom corners
        if (!auto_drop) {
            float visual_scale = m_scale_factor;
            float head_s       = 2.0f * visual_scale; // Width of the arrowhead wings
            float z_gap        = 1.0f * visual_scale; // Gap between box and arrow tip
            float arrow_h      = 5.0f * visual_scale; // Total height of the arrow stem
 
            // 4 bottom corners
            std::vector<Vec3f> corners = {{b_min.x(), b_min.y(), b_min.z()},
                                          {b_max.x(), b_min.y(), b_min.z()},
                                          {b_max.x(), b_max.y(), b_min.z()},
                                          {b_min.x(), b_max.y(), b_min.z()}};
 
            for (const auto& pt : corners) {
                Vec3f tip = {pt.x(), pt.y(), pt.z() - z_gap};
                Vec3f base = {pt.x(), pt.y(), tip.z() - arrow_h};
 
                // Stem
                init_data.add_vertex(base);
                init_data.add_vertex(tip);
 
                // Wings
                // Determine direction to the center of the footprint
                float dirX = (pt.x() == b_min.x()) ? head_s : -head_s;
                float dirY = (pt.y() == b_min.y()) ? head_s : -head_s;
 
                // Wing 1 (X-Inward)
                init_data.add_vertex(tip);
                init_data.add_vertex(Vec3f(tip.x() + dirX, tip.y(), tip.z() - head_s));
 
                // Wing 2 (Y-Inward)
                init_data.add_vertex(tip);
                init_data.add_vertex(Vec3f(tip.x(), tip.y() + dirY, tip.z() - head_s));
            }
        }
 
        // Finalize indices
        for (unsigned int i = 0; i < init_data.vertices_count(); ++i) {
            init_data.add_index(i);
        }
 
        m_box.init_from(std::move(init_data));
    }
 
    glsafe(::glEnable(GL_DEPTH_TEST));
 
#if SLIC3R_OPENGL_ES
    GLShaderProgram* shader = wxGetApp().get_shader("dashed_lines");
#else
    if (!OpenGLManager::get_gl_info().is_core_profile())
        glsafe(::glLineWidth(2.0f * m_scale_factor));
 
    GLShaderProgram* shader = OpenGLManager::get_gl_info().is_core_profile() ? wxGetApp().get_shader("dashed_thick_lines") : wxGetApp().get_shader("flat");
#endif // SLIC3R_OPENGL_ES
    if (shader == nullptr)
        return;
 
    shader->start_using();
    const Camera& camera = wxGetApp().plater()->get_camera();
    shader->set_uniform("view_model_matrix", camera.get_view_matrix() * trafo);
    shader->set_uniform("projection_matrix", camera.get_projection_matrix());
#if !SLIC3R_OPENGL_ES
    if (OpenGLManager::get_gl_info().is_core_profile()) {
#endif // !SLIC3R_OPENGL_ES
        const std::array<int, 4>& viewport = camera.get_viewport();
        shader->set_uniform("viewport_size", Vec2d(double(viewport[2]), double(viewport[3])));
        shader->set_uniform("width", 1.5f);
        shader->set_uniform("gap_size", 0.0f);
#if !SLIC3R_OPENGL_ES
    }
#endif // !SLIC3R_OPENGL_ES
    m_box.set_color(to_rgba(color));
    m_box.render();
    shader->stop_using();
}

Here is the call graph for this function:

◆ render_bounding_box() [3/3]

void Slic3r::GUI::Selection::render_bounding_box	(	const BoundingBoxf3 &	box,
		const Transform3d &	trafo,
		const ColorRGB &	color,
		float	scale )

inline

                                                                                                                     {
        m_scale_factor = scale;
        render_bounding_box(box, trafo, get_auto_drop(), color);
    }

References get_auto_drop(), m_scale_factor, render_bounding_box(), and scale().

Here is the call graph for this function:

◆ render_sidebar_hints()

void Slic3r::GUI::Selection::render_sidebar_hints	(	const std::string &	sidebar_field,
		bool	uniform_scale )

{
    if (sidebar_field.empty())
        return;
 
    GLShaderProgram* shader = wxGetApp().get_shader(boost::starts_with(sidebar_field, "layer") ? "flat" : "gouraud_light");
    if (shader == nullptr)
        return;
 
    shader->start_using();
 
    glsafe(::glEnable(GL_DEPTH_TEST));
 
    Vec3d center = get_bounding_box().center();
    Transform3d orient_matrix = Transform3d::Identity();
 
    if (!boost::starts_with(sidebar_field, "layer")) {
        shader->set_uniform("emission_factor", 0.05f);
        const auto &[box, box_trafo] = get_bounding_box_in_current_reference_system();
        // BBS
        if (is_single_full_instance() && !wxGetApp().obj_manipul()->is_world_coordinates()) {
            center                       = box_trafo.translation();
            orient_matrix = (*m_volumes)[*m_list.begin()]->get_instance_transformation().get_rotation_matrix();
        } else if (is_single_volume_or_modifier()) {
            if (!wxGetApp().obj_manipul()->is_world_coordinates()) {
                if (wxGetApp().obj_manipul()->is_local_coordinates()) {
                    orient_matrix               = get_bounding_box_in_current_reference_system().second;
                    orient_matrix.translation() = Vec3d::Zero();
                } else {
                    orient_matrix = (*m_volumes)[*m_list.begin()]->get_instance_transformation().get_rotation_matrix();
                    center       = box_trafo.translation();
                }
            }
        } else {
            if (requires_local_axes()) {
                orient_matrix = (*m_volumes)[*m_list.begin()]->get_instance_transformation().get_rotation_matrix();
            }
        }
    }
    const Transform3d base_matrix = Geometry::assemble_transform(center);
 
    if (!boost::starts_with(sidebar_field, "layer"))
        glsafe(::glClear(GL_DEPTH_BUFFER_BIT));
    if (boost::starts_with(sidebar_field, "position"))
        render_sidebar_position_hints(sidebar_field, *shader, base_matrix * orient_matrix);
    else if (boost::starts_with(sidebar_field, "rotation"))
        render_sidebar_rotation_hints(sidebar_field, *shader, base_matrix * orient_matrix);
    else if (boost::starts_with(sidebar_field, "absolute_rotation"))
        render_sidebar_rotation_hints(sidebar_field, *shader, base_matrix * orient_matrix);
    else if (boost::starts_with(sidebar_field, "scale") || boost::starts_with(sidebar_field, "size"))
        //BBS: GUI refactor: add uniform_scale from gizmo
        render_sidebar_scale_hints(sidebar_field, uniform_scale, *shader, base_matrix * orient_matrix);
    else if (boost::starts_with(sidebar_field, "layer"))
        render_sidebar_layers_hints(sidebar_field, *shader);
 
 
    shader->stop_using();
}

References Slic3r::Geometry::assemble_transform(), Slic3r::BoundingBox3Base< PointType >::center(), center(), get_bounding_box(), get_bounding_box_in_current_reference_system(), GL_DEPTH_BUFFER_BIT, GL_DEPTH_TEST, glClear, glEnable, glsafe, is_single_full_instance(), is_single_volume_or_modifier(), m_list, render_sidebar_layers_hints(), render_sidebar_position_hints(), render_sidebar_rotation_hints(), render_sidebar_scale_hints(), requires_local_axes(), Slic3r::GLShaderProgram::set_uniform(), Slic3r::GLShaderProgram::start_using(), and Slic3r::GLShaderProgram::stop_using().

Here is the call graph for this function:

◆ render_sidebar_layers_hints()

void Slic3r::GUI::Selection::render_sidebar_layers_hints	(	const std::string &	sidebar_field,
		GLShaderProgram &	shader )

private

{
    static const float Margin = 10.0f;
 
    std::string field = sidebar_field;
 
    // extract max_z
    std::string::size_type pos = field.rfind("_");
    if (pos == std::string::npos)
        return;
 
    const float max_z = float(string_to_double_decimal_point(field.substr(pos + 1)));
 
    // extract min_z
    field = field.substr(0, pos);
    pos = field.rfind("_");
    if (pos == std::string::npos)
        return;
 
    const float min_z = float(string_to_double_decimal_point(field.substr(pos + 1)));
 
    // extract type
    field = field.substr(0, pos);
    pos = field.rfind("_");
    if (pos == std::string::npos)
        return;
 
    const int type = std::stoi(field.substr(pos + 1));
 
    const BoundingBoxf3& box = get_bounding_box();
 
    // view dependend order of rendering to keep correct transparency
    const bool camera_on_top = wxGetApp().plater()->get_camera().is_looking_downward();
    const float z1 = camera_on_top ? min_z : max_z;
    const float z2 = camera_on_top ? max_z : min_z;
 
    const Vec3f p1 = { float(box.min.x()) - Margin, float(box.min.y()) - Margin, z1 };
    const Vec3f p2 = { float(box.max.x()) + Margin, float(box.max.y()) + Margin, z2 };
 
    glsafe(::glEnable(GL_DEPTH_TEST));
    glsafe(::glDisable(GL_CULL_FACE));
    glsafe(::glEnable(GL_BLEND));
    glsafe(::glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA));
 
    if (!m_planes.models[0].is_initialized() || !is_approx(m_planes.check_points[0], p1)) {
        m_planes.check_points[0] = p1;
        m_planes.models[0].reset();
 
        GLModel::Geometry init_data;
        init_data.format = { GLModel::Geometry::EPrimitiveType::Triangles, GLModel::Geometry::EVertexLayout::P3 };
        init_data.reserve_vertices(4);
        init_data.reserve_indices(6);
 
        // vertices
        init_data.add_vertex(Vec3f(p1.x(), p1.y(), z1));
        init_data.add_vertex(Vec3f(p2.x(), p1.y(), z1));
        init_data.add_vertex(Vec3f(p2.x(), p2.y(), z1));
        init_data.add_vertex(Vec3f(p1.x(), p2.y(), z1));
 
        // indices
        init_data.add_triangle(0, 1, 2);
        init_data.add_triangle(2, 3, 0);
 
        m_planes.models[0].init_from(std::move(init_data));
    }
 
    if (!m_planes.models[1].is_initialized() || !is_approx(m_planes.check_points[1], p2)) {
        m_planes.check_points[1] = p2;
        m_planes.models[1].reset();
 
        GLModel::Geometry init_data;
        init_data.format = { GLModel::Geometry::EPrimitiveType::Triangles, GLModel::Geometry::EVertexLayout::P3 };
        init_data.reserve_vertices(4);
        init_data.reserve_indices(6);
 
        // vertices
        init_data.add_vertex(Vec3f(p1.x(), p1.y(), z2));
        init_data.add_vertex(Vec3f(p2.x(), p1.y(), z2));
        init_data.add_vertex(Vec3f(p2.x(), p2.y(), z2));
        init_data.add_vertex(Vec3f(p1.x(), p2.y(), z2));
 
        // indices
        init_data.add_triangle(0, 1, 2);
        init_data.add_triangle(2, 3, 0);
 
        m_planes.models[1].init_from(std::move(init_data));
    }
 
    const Camera& camera = wxGetApp().plater()->get_camera();
    shader.set_uniform("view_model_matrix", camera.get_view_matrix());
    shader.set_uniform("projection_matrix", camera.get_projection_matrix());
 
    m_planes.models[0].set_color((camera_on_top && type == 1) || (!camera_on_top && type == 2) ? SOLID_PLANE_COLOR : TRANSPARENT_PLANE_COLOR);
    m_planes.models[0].render();
    m_planes.models[1].set_color((camera_on_top && type == 2) || (!camera_on_top && type == 1) ? SOLID_PLANE_COLOR : TRANSPARENT_PLANE_COLOR);
    m_planes.models[1].render();
 
    glsafe(::glEnable(GL_CULL_FACE));
    glsafe(::glDisable(GL_BLEND));
}

References Slic3r::GUI::GLModel::Geometry::add_triangle(), Slic3r::GUI::GLModel::Geometry::add_vertex(), Slic3r::GUI::GLModel::Geometry::format, get_bounding_box(), Slic3r::GUI::Camera::get_projection_matrix(), Slic3r::GUI::Camera::get_view_matrix(), GL_BLEND, GL_CULL_FACE, GL_DEPTH_TEST, GL_ONE_MINUS_SRC_ALPHA, GL_SRC_ALPHA, glBlendFunc, glDisable, glEnable, glsafe, Slic3r::is_approx(), m_planes, Slic3r::BoundingBoxBase< PointType, std::vector< PointType > >::max, Slic3r::BoundingBoxBase< PointType, std::vector< PointType > >::min, Slic3r::GUI::GLModel::Geometry::P3, Slic3r::GUI::GLModel::Geometry::reserve_indices(), Slic3r::GUI::GLModel::Geometry::reserve_vertices(), Slic3r::GLShaderProgram::set_uniform(), SOLID_PLANE_COLOR, Slic3r::string_to_double_decimal_point(), TRANSPARENT_PLANE_COLOR, and Slic3r::GUI::GLModel::Geometry::Triangles.

Referenced by render_sidebar_hints().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ render_sidebar_position_hints()

void Slic3r::GUI::Selection::render_sidebar_position_hints	(	const std::string &	sidebar_field,
		GLShaderProgram &	shader,
		const Transform3d &	matrix )

private

{
    const Camera& camera = wxGetApp().plater()->get_camera();
    const Transform3d& view_matrix = camera.get_view_matrix();
    shader.set_uniform("projection_matrix", camera.get_projection_matrix());
 
    if (boost::ends_with(sidebar_field, "x")) {
        const Transform3d model_matrix = matrix * Geometry::assemble_transform(Vec3d::Zero(), -0.5 * PI * Vec3d::UnitZ());
        shader.set_uniform("view_model_matrix", view_matrix * model_matrix);
        const Matrix3d view_normal_matrix = view_matrix.matrix().block(0, 0, 3, 3) * model_matrix.matrix().block(0, 0, 3, 3).inverse().transpose();
        shader.set_uniform("view_normal_matrix", view_normal_matrix);
        m_arrow.set_color(get_color(X));
        m_arrow.render();
    }
    else if (boost::ends_with(sidebar_field, "y")) {
        shader.set_uniform("view_model_matrix", view_matrix * matrix);
        shader.set_uniform("view_normal_matrix", (Matrix3d)Matrix3d::Identity());
        m_arrow.set_color(get_color(Y));
        m_arrow.render();
    }
    else if (boost::ends_with(sidebar_field, "z")) {
        const Transform3d model_matrix = matrix * Geometry::assemble_transform(Vec3d::Zero(), 0.5 * PI * Vec3d::UnitX());
        shader.set_uniform("view_model_matrix", view_matrix * model_matrix);
        const Matrix3d view_normal_matrix = view_matrix.matrix().block(0, 0, 3, 3) * model_matrix.matrix().block(0, 0, 3, 3).inverse().transpose();
        shader.set_uniform("view_normal_matrix", view_normal_matrix);
        m_arrow.set_color(get_color(Z));
        m_arrow.render();
    }
}

References Slic3r::Geometry::assemble_transform(), Slic3r::GUI::get_color(), Slic3r::GUI::Camera::get_projection_matrix(), Slic3r::GUI::Camera::get_view_matrix(), m_arrow, PI, Slic3r::GLShaderProgram::set_uniform(), Slic3r::X, Slic3r::Y, and Slic3r::Z.

Referenced by render_sidebar_hints().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ render_sidebar_rotation_hints()

void Slic3r::GUI::Selection::render_sidebar_rotation_hints	(	const std::string &	sidebar_field,
		GLShaderProgram &	shader,
		const Transform3d &	matrix )

private

{
    auto render_sidebar_rotation_hint = [this](GLShaderProgram& shader, const Transform3d& view_matrix, const Transform3d& model_matrix) {
        shader.set_uniform("view_model_matrix", view_matrix * model_matrix);
        Matrix3d view_normal_matrix = view_matrix.matrix().block(0, 0, 3, 3) * model_matrix.matrix().block(0, 0, 3, 3).inverse().transpose();
        shader.set_uniform("view_normal_matrix", view_normal_matrix);
        m_curved_arrow.render();
        const Transform3d matrix = model_matrix * Geometry::assemble_transform(Vec3d::Zero(), PI * Vec3d::UnitZ());
        shader.set_uniform("view_model_matrix", view_matrix * matrix);
        view_normal_matrix = view_matrix.matrix().block(0, 0, 3, 3) * matrix.matrix().block(0, 0, 3, 3).inverse().transpose();
        shader.set_uniform("view_normal_matrix", view_normal_matrix);
        m_curved_arrow.render();
    };
 
    const Camera& camera = wxGetApp().plater()->get_camera();
    const Transform3d& view_matrix = camera.get_view_matrix();
    shader.set_uniform("projection_matrix", camera.get_projection_matrix());
 
    if (boost::ends_with(sidebar_field, "x")) {
        m_curved_arrow.set_color(get_color(X));
        render_sidebar_rotation_hint(shader, view_matrix, matrix * Geometry::assemble_transform(Vec3d::Zero(), 0.5 * PI * Vec3d::UnitY()));
    }
    else if (boost::ends_with(sidebar_field, "y")) {
        m_curved_arrow.set_color(get_color(Y));
        render_sidebar_rotation_hint(shader, view_matrix, matrix * Geometry::assemble_transform(Vec3d::Zero(), -0.5 * PI * Vec3d::UnitX()));
    }
    else if (boost::ends_with(sidebar_field, "z")) {
        m_curved_arrow.set_color(get_color(Z));
        render_sidebar_rotation_hint(shader, view_matrix, matrix);
    }
}

References Slic3r::Geometry::assemble_transform(), Slic3r::GUI::get_color(), Slic3r::GUI::Camera::get_projection_matrix(), Slic3r::GUI::Camera::get_view_matrix(), m_curved_arrow, PI, Slic3r::GLShaderProgram::set_uniform(), Slic3r::X, Slic3r::Y, and Slic3r::Z.

Referenced by render_sidebar_hints().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ render_sidebar_scale_hints()

void Slic3r::GUI::Selection::render_sidebar_scale_hints	(	const std::string &	sidebar_field,
		bool	gizmo_uniform_scale,
		GLShaderProgram &	shader,
		const Transform3d &	matrix )

private

{
    // BBS
    //bool uniform_scale = requires_uniform_scale() || wxGetApp().obj_manipul()->get_uniform_scaling();
    bool uniform_scale = requires_uniform_scale() || gizmo_uniform_scale;
 
    auto render_sidebar_scale_hint = [this, uniform_scale](Axis axis, GLShaderProgram& shader, const Transform3d& view_matrix, const Transform3d& model_matrix) {
        m_arrow.set_color(uniform_scale ? UNIFORM_SCALE_COLOR : get_color(axis));
        Transform3d matrix = model_matrix * Geometry::assemble_transform(5.0 * Vec3d::UnitY());
        shader.set_uniform("view_model_matrix", view_matrix * matrix);
        Matrix3d view_normal_matrix = view_matrix.matrix().block(0, 0, 3, 3) * matrix.matrix().block(0, 0, 3, 3).inverse().transpose();
        shader.set_uniform("view_normal_matrix", view_normal_matrix);
        m_arrow.render();
 
        matrix = model_matrix * Geometry::assemble_transform(-5.0 * Vec3d::UnitY(), PI * Vec3d::UnitZ());
        shader.set_uniform("view_model_matrix", view_matrix * matrix);
        view_normal_matrix = view_matrix.matrix().block(0, 0, 3, 3) * matrix.matrix().block(0, 0, 3, 3).inverse().transpose();
        shader.set_uniform("view_normal_matrix", view_normal_matrix);
        m_arrow.render();
    };
 
    const Camera& camera = wxGetApp().plater()->get_camera();
    const Transform3d& view_matrix = camera.get_view_matrix();
    shader.set_uniform("projection_matrix", camera.get_projection_matrix());
 
    if (boost::ends_with(sidebar_field, "x") || uniform_scale) {
        render_sidebar_scale_hint(X, shader, view_matrix, matrix * Geometry::assemble_transform(Vec3d::Zero(), -0.5 * PI * Vec3d::UnitZ()));
    }
 
    if (boost::ends_with(sidebar_field, "y") || uniform_scale) {
        render_sidebar_scale_hint(Y, shader, view_matrix, matrix);
    }
 
    if (boost::ends_with(sidebar_field, "z") || uniform_scale) {
        render_sidebar_scale_hint(Z, shader, view_matrix, matrix * Geometry::assemble_transform(Vec3d::Zero(), 0.5 * PI * Vec3d::UnitX()));
    }
}

References Slic3r::Geometry::assemble_transform(), Slic3r::GUI::get_color(), Slic3r::GUI::Camera::get_projection_matrix(), Slic3r::GUI::Camera::get_view_matrix(), m_arrow, PI, requires_uniform_scale(), Slic3r::GLShaderProgram::set_uniform(), UNIFORM_SCALE_COLOR, Slic3r::X, Slic3r::Y, and Slic3r::Z.

Referenced by render_sidebar_hints().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ render_synchronized_volumes()

void Slic3r::GUI::Selection::render_synchronized_volumes ( )

private

{
    if (m_mode == Instance)
        return;
 
    const ECoordinatesType coordinates_type = wxGetApp().obj_manipul()->get_coordinates_type();
    BoundingBoxf3 box;
    Transform3d trafo;
 
    for (unsigned int i : m_list) {
        const GLVolume& volume = *(*m_volumes)[i];
        int object_idx = volume.object_idx();
        int volume_idx = volume.volume_idx();
        for (unsigned int j = 0; j < (unsigned int)m_volumes->size(); ++j) {
            if (i == j)
                continue;
 
            const GLVolume& v = *(*m_volumes)[j];
            if (v.object_idx() != object_idx || v.volume_idx() != volume_idx)
                continue;
 
            if (coordinates_type == ECoordinatesType::World) {
                box = v.transformed_convex_hull_bounding_box();
                trafo = Transform3d::Identity();
            }
            else if (coordinates_type == ECoordinatesType::Local) {
                box = v.bounding_box();
                trafo = v.world_matrix();
            }
            else {
                box = v.transformed_convex_hull_bounding_box(v.get_volume_transformation().get_matrix());
                trafo = v.get_instance_transformation().get_matrix();
            }
            const bool auto_drop = get_auto_drop();
            render_bounding_box(box, trafo, auto_drop, ColorRGB::YELLOW());
        }
    }
}

References Slic3r::GLVolume::bounding_box(), get_auto_drop(), Slic3r::GLVolume::get_instance_transformation(), Slic3r::Geometry::Transformation::get_matrix(), Slic3r::GLVolume::get_volume_transformation(), Instance, Slic3r::GUI::Local, m_list, m_mode, m_volumes, Slic3r::GLVolume::object_idx(), render_bounding_box(), Slic3r::GLVolume::transformed_convex_hull_bounding_box(), Slic3r::GLVolume::volume_idx(), Slic3r::GUI::World, Slic3r::GLVolume::world_matrix(), and Slic3r::ColorRGB::YELLOW().

Referenced by render().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ requires_local_axes()

bool Slic3r::GUI::Selection::requires_local_axes ( ) const

{
    return m_mode == Volume && is_from_single_instance();
}

References is_from_single_instance(), m_mode, and Volume.

Referenced by render_sidebar_hints().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ requires_uniform_scale()

bool Slic3r::GUI::Selection::requires_uniform_scale ( ) const

{
    if (is_single_full_instance() || is_single_modifier() || is_single_volume())
        return false;
 
    return true;
}

References is_single_full_instance(), is_single_modifier(), and is_single_volume().

Referenced by render_sidebar_scale_hints().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ rotate() [1/3]

void Slic3r::GUI::Selection::rotate	(	const Vec3d &	rotation,
		TransformationType	transformation_type )

{
    if (!m_valid)
        return;
 
    assert(transformation_type.relative() || (transformation_type.absolute() && transformation_type.local()));
 
    bool requires_general_synchronization = false;
 
    for (unsigned int i : m_list) {
        Transform3d rotation_matrix = Geometry::rotation_transform(rotation);
        GLVolume& v = *(*m_volumes)[i];
        const VolumeCache& volume_data = m_cache.volumes_data[i];
        const Geometry::Transformation& inst_trafo = volume_data.get_instance_transform();
        if (m_mode == Instance && !is_wipe_tower()) {
            assert(is_from_fully_selected_instance(i));
            if (transformation_type.instance()) {
                // ensure that the instance rotates as a rigid body
                Transform3d inst_rotation_matrix = inst_trafo.get_rotation_matrix();
                if (inst_trafo.is_left_handed()) {
                    Geometry::TransformationSVD inst_svd(inst_trafo);
                    inst_rotation_matrix = inst_svd.u * inst_svd.v.transpose();
                    // ensure the rotation has the proper direction
                    if (!rotation.normalized().cwiseAbs().isApprox(Vec3d::UnitX()))
                        rotation_matrix = rotation_matrix.inverse();
                }
 
                const Transform3d inst_matrix_no_offset = inst_trafo.get_matrix_no_offset();
                rotation_matrix = inst_matrix_no_offset.inverse() * inst_rotation_matrix * rotation_matrix * inst_rotation_matrix.inverse() * inst_matrix_no_offset;
 
                // rotate around selection center
                const Vec3d inst_pivot = inst_trafo.get_matrix_no_offset().inverse() * (m_cache.rotation_pivot - inst_trafo.get_offset());
                rotation_matrix = Geometry::translation_transform(inst_pivot) * rotation_matrix * Geometry::translation_transform(-inst_pivot);
 
                // Detects if the rotation is equivalent to a world rotation around the Z axis
                // If not, force for a full synchronization of unselected instances
                if (!requires_general_synchronization) {
                    const Geometry::Transformation& vol_trafo = volume_data.get_volume_transform();
                    const Transform3d old_world_rotation_matrix = (inst_trafo * vol_trafo).get_rotation_matrix();
                    const Transform3d new_world_rotation_matrix = (inst_trafo * Geometry::Transformation(rotation_matrix) * vol_trafo).get_rotation_matrix();
                    if (std::abs((old_world_rotation_matrix * Vec3d::UnitX()).z() - (new_world_rotation_matrix * Vec3d::UnitX()).z()) > EPSILON)
                        requires_general_synchronization = true;
                    else if (std::abs((old_world_rotation_matrix * Vec3d::UnitY()).z() - (new_world_rotation_matrix * Vec3d::UnitY()).z()) > EPSILON)
                        requires_general_synchronization = true;
                    else if (std::abs((old_world_rotation_matrix * Vec3d::UnitZ()).z() - (new_world_rotation_matrix * Vec3d::UnitZ()).z()) > EPSILON)
                        requires_general_synchronization = true;
                }
            }
            transform_instance_relative(v, volume_data, transformation_type, rotation_matrix, m_cache.rotation_pivot);
        }
        else {
            if (!is_single_volume_or_modifier()) {
                assert(transformation_type.world());
                transform_volume_relative(v, volume_data, transformation_type, rotation_matrix, m_cache.rotation_pivot);
            }
            else {
                if (transformation_type.instance()) {
                    // ensure that the volume rotates as a rigid body
                    const Transform3d inst_scale_matrix = inst_trafo.get_scaling_factor_matrix();
                    rotation_matrix = inst_scale_matrix.inverse() * rotation_matrix * inst_scale_matrix;
                }
                else {
                    if (transformation_type.local()) {
                        // ensure that the volume rotates as a rigid body
                        const Geometry::Transformation& vol_trafo = volume_data.get_volume_transform();
                        const Transform3d vol_matrix_no_offset = vol_trafo.get_matrix_no_offset();
                        const Transform3d inst_scale_matrix = inst_trafo.get_scaling_factor_matrix();
                        Transform3d vol_rotation_matrix = vol_trafo.get_rotation_matrix();
                        if (vol_trafo.is_left_handed()) {
                            Geometry::TransformationSVD vol_svd(vol_trafo);
                            vol_rotation_matrix = vol_svd.u * vol_svd.v.transpose();
                            // ensure the rotation has the proper direction
                            if (!rotation.normalized().cwiseAbs().isApprox(Vec3d::UnitX()))
                                rotation_matrix = rotation_matrix.inverse();
                        }
                        rotation_matrix = vol_matrix_no_offset.inverse() * inst_scale_matrix.inverse() * vol_rotation_matrix * rotation_matrix *
                            vol_rotation_matrix.inverse() * inst_scale_matrix * vol_matrix_no_offset;
                    }
                }
                transform_volume_relative(v, volume_data, transformation_type, rotation_matrix, m_cache.rotation_pivot);
            }
        }
    }
 
#if !DISABLE_INSTANCES_SYNCH
    if (m_mode == Instance) {
        int rot_axis_max = 0;
        rotation.cwiseAbs().maxCoeff(&rot_axis_max);
        const SyncRotationType type = (transformation_type.instance() && requires_general_synchronization) ||
                                      (!transformation_type.instance() && rot_axis_max != 2) ||
                                      rotation.isApprox(Vec3d::Zero()) ?
            SyncRotationType::GENERAL : SyncRotationType::NONE;
        synchronize_unselected_instances(type);
    }
    else if (m_mode == Volume)
        synchronize_unselected_volumes();
#endif // !DISABLE_INSTANCES_SYNCH
 
    set_bounding_boxes_dirty();
    if (wxGetApp().plater()->canvas3D()->get_canvas_type() != GLCanvas3D::ECanvasType::CanvasAssembleView) {
        wxGetApp().plater()->canvas3D()->requires_check_outside_state();
    }
}

References Slic3r::GUI::TransformationType::absolute(), Slic3r::GUI::GLCanvas3D::CanvasAssembleView, EPSILON, GENERAL, Slic3r::GUI::Selection::VolumeCache::get_instance_transform(), Slic3r::Geometry::Transformation::get_matrix_no_offset(), Slic3r::Geometry::Transformation::get_offset(), Slic3r::Geometry::Transformation::get_rotation_matrix(), Slic3r::Geometry::Transformation::get_scaling_factor_matrix(), Slic3r::GUI::Selection::VolumeCache::get_volume_transform(), Instance, Slic3r::GUI::TransformationType::instance(), is_from_fully_selected_instance(), Slic3r::Geometry::Transformation::is_left_handed(), is_single_volume_or_modifier(), is_wipe_tower(), Slic3r::GUI::TransformationType::local(), m_cache, m_list, m_mode, m_valid, NONE, Slic3r::GUI::plater(), Slic3r::GUI::TransformationType::relative(), Slic3r::Geometry::rotation_transform(), set_bounding_boxes_dirty(), synchronize_unselected_instances(), synchronize_unselected_volumes(), transform_instance_relative(), transform_volume_relative(), Slic3r::Geometry::translation_transform(), Slic3r::Geometry::TransformationSVD::u, Slic3r::Geometry::TransformationSVD::v, Volume, and Slic3r::GUI::TransformationType::world().

Referenced by Slic3r::GUI::GizmoObjectManipulation::change_absolute_rotation_value(), Slic3r::GUI::GizmoObjectManipulation::change_rotation_value(), Slic3r::GUI::do_local_z_rotate(), and Slic3r::GUI::dragging_rotate_gizmo().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ rotate() [2/3]

void Slic3r::GUI::Selection::rotate	(	unsigned int	object_idx,
		unsigned int	instance_idx,
		const Transform3d &	overwrite_tran )

{
    if (!m_valid) return;
 
    for (unsigned int i : m_list) {
        GLVolume &v = *(*m_volumes)[i];
        if (v.object_idx() == (int) object_idx && v.instance_idx() == (int) instance_idx) {
            v.set_instance_transformation(overwrite_tran);
        }
    }
 
    std::set<unsigned int> done; // prevent processing volumes twice
    done.insert(m_list.begin(), m_list.end());
    for (unsigned int i : m_list) {
        if (done.size() == m_volumes->size()) break;
 
        int object_idx = (*m_volumes)[i]->object_idx();
        if (object_idx >= 1000) continue;
 
        // Process unselected volumes of the object.
        for (unsigned int j = 0; j < (unsigned int) m_volumes->size(); ++j) {
            if (done.size() == m_volumes->size()) break;
 
            if (done.find(j) != done.end()) continue;
 
            GLVolume &v = *(*m_volumes)[j];
            if (v.object_idx() != object_idx || v.instance_idx() != (int) instance_idx)
                continue;
 
            v.set_instance_transformation(overwrite_tran);
            done.insert(j);
        }
    }
    this->set_bounding_boxes_dirty();
}

References Slic3r::GLVolume::instance_idx(), m_list, m_valid, m_volumes, Slic3r::GLVolume::object_idx(), set_bounding_boxes_dirty(), and Slic3r::GLVolume::set_instance_transformation().

Here is the call graph for this function:

◆ rotate() [3/3]

void Slic3r::GUI::Selection::rotate	(	unsigned int	object_idx,
		unsigned int	instance_idx,
		unsigned int	volume_idx,
		const Transform3d &	overwrite_tran )

{
    if (!m_valid) return;
 
    for (unsigned int i : m_list) {
        GLVolume &v = *(*m_volumes)[i];
        if (v.object_idx() == (int) object_idx && v.instance_idx() == (int) instance_idx && v.volume_idx() == (int) volume_idx) {
            v.set_volume_transformation(overwrite_tran);
        }
    }
    this->set_bounding_boxes_dirty();
}

References Slic3r::GLVolume::instance_idx(), m_list, m_valid, Slic3r::GLVolume::object_idx(), set_bounding_boxes_dirty(), Slic3r::GLVolume::set_volume_transformation(), and Slic3r::GLVolume::volume_idx().

Here is the call graph for this function:

◆ scale()

void Slic3r::GUI::Selection::scale	(	const Vec3d &	scale,
		TransformationType	transformation_type )

{
    scale_and_translate(scale, Vec3d::Zero(), transformation_type);
}

References scale(), and scale_and_translate().

Referenced by Slic3r::GUI::adjust_settings_for_flowrate_calib(), Slic3r::GUI::GizmoObjectManipulation::do_scale(), Slic3r::GUI::GLGizmoSVG::draw_size(), render_bounding_box(), render_bounding_box(), Slic3r::GUI::GLGizmoMeasure::render_dimensioning(), scale(), scale_and_translate(), and scale_to_fit_print_volume().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ scale_and_translate()

void Slic3r::GUI::Selection::scale_and_translate	(	const Vec3d &	scale,
		const Vec3d &	world_translation,
		TransformationType	transformation_type )

{
    if (!m_valid) return;
 
    Vec3d relative_scale = scale;
    if (transformation_type.absolute()) {
        // converts to relative scale
        if (m_mode == Instance) {
            if (is_single_full_instance()) {
                BoundingBoxf3 current_box = get_bounding_box_in_current_reference_system().first;
                BoundingBoxf3 original_box;
                if (transformation_type.world())
                    original_box = get_full_unscaled_instance_bounding_box();
                else
                    original_box = get_full_unscaled_instance_local_bounding_box();
 
                relative_scale = original_box.size().cwiseProduct(scale).cwiseQuotient(current_box.size());
            }
        }
        transformation_type.set_relative();
    }
 
    for (unsigned int i : m_list) {
        GLVolume &                      v           = *(*m_volumes)[i];
        const VolumeCache &             volume_data = m_cache.volumes_data[i];
        const Geometry::Transformation &inst_trafo  = volume_data.get_instance_transform();
 
        if (m_mode == Instance) {
            if (transformation_type.instance()) {
                const Vec3d world_inst_pivot = m_cache.dragging_center - inst_trafo.get_offset();
                const Vec3d local_inst_pivot = inst_trafo.get_matrix_no_offset().inverse() * world_inst_pivot;
                Matrix3d    inst_rotation, inst_scale;
                inst_trafo.get_matrix().computeRotationScaling(&inst_rotation, &inst_scale);
                const Transform3d offset_trafo = Geometry::translation_transform(inst_trafo.get_offset() + world_translation);
                const Transform3d scale_trafo  = Transform3d(inst_scale) * Geometry::scale_transform(relative_scale);
                v.set_instance_transformation(Geometry::translation_transform(world_inst_pivot) * offset_trafo * Transform3d(inst_rotation) * scale_trafo *
                                              Geometry::translation_transform(-local_inst_pivot));
            } else
                transform_instance_relative(v, volume_data, transformation_type, Geometry::translation_transform(world_translation) * Geometry::scale_transform(relative_scale),
                                            m_cache.dragging_center);
            // update the instance assemble transform
            ModelObject *            object             = m_model->objects[v.object_idx()];
            Geometry::Transformation assemble_transform = object->instances[v.instance_idx()]->get_assemble_transformation();
            assemble_transform.set_scaling_factor(v.get_instance_scaling_factor());
            object->instances[v.instance_idx()]->set_assemble_transformation(assemble_transform);
        } else {
            if (!is_single_volume_or_modifier()) {
                assert(transformation_type.world());
                transform_volume_relative(v, volume_data, transformation_type, Geometry::translation_transform(world_translation) * Geometry::scale_transform(scale),
                                          m_cache.dragging_center);
            } else {
                transformation_type.set_independent();
                Vec3d translation;
                if (transformation_type.local()) {
                    translation = volume_data.get_volume_transform().get_matrix_no_offset().inverse() * inst_trafo.get_matrix_no_offset().inverse() * world_translation;
                }
                else if (transformation_type.instance())
                    translation = inst_trafo.get_matrix_no_offset().inverse() * world_translation;
                else
                    translation = world_translation;
                transform_volume_relative(v, volume_data, transformation_type, Geometry::translation_transform(translation) * Geometry::scale_transform(scale),
                                          m_cache.dragging_center);
            }
        }
    }
 
#if !DISABLE_INSTANCES_SYNCH
    if (m_mode == Instance)
        // even if there is no rotation, we pass SyncRotationType::GENERAL to force
        // synchronize_unselected_instances() to apply the scale to the other instances
        synchronize_unselected_instances(SyncRotationType::GENERAL);
    else if (m_mode == Volume)
        synchronize_unselected_volumes();
#endif // !DISABLE_INSTANCES_SYNCH
 
    set_bounding_boxes_dirty();
    if (wxGetApp().plater()->canvas3D()->get_canvas_type() != GLCanvas3D::ECanvasType::CanvasAssembleView) {
        wxGetApp().plater()->canvas3D()->requires_check_outside_state();
    }
}

References Slic3r::GUI::TransformationType::absolute(), Slic3r::Geometry::assemble_transform(), Slic3r::GUI::GLCanvas3D::CanvasAssembleView, GENERAL, get_bounding_box_in_current_reference_system(), get_full_unscaled_instance_bounding_box(), get_full_unscaled_instance_local_bounding_box(), Slic3r::GLVolume::get_instance_scaling_factor(), Slic3r::GUI::Selection::VolumeCache::get_instance_transform(), Slic3r::Geometry::Transformation::get_matrix(), Slic3r::Geometry::Transformation::get_matrix_no_offset(), Slic3r::Geometry::Transformation::get_offset(), Slic3r::GUI::Selection::VolumeCache::get_volume_transform(), Instance, Slic3r::GUI::TransformationType::instance(), Slic3r::GLVolume::instance_idx(), is_single_full_instance(), is_single_volume_or_modifier(), Slic3r::GUI::TransformationType::local(), m_cache, m_list, m_mode, m_model, m_valid, Slic3r::GLVolume::object_idx(), Slic3r::GUI::plater(), scale(), Slic3r::Geometry::scale_transform(), set_bounding_boxes_dirty(), Slic3r::GUI::TransformationType::set_independent(), Slic3r::GLVolume::set_instance_transformation(), Slic3r::GUI::TransformationType::set_relative(), Slic3r::BoundingBox3Base< PointType >::size(), synchronize_unselected_instances(), synchronize_unselected_volumes(), transform_instance_relative(), transform_volume_relative(), Slic3r::Geometry::translation_transform(), Volume, and Slic3r::GUI::TransformationType::world().

Referenced by mirror(), Slic3r::GUI::GLGizmoScale3D::on_mouse(), and scale().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ scale_to_fit_print_volume()

void Slic3r::GUI::Selection::scale_to_fit_print_volume ( const DynamicPrintConfig & config )

{
    if (is_empty() || m_mode == Volume)
        return;
 
    // adds 1/100th of a mm on all sides to avoid false out of print volume detections due to floating-point roundings
    Vec3d box_size = get_bounding_box().size() + 0.01 * Vec3d::Ones();
 
    const ConfigOptionPoints* opt = dynamic_cast<const ConfigOptionPoints*>(config.option("printable_area"));
    if (opt != nullptr) {
        BoundingBox bed_box_2D = get_extents(Polygon::new_scale(opt->values));
        BoundingBoxf3 print_volume({ unscale<double>(bed_box_2D.min(0)), unscale<double>(bed_box_2D.min(1)), 0.0 }, { unscale<double>(bed_box_2D.max(0)), unscale<double>(bed_box_2D.max(1)), config.opt_float("printable_height") });
        Vec3d print_volume_size = print_volume.size();
        double sx = (box_size(0) != 0.0) ? print_volume_size(0) / box_size(0) : 0.0;
        double sy = (box_size(1) != 0.0) ? print_volume_size(1) / box_size(1) : 0.0;
        double sz = (box_size(2) != 0.0) ? print_volume_size(2) / box_size(2) : 0.0;
        if (sx != 0.0 && sy != 0.0 && sz != 0.0)
        {
            double s = std::min(sx, std::min(sy, sz));
            if (s != 1.0) {
                wxGetApp().plater()->take_snapshot("Scale To Fit");
 
                TransformationType type;
                type.set_world();
                type.set_relative();
                type.set_joint();
 
                // apply scale
                start_dragging();
                scale(s * Vec3d::Ones(), type);
                wxGetApp().plater()->canvas3D()->do_scale(""); // avoid storing another snapshot
 
                // center selection on print bed
                start_dragging();
                translate(print_volume.center() - get_bounding_box().center());
                wxGetApp().plater()->canvas3D()->do_move(""); // avoid storing another snapshot
 
                // BBS
                //wxGetApp().obj_manipul()->set_dirty();
            }
        }
    }
}

References center(), get_bounding_box(), Slic3r::get_extents(), is_empty(), m_mode, Slic3r::BoundingBoxBase< PointType, APointsType >::max, Slic3r::BoundingBoxBase< PointType, APointsType >::min, Slic3r::Polygon::new_scale(), Slic3r::DynamicConfig::opt_float(), Slic3r::ConfigBase::option(), scale(), Slic3r::GUI::TransformationType::set_joint(), Slic3r::GUI::TransformationType::set_relative(), Slic3r::GUI::TransformationType::set_world(), Slic3r::BoundingBox3Base< PointType >::size(), translate(), Slic3r::unscale(), and Volume.

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

Here is the call graph for this function:

Here is the caller graph for this function:

◆ set_auto_drop()

void Slic3r::GUI::Selection::set_auto_drop ( bool enabled )

{
    if (!m_valid)
        return;
 
    std::set<int> object_idxs;
    for (const auto& [obj_idx, inst_list] : m_cache.content) {
        object_idxs.insert(obj_idx);
    }
 
    std::string snapshot_text = (boost::format("%1%") % (enabled ? "Set Selection Auto-Drop Enabled" : "Set Selection Auto-Drop Disabled")).str();
    wxGetApp().plater()->take_snapshot(snapshot_text);
 
    // auto_drop is shared by all instances of an object.
    for (int obj_idx : object_idxs) {
        ModelObject* object = m_model->objects[obj_idx];
        object->auto_drop = enabled;
    }
 
    // update scene
    wxGetApp().plater()->update();
}

References m_cache, m_model, and m_valid.

Referenced by Slic3r::GUI::MenuFactory::append_menu_item_set_auto_drop().

Here is the caller graph for this function:

◆ set_bounding_boxes_dirty()

void Slic3r::GUI::Selection::set_bounding_boxes_dirty ( )

inlineprivate

                                    {
        m_bounding_box.reset();
        m_unscaled_instance_bounding_box.reset(); m_scaled_instance_bounding_box.reset();
        m_full_unscaled_instance_bounding_box.reset();
        m_full_scaled_instance_bounding_box.reset();
        m_full_unscaled_instance_local_bounding_box.reset();
        m_bounding_box_in_current_reference_system.reset();
        m_bounding_sphere.reset();
    }

References m_bounding_box, m_bounding_box_in_current_reference_system, m_bounding_sphere, m_full_scaled_instance_bounding_box, m_full_unscaled_instance_bounding_box, m_full_unscaled_instance_local_bounding_box, m_scaled_instance_bounding_box, and m_unscaled_instance_bounding_box.

Referenced by Selection(), add(), add_all(), add_curr_plate(), add_instance(), add_object(), add_object_from_idx(), add_volume(), add_volumes(), clear(), flattening_rotate(), instances_changed(), move_to_center(), remove(), remove_curr_plate(), remove_instance(), remove_object(), remove_volume(), remove_volumes(), rotate(), rotate(), rotate(), scale_and_translate(), set_deserialized(), translate(), translate(), translate(), translate(), and volumes_changed().

Here is the caller graph for this function:

◆ set_caches()

void Slic3r::GUI::Selection::set_caches ( )

private

{
    m_cache.volumes_data.clear();
    m_cache.sinking_volumes.clear();
    for (unsigned int i = 0; i < (unsigned int)m_volumes->size(); ++i) {
        const GLVolume& v = *(*m_volumes)[i];
        m_cache.volumes_data.emplace(i, VolumeCache(v.get_volume_transformation(), v.get_instance_transformation()));
        if (v.is_sinking())
            m_cache.sinking_volumes.push_back(i);
    }
    m_cache.dragging_center = get_bounding_box().center();
    m_cache.rotation_pivot = get_bounding_sphere().first;
}

References Slic3r::BoundingBox3Base< PointType >::center(), get_bounding_box(), get_bounding_sphere(), Slic3r::GLVolume::get_instance_transformation(), Slic3r::GLVolume::get_volume_transformation(), Slic3r::GLVolume::is_sinking(), m_cache, and m_volumes.

Referenced by move_to_center(), and setup_cache().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ set_deserialized()

void Slic3r::GUI::Selection::set_deserialized	(	EMode	mode,
		const std::vector< std::pair< size_t, size_t > > &	volumes_and_instances )

{
    if (! m_valid)
        return;
 
    m_mode = mode;
    for (unsigned int i : m_list)
        (*m_volumes)[i]->selected = false;
    m_list.clear();
    for (unsigned int i = 0; i < (unsigned int)m_volumes->size(); ++ i)
    if (std::binary_search(volumes_and_instances.begin(), volumes_and_instances.end(), (*m_volumes)[i]->geometry_id))
      do_add_volume(i);
    update_type();
    set_bounding_boxes_dirty();
}

References do_add_volume(), m_list, m_mode, m_valid, m_volumes, set_bounding_boxes_dirty(), and update_type().

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

Here is the call graph for this function:

Here is the caller graph for this function:

◆ set_enabled()

void Slic3r::GUI::Selection::set_enabled ( bool enable )

inline

217{ m_enabled = enable; }

References m_enabled.

◆ set_mode()

void Slic3r::GUI::Selection::set_mode ( EMode mode )

inline

223{ m_mode = mode; }

References m_mode.

◆ set_model()

void Slic3r::GUI::Selection::set_model ( Model * model )

{
    m_model = model;
    update_valid();
}

References m_model, and update_valid().

Here is the call graph for this function:

◆ set_printable()

void Slic3r::GUI::Selection::set_printable ( bool printable )

{
    if (!m_valid)
        return;
 
    std::set<std::pair<int, int>> instances_idxs;
    for (const auto& [obj_idx, inst_list] : m_cache.content) {
        for (int inst_idx : inst_list) {
            instances_idxs.insert({obj_idx, inst_idx});
        }
    }
 
    std::string snapshot_text = (boost::format("%1%") % (printable ? "Set Selection Printable" : "Set Selection Unprintable")).str();
    wxGetApp().plater()->take_snapshot(snapshot_text);
 
    // set printable value for all instances in object
    for (const auto& [obj_idx, inst_idx] : instances_idxs)
    {
        ModelObject* object = m_model->objects[obj_idx];
        for (auto inst : object->instances)
            inst->printable = printable;
        wxGetApp().obj_list()->update_printable_state(obj_idx, inst_idx);
 
        //update printable state on canvas
        wxGetApp().plater()->canvas3D()->update_instance_printable_state_for_object((size_t) obj_idx);
    }
 
    // update scene
    wxGetApp().plater()->update();
}

References Slic3r::ModelObject::instances, m_cache, m_model, and m_valid.

Referenced by Slic3r::GUI::MenuFactory::append_menu_item_set_printable().

Here is the caller graph for this function:

◆ set_volume_selection_mode()

void Slic3r::GUI::Selection::set_volume_selection_mode ( EMode mode )

inline

379{ if (!m_volume_selection_locked) m_volume_selection_mode = mode; }

References m_volume_selection_locked, and m_volume_selection_mode.

◆ set_volumes()

void Slic3r::GUI::Selection::set_volumes ( GLVolumePtrs * volumes )

{
    m_volumes = volumes;
    update_valid();
}

References m_volumes, and update_valid().

Here is the call graph for this function:

◆ setup_cache()

void Slic3r::GUI::Selection::setup_cache ( )

{
    if (!m_valid)
        return;
 
    set_caches();
}

References m_valid, and set_caches().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ synchronize_unselected_instances()

void Slic3r::GUI::Selection::synchronize_unselected_instances ( SyncRotationType sync_rotation_type )

{
    std::set<unsigned int> done;  // prevent processing volumes twice
    done.insert(m_list.begin(), m_list.end());
 
    for (unsigned int i : m_list) {
        if (done.size() == m_volumes->size())
            break;
 
        const GLVolume* volume_i = (*m_volumes)[i];
        const int object_idx = volume_i->object_idx();
        if (object_idx >= 1000)
            continue;
 
        const int instance_idx = volume_i->instance_idx();
        const Transform3d& curr_inst_trafo_i = volume_i->get_instance_transformation().get_matrix();
        const Transform3d& old_inst_trafo_i = m_cache.volumes_data[i].get_instance_transform().get_matrix();
        bool               mirrored = is_left_handed(curr_inst_trafo_i) != is_left_handed(old_inst_trafo_i);
//        bool               mirrored = curr_inst_trafo_i.linear().determinant() * old_inst_trafo_i.linear().determinant() < 0;
 
        // Process unselected instances.
        for (unsigned int j = 0; j < (unsigned int)m_volumes->size(); ++j) {
            if (done.size() == m_volumes->size())
                break;
            if (done.find(j) != done.end())
                continue;
            GLVolume* volume_j = (*m_volumes)[j];
            if (volume_j->object_idx() != object_idx || volume_j->instance_idx() == instance_idx)
                continue;
            const Transform3d& old_inst_trafo_j = m_cache.volumes_data[j].get_instance_transform().get_matrix();
            assert(is_rotation_xy_synchronized(old_inst_trafo_i, old_inst_trafo_j));
            Transform3d        new_inst_trafo_j = volume_j->get_instance_transformation().get_matrix();
            if (sync_rotation_type == SyncRotationType::RESET) {
                Geometry::Transformation new_inst_trafo_j_no_rotation(new_inst_trafo_j);
                new_inst_trafo_j_no_rotation.reset_rotation();
                new_inst_trafo_j = new_inst_trafo_j_no_rotation.get_matrix();
            }
            else if (sync_rotation_type != SyncRotationType::NONE || mirrored)
                new_inst_trafo_j.linear() = (old_inst_trafo_j.linear() * old_inst_trafo_i.linear().inverse()) * curr_inst_trafo_i.linear();
 
            // Instances of the same object must remain at the same height. auto_drop
            // only controls snapping after the move, not the instance transform itself.
            if (wxGetApp().preset_bundle->printers.get_edited_preset().printer_technology() != ptSLA)
                new_inst_trafo_j.translation().z() = curr_inst_trafo_i.translation().z();
 
            assert(is_rotation_xy_synchronized(curr_inst_trafo_i, new_inst_trafo_j));
            volume_j->set_instance_transformation(new_inst_trafo_j);
            done.insert(j);
        }
    }
 
#ifndef NDEBUG
    verify_instances_rotation_synchronized(*m_model, *m_volumes);
#endif /* NDEBUG */
}

References Slic3r::GLVolume::get_instance_transformation(), Slic3r::Geometry::Transformation::get_matrix(), Slic3r::GLVolume::instance_idx(), Slic3r::GUI::is_left_handed(), Slic3r::GUI::is_rotation_xy_synchronized(), m_cache, m_list, m_model, m_volumes, NONE, Slic3r::GLVolume::object_idx(), Slic3r::ptSLA, RESET, Slic3r::Geometry::Transformation::reset_rotation(), Slic3r::GLVolume::set_instance_transformation(), and Slic3r::GUI::verify_instances_rotation_synchronized().

Referenced by Slic3r::GUI::face_selected_volume_to_camera(), flattening_rotate(), Slic3r::GUI::GizmoObjectManipulation::reset_rotation_value(), rotate(), scale_and_translate(), Slic3r::GUI::selection_transform(), and translate().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ synchronize_unselected_volumes()

void Slic3r::GUI::Selection::synchronize_unselected_volumes ( )

{
    for (unsigned int i : m_list) {
        const GLVolume* volume = (*m_volumes)[i];
        const int object_idx = volume->object_idx();
        if (object_idx >= 1000)
            continue;
 
        const int volume_idx = volume->volume_idx();
        const Geometry::Transformation& trafo = volume->get_volume_transformation();
 
        // Process unselected volumes.
        for (unsigned int j = 0; j < (unsigned int)m_volumes->size(); ++j) {
            if (j == i)
                continue;
 
            GLVolume* v = (*m_volumes)[j];
            if (v->object_idx() != object_idx || v->volume_idx() != volume_idx)
                continue;
 
            v->set_volume_transformation(trafo);
        }
    }
}

References Slic3r::GLVolume::get_volume_transformation(), m_list, m_volumes, Slic3r::GLVolume::object_idx(), Slic3r::GLVolume::set_volume_transformation(), and Slic3r::GLVolume::volume_idx().

Referenced by Slic3r::GUI::GLGizmoAlignment::finish_operation(), Slic3r::GUI::GizmoObjectManipulation::reset_rotation_value(), rotate(), scale_and_translate(), and translate().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ transform_instance_relative()

void Slic3r::GUI::Selection::transform_instance_relative	(	GLVolume &	volume,
		const VolumeCache &	volume_data,
		TransformationType	transformation_type,
		const Transform3d &	transform,
		const Vec3d &	world_pivot )

private

{
    assert(transformation_type.relative());
 
    const Geometry::Transformation& inst_trafo = volume_data.get_instance_transform();
    if (transformation_type.world()) {
        const Vec3d inst_pivot = transformation_type.independent() && !is_from_single_instance() ? inst_trafo.get_offset() : world_pivot;
        const Transform3d trafo = Geometry::translation_transform(inst_pivot) * transform * Geometry::translation_transform(-inst_pivot);
        volume.set_instance_transformation(trafo * inst_trafo.get_matrix());
    }
    else if (transformation_type.instance())
        volume.set_instance_transformation(inst_trafo.get_matrix() * transform);
    else
        assert(false);
}

References Slic3r::GUI::Selection::VolumeCache::get_instance_transform(), Slic3r::Geometry::Transformation::get_matrix(), Slic3r::Geometry::Transformation::get_offset(), Slic3r::GUI::TransformationType::independent(), Slic3r::GUI::TransformationType::instance(), is_from_single_instance(), Slic3r::GUI::TransformationType::relative(), Slic3r::GLVolume::set_instance_transformation(), Slic3r::transform(), Slic3r::Geometry::translation_transform(), and Slic3r::GUI::TransformationType::world().

Referenced by rotate(), scale_and_translate(), and translate().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ transform_volume_relative()

void Slic3r::GUI::Selection::transform_volume_relative	(	GLVolume &	volume,
		const VolumeCache &	volume_data,
		TransformationType	transformation_type,
		const Transform3d &	transform,
		const Vec3d &	world_pivot )

private

{
    assert(transformation_type.relative());
 
    const Geometry::Transformation& vol_trafo = volume_data.get_volume_transform();
    const Geometry::Transformation& inst_trafo = volume_data.get_instance_transform();
 
    if (transformation_type.world()) {
        const Vec3d inst_pivot = transformation_type.independent() ? vol_trafo.get_offset() : (Vec3d)(inst_trafo.get_matrix().inverse() * world_pivot);
        const Transform3d inst_matrix_no_offset = inst_trafo.get_matrix_no_offset();
        const Transform3d trafo = Geometry::translation_transform(inst_pivot) * inst_matrix_no_offset.inverse() * transform * inst_matrix_no_offset * Geometry::translation_transform(-inst_pivot);
        volume.set_volume_transformation(trafo * vol_trafo.get_matrix());
    }
    else if (transformation_type.instance()) {
        const Vec3d inst_pivot = transformation_type.independent() ? vol_trafo.get_offset() : (Vec3d)(inst_trafo.get_matrix().inverse() * world_pivot);
        const Transform3d trafo = Geometry::translation_transform(inst_pivot) * transform * Geometry::translation_transform(-inst_pivot);
        volume.set_volume_transformation(trafo * vol_trafo.get_matrix());
    }
    else if (transformation_type.local())
        volume.set_volume_transformation(vol_trafo.get_matrix() * transform);
    else
        assert(false);
}

References Slic3r::GUI::Selection::VolumeCache::get_instance_transform(), Slic3r::Geometry::Transformation::get_matrix(), Slic3r::Geometry::Transformation::get_matrix_no_offset(), Slic3r::Geometry::Transformation::get_offset(), Slic3r::GUI::Selection::VolumeCache::get_volume_transform(), Slic3r::GUI::TransformationType::independent(), Slic3r::GUI::TransformationType::instance(), Slic3r::GUI::TransformationType::local(), Slic3r::GUI::TransformationType::relative(), Slic3r::GLVolume::set_volume_transformation(), Slic3r::transform(), Slic3r::Geometry::translation_transform(), and Slic3r::GUI::TransformationType::world().

Referenced by rotate(), scale_and_translate(), and translate().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ translate() [1/4]

void Slic3r::GUI::Selection::translate	(	const Vec3d &	displacement,
		TransformationType	transformation_type )

{
    if (!m_valid) return;
 
    for (unsigned int i : m_list) {
        GLVolume &         v           = *(*m_volumes)[i];
        const VolumeCache &volume_data = m_cache.volumes_data[i];
        if (m_mode == Instance && !is_wipe_tower()) {
            assert(is_from_fully_selected_instance(i));
            if (transformation_type.instance()) {
                const Geometry::Transformation &inst_trafo = volume_data.get_instance_transform();
                v.set_instance_offset(inst_trafo.get_offset() + inst_trafo.get_rotation_matrix() * displacement);
            } else
                transform_instance_relative(v, volume_data, transformation_type, Geometry::translation_transform(displacement), m_cache.dragging_center);
        } else {
            if (v.is_wipe_tower) {//in world cs
                int           plate_idx           = v.object_idx() - 1000;
                const Polygons bed_polys{wxGetApp().plater()->get_partplate_list().get_plate(plate_idx)->get_shared_printable_polygon()};
                Vec3d         tower_origin        = m_cache.volumes_data[i].get_volume_position();
                Vec3d         actual_displacement = displacement;
                // Both preview volumes carry the brim in their bounding box, and the release
                // clamp holds it WIPE_TOWER_MARGIN inside — same margin, so drops don't snap.
                const double margin = WIPE_TOWER_MARGIN;
 
                actual_displacement = (m_cache.volumes_data[i].get_instance_rotation_matrix() * m_cache.volumes_data[i].get_instance_scale_matrix() *
                                        m_cache.volumes_data[i].get_instance_mirror_matrix())
                                            .inverse() *
                                        displacement;
                BoundingBoxf3 tower_bbox = v.bounding_box();
                tower_bbox.translate(actual_displacement + tower_origin);
                BoundingBox   tower_bbox2d = BoundingBox(scaled(Vec2f(tower_bbox.min[0], tower_bbox.min[1])), scaled(Vec2f(tower_bbox.max[0], tower_bbox.max[1])));
                const Vec2f   offset       = WipeTower::move_box_inside_polygon(tower_bbox2d, bed_polys, scaled(margin));
                actual_displacement += Vec3d(offset[0], offset[1],0);
                v.set_volume_offset(m_cache.volumes_data[i].get_volume_position() + actual_displacement);
            }
            else if (transformation_type.local() && transformation_type.absolute()) {
                const Geometry::Transformation &vol_trafo  = volume_data.get_volume_transform();
                const Geometry::Transformation &inst_trafo = volume_data.get_instance_transform();
                v.set_volume_offset(vol_trafo.get_offset() + inst_trafo.get_scaling_factor_matrix().inverse() * vol_trafo.get_rotation_matrix() * displacement);
            } else {
                Vec3d relative_disp = displacement;
                if (transformation_type.world() && transformation_type.instance())
                    relative_disp = volume_data.get_instance_transform().get_scaling_factor_matrix().inverse() * relative_disp;
 
                transform_volume_relative(v, volume_data, transformation_type, Geometry::translation_transform(relative_disp), m_cache.dragging_center);
            }
        }
    }
 
#if !DISABLE_INSTANCES_SYNCH
    if (m_mode == Instance)
        synchronize_unselected_instances(SyncRotationType::NONE);
    else if (m_mode == Volume)
        synchronize_unselected_volumes();
#endif // !DISABLE_INSTANCES_SYNCH
    if (wxGetApp().plater()->canvas3D()->get_canvas_type() != GLCanvas3D::ECanvasType::CanvasAssembleView) {
        ensure_not_below_bed();
    }
    set_bounding_boxes_dirty();
    if (wxGetApp().plater()->canvas3D()->get_canvas_type() != GLCanvas3D::ECanvasType::CanvasAssembleView) {
        wxGetApp().plater()->canvas3D()->requires_check_outside_state();
    }
}

References Slic3r::GUI::TransformationType::absolute(), Slic3r::GLVolume::bounding_box(), Slic3r::GUI::GLCanvas3D::CanvasAssembleView, ensure_not_below_bed(), Slic3r::GUI::Selection::VolumeCache::get_instance_transform(), Slic3r::Geometry::Transformation::get_offset(), Slic3r::Geometry::Transformation::get_rotation_matrix(), Slic3r::Geometry::Transformation::get_scaling_factor_matrix(), Slic3r::GUI::Selection::VolumeCache::get_volume_transform(), Instance, Slic3r::GUI::TransformationType::instance(), is_from_fully_selected_instance(), is_wipe_tower(), Slic3r::GUI::TransformationType::local(), m_cache, m_list, m_mode, m_valid, Slic3r::BoundingBoxBase< PointType, std::vector< PointType > >::max, Slic3r::BoundingBoxBase< PointType, std::vector< PointType > >::min, Slic3r::WipeTower::move_box_inside_polygon(), NONE, Slic3r::GLVolume::object_idx(), Slic3r::offset(), Slic3r::GUI::plater(), Slic3r::scaled(), set_bounding_boxes_dirty(), Slic3r::GLVolume::set_instance_offset(), Slic3r::GLVolume::set_volume_offset(), synchronize_unselected_instances(), synchronize_unselected_volumes(), transform_instance_relative(), transform_volume_relative(), Slic3r::BoundingBox3Base< PointType >::translate(), Slic3r::Geometry::translation_transform(), Volume, WIPE_TOWER_MARGIN, and Slic3r::GUI::TransformationType::world().

Referenced by Slic3r::GUI::GLGizmoAlignment::align_objects_generic(), Slic3r::GUI::GLGizmoAlignment::align_to_center(), Slic3r::GUI::GLGizmoAlignment::apply_transformation(), Slic3r::GUI::GizmoObjectManipulation::change_position_value(), Slic3r::GUI::GLGizmoAlignment::distribute_objects_generic(), Slic3r::GUI::do_local_z_move(), drop(), Slic3r::GUI::GLGizmoMove3D::on_dragging(), and scale_to_fit_print_volume().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ translate() [2/4]

void Slic3r::GUI::Selection::translate	(	unsigned int	object_idx,
		const Vec3d &	displacement )

{
    if (!m_valid)
        return;
 
    //BOOST_LOG_TRIVIAL(debug) << __FUNCTION__ << boost::format(": obj %1%") % object_idx;
    //BOOST_LOG_TRIVIAL(debug) << __FUNCTION__ << boost::format(": %1%, displacement {%2%, %3%, %4%}") % __LINE__ % displacement(X) % displacement(Y) % displacement(Z);
    for (unsigned int i : m_list) {
        GLVolume& v = *(*m_volumes)[i];
        if (v.object_idx() == (int)object_idx)
            v.set_instance_offset(v.get_instance_offset() + displacement);
    }
 
    std::set<unsigned int> done;  // prevent processing volumes twice
    done.insert(m_list.begin(), m_list.end());
 
    for (unsigned int i : m_list) {
        if (done.size() == m_volumes->size())
            break;
 
        int object_idx = (*m_volumes)[i]->object_idx();
        if (object_idx >= 1000)
            continue;
 
        // Process unselected volumes of the object.
        for (unsigned int j = 0; j < (unsigned int)m_volumes->size(); ++j) {
            if (done.size() == m_volumes->size())
                break;
 
            if (done.find(j) != done.end())
                continue;
 
            GLVolume& v = *(*m_volumes)[j];
            if (v.object_idx() != object_idx)
                continue;
 
            v.set_instance_offset(v.get_instance_offset() + displacement);
            done.insert(j);
        }
    }
 
    this->set_bounding_boxes_dirty();
}

References Slic3r::GLVolume::get_instance_offset(), m_list, m_valid, m_volumes, Slic3r::GLVolume::object_idx(), set_bounding_boxes_dirty(), and Slic3r::GLVolume::set_instance_offset().

Here is the call graph for this function:

◆ translate() [3/4]

void Slic3r::GUI::Selection::translate	(	unsigned int	object_idx,
		unsigned int	instance_idx,
		const Vec3d &	displacement )

{
    if (!m_valid)
        return;
 
    //BOOST_LOG_TRIVIAL(debug) << __FUNCTION__ << boost::format(": obj %1%, instance %2%") % object_idx % instance_idx;
    //BOOST_LOG_TRIVIAL(debug) << __FUNCTION__ << boost::format(": %1%, displacement {%2%, %3%, %4%}") % __LINE__ % displacement(X) % displacement(Y) % displacement(Z);
    // Every volume of the instance, selected or not, so that the instance moves as a whole.
    for (GLVolume* v : *m_volumes) {
        if (v->object_idx() == (int)object_idx && v->instance_idx() == (int)instance_idx)
            v->set_instance_offset(v->get_instance_offset() + displacement);
    }
 
    this->set_bounding_boxes_dirty();
}

References m_valid, m_volumes, and set_bounding_boxes_dirty().

Here is the call graph for this function:

◆ translate() [4/4]

void Slic3r::GUI::Selection::translate	(	unsigned int	object_idx,
		unsigned int	instance_idx,
		unsigned int	volume_idx,
		const Vec3d &	displacement,
		bool	local = true )

{
    if (!m_valid) return;
 
    for (unsigned int i : m_list) {
        GLVolume &v = *(*m_volumes)[i];
        if (v.object_idx() == (int) object_idx && v.instance_idx() == (int) instance_idx && v.volume_idx() == (int) volume_idx) {
            Vec3d local_displacement = displacement;
            if (!local)
                local_displacement = v.get_instance_transformation().get_matrix_no_offset().inverse() * displacement;
            v.set_volume_offset(v.get_volume_offset() + local_displacement);
        }
    }
 
    this->set_bounding_boxes_dirty();
}

References Slic3r::GLVolume::get_instance_transformation(), Slic3r::Geometry::Transformation::get_matrix_no_offset(), Slic3r::GLVolume::get_volume_offset(), Slic3r::GLVolume::instance_idx(), m_list, m_valid, Slic3r::GLVolume::object_idx(), set_bounding_boxes_dirty(), Slic3r::GLVolume::set_volume_offset(), and Slic3r::GLVolume::volume_idx().

Here is the call graph for this function:

◆ unlock_volume_selection_mode()

void Slic3r::GUI::Selection::unlock_volume_selection_mode ( )

inline

381{ m_volume_selection_locked = false; }

References m_volume_selection_locked.

◆ update_type()

void Slic3r::GUI::Selection::update_type ( )

private

{
    m_cache.content.clear();
    m_type = Mixed;
 
    for (unsigned int i : m_list)
    {
        const GLVolume* volume = (*m_volumes)[i];
        int obj_idx = volume->object_idx();
        int inst_idx = volume->instance_idx();
        ObjectIdxsToInstanceIdxsMap::iterator obj_it = m_cache.content.find(obj_idx);
        if (obj_it == m_cache.content.end())
            obj_it = m_cache.content.insert(ObjectIdxsToInstanceIdxsMap::value_type(obj_idx, InstanceIdxsList())).first;
 
        obj_it->second.insert(inst_idx);
    }
 
    bool requires_disable = false;
 
    if (!m_valid)
        m_type = Invalid;
    else
    {
        if (m_list.empty())
            m_type = Empty;
        else if (m_list.size() == 1)
        {
            const GLVolume* first = (*m_volumes)[*m_list.begin()];
            if (first->is_wipe_tower)
                m_type = WipeTower;
            else if (first->is_modifier)
            {
                m_type = SingleModifier;
                requires_disable = true;
            }
            else
            {
                const ModelObject* model_object = m_model->objects[first->object_idx()];
                unsigned int volumes_count = (unsigned int)model_object->volumes.size();
                unsigned int instances_count = (unsigned int)model_object->instances.size();
                if (volumes_count * instances_count == 1)
                {
                    m_type = SingleFullObject;
                    // ensures the correct mode is selected
                    m_mode = Instance;
                }
                else if (volumes_count == 1) // instances_count > 1
                {
                    m_type = SingleFullInstance;
                    // ensures the correct mode is selected
                    m_mode = Instance;
                }
                else
                {
                    m_type = SingleVolume;
                    requires_disable = true;
                }
            }
        }
        else
        {
            unsigned int sla_volumes_count = 0;
            // Note: sla_volumes_count is a count of the selected sla_volumes per object instead of per instance, like a model_volumes_count is
            for (unsigned int i : m_list) {
                if ((*m_volumes)[i]->volume_idx() < 0)
                    ++sla_volumes_count;
            }
 
            if (m_cache.content.size() == 1) // single object
            {
                const ModelObject* model_object = m_model->objects[m_cache.content.begin()->first];
                unsigned int model_volumes_count = (unsigned int)model_object->volumes.size();
 
                unsigned int instances_count = (unsigned int)model_object->instances.size();
                unsigned int selected_instances_count = (unsigned int)m_cache.content.begin()->second.size();
                if (model_volumes_count * instances_count + sla_volumes_count == (unsigned int)m_list.size())
                {
                    m_type = SingleFullObject;
                    // ensures the correct mode is selected
                    m_mode = Instance;
                }
                else if (selected_instances_count == 1)
                {
                    if (model_volumes_count + sla_volumes_count == (unsigned int)m_list.size())
                    {
                        m_type = SingleFullInstance;
                        // ensures the correct mode is selected
                        m_mode = Instance;
                    }
                    else
                    {
                        unsigned int modifiers_count = 0;
                        for (unsigned int i : m_list)
                        {
                            if ((*m_volumes)[i]->is_modifier)
                                ++modifiers_count;
                        }
 
                        if (modifiers_count == 0)
                            m_type = MultipleVolume;
                        else if (modifiers_count == (unsigned int)m_list.size())
                            m_type = MultipleModifier;
 
                        requires_disable = true;
                    }
                }
                else if ((selected_instances_count > 1) && (selected_instances_count * model_volumes_count + sla_volumes_count == (unsigned int)m_list.size()))
                {
                    m_type = MultipleFullInstance;
                    // ensures the correct mode is selected
                    m_mode = Instance;
                }
            }
            else
            {
                unsigned int sels_cntr = 0;
                for (ObjectIdxsToInstanceIdxsMap::iterator it = m_cache.content.begin(); it != m_cache.content.end(); ++it)
                {
                    bool               is_wipe_tower   = it->first >= 1000;
                    int                actual_obj_id   = is_wipe_tower ? it->first - 1000 : it->first;
                    const ModelObject *model_object    = m_model->objects[actual_obj_id];
                    unsigned int volumes_count = (unsigned int)model_object->volumes.size();
                    unsigned int instances_count = (unsigned int)model_object->instances.size();
                    sels_cntr += volumes_count * instances_count;
                }
                if (sels_cntr + sla_volumes_count == (unsigned int)m_list.size())
                {
                    m_type = MultipleFullObject;
                    // ensures the correct mode is selected
                    m_mode = Instance;
                }
            }
        }
    }
 
    //BBS: remove the disable logic here
    /*int object_idx = get_object_idx();
    int instance_idx = get_instance_idx();
    for (GLVolume* v : *m_volumes)
    {
        v->disabled = requires_disable ? (v->object_idx() != object_idx) || (v->instance_idx() != instance_idx) : false;
    }*/
 
#if ENABLE_SELECTION_DEBUG_OUTPUT
    std::cout << "Selection: ";
    std::cout << "mode: ";
    switch (m_mode)
    {
    case Volume:
    {
        std::cout << "Volume";
        break;
    }
    case Instance:
    {
        std::cout << "Instance";
        break;
    }
    }
 
    std::cout << " - type: ";
 
    switch (m_type)
    {
    case Invalid:
    {
        std::cout << "Invalid" << std::endl;
        break;
    }
    case Empty:
    {
        std::cout << "Empty" << std::endl;
        break;
    }
    case WipeTower:
    {
        std::cout << "WipeTower" << std::endl;
        break;
    }
    case SingleModifier:
    {
        std::cout << "SingleModifier" << std::endl;
        break;
    }
    case MultipleModifier:
    {
        std::cout << "MultipleModifier" << std::endl;
        break;
    }
    case SingleVolume:
    {
        std::cout << "SingleVolume" << std::endl;
        break;
    }
    case MultipleVolume:
    {
        std::cout << "MultipleVolume" << std::endl;
        break;
    }
    case SingleFullObject:
    {
        std::cout << "SingleFullObject" << std::endl;
        break;
    }
    case MultipleFullObject:
    {
        std::cout << "MultipleFullObject" << std::endl;
        break;
    }
    case SingleFullInstance:
    {
        std::cout << "SingleFullInstance" << std::endl;
        break;
    }
    case MultipleFullInstance:
    {
        std::cout << "MultipleFullInstance" << std::endl;
        break;
    }
    case Mixed:
    {
        std::cout << "Mixed" << std::endl;
        break;
    }
    }
#endif // ENABLE_SELECTION_DEBUG_OUTPUT
}

References Empty, Instance, Slic3r::GLVolume::instance_idx(), Slic3r::ModelObject::instances, Invalid, is_wipe_tower(), m_cache, m_list, m_mode, m_model, m_type, m_valid, m_volumes, Mixed, MultipleFullInstance, MultipleFullObject, MultipleModifier, MultipleVolume, Slic3r::GLVolume::object_idx(), SingleFullInstance, SingleFullObject, SingleModifier, SingleVolume, Volume, Slic3r::ModelObject::volumes, volumes_count(), and WipeTower.

Referenced by add(), add_all(), add_curr_plate(), add_instance(), add_object(), add_object_from_idx(), add_volume(), add_volumes(), clear(), instances_changed(), remove(), remove_curr_plate(), remove_instance(), remove_object(), remove_volume(), remove_volumes(), set_deserialized(), and volumes_changed().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ update_valid()

void Slic3r::GUI::Selection::update_valid ( )

private

{
    m_valid = (m_volumes != nullptr) && (m_model != nullptr);
}

References m_model, m_valid, and m_volumes.

Referenced by set_model(), and set_volumes().

Here is the caller graph for this function:

◆ volumes_changed()

void Slic3r::GUI::Selection::volumes_changed ( const std::vector< size_t > & map_volume_old_to_new )

{
    assert(m_valid);
    assert(m_mode == Volume);
    IndicesList list_new;
    for (unsigned int idx : m_list)
        if (map_volume_old_to_new[idx] != size_t(-1)) {
            unsigned int new_idx = (unsigned int)map_volume_old_to_new[idx];
            (*m_volumes)[new_idx]->selected = true;
            list_new.insert(new_idx);
        }
    m_list = std::move(list_new);
    update_type();
    this->set_bounding_boxes_dirty();
}

References m_list, m_mode, m_valid, set_bounding_boxes_dirty(), update_type(), and Volume.

Here is the call graph for this function:

◆ volumes_count()

unsigned int Slic3r::GUI::Selection::volumes_count ( ) const

inline

322{ return (unsigned int)m_list.size(); }

References m_list.

Referenced by Slic3r::GUI::MenuFactory::append_menu_item_edit_svg(), Slic3r::GUI::MenuFactory::append_menu_item_edit_text(), Slic3r::GUI::do_local_z_rotate(), anonymous_namespace{SurfaceDrag.cpp}::is_embossed_object(), Slic3r::GUI::GLGizmoAssembly::on_is_activable(), Slic3r::GUI::GLGizmoMeasure::on_is_activable(), and update_type().

Here is the caller graph for this function:

Member Data Documentation

◆ m_arrow

GLModel Slic3r::GUI::Selection::m_arrow

private

Referenced by init(), render_sidebar_position_hints(), and render_sidebar_scale_hints().

◆ m_auto_drop

bool Slic3r::GUI::Selection::m_auto_drop = true

private

Referenced by render_bounding_box().

◆ m_bounding_box

std::optional<BoundingBoxf3> Slic3r::GUI::Selection::m_bounding_box

private

Referenced by get_bounding_box(), and set_bounding_boxes_dirty().

◆ m_bounding_box_in_current_reference_system

std::optional<std::pair<BoundingBoxf3, Transform3d> > Slic3r::GUI::Selection::m_bounding_box_in_current_reference_system

private

Referenced by get_bounding_box_in_current_reference_system(), and set_bounding_boxes_dirty().

◆ m_bounding_sphere

std::optional<std::pair<Vec3d, double> > Slic3r::GUI::Selection::m_bounding_sphere

private

Referenced by get_bounding_sphere(), and set_bounding_boxes_dirty().

◆ m_box

GLModel Slic3r::GUI::Selection::m_box

private

Referenced by render_bounding_box().

◆ m_cache

Cache Slic3r::GUI::Selection::m_cache

private

Referenced by copy_to_clipboard(), ensure_on_bed(), erase(), get_auto_drop(), get_content(), get_drop_min_z(), get_instance_idx(), get_instance_idxs(), get_object_idx(), get_selected_object_instances(), move_to_center(), rotate(), scale_and_translate(), set_auto_drop(), set_caches(), set_printable(), synchronize_unselected_instances(), translate(), and update_type().

◆ m_clipboard

Clipboard Slic3r::GUI::Selection::m_clipboard

private

Referenced by copy_to_clipboard(), get_clipboard(), paste_from_clipboard(), paste_objects_from_clipboard(), and paste_volumes_from_clipboard().

◆ m_curved_arrow

GLModel Slic3r::GUI::Selection::m_curved_arrow

private

Referenced by init(), and render_sidebar_rotation_hints().

◆ m_enabled

bool Slic3r::GUI::Selection::m_enabled

private

Referenced by Selection(), is_enabled(), and set_enabled().

◆ m_full_scaled_instance_bounding_box

std::optional<BoundingBoxf3> Slic3r::GUI::Selection::m_full_scaled_instance_bounding_box

private

Referenced by get_full_scaled_instance_bounding_box(), and set_bounding_boxes_dirty().

◆ m_full_unscaled_instance_bounding_box

std::optional<BoundingBoxf3> Slic3r::GUI::Selection::m_full_unscaled_instance_bounding_box

private

Referenced by get_full_unscaled_instance_bounding_box(), and set_bounding_boxes_dirty().

◆ m_full_unscaled_instance_local_bounding_box

std::optional<BoundingBoxf3> Slic3r::GUI::Selection::m_full_unscaled_instance_local_bounding_box

private

Referenced by get_full_unscaled_instance_local_bounding_box(), and set_bounding_boxes_dirty().

◆ m_list

IndicesList Slic3r::GUI::Selection::m_list

private

Referenced by add(), add_all(), clear(), contains_all_volumes(), contains_any_volume(), contains_volume(), copy_to_clipboard(), do_add_volume(), do_remove_volume(), ensure_not_below_bed(), erase(), flattening_rotate(), get_bounding_box(), get_bounding_box_in_reference_system(), get_bounding_sphere(), get_first_volume(), get_full_scaled_instance_bounding_box(), get_full_unscaled_instance_bounding_box(), get_full_unscaled_instance_local_bounding_box(), get_missing_volume_idxs_from(), get_scaled_instance_bounding_box(), get_unscaled_instance_bounding_box(), get_unselected_volume_idxs_from(), get_volume_idxs(), instances_changed(), is_from_fully_selected_instance(), is_single_full_instance(), is_single_text(), is_single_volume_instance(), is_sla_compliant(), matches(), move_to_center(), notify_instance_update(), render_sidebar_hints(), render_synchronized_volumes(), rotate(), rotate(), rotate(), scale_and_translate(), set_deserialized(), synchronize_unselected_instances(), synchronize_unselected_volumes(), translate(), translate(), translate(), update_type(), volumes_changed(), and volumes_count().

◆ m_mode

◆ m_model

◆ m_planes

Planes Slic3r::GUI::Selection::m_planes

private

Referenced by render_sidebar_layers_hints().

◆ m_scale_factor

float Slic3r::GUI::Selection::m_scale_factor

private

Referenced by Selection(), render(), render_bounding_box(), render_bounding_box(), and render_bounding_box().

◆ m_scaled_instance_bounding_box

std::optional<BoundingBoxf3> Slic3r::GUI::Selection::m_scaled_instance_bounding_box

private

Referenced by get_scaled_instance_bounding_box(), and set_bounding_boxes_dirty().

◆ m_type

EType Slic3r::GUI::Selection::m_type

private

Referenced by Selection(), is_empty(), is_mixed(), is_multiple_full_instance(), is_multiple_full_object(), is_multiple_modifier(), is_multiple_volume(), is_single_full_instance(), is_single_full_object(), is_single_modifier(), is_single_volume(), is_wipe_tower(), and update_type().

◆ m_unscaled_instance_bounding_box

std::optional<BoundingBoxf3> Slic3r::GUI::Selection::m_unscaled_instance_bounding_box

private

Referenced by get_unscaled_instance_bounding_box(), and set_bounding_boxes_dirty().

◆ m_valid

bool Slic3r::GUI::Selection::m_valid

private

Referenced by Selection(), add(), add_all(), add_curr_plate(), add_instance(), add_object(), add_object_from_idx(), add_volume(), add_volumes(), clear(), copy_to_clipboard(), erase(), flattening_rotate(), get_auto_drop(), get_bounding_box(), get_bounding_sphere(), get_drop_min_z(), get_full_scaled_instance_bounding_box(), get_full_unscaled_instance_bounding_box(), get_full_unscaled_instance_local_bounding_box(), get_scaled_instance_bounding_box(), get_unscaled_instance_bounding_box(), get_volume(), get_volume(), instances_changed(), is_single_full_instance(), move_to_center(), paste_from_clipboard(), remove(), remove_all(), remove_curr_plate(), remove_instance(), remove_object(), remove_volume(), remove_volumes(), render(), rotate(), rotate(), rotate(), scale_and_translate(), set_auto_drop(), set_deserialized(), set_printable(), setup_cache(), translate(), translate(), translate(), translate(), update_type(), update_valid(), and volumes_changed().

◆ m_volume_selection_locked

bool Slic3r::GUI::Selection::m_volume_selection_locked { false }

private

208{ false };

Referenced by lock_volume_selection_mode(), set_volume_selection_mode(), and unlock_volume_selection_mode().

◆ m_volume_selection_mode

EMode Slic3r::GUI::Selection::m_volume_selection_mode { Instance }

private

207{ Instance };

Referenced by add(), get_volume_selection_mode(), and set_volume_selection_mode().

◆ m_volumes

GLVolumePtrs* Slic3r::GUI::Selection::m_volumes

private

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

/home/runner/work/OrcaSlicer/OrcaSlicer/src/slic3r/GUI/Selection.hpp
/home/runner/work/OrcaSlicer/OrcaSlicer/src/slic3r/GUI/Selection.cpp

	OrcaSlicer latest OrcaSlicer

Classes

Public Types

Public Member Functions

Private Member Functions

Private Attributes

Detailed Description

Class Documentation

◆ Slic3r::GUI::Selection::Cache

◆ Slic3r::GUI::Selection::Planes

Member Typedef Documentation

◆ IndicesList

◆ InstanceIdxsList

◆ ObjectIdxsToInstanceIdxsMap

◆ VolumesCache

Member Enumeration Documentation

◆ EMode

◆ EType

◆ SyncRotationType

Constructor & Destructor Documentation

◆ Selection()

Member Function Documentation

◆ add()

◆ add_all()

◆ add_curr_plate()

◆ add_instance()

◆ add_object()

◆ add_object_from_idx()

◆ add_volume()

◆ add_volumes()

◆ can_drop()

◆ center()

◆ center_plate()

◆ clear()

◆ clone()

◆ contains_all_volumes()

◆ contains_any_volume()

◆ contains_sinking_volumes()

◆ contains_volume()

◆ copy_to_clipboard()

◆ cut_to_clipboard()

◆ do_add_volume()

◆ do_add_volumes()

◆ do_remove_instance()

◆ do_remove_object()

◆ do_remove_volume()

◆ drop()

◆ ensure_not_below_bed()

◆ ensure_on_bed()

◆ erase()

◆ fill_color()

◆ flattening_rotate()

◆ get_auto_drop()

◆ get_bounding_box()

◆ get_bounding_box_in_current_reference_system()

◆ get_bounding_box_in_reference_system()

◆ get_bounding_sphere()

◆ get_clipboard()

◆ get_content()

◆ get_drop_min_z()

◆ get_first_volume()

◆ get_full_scaled_instance_bounding_box()

◆ get_full_unscaled_instance_bounding_box()

◆ get_full_unscaled_instance_local_bounding_box()

◆ get_instance_idx()

◆ get_instance_idxs()

◆ get_missing_volume_idxs_from()

◆ get_mode()

◆ get_model()

◆ get_object_idx()

◆ get_scaled_instance_bounding_box()

◆ get_selected_object_instances()

◆ get_selected_single_intance()

◆ get_selected_single_object()

◆ get_selected_single_volume()

◆ get_unscaled_instance_bounding_box()

◆ get_unselected_volume_idxs_from()

◆ get_volume() [1/2]

◆ get_volume() [2/2]

◆ get_volume_idxs()

◆ get_volume_idxs_from_instance()