Slic3r::SLAPrintObject Class Reference

#include <src/libslic3r/SLAPrint.hpp>

Inheritance diagram for Slic3r::SLAPrintObject:

Collaboration diagram for Slic3r::SLAPrintObject:

Classes
class	HollowingData
struct	Instance
class	SliceRecord
struct	SupportData

Public Types
using	PrintObjectStepEnum = PrintObjectStepEnumType
typedef PrintState< PrintObjectStepEnum, COUNT >	PrintObjectState
using	Timestamp = uint64_t

Public Member Functions
	SLAPrintObject (const SLAPrintObject &)=delete
SLAPrintObject &	operator= (const SLAPrintObject &)=delete
const SLAPrintObjectConfig &	config () const
const Transform3d &	trafo () const
bool	is_left_handed () const
const std::vector< Instance > &	instances () const
const TriangleMesh &	support_mesh () const
const TriangleMesh &	pad_mesh () const
const std::shared_ptr< const indexed_triangle_set > &	get_mesh_to_print () const
std::vector< csg::CSGPart >	get_parts_to_slice () const
std::vector< csg::CSGPart >	get_parts_to_slice (SLAPrintObjectStep step) const
sla::SupportPoints	transformed_support_points () const
sla::DrainHoles	transformed_drainhole_points () const
double	get_elevation () const
double	get_current_elevation () const
const std::vector< sla::SupportPoint > &	get_support_points () const
const std::vector< SliceRecord > &	get_slice_index () const
const SliceRecord &	closest_slice_to_print_level (coord_t print_level, coord_t max_epsilon=std::numeric_limits< coord_t >::max()) const
const SliceRecord &	closest_slice_to_slice_level (float slice_level, float max_epsilon=std::numeric_limits< float >::max()) const
PrintType *	print ()
const PrintType *	print () const
bool	is_step_done (PrintObjectStepEnum step) const
PrintStateBase::StateWithTimeStamp	step_state_with_timestamp (PrintObjectStepEnum step) const
PrintStateBase::StateWithWarnings	step_state_with_warnings (PrintObjectStepEnum step) const
auto	last_completed_step () const
const ModelObject *	model_object () const
ModelObject *	model_object ()
ObjectID	id () const
virtual Timestamp	timestamp () const

Static Public Attributes
static constexpr const size_t	PrintObjectStepEnumSize = COUNT

Protected Member Functions
	SLAPrintObject (SLAPrint *print, ModelObject *model_object)
	~SLAPrintObject ()
void	config_apply (const ConfigBase &other, bool ignore_nonexistent=false)
void	config_apply_only (const ConfigBase &other, const t_config_option_keys &keys, bool ignore_nonexistent=false)
void	set_trafo (const Transform3d &trafo, bool left_handed)
template<class InstVec >
void	set_instances (InstVec &&instances)
bool	invalidate_step (SLAPrintObjectStep step)
bool	invalidate_all_steps ()
bool	invalidate_state_by_config_options (const std::vector< t_config_option_key > &opt_keys)
bool	set_started (PrintObjectStepEnum step)
PrintStateBase::TimeStamp	set_done (PrintObjectStepEnum step)
bool	invalidate_step (PrintObjectStepEnum step)
template<typename StepTypeIterator >
bool	invalidate_steps (StepTypeIterator step_begin, StepTypeIterator step_end)
bool	invalidate_steps (std::initializer_list< PrintObjectStepEnum > il)
bool	is_step_started_unguarded (PrintObjectStepEnum step) const
bool	is_step_done_unguarded (PrintObjectStepEnum step) const
bool	is_step_enabled_unguarded (PrintObjectStepEnum step) const
void	enable_step_unguarded (PrintObjectStepEnum step, bool enable)
void	enable_all_steps_unguarded (bool enable)
void	finalize_impl ()
bool	query_reset_dirty_step_unguarded (PrintObjectStepEnum step)
void	active_step_add_warning (PrintStateBase::WarningLevel warning_level, const std::string &message, int message_id=0)
void	throw_if_canceled ()
void	status_update_warnings (PrintBase *print, int step, PrintStateBase::WarningLevel warning_level, const std::string &message)
void	set_new_unique_id ()
void	set_invalid_id ()
void	copy_id (const ObjectBase &rhs)
virtual void	assign_new_unique_ids_recursive ()

Static Protected Member Functions
static std::mutex &	state_mutex (PrintBase *print)
static std::function< void()>	cancel_callback (PrintBase *print)

Protected Attributes
friend	PrintType
PrintType *	m_print
ModelObject *	m_model_object

Private Types
using	Inherited = _SLAPrintObjectBase
using	CSGContainer = std::multiset< CSGPartForStep >

Private Member Functions
const std::vector< ExPolygons > &	get_model_slices () const
const std::vector< ExPolygons > &	get_support_slices () const
auto	mesh_to_slice (SLAPrintObjectStep s) const
auto	mesh_to_slice () const
template<class Archive >
void	serialize (Archive &ar)

Static Private Member Functions
template<class T >
static T	level (const SliceRecord &sr)
template<class T >
static SliceRecord	create_slice_record (T val)
template<class Container , class T >
static auto	closest_slice_record (Container &cont, T lvl, T eps=std::numeric_limits< T >::max()) -> decltype(cont.begin())
static ObjectID	generate_new_id ()
template<class Archive >
static void	load_and_construct (Archive &ar, cereal::construct< ObjectBase > &construct)

Private Attributes
SLAPrintObjectConfig	m_config
Transform3d	m_trafo = Transform3d::Identity()
bool	m_left_handed = false
std::vector< Instance >	m_instances
std::vector< ExPolygons >	m_model_slices
std::vector< SliceRecord >	m_slice_index
std::vector< float >	m_model_height_levels
std::unique_ptr< SupportData >	m_supportdata
CSGContainer	m_mesh_to_slice
std::array< std::shared_ptr< const indexed_triangle_set >, SLAPrintObjectStep::slaposCount+1 >	m_preview_meshes
std::unique_ptr< HollowingData >	m_hollowing_data
PrintState< PrintObjectStepEnum, COUNT >	m_state
ObjectID	m_id

Static Private Attributes
static size_t	s_last_id = 0

Friends
class	SLAPrint
class	PrintBaseWithState< SLAPrintStep, slapsCount >

Detailed Description

---

Class Documentation

Slic3r::SLAPrintObject::HollowingData

class Slic3r::SLAPrintObject::HollowingData

Collaboration diagram for Slic3r::SLAPrintObject::HollowingData:

Class Members
InteriorPtr	interior

Member Typedef Documentation

CSGContainer

using Slic3r::SLAPrintObject::CSGContainer = std::multiset<CSGPartForStep>

private

Inherited

using Slic3r::SLAPrintObject::Inherited = _SLAPrintObjectBase

private

PrintObjectState

template<typename PrintType , typename PrintObjectStepEnumType , const size_t COUNT>

typedef PrintState<PrintObjectStepEnum, COUNT> Slic3r::PrintObjectBaseWithState< PrintType, PrintObjectStepEnumType, COUNT >::PrintObjectState

inherited

PrintObjectStepEnum

template<typename PrintType , typename PrintObjectStepEnumType , const size_t COUNT>

using Slic3r::PrintObjectBaseWithState< PrintType, PrintObjectStepEnumType, COUNT >::PrintObjectStepEnum = PrintObjectStepEnumType

inherited

Timestamp

using Slic3r::ObjectBase::Timestamp = uint64_t

inherited

Constructor & Destructor Documentation

SLAPrintObject() [1/2]

Slic3r::SLAPrintObject::SLAPrintObject ( const SLAPrintObject &  )

delete

SLAPrintObject() [2/2]

Slic3r::SLAPrintObject::SLAPrintObject ( SLAPrint *  print, ModelObject *  model_object  )

protected

    : Inherited(print, model_object)
{}

~SLAPrintObject()

Slic3r::SLAPrintObject::~SLAPrintObject ( )

protected

{}

Member Function Documentation

active_step_add_warning()

template<typename PrintType , typename PrintObjectStepEnumType , const size_t COUNT>

void Slic3r::PrintObjectBaseWithState< PrintType, PrintObjectStepEnumType, COUNT >::active_step_add_warning ( PrintStateBase::WarningLevel  warning_level, const std::string &  message, int  message_id = 0  )

inlineprotectedinherited

                                                                                                                                    {
      std::pair<PrintObjectStepEnum, bool> active_step = m_state.active_step_add_warning(warning_level, message, message_id, PrintObjectBase::state_mutex(m_print));
      if (active_step.second)
        this->status_update_warnings(m_print, static_cast<int>(active_step.first), warning_level, message);
    }

References Slic3r::PrintState< StepType, COUNT >::active_step_add_warning(), Slic3r::PrintObjectBaseWithState< PrintType, PrintObjectStepEnumType, COUNT >::m_print, Slic3r::PrintObjectBaseWithState< PrintType, PrintObjectStepEnumType, COUNT >::m_state, Slic3r::PrintObjectBase::state_mutex(), and Slic3r::PrintObjectBase::status_update_warnings().

Referenced by Slic3r::SLAPrint::Steps::generate_preview().

Here is the call graph for this function:

Here is the caller graph for this function:

assign_new_unique_ids_recursive()

virtual void Slic3r::ObjectBase::assign_new_unique_ids_recursive ( )

inlineprotectedvirtualinherited

Reimplemented in Slic3r::Model, Slic3r::ModelObject, and Slic3r::ModelVolume.

{ this->set_new_unique_id(); }

References Slic3r::ObjectBase::set_new_unique_id().

Here is the call graph for this function:

cancel_callback()

std::function< void()> Slic3r::PrintObjectBase::cancel_callback ( PrintBase *  print )

staticprotectedinherited

{ 
  return print->cancel_callback();
}

References Slic3r::PrintBase::cancel_callback().

Referenced by Slic3r::PrintObjectBaseWithState< PrintType, PrintObjectStepEnumType, COUNT >::invalidate_all_steps(), Slic3r::PrintObjectBaseWithState< PrintType, PrintObjectStepEnumType, COUNT >::invalidate_step(), Slic3r::PrintObjectBaseWithState< PrintType, PrintObjectStepEnumType, COUNT >::invalidate_steps(), and Slic3r::PrintObjectBaseWithState< PrintType, PrintObjectStepEnumType, COUNT >::invalidate_steps().

Here is the call graph for this function:

Here is the caller graph for this function:

closest_slice_record()

template<class Container , class T >

static auto Slic3r::SLAPrintObject::closest_slice_record ( Container &  cont, T  lvl, T  eps = std::numeric_limits<T>::max()  ) -> decltype (cont.begin())

inlinestaticprivate

    {
        if(cont.empty()) return cont.end();
        if(cont.size() == 1 && std::abs(level<T>(cont.front()) - lvl) > eps)
            return cont.end();
 
        SliceRecord query = create_slice_record(lvl);
 
        auto it = std::lower_bound(cont.begin(), cont.end(), query,
                                   [](const SliceRecord& r1,
                                      const SliceRecord& r2)
        {
            return level<T>(r1) < level<T>(r2);
        });
        
        if(it == cont.end()) return it;
 
        T diff = std::abs(level<T>(*it) - lvl);
 
        if(it != cont.begin()) {
            auto it_prev = std::prev(it);
            T diff_prev = std::abs(level<T>(*it_prev) - lvl);
            if(diff_prev < diff) { diff = diff_prev; it = it_prev; }
        }
 
        if(diff > eps) it = cont.end();
 
        return it;
    }

References create_slice_record(), and Slic3r::diff().

Referenced by closest_slice_to_print_level(), closest_slice_to_slice_level(), and Slic3r::SLAPrint::Steps::slice_model().

Here is the call graph for this function:

Here is the caller graph for this function:

closest_slice_to_print_level()

const SliceRecord & Slic3r::SLAPrintObject::closest_slice_to_print_level ( coord_t  print_level, coord_t  max_epsilon = std::numeric_limits<coord_t>::max()  ) const

inline

    {
        auto it = closest_slice_record(m_slice_index, print_level, max_epsilon);
        return it == m_slice_index.end() ? SliceRecord::EMPTY : *it;
    }

References closest_slice_record(), Slic3r::SLAPrintObject::SliceRecord::EMPTY, and m_slice_index.

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

Here is the call graph for this function:

Here is the caller graph for this function:

closest_slice_to_slice_level()

const SliceRecord & Slic3r::SLAPrintObject::closest_slice_to_slice_level ( float  slice_level, float  max_epsilon = std::numeric_limits<float>::max()  ) const

inline

    {
        auto it = closest_slice_record(m_slice_index, slice_level, max_epsilon);
        return it == m_slice_index.end() ? SliceRecord::EMPTY : *it;
    }

References closest_slice_record(), Slic3r::SLAPrintObject::SliceRecord::EMPTY, and m_slice_index.

Here is the call graph for this function:

config()

const SLAPrintObjectConfig & Slic3r::SLAPrintObject::config ( ) const

inline

{ return m_config; }

References m_config.

Referenced by Slic3r::SLAPrintStatistics::config(), Slic3r::SLAPrintStatistics::finalize_output_path(), Slic3r::SLAPrintStatistics::placeholders(), Slic3r::SLAPrint::Steps::slice_model(), Slic3r::SLAPrint::Steps::slice_supports(), Slic3r::SLAPrint::Steps::support_points(), Slic3r::SLAPrint::Steps::support_tree(), and Slic3r::GUI::update_arrangepoly_slaprint().

Here is the caller graph for this function:

config_apply()

void Slic3r::SLAPrintObject::config_apply ( const ConfigBase &  other, bool  ignore_nonexistent = false  )

inlineprotected

{ m_config.apply(other, ignore_nonexistent); }

References m_config.

config_apply_only()

void Slic3r::SLAPrintObject::config_apply_only ( const ConfigBase &  other, const t_config_option_keys &  keys, bool  ignore_nonexistent = false  )

inlineprotected

        { m_config.apply_only(other, keys, ignore_nonexistent); }

References m_config.

copy_id()

void Slic3r::ObjectBase::copy_id ( const ObjectBase &  rhs )

inlineprotectedinherited

{ m_id = rhs.id(); }

References Slic3r::ObjectBase::id(), and Slic3r::ObjectBase::m_id.

Referenced by Slic3r::CutObjectBase::copy().

Here is the call graph for this function:

Here is the caller graph for this function:

create_slice_record()

template<class T >

static SliceRecord Slic3r::SLAPrintObject::create_slice_record ( T  val )

inlinestaticprivate

    {
        static_assert(std::is_arithmetic<T>::value, "Arithmetic only!");
        return std::is_integral<T>::value
                   ? SliceRecord{coord_t(val), 0.f, 0.f}
                   : SliceRecord{0, float(val), 0.f};
    }

Referenced by closest_slice_record().

Here is the caller graph for this function:

enable_all_steps_unguarded()

template<typename PrintType , typename PrintObjectStepEnumType , const size_t COUNT>

void Slic3r::PrintObjectBaseWithState< PrintType, PrintObjectStepEnumType, COUNT >::enable_all_steps_unguarded ( bool  enable )

inlineprotectedinherited

{ m_state.enable_all_unguarded(enable); }

References Slic3r::PrintState< StepType, COUNT >::enable_all_unguarded(), and Slic3r::PrintObjectBaseWithState< PrintType, PrintObjectStepEnumType, COUNT >::m_state.

Here is the call graph for this function:

enable_step_unguarded()

template<typename PrintType , typename PrintObjectStepEnumType , const size_t COUNT>

void Slic3r::PrintObjectBaseWithState< PrintType, PrintObjectStepEnumType, COUNT >::enable_step_unguarded ( PrintObjectStepEnum  step, bool  enable  )

inlineprotectedinherited

{ m_state.enable_unguarded(step, enable); }

References Slic3r::PrintState< StepType, COUNT >::enable_unguarded(), and Slic3r::PrintObjectBaseWithState< PrintType, PrintObjectStepEnumType, COUNT >::m_state.

Referenced by Slic3r::PrintBaseWithState< PrintStepEnumType, COUNT >::set_task_impl().

Here is the call graph for this function:

Here is the caller graph for this function:

finalize_impl()

template<typename PrintType , typename PrintObjectStepEnumType , const size_t COUNT>

void Slic3r::PrintObjectBaseWithState< PrintType, PrintObjectStepEnumType, COUNT >::finalize_impl ( )

inlineprotectedinherited

{ m_state.enable_all_unguarded(true); m_state.mark_canceled_unguarded(); }

References Slic3r::PrintState< StepType, COUNT >::enable_all_unguarded(), Slic3r::PrintObjectBaseWithState< PrintType, PrintObjectStepEnumType, COUNT >::m_state, and Slic3r::PrintState< StepType, COUNT >::mark_canceled_unguarded().

Here is the call graph for this function:

generate_new_id()

static ObjectID Slic3r::ObjectBase::generate_new_id ( )

inlinestaticprivateinherited

{ return ObjectID(++ s_last_id); }

References Slic3r::ObjectBase::s_last_id.

Referenced by Slic3r::ObjectBase::set_new_unique_id().

Here is the caller graph for this function:

get_current_elevation()

double Slic3r::SLAPrintObject::get_current_elevation

(

)

const

{
    if (is_zero_elevation(m_config)) return 0.;
 
    bool has_supports = is_step_done(slaposSupportTree);
    bool has_pad      = is_step_done(slaposPad);
 
    if(!has_supports && !has_pad)
        return 0;
    else if(has_supports && !has_pad) {
        return m_config.support_object_elevation.getFloat();
    }
 
    return get_elevation();
}

References get_elevation(), Slic3r::PrintObjectBaseWithState< PrintType, PrintObjectStepEnumType, COUNT >::is_step_done(), Slic3r::is_zero_elevation(), m_config, Slic3r::slaposPad, and Slic3r::slaposSupportTree.

Referenced by Slic3r::GUI::CommonGizmosDataObjects::SelectionInfo::on_update(), Slic3r::GUI::GLCanvas3D::reload_scene(), Slic3r::GUI::GLGizmoHollow::render_points(), Slic3r::GUI::GLGizmoSlaSupports::render_points(), Slic3r::GUI::GLGizmoSlaBase::unproject_on_mesh(), Slic3r::GUI::GLGizmoHollow::update_hole_raycasters_for_picking_transform(), Slic3r::GUI::GLGizmoSlaSupports::update_point_raycasters_for_picking_transform(), and Slic3r::GUI::GLGizmoSlaBase::update_volumes().

Here is the call graph for this function:

Here is the caller graph for this function:

get_elevation()

double Slic3r::SLAPrintObject::get_elevation

(

)

const

                                           {
    if (is_zero_elevation(m_config)) return 0.;
 
    bool en = m_config.supports_enable.getBool();
 
    double ret = en ? m_config.support_object_elevation.getFloat() : 0.;
 
    if(m_config.pad_enable.getBool()) {
        // Normally the elevation for the pad itself would be the thickness of
        // its walls but currently it is half of its thickness. Whatever it
        // will be in the future, we provide the config to the get_pad_elevation
        // method and we will have the correct value
        sla::PadConfig pcfg = make_pad_cfg(m_config);
        if(!pcfg.embed_object) ret += pcfg.required_elevation();
    }
 
    return ret;
}

References Slic3r::sla::PadConfig::embed_object, Slic3r::is_zero_elevation(), m_config, Slic3r::make_pad_cfg(), and Slic3r::sla::PadConfig::required_elevation().

Referenced by get_current_elevation(), Slic3r::SLAPrint::Steps::slice_model(), and Slic3r::GUI::update_arrangepoly_slaprint().

Here is the call graph for this function:

Here is the caller graph for this function:

get_mesh_to_print()

const std::shared_ptr< const indexed_triangle_set > & Slic3r::SLAPrintObject::get_mesh_to_print

(

)

const

{
    int s = last_completed_step();
 
    while (s > 0 && ! m_preview_meshes[s])
        --s;
 
    return m_preview_meshes[s];
}

References Slic3r::PrintObjectBaseWithState< PrintType, PrintObjectStepEnumType, COUNT >::last_completed_step(), and m_preview_meshes.

Referenced by Slic3r::GUI::GLGizmoHollow::data_changed(), Slic3r::GUI::Plater::export_stl_obj(), Slic3r::SLAPrint::Steps::generate_pad(), Slic3r::SLAPrint::Steps::generate_preview(), Slic3r::GLVolumeCollection::load_object_auxiliary(), Slic3r::GUI::CommonGizmosDataObjects::Raycaster::on_update(), Slic3r::GUI::CommonGizmosDataObjects::SupportsClipper::on_update(), Slic3r::SLAPrint::Steps::support_points(), Slic3r::GUI::update_arrangepoly_slaprint(), and Slic3r::GUI::GLGizmoSlaBase::update_volumes().

Here is the call graph for this function:

Here is the caller graph for this function:

get_model_slices()

const std::vector< ExPolygons > & Slic3r::SLAPrintObject::get_model_slices ( ) const

inlineprivate

{ return m_model_slices; }

References m_model_slices.

Referenced by Slic3r::SLAPrintObject::SliceRecord::get_slice(), and Slic3r::SLAPrint::Steps::support_points().

Here is the caller graph for this function:

get_parts_to_slice() [1/2]

std::vector< csg::CSGPart > Slic3r::SLAPrintObject::get_parts_to_slice

(

)

const

{
    return get_parts_to_slice(slaposCount);
}

References get_parts_to_slice(), and Slic3r::slaposCount.

Referenced by get_parts_to_slice(), Slic3r::GLVolumeCollection::load_object_auxiliary(), Slic3r::GUI::CommonGizmosDataObjects::ObjectClipper::on_update(), and Slic3r::GUI::processed_objects_idxs().

Here is the call graph for this function:

Here is the caller graph for this function:

get_parts_to_slice() [2/2]

std::vector< csg::CSGPart > Slic3r::SLAPrintObject::get_parts_to_slice

(

SLAPrintObjectStep

step

)

const

{
    auto laststep = last_completed_step();
    SLAPrintObjectStep s = std::min(untilstep, laststep);
 
    if (s == slaposCount)
        return {};
 
    std::vector<csg::CSGPart> ret;
 
    for (unsigned int step = 0; step < s; ++step) {
        auto r = m_mesh_to_slice.equal_range(SLAPrintObjectStep(step));
        csg::copy_csgrange_shallow(Range{r.first, r.second}, std::back_inserter(ret));
    }
 
    return ret;
}

References Slic3r::csg::copy_csgrange_shallow(), Slic3r::PrintObjectBaseWithState< PrintType, PrintObjectStepEnumType, COUNT >::last_completed_step(), m_mesh_to_slice, and Slic3r::slaposCount.

Here is the call graph for this function:

get_slice_index()

const std::vector< SliceRecord > & Slic3r::SLAPrintObject::get_slice_index ( ) const

inline

                                                          {
        return m_slice_index;
    }

References m_slice_index.

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

Here is the caller graph for this function:

get_support_points()

const std::vector< sla::SupportPoint > & Slic3r::SLAPrintObject::get_support_points

(

)

const

{
    return m_supportdata? m_supportdata->input.pts : EMPTY_SUPPORT_POINTS;
}

References m_supportdata.

get_support_slices()

const std::vector< ExPolygons > & Slic3r::SLAPrintObject::get_support_slices ( ) const

private

{
    // assert(is_step_done(slaposSliceSupports));
    if (!m_supportdata) return EMPTY_SLICES;
    return m_supportdata->support_slices;
}

References m_supportdata.

Referenced by Slic3r::SLAPrintObject::SliceRecord::get_slice().

Here is the caller graph for this function:

id()

ObjectID Slic3r::ObjectBase::id ( ) const

inlineinherited

{ return m_id; }

References Slic3r::ObjectBase::m_id.

Referenced by Slic3r::Model::Model(), Slic3r::ModelInstance::ModelInstance(), Slic3r::ModelMaterial::ModelMaterial(), Slic3r::ModelObject::ModelObject(), Slic3r::ModelObject::ModelObject(), Slic3r::ModelObject::ModelObject(), Slic3r::ModelObject::ModelObject(), Slic3r::ModelObject::ModelObject(), Slic3r::ModelVolume::ModelVolume(), Slic3r::ModelVolume::ModelVolume(), Slic3r::ModelVolume::ModelVolume(), Slic3r::_3MF_Importer::_load_model_from_file(), Slic3r::GUI::Plater::priv::actualize_slicing_warnings(), Slic3r::ModelObjectStatusDB::add(), Slic3r::ModelObjectStatusDB::add_if_new(), Slic3r::Print::apply(), Slic3r::SLAPrint::apply(), Slic3r::GUI::GLGizmoFdmSupports::apply_data_from_backend(), Slic3r::ModelVolume::check(), Slic3r::check_model_ids_equal(), Slic3r::ModelObject::convert_units(), Slic3r::ObjectBase::copy_id(), Slic3r::PrintObjectStatusDB::count(), anonymous_namespace{RaycastManager.cpp}::create_key(), priv::create_volume(), Slic3r::GUI::Emboss::create_volume_sources(), Slic3r::GUI::GLGizmoHollow::data_changed(), Slic3r::GUI::GLGizmoPainterBase::data_changed(), Slic3r::GUI::GLGizmoSlaSupports::data_changed(), Slic3r::Model::delete_object(), Slic3r::GUI::Plater::export_stl_obj(), Slic3r::ModelObjectStatusDB::get(), Slic3r::GUI::get_arrange_poly(), Slic3r::GUI::GLGizmoSlaSupports::get_data_from_backend(), Slic3r::PrintObjectStatusDB::get_range(), Slic3r::GUI::GLGizmoFdmSupports::has_backend_supports(), Slic3r::GUI::GLGizmoSlaSupports::has_backend_supports(), Slic3r::CutObjectBase::has_same_id(), Slic3r::UndoRedo::StackImpl::immutable_object_id_impl(), Slic3r::GUI::GLGizmoSimplify::init_model(), Slic3r::inner_brim_area(), Slic3r::ModelObject::is_cut(), Slic3r::CutObjectBase::is_equal(), Slic3r::ObjectBase::load_and_construct(), Slic3r::UndoRedo::StackImpl::load_snapshot(), Slic3r::GUI::ObjectList::merge(), Slic3r::model_property_changed(), Slic3r::model_volume_list_changed(), Slic3r::model_volume_list_copy_configs(), Slic3r::ModelConfigObject::object_id_and_timestamp_match(), Slic3r::ObjectWithTimestamp::object_id_and_timestamp_match(), Slic3r::GUI::GLGizmoEmboss::on_mouse_change_selection(), Slic3r::GUI::CommonGizmosDataObjects::SelectionInfo::on_update(), Slic3r::CutObjectBase::operator<(), Slic3r::Model::operator=(), Slic3r::ModelObject::operator=(), Slic3r::ModelObject::operator=(), Slic3r::CutObjectBase::operator==(), Slic3r::GUI::GLGizmoCut3D::perform_cut(), Slic3r::GUI::GLGizmoEmboss::process(), Slic3r::GUI::processed_objects_idxs(), Slic3r::GUI::GLCanvas3D::reload_scene(), Slic3r::GUI::GLCanvas3D::LayersEditing::select_object(), Slic3r::ModelMaterial::serialize(), Slic3r::SLAPrintObject::SliceRecord::set_model_slice_idx(), Slic3r::SLAPrintObject::SliceRecord::set_support_slice_idx(), Slic3r::slices_to_regions(), Slic3r::ModelObject::split(), Slic3r::UndoRedo::StackImpl::take_snapshot(), Slic3r::top_level_outer_brim_area(), Slic3r::GUI::update_object_cut_id(), and anonymous_namespace{EmbossJob.cpp}::update_volume_name().

instances()

const std::vector< Instance > & Slic3r::SLAPrintObject::instances ( ) const

inline

{ return m_instances; }

References m_instances.

Referenced by Slic3r::GUI::GLCanvas3D::_render_sla_slices(), Slic3r::get_all_polygons(), and set_instances().

Here is the caller graph for this function:

invalidate_all_steps()

bool Slic3r::SLAPrintObject::invalidate_all_steps ( )

protected

{
    return Inherited::invalidate_all_steps() || m_print->invalidate_all_steps();
}

References Slic3r::PrintObjectBaseWithState< PrintType, PrintObjectStepEnumType, COUNT >::invalidate_all_steps(), and Slic3r::PrintObjectBaseWithState< PrintType, PrintObjectStepEnumType, COUNT >::m_print.

Referenced by invalidate_step().

Here is the call graph for this function:

Here is the caller graph for this function:

invalidate_state_by_config_options()

bool Slic3r::SLAPrintObject::invalidate_state_by_config_options ( const std::vector< t_config_option_key > &  opt_keys )

protected

{
    if (opt_keys.empty())
        return false;
 
    std::vector<SLAPrintObjectStep> steps;
    bool invalidated = false;
    for (const t_config_option_key &opt_key : opt_keys) {
        if (   opt_key == "hollowing_enable"
            || opt_key == "hollowing_min_thickness"
            || opt_key == "hollowing_quality"
            || opt_key == "hollowing_closing_distance"
            ) {
            steps.emplace_back(slaposHollowing);
        } else if (
               opt_key == "layer_height"
            || opt_key == "faded_layers"
            || opt_key == "pad_enable"
            || opt_key == "pad_wall_thickness"
            || opt_key == "supports_enable"
            || opt_key == "support_tree_type"
            || opt_key == "support_object_elevation"
            || opt_key == "branchingsupport_object_elevation"
            || opt_key == "pad_around_object"
            || opt_key == "pad_around_object_everywhere"
            || opt_key == "slice_closing_radius"
            || opt_key == "slicing_mode") {
            steps.emplace_back(slaposObjectSlice);
        } else if (
               opt_key == "support_points_density_relative"
            || opt_key == "support_enforcers_only"
            || opt_key == "support_points_minimal_distance") {
            steps.emplace_back(slaposSupportPoints);
        } else if (
               opt_key == "support_head_front_diameter"
            || opt_key == "support_head_penetration"
            || opt_key == "support_head_width"
            || opt_key == "support_pillar_diameter"
            || opt_key == "support_pillar_widening_factor"
            || opt_key == "support_small_pillar_diameter_percent"
            || opt_key == "support_max_weight_on_model"
            || opt_key == "support_max_bridges_on_pillar"
            || opt_key == "support_pillar_connection_mode"
            || opt_key == "support_buildplate_only"
            || opt_key == "support_base_diameter"
            || opt_key == "support_base_height"
            || opt_key == "support_critical_angle"
            || opt_key == "support_max_bridge_length"
            || opt_key == "support_max_pillar_link_distance"
            || opt_key == "support_base_safety_distance"
 
            || opt_key == "branchingsupport_head_front_diameter"
            || opt_key == "branchingsupport_head_penetration"
            || opt_key == "branchingsupport_head_width"
            || opt_key == "branchingsupport_pillar_diameter"
            || opt_key == "branchingsupport_pillar_widening_factor"
            || opt_key == "branchingsupport_small_pillar_diameter_percent"
            || opt_key == "branchingsupport_max_weight_on_model"
            || opt_key == "branchingsupport_max_bridges_on_pillar"
            || opt_key == "branchingsupport_pillar_connection_mode"
            || opt_key == "branchingsupport_buildplate_only"
            || opt_key == "branchingsupport_base_diameter"
            || opt_key == "branchingsupport_base_height"
            || opt_key == "branchingsupport_critical_angle"
            || opt_key == "branchingsupport_max_bridge_length"
            || opt_key == "branchingsupport_max_pillar_link_distance"
            || opt_key == "branchingsupport_base_safety_distance"
 
            || opt_key == "pad_object_gap"
            ) {
            steps.emplace_back(slaposSupportTree);
        } else if (
               opt_key == "pad_wall_height"
            || opt_key == "pad_brim_size"
            || opt_key == "pad_max_merge_distance"
            || opt_key == "pad_wall_slope"
            || opt_key == "pad_edge_radius"
            || opt_key == "pad_object_connector_stride"
            || opt_key == "pad_object_connector_width"
            || opt_key == "pad_object_connector_penetration"
            ) {
            steps.emplace_back(slaposPad);
        } else {
            // All keys should be covered.
            assert(false);
        }
    }
 
    sort_remove_duplicates(steps);
    for (SLAPrintObjectStep step : steps)
        invalidated |= this->invalidate_step(step);
    return invalidated;
}

References invalidate_step(), Slic3r::slaposHollowing, Slic3r::slaposObjectSlice, Slic3r::slaposPad, Slic3r::slaposSupportPoints, Slic3r::slaposSupportTree, and Slic3r::sort_remove_duplicates().

Here is the call graph for this function:

invalidate_step() [1/2]

template<typename PrintType , typename PrintObjectStepEnumType , const size_t COUNT>

bool Slic3r::PrintObjectBaseWithState< PrintType, PrintObjectStepEnumType, COUNT >::invalidate_step ( PrintObjectStepEnum  step )

inlineprotectedinherited

        { return m_state.invalidate(step, PrintObjectBase::cancel_callback(m_print)); }

References Slic3r::PrintObjectBase::cancel_callback(), Slic3r::PrintState< StepType, COUNT >::invalidate(), Slic3r::PrintObjectBaseWithState< PrintType, PrintObjectStepEnumType, COUNT >::m_print, and Slic3r::PrintObjectBaseWithState< PrintType, PrintObjectStepEnumType, COUNT >::m_state.

Referenced by invalidate_step().

Here is the call graph for this function:

Here is the caller graph for this function:

invalidate_step() [2/2]

bool Slic3r::SLAPrintObject::invalidate_step ( SLAPrintObjectStep  step )

protected

{
    bool invalidated = Inherited::invalidate_step(step);
    // propagate to dependent steps
    if (step == slaposAssembly) {
        invalidated |= this->invalidate_all_steps();
    } else if (step == slaposHollowing) {
        invalidated |= invalidated |= this->invalidate_steps({ slaposDrillHoles, slaposObjectSlice, slaposSupportPoints, slaposSupportTree, slaposPad, slaposSliceSupports });
    } else if (step == slaposDrillHoles) {
        invalidated |= this->invalidate_steps({ slaposObjectSlice, slaposSupportPoints, slaposSupportTree, slaposPad, slaposSliceSupports });
        invalidated |= m_print->invalidate_step(slapsMergeSlicesAndEval);
    } else if (step == slaposObjectSlice) {
        invalidated |= this->invalidate_steps({ slaposSupportPoints, slaposSupportTree, slaposPad, slaposSliceSupports });
        invalidated |= m_print->invalidate_step(slapsMergeSlicesAndEval);
    } else if (step == slaposSupportPoints) {
        invalidated |= this->invalidate_steps({ slaposSupportTree, slaposPad, slaposSliceSupports });
        invalidated |= m_print->invalidate_step(slapsMergeSlicesAndEval);
    } else if (step == slaposSupportTree) {
        invalidated |= this->invalidate_steps({ slaposPad, slaposSliceSupports });
        invalidated |= m_print->invalidate_step(slapsMergeSlicesAndEval);
    } else if (step == slaposPad) {
        invalidated |= this->invalidate_steps({slaposSliceSupports});
        invalidated |= m_print->invalidate_step(slapsMergeSlicesAndEval);
    } else if (step == slaposSliceSupports) {
        invalidated |= m_print->invalidate_step(slapsMergeSlicesAndEval);
    }
    return invalidated;
}

References invalidate_all_steps(), Slic3r::PrintObjectBaseWithState< PrintType, PrintObjectStepEnumType, COUNT >::invalidate_step(), Slic3r::PrintObjectBaseWithState< PrintType, PrintObjectStepEnumType, COUNT >::invalidate_steps(), Slic3r::PrintObjectBaseWithState< PrintType, PrintObjectStepEnumType, COUNT >::m_print, Slic3r::slaposAssembly, Slic3r::slaposDrillHoles, Slic3r::slaposHollowing, Slic3r::slaposObjectSlice, Slic3r::slaposPad, Slic3r::slaposSliceSupports, Slic3r::slaposSupportPoints, Slic3r::slaposSupportTree, and Slic3r::slapsMergeSlicesAndEval.

Referenced by invalidate_state_by_config_options().

Here is the call graph for this function:

Here is the caller graph for this function:

invalidate_steps() [1/2]

template<typename PrintType , typename PrintObjectStepEnumType , const size_t COUNT>

bool Slic3r::PrintObjectBaseWithState< PrintType, PrintObjectStepEnumType, COUNT >::invalidate_steps ( std::initializer_list< PrintObjectStepEnum >  il )

inlineprotectedinherited

        { return m_state.invalidate_multiple(il.begin(), il.end(), PrintObjectBase::cancel_callback(m_print)); }

References Slic3r::PrintObjectBase::cancel_callback(), Slic3r::PrintState< StepType, COUNT >::invalidate_multiple(), Slic3r::PrintObjectBaseWithState< PrintType, PrintObjectStepEnumType, COUNT >::m_print, and Slic3r::PrintObjectBaseWithState< PrintType, PrintObjectStepEnumType, COUNT >::m_state.

Here is the call graph for this function:

invalidate_steps() [2/2]

template<typename PrintType , typename PrintObjectStepEnumType , const size_t COUNT>

template<typename StepTypeIterator >

bool Slic3r::PrintObjectBaseWithState< PrintType, PrintObjectStepEnumType, COUNT >::invalidate_steps ( StepTypeIterator  step_begin, StepTypeIterator  step_end  )

inlineprotectedinherited

        { return m_state.invalidate_multiple(step_begin, step_end, PrintObjectBase::cancel_callback(m_print)); }

References Slic3r::PrintObjectBase::cancel_callback(), Slic3r::PrintState< StepType, COUNT >::invalidate_multiple(), Slic3r::PrintObjectBaseWithState< PrintType, PrintObjectStepEnumType, COUNT >::m_print, and Slic3r::PrintObjectBaseWithState< PrintType, PrintObjectStepEnumType, COUNT >::m_state.

Referenced by invalidate_step().

Here is the call graph for this function:

Here is the caller graph for this function:

is_left_handed()

bool Slic3r::SLAPrintObject::is_left_handed ( ) const

inline

{ return m_left_handed; }

References m_left_handed.

Referenced by Slic3r::GUI::GLCanvas3D::_render_sla_slices(), and Slic3r::get_all_polygons().

Here is the caller graph for this function:

is_step_done()

template<typename PrintType , typename PrintObjectStepEnumType , const size_t COUNT>

bool Slic3r::PrintObjectBaseWithState< PrintType, PrintObjectStepEnumType, COUNT >::is_step_done ( PrintObjectStepEnum  step ) const

inlineinherited

{ return m_state.is_done(step, PrintObjectBase::state_mutex(m_print)); }

References Slic3r::PrintState< StepType, COUNT >::is_done(), Slic3r::PrintObjectBaseWithState< PrintType, PrintObjectStepEnumType, COUNT >::m_print, Slic3r::PrintObjectBaseWithState< PrintType, PrintObjectStepEnumType, COUNT >::m_state, and Slic3r::PrintObjectBase::state_mutex().

Referenced by Slic3r::GUI::GLCanvas3D::_load_print_object_toolpaths(), Slic3r::GUI::GLCanvas3D::_render_sla_slices(), get_current_elevation(), pad_mesh(), and support_mesh().

Here is the call graph for this function:

Here is the caller graph for this function:

is_step_done_unguarded()

template<typename PrintType , typename PrintObjectStepEnumType , const size_t COUNT>

bool Slic3r::PrintObjectBaseWithState< PrintType, PrintObjectStepEnumType, COUNT >::is_step_done_unguarded ( PrintObjectStepEnum  step ) const

inlineprotectedinherited

{ return m_state.is_done_unguarded(step); }

References Slic3r::PrintState< StepType, COUNT >::is_done_unguarded(), and Slic3r::PrintObjectBaseWithState< PrintType, PrintObjectStepEnumType, COUNT >::m_state.

Referenced by Slic3r::PrintObjectBaseWithState< PrintType, PrintObjectStepEnumType, COUNT >::last_completed_step().

Here is the call graph for this function:

Here is the caller graph for this function:

is_step_enabled_unguarded()

template<typename PrintType , typename PrintObjectStepEnumType , const size_t COUNT>

bool Slic3r::PrintObjectBaseWithState< PrintType, PrintObjectStepEnumType, COUNT >::is_step_enabled_unguarded ( PrintObjectStepEnum  step ) const

inlineprotectedinherited

{ return m_state.is_enabled_unguarded(step); }

References Slic3r::PrintState< StepType, COUNT >::is_enabled_unguarded(), and Slic3r::PrintObjectBaseWithState< PrintType, PrintObjectStepEnumType, COUNT >::m_state.

Referenced by Slic3r::PrintBaseWithState< PrintStepEnumType, COUNT >::set_task_impl().

Here is the call graph for this function:

Here is the caller graph for this function:

is_step_started_unguarded()

template<typename PrintType , typename PrintObjectStepEnumType , const size_t COUNT>

bool Slic3r::PrintObjectBaseWithState< PrintType, PrintObjectStepEnumType, COUNT >::is_step_started_unguarded ( PrintObjectStepEnum  step ) const

inlineprotectedinherited

{ return m_state.is_started_unguarded(step); }

References Slic3r::PrintState< StepType, COUNT >::is_started_unguarded(), and Slic3r::PrintObjectBaseWithState< PrintType, PrintObjectStepEnumType, COUNT >::m_state.

Referenced by Slic3r::PrintBaseWithState< PrintStepEnumType, COUNT >::set_task_impl().

Here is the call graph for this function:

Here is the caller graph for this function:

last_completed_step()

template<typename PrintType , typename PrintObjectStepEnumType , const size_t COUNT>

auto Slic3r::PrintObjectBaseWithState< PrintType, PrintObjectStepEnumType, COUNT >::last_completed_step ( ) const

inlineinherited

    {
        static_assert(COUNT > 0, "Step count should be > 0");
        auto s = int(COUNT) - 1;
 
        std::lock_guard lk(state_mutex(m_print));
        while (s >= 0 && ! is_step_done_unguarded(PrintObjectStepEnum(s)))
            --s;
 
        if (s < 0)
            s = COUNT;
 
        return PrintObjectStepEnum(s);
    }

References Slic3r::PrintObjectBaseWithState< PrintType, PrintObjectStepEnumType, COUNT >::is_step_done_unguarded(), Slic3r::PrintObjectBaseWithState< PrintType, PrintObjectStepEnumType, COUNT >::m_print, and Slic3r::PrintObjectBase::state_mutex().

Referenced by Slic3r::GUI::GLGizmoSlaSupports::data_changed(), get_mesh_to_print(), get_parts_to_slice(), Slic3r::GUI::update_arrangepoly_slaprint(), and Slic3r::GUI::GLGizmoSlaBase::update_volumes().

Here is the call graph for this function:

Here is the caller graph for this function:

level()

template<class T >

static T Slic3r::SLAPrintObject::level ( const SliceRecord &  sr )

inlinestaticprivate

    {
        static_assert(std::is_arithmetic<T>::value, "Arithmetic only!");
        return std::is_integral<T>::value ? T(sr.print_level())
                                          : T(sr.slice_level());
    }

References Slic3r::SLAPrintObject::SliceRecord::print_level(), and Slic3r::SLAPrintObject::SliceRecord::slice_level().

Here is the call graph for this function:

load_and_construct()

template<class Archive >

static void Slic3r::ObjectBase::load_and_construct ( Archive &  ar, cereal::construct< ObjectBase > &  construct  )

inlinestaticprivateinherited

{ ObjectID id; ar(id); construct(id); }

References Slic3r::ObjectBase::id().

Here is the call graph for this function:

mesh_to_slice() [1/2]

auto Slic3r::SLAPrintObject::mesh_to_slice ( ) const

inlineprivate

{ return range(m_mesh_to_slice); }

References Slic3r::range().

Here is the call graph for this function:

mesh_to_slice() [2/2]

auto Slic3r::SLAPrintObject::mesh_to_slice ( SLAPrintObjectStep  s ) const

inlineprivate

    {
        auto r = m_mesh_to_slice.equal_range(s);
 
        return Range{r.first, r.second};
    }

Referenced by Slic3r::SLAPrint::Steps::generate_preview(), Slic3r::SLAPrint::Steps::hollow_model(), and Slic3r::SLAPrint::Steps::slice_model().

Here is the caller graph for this function:

model_object() [1/2]

ModelObject * Slic3r::PrintObjectBase::model_object ( )

inlineinherited

{ return m_model_object; }

References Slic3r::PrintObjectBase::m_model_object.

model_object() [2/2]

const ModelObject * Slic3r::PrintObjectBase::model_object ( ) const

inlineinherited

{ return m_model_object; }

References Slic3r::PrintObjectBase::m_model_object.

Referenced by Slic3r::PrintObject::PrintObject(), Slic3r::GUI::GLCanvas3D::_set_warning_notification(), Slic3r::Print::apply(), Slic3r::SLAPrint::apply(), Slic3r::SeamPlacerImpl::compute_global_occlusion(), Slic3r::SLAPrint::Steps::drill_holes(), Slic3r::GUI::Plater::export_stl_obj(), Slic3r::SeamPlacerImpl::gather_enforcers_blockers(), Slic3r::PrintObject::is_mm_painted(), Slic3r::GLVolumeCollection::load_object_auxiliary(), Slic3r::SLAPrint::Steps::mesh_assembly(), Slic3r::mmu_segmentation_top_and_bottom_layers(), Slic3r::multi_material_segmentation_by_painting(), Slic3r::GCode::process_layer_single_object(), Slic3r::SLAPrint::Steps::slice_model(), Slic3r::SLAPrint::Steps::support_points(), transformed_drainhole_points(), transformed_support_points(), Slic3r::GUI::GLGizmoSlaBase::update_volumes(), and Slic3r::Print::validate().

Here is the caller graph for this function:

operator=()

SLAPrintObject & Slic3r::SLAPrintObject::operator= ( const SLAPrintObject &  )

delete

pad_mesh()

const TriangleMesh & Slic3r::SLAPrintObject::pad_mesh

(

)

const

{
    if(m_config.pad_enable.getBool() && is_step_done(slaposPad) && m_supportdata)
        return m_supportdata->pad_mesh;
 
    return EMPTY_MESH;
}

References Slic3r::PrintObjectBaseWithState< PrintType, PrintObjectStepEnumType, COUNT >::is_step_done(), m_config, m_supportdata, and Slic3r::slaposPad.

Referenced by Slic3r::GLVolumeCollection::load_object_auxiliary(), Slic3r::GUI::CommonGizmosDataObjects::SupportsClipper::on_update(), and Slic3r::GUI::GLGizmoSlaBase::update_volumes().

Here is the call graph for this function:

Here is the caller graph for this function:

print() [1/2]

template<typename PrintType , typename PrintObjectStepEnumType , const size_t COUNT>

PrintType * Slic3r::PrintObjectBaseWithState< PrintType, PrintObjectStepEnumType, COUNT >::print ( )

inlineinherited

{ return m_print; }

References Slic3r::PrintObjectBaseWithState< PrintType, PrintObjectStepEnumType, COUNT >::m_print.

Referenced by Slic3r::FillLightning::Generator::Generator(), Slic3r::FFFTreeSupport::TreeSupportMeshGroupSettings::TreeSupportMeshGroupSettings(), Slic3r::FillAdaptive::adaptive_fill_line_spacing(), Slic3r::LayerRegion::bridging_flow(), Slic3r::fff_tree_support_generate(), Slic3r::FFFTreeSupport::generate_overhangs(), Slic3r::get_boundary_external(), Slic3r::get_default_perimeter_spacing(), Slic3r::get_perimeter_spacing_external(), Slic3r::LayerRegion::make_perimeters(), Slic3r::mmu_segmentation_top_and_bottom_layers(), Slic3r::multi_material_segmentation_by_painting(), Slic3r::GCode::process_layer_single_object(), Slic3r::support_material_flow(), and Slic3r::support_material_interface_flow().

Here is the caller graph for this function:

print() [2/2]

template<typename PrintType , typename PrintObjectStepEnumType , const size_t COUNT>

const PrintType * Slic3r::PrintObjectBaseWithState< PrintType, PrintObjectStepEnumType, COUNT >::print ( ) const

inlineinherited

{ return m_print; }

References Slic3r::PrintObjectBaseWithState< PrintType, PrintObjectStepEnumType, COUNT >::m_print.

query_reset_dirty_step_unguarded()

template<typename PrintType , typename PrintObjectStepEnumType , const size_t COUNT>

bool Slic3r::PrintObjectBaseWithState< PrintType, PrintObjectStepEnumType, COUNT >::query_reset_dirty_step_unguarded ( PrintObjectStepEnum  step )

inlineprotectedinherited

{ return m_state.query_reset_dirty_unguarded(step); }

References Slic3r::PrintObjectBaseWithState< PrintType, PrintObjectStepEnumType, COUNT >::m_state, and Slic3r::PrintState< StepType, COUNT >::query_reset_dirty_unguarded().

Here is the call graph for this function:

serialize()

template<class Archive >

void Slic3r::ObjectBase::serialize ( Archive &  ar )

inlineprivateinherited

{ ar(m_id); }

References Slic3r::ObjectBase::m_id.

set_done()

template<typename PrintType , typename PrintObjectStepEnumType , const size_t COUNT>

PrintStateBase::TimeStamp Slic3r::PrintObjectBaseWithState< PrintType, PrintObjectStepEnumType, COUNT >::set_done ( PrintObjectStepEnum  step )

inlineprotectedinherited

                                                             { 
    std::pair<PrintStateBase::TimeStamp, bool> status = m_state.set_done(step, PrintObjectBase::state_mutex(m_print), [this](){ this->throw_if_canceled(); });
        if (status.second)
            this->status_update_warnings(m_print, static_cast<int>(step), PrintStateBase::WarningLevel::NON_CRITICAL, std::string());
        return status.first;
  }

References Slic3r::PrintObjectBaseWithState< PrintType, PrintObjectStepEnumType, COUNT >::m_print, Slic3r::PrintObjectBaseWithState< PrintType, PrintObjectStepEnumType, COUNT >::m_state, Slic3r::PrintStateBase::NON_CRITICAL, Slic3r::PrintState< StepType, COUNT >::set_done(), Slic3r::PrintObjectBase::state_mutex(), Slic3r::PrintObjectBase::status_update_warnings(), and Slic3r::PrintObjectBaseWithState< PrintType, PrintObjectStepEnumType, COUNT >::throw_if_canceled().

Here is the call graph for this function:

set_instances()

template<class InstVec >

void Slic3r::SLAPrintObject::set_instances ( InstVec &&  instances )

inlineprotected

{ m_instances = std::forward<InstVec>(instances); }

References instances(), and m_instances.

Here is the call graph for this function:

set_invalid_id()

void Slic3r::ObjectBase::set_invalid_id ( )

inlineprotectedinherited

{ m_id = 0; }

References Slic3r::ObjectBase::m_id.

Referenced by Slic3r::CutObjectBase::invalidate().

Here is the caller graph for this function:

set_new_unique_id()

void Slic3r::ObjectBase::set_new_unique_id ( )

inlineprotectedinherited

{ m_id = generate_new_id(); }

References Slic3r::ObjectBase::generate_new_id(), and Slic3r::ObjectBase::m_id.

Referenced by Slic3r::ModelVolume::ModelVolume(), Slic3r::Model::assign_new_unique_ids_recursive(), Slic3r::ObjectBase::assign_new_unique_ids_recursive(), Slic3r::ModelObject::assign_new_unique_ids_recursive(), Slic3r::CutObjectBase::init(), Slic3r::ModelMaterial::set_new_unique_id(), Slic3r::ModelObject::set_new_unique_id(), and Slic3r::ModelVolume::set_new_unique_id().

Here is the call graph for this function:

Here is the caller graph for this function:

set_started()

template<typename PrintType , typename PrintObjectStepEnumType , const size_t COUNT>

bool Slic3r::PrintObjectBaseWithState< PrintType, PrintObjectStepEnumType, COUNT >::set_started ( PrintObjectStepEnum  step )

inlineprotectedinherited

        { return m_state.set_started(step, PrintObjectBase::state_mutex(m_print), [this](){ this->throw_if_canceled(); }); }

References Slic3r::PrintObjectBaseWithState< PrintType, PrintObjectStepEnumType, COUNT >::m_print, Slic3r::PrintObjectBaseWithState< PrintType, PrintObjectStepEnumType, COUNT >::m_state, Slic3r::PrintState< StepType, COUNT >::set_started(), Slic3r::PrintObjectBase::state_mutex(), and Slic3r::PrintObjectBaseWithState< PrintType, PrintObjectStepEnumType, COUNT >::throw_if_canceled().

Here is the call graph for this function:

set_trafo()

void Slic3r::SLAPrintObject::set_trafo ( const Transform3d &  trafo, bool  left_handed  )

inlineprotected

                                                                                  {
        m_trafo = trafo;
        m_left_handed = left_handed;
    }

References m_left_handed, m_trafo, and trafo().

Here is the call graph for this function:

state_mutex()

std::mutex & Slic3r::PrintObjectBase::state_mutex ( PrintBase *  print )

staticprotectedinherited

{ 
  return print->state_mutex();
}

References Slic3r::PrintBase::state_mutex().

Referenced by Slic3r::PrintObjectBaseWithState< PrintType, PrintObjectStepEnumType, COUNT >::active_step_add_warning(), Slic3r::PrintObjectBaseWithState< PrintType, PrintObjectStepEnumType, COUNT >::is_step_done(), Slic3r::PrintObjectBaseWithState< PrintType, PrintObjectStepEnumType, COUNT >::last_completed_step(), Slic3r::PrintObjectBaseWithState< PrintType, PrintObjectStepEnumType, COUNT >::set_done(), Slic3r::PrintObjectBaseWithState< PrintType, PrintObjectStepEnumType, COUNT >::set_started(), Slic3r::PrintObjectBaseWithState< PrintType, PrintObjectStepEnumType, COUNT >::step_state_with_timestamp(), and Slic3r::PrintObjectBaseWithState< PrintType, PrintObjectStepEnumType, COUNT >::step_state_with_warnings().

Here is the call graph for this function:

Here is the caller graph for this function:

status_update_warnings()

void Slic3r::PrintObjectBase::status_update_warnings ( PrintBase *  print, int  step, PrintStateBase::WarningLevel  warning_level, const std::string &  message  )

protectedinherited

{
    print->status_update_warnings(step, warning_level, message, this);
}

References Slic3r::PrintBase::status_update_warnings().

Referenced by Slic3r::PrintObjectBaseWithState< PrintType, PrintObjectStepEnumType, COUNT >::active_step_add_warning(), and Slic3r::PrintObjectBaseWithState< PrintType, PrintObjectStepEnumType, COUNT >::set_done().

Here is the call graph for this function:

Here is the caller graph for this function:

step_state_with_timestamp()

template<typename PrintType , typename PrintObjectStepEnumType , const size_t COUNT>

PrintStateBase::StateWithTimeStamp Slic3r::PrintObjectBaseWithState< PrintType, PrintObjectStepEnumType, COUNT >::step_state_with_timestamp ( PrintObjectStepEnum  step ) const

inlineinherited

{ return m_state.state_with_timestamp(step, PrintObjectBase::state_mutex(m_print)); }

References Slic3r::PrintObjectBaseWithState< PrintType, PrintObjectStepEnumType, COUNT >::m_print, Slic3r::PrintObjectBaseWithState< PrintType, PrintObjectStepEnumType, COUNT >::m_state, Slic3r::PrintObjectBase::state_mutex(), and Slic3r::PrintState< StepType, COUNT >::state_with_timestamp().

Here is the call graph for this function:

step_state_with_warnings()

template<typename PrintType , typename PrintObjectStepEnumType , const size_t COUNT>

PrintStateBase::StateWithWarnings Slic3r::PrintObjectBaseWithState< PrintType, PrintObjectStepEnumType, COUNT >::step_state_with_warnings ( PrintObjectStepEnum  step ) const

inlineinherited

{ return m_state.state_with_warnings(step, PrintObjectBase::state_mutex(m_print)); }

References Slic3r::PrintObjectBaseWithState< PrintType, PrintObjectStepEnumType, COUNT >::m_print, Slic3r::PrintObjectBaseWithState< PrintType, PrintObjectStepEnumType, COUNT >::m_state, Slic3r::PrintObjectBase::state_mutex(), and Slic3r::PrintState< StepType, COUNT >::state_with_warnings().

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

Here is the call graph for this function:

Here is the caller graph for this function:

support_mesh()

const TriangleMesh & Slic3r::SLAPrintObject::support_mesh

(

)

const

{
    if (m_config.supports_enable.getBool() &&
        is_step_done(slaposSupportTree) &&
        m_supportdata)
        return m_supportdata->tree_mesh;
 
    return EMPTY_MESH;
}

References Slic3r::PrintObjectBaseWithState< PrintType, PrintObjectStepEnumType, COUNT >::is_step_done(), m_config, m_supportdata, and Slic3r::slaposSupportTree.

Referenced by Slic3r::GLVolumeCollection::load_object_auxiliary(), Slic3r::GUI::CommonGizmosDataObjects::SupportsClipper::on_update(), Slic3r::SLAPrint::Steps::support_tree(), Slic3r::GUI::update_arrangepoly_slaprint(), and Slic3r::GUI::GLGizmoSlaBase::update_volumes().

Here is the call graph for this function:

Here is the caller graph for this function:

throw_if_canceled()

template<typename PrintType , typename PrintObjectStepEnumType , const size_t COUNT>

void Slic3r::PrintObjectBaseWithState< PrintType, PrintObjectStepEnumType, COUNT >::throw_if_canceled ( )

inlineprotectedinherited

{ if (m_print->canceled()) throw CanceledException(); }

References Slic3r::PrintObjectBaseWithState< PrintType, PrintObjectStepEnumType, COUNT >::m_print.

Referenced by Slic3r::PrintObjectBaseWithState< PrintType, PrintObjectStepEnumType, COUNT >::set_done(), and Slic3r::PrintObjectBaseWithState< PrintType, PrintObjectStepEnumType, COUNT >::set_started().

Here is the caller graph for this function:

timestamp()

virtual Timestamp Slic3r::ObjectBase::timestamp ( ) const

inlinevirtualinherited

Reimplemented in Slic3r::ModelConfigObject, and Slic3r::ObjectWithTimestamp.

{ return 0; }

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

Here is the caller graph for this function:

trafo()

const Transform3d & Slic3r::SLAPrintObject::trafo ( ) const

inline

{ return m_trafo; }

References m_trafo.

Referenced by Slic3r::SLAPrint::apply(), Slic3r::SLAPrint::Steps::drill_holes(), Slic3r::GLVolumeCollection::load_object_auxiliary(), Slic3r::SLAPrint::Steps::mesh_assembly(), Slic3r::GUI::CommonGizmosDataObjects::Raycaster::on_update(), Slic3r::GUI::CommonGizmosDataObjects::ObjectClipper::on_update(), Slic3r::GUI::CommonGizmosDataObjects::SupportsClipper::render_cut(), set_trafo(), Slic3r::SLAPrint::Steps::support_points(), transformed_drainhole_points(), transformed_support_points(), Slic3r::GUI::update_arrangepoly_slaprint(), and Slic3r::GUI::GLGizmoSlaBase::update_volumes().

Here is the caller graph for this function:

transformed_drainhole_points()

sla::DrainHoles Slic3r::SLAPrintObject::transformed_drainhole_points

(

)

const

{
    assert(model_object());
 
    return sla::transformed_drainhole_points(*model_object(), trafo());
}

References Slic3r::PrintObjectBase::model_object(), trafo(), and Slic3r::sla::transformed_drainhole_points().

Referenced by Slic3r::SLAPrint::Steps::generate_preview().

Here is the call graph for this function:

Here is the caller graph for this function:

transformed_support_points()

sla::SupportPoints Slic3r::SLAPrintObject::transformed_support_points

(

)

const

{
    assert(model_object());
 
    return sla::transformed_support_points(*model_object(), trafo());
}

References Slic3r::PrintObjectBase::model_object(), trafo(), and Slic3r::sla::transformed_support_points().

Referenced by Slic3r::SLAPrint::Steps::support_points().

Here is the call graph for this function:

Here is the caller graph for this function:

Friends And Related Symbol Documentation

PrintBaseWithState< SLAPrintStep, slapsCount >

friend class PrintBaseWithState< SLAPrintStep, slapsCount >

friend

SLAPrint

friend class SLAPrint

friend

Member Data Documentation

m_config

SLAPrintObjectConfig Slic3r::SLAPrintObject::m_config

private

Referenced by Slic3r::SLAPrint::Steps::apply_printer_corrections(), config(), config_apply(), config_apply_only(), Slic3r::SLAPrint::Steps::generate_pad(), Slic3r::SLAPrint::Steps::generate_preview_vdb(), get_current_elevation(), get_elevation(), Slic3r::SLAPrint::Steps::hollow_model(), pad_mesh(), Slic3r::SLAPrint::Steps::slice_supports(), support_mesh(), Slic3r::SLAPrint::Steps::support_points(), and Slic3r::SLAPrint::Steps::support_tree().

m_hollowing_data

std::unique_ptr<HollowingData> Slic3r::SLAPrintObject::m_hollowing_data

private

Referenced by Slic3r::SLAPrint::Steps::drill_holes(), Slic3r::SLAPrint::Steps::generate_preview(), Slic3r::SLAPrint::Steps::hollow_model(), and Slic3r::SLAPrint::Steps::mesh_assembly().

m_id

ObjectID Slic3r::ObjectBase::m_id

privateinherited

Referenced by Slic3r::ObjectBase::copy_id(), Slic3r::ObjectBase::id(), Slic3r::ObjectBase::serialize(), Slic3r::ObjectBase::set_invalid_id(), and Slic3r::ObjectBase::set_new_unique_id().

m_instances

std::vector<Instance> Slic3r::SLAPrintObject::m_instances

private

Referenced by instances(), and set_instances().

m_left_handed

bool Slic3r::SLAPrintObject::m_left_handed = false

private

Referenced by is_left_handed(), and set_trafo().

m_mesh_to_slice

CSGContainer Slic3r::SLAPrintObject::m_mesh_to_slice

private

Referenced by Slic3r::SLAPrint::Steps::drill_holes(), Slic3r::SLAPrint::Steps::generate_preview(), Slic3r::SLAPrint::Steps::generate_preview_vdb(), get_parts_to_slice(), Slic3r::SLAPrint::Steps::hollow_model(), Slic3r::SLAPrint::Steps::mesh_assembly(), Slic3r::SLAPrint::Steps::slice_model(), and Slic3r::SLAPrint::Steps::support_points().

m_model_height_levels

std::vector<float> Slic3r::SLAPrintObject::m_model_height_levels

private

Referenced by Slic3r::SLAPrint::Steps::slice_model(), and Slic3r::SLAPrint::Steps::support_points().

m_model_object

ModelObject* Slic3r::PrintObjectBase::m_model_object

protectedinherited

Referenced by Slic3r::SLAPrint::Steps::generate_preview(), Slic3r::PrintObjectBase::model_object(), Slic3r::PrintObjectBase::model_object(), and Slic3r::SLAPrint::Steps::support_points().

m_model_slices

std::vector<ExPolygons> Slic3r::SLAPrintObject::m_model_slices

private

Referenced by Slic3r::SLAPrint::Steps::apply_printer_corrections(), get_model_slices(), and Slic3r::SLAPrint::Steps::slice_model().

m_preview_meshes

std::array<std::shared_ptr<const indexed_triangle_set>, SLAPrintObjectStep::slaposCount + 1> Slic3r::SLAPrintObject::m_preview_meshes

private

Referenced by Slic3r::SLAPrint::Steps::generate_preview(), and get_mesh_to_print().

m_print

template<typename PrintType , typename PrintObjectStepEnumType , const size_t COUNT>

PrintType* Slic3r::PrintObjectBaseWithState< PrintType, PrintObjectStepEnumType, COUNT >::m_print

protectedinherited

Referenced by Slic3r::PrintObjectBaseWithState< PrintType, PrintObjectStepEnumType, COUNT >::active_step_add_warning(), Slic3r::SLAPrint::Steps::generate_preview_vdb(), Slic3r::PrintObjectBaseWithState< PrintType, PrintObjectStepEnumType, COUNT >::invalidate_all_steps(), invalidate_all_steps(), Slic3r::PrintObjectBaseWithState< PrintType, PrintObjectStepEnumType, COUNT >::invalidate_step(), invalidate_step(), Slic3r::PrintObjectBaseWithState< PrintType, PrintObjectStepEnumType, COUNT >::invalidate_steps(), Slic3r::PrintObjectBaseWithState< PrintType, PrintObjectStepEnumType, COUNT >::invalidate_steps(), Slic3r::PrintObjectBaseWithState< PrintType, PrintObjectStepEnumType, COUNT >::is_step_done(), Slic3r::PrintObjectBaseWithState< PrintType, PrintObjectStepEnumType, COUNT >::last_completed_step(), Slic3r::PrintObjectBaseWithState< PrintType, PrintObjectStepEnumType, COUNT >::print(), Slic3r::PrintObjectBaseWithState< PrintType, PrintObjectStepEnumType, COUNT >::print(), Slic3r::PrintObjectBaseWithState< PrintType, PrintObjectStepEnumType, COUNT >::set_done(), Slic3r::PrintObjectBaseWithState< PrintType, PrintObjectStepEnumType, COUNT >::set_started(), Slic3r::PrintObjectBaseWithState< PrintType, PrintObjectStepEnumType, COUNT >::step_state_with_timestamp(), Slic3r::PrintObjectBaseWithState< PrintType, PrintObjectStepEnumType, COUNT >::step_state_with_warnings(), and Slic3r::PrintObjectBaseWithState< PrintType, PrintObjectStepEnumType, COUNT >::throw_if_canceled().

m_slice_index

std::vector<SliceRecord> Slic3r::SLAPrintObject::m_slice_index

private

Referenced by Slic3r::SLAPrint::Steps::apply_printer_corrections(), closest_slice_to_print_level(), closest_slice_to_slice_level(), get_slice_index(), Slic3r::SLAPrint::Steps::slice_model(), and Slic3r::SLAPrint::Steps::slice_supports().

m_state

template<typename PrintType , typename PrintObjectStepEnumType , const size_t COUNT>

PrintState<PrintObjectStepEnum, COUNT> Slic3r::PrintObjectBaseWithState< PrintType, PrintObjectStepEnumType, COUNT >::m_state

privateinherited

Referenced by Slic3r::PrintObjectBaseWithState< PrintType, PrintObjectStepEnumType, COUNT >::active_step_add_warning(), Slic3r::PrintObjectBaseWithState< PrintType, PrintObjectStepEnumType, COUNT >::enable_all_steps_unguarded(), Slic3r::PrintObjectBaseWithState< PrintType, PrintObjectStepEnumType, COUNT >::enable_step_unguarded(), Slic3r::PrintObjectBaseWithState< PrintType, PrintObjectStepEnumType, COUNT >::finalize_impl(), Slic3r::PrintObjectBaseWithState< PrintType, PrintObjectStepEnumType, COUNT >::invalidate_all_steps(), Slic3r::PrintObjectBaseWithState< PrintType, PrintObjectStepEnumType, COUNT >::invalidate_step(), Slic3r::PrintObjectBaseWithState< PrintType, PrintObjectStepEnumType, COUNT >::invalidate_steps(), Slic3r::PrintObjectBaseWithState< PrintType, PrintObjectStepEnumType, COUNT >::invalidate_steps(), Slic3r::PrintObjectBaseWithState< PrintType, PrintObjectStepEnumType, COUNT >::is_step_done(), Slic3r::PrintObjectBaseWithState< PrintType, PrintObjectStepEnumType, COUNT >::is_step_done_unguarded(), Slic3r::PrintObjectBaseWithState< PrintType, PrintObjectStepEnumType, COUNT >::is_step_enabled_unguarded(), Slic3r::PrintObjectBaseWithState< PrintType, PrintObjectStepEnumType, COUNT >::is_step_started_unguarded(), Slic3r::PrintObjectBaseWithState< PrintType, PrintObjectStepEnumType, COUNT >::query_reset_dirty_step_unguarded(), Slic3r::PrintObjectBaseWithState< PrintType, PrintObjectStepEnumType, COUNT >::set_done(), Slic3r::PrintObjectBaseWithState< PrintType, PrintObjectStepEnumType, COUNT >::set_started(), Slic3r::PrintObjectBaseWithState< PrintType, PrintObjectStepEnumType, COUNT >::step_state_with_timestamp(), and Slic3r::PrintObjectBaseWithState< PrintType, PrintObjectStepEnumType, COUNT >::step_state_with_warnings().

m_supportdata

std::unique_ptr<SupportData> Slic3r::SLAPrintObject::m_supportdata

private

Referenced by Slic3r::SLAPrint::Steps::apply_printer_corrections(), Slic3r::SLAPrint::Steps::drill_holes(), Slic3r::SLAPrint::Steps::generate_pad(), get_support_points(), get_support_slices(), Slic3r::SLAPrint::Steps::hollow_model(), Slic3r::SLAPrint::Steps::mesh_assembly(), pad_mesh(), Slic3r::SLAPrint::Steps::slice_supports(), support_mesh(), Slic3r::SLAPrint::Steps::support_points(), and Slic3r::SLAPrint::Steps::support_tree().

m_trafo

Transform3d Slic3r::SLAPrintObject::m_trafo = Transform3d::Identity()

private

Referenced by set_trafo(), and trafo().

PrintObjectStepEnumSize

template<typename PrintType , typename PrintObjectStepEnumType , const size_t COUNT>

constexpr const size_t Slic3r::PrintObjectBaseWithState< PrintType, PrintObjectStepEnumType, COUNT >::PrintObjectStepEnumSize = COUNT

staticconstexprinherited

PrintType

template<typename PrintType , typename PrintObjectStepEnumType , const size_t COUNT>

friend Slic3r::PrintObjectBaseWithState< PrintType, PrintObjectStepEnumType, COUNT >::PrintType

protectedinherited

s_last_id

size_t Slic3r::ObjectBase::s_last_id = 0

staticprivateinherited

Referenced by Slic3r::ObjectBase::generate_new_id().

---

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

• src/libslic3r/SLAPrint.hpp
• src/libslic3r/SLAPrint.cpp