#include </home/runner/work/OrcaSlicer/OrcaSlicer/src/libslic3r/Print.hpp>

Collaboration diagram for Slic3r::WipeTowerData:

Classes
struct	WipeTowerMeshData

Public Member Functions
void	clear ()
void	construct_mesh (float width, float depth, float height, float brim_width, bool is_rib_wipe_tower, float rib_width, float rib_length, bool fillet_wall, float cone_angle=0.f)

Public Attributes
ToolOrdering &	tool_ordering
std::unique_ptr< std::vector< WipeTower::ToolChangeResult > >	priming
std::vector< std::vector< WipeTower::ToolChangeResult > >	tool_changes
std::unique_ptr< WipeTower::ToolChangeResult >	final_purge
std::vector< float >	used_filament
int	number_of_toolchanges
float	depth
float	width
std::vector< std::pair< float, float > >	z_and_depth_pairs
float	brim_width
float	height
BoundingBoxf	bbx
Vec2f	rib_offset
std::optional< WipeTowerMeshData >	wipe_tower_mesh_data

Private Member Functions
	WipeTowerData (ToolOrdering &tool_ordering)
	WipeTowerData (const WipeTowerData &)=delete
WipeTowerData &	operator= (const WipeTowerData &)=delete

Friends
class	Print

Detailed Description

Class Documentation

◆ Slic3r::WipeTowerData::WipeTowerMeshData

struct Slic3r::WipeTowerData::WipeTowerMeshData

Collaboration diagram for Slic3r::WipeTowerData::WipeTowerMeshData:

Class Members
Polygon	bottom
TriangleMesh	real_brim_mesh
TriangleMesh	real_wipe_tower_mesh

Constructor & Destructor Documentation

◆ WipeTowerData() [1/2]

Slic3r::WipeTowerData::WipeTowerData ( ToolOrdering & tool_ordering )

inlineprivate

949: tool_ordering(tool_ordering) { clear(); }

Slic3r::WipeTowerData::clear

void clear()

Definition Print.hpp:930

Slic3r::WipeTowerData::tool_ordering

ToolOrdering & tool_ordering

Definition Print.hpp:911

References clear(), and tool_ordering.

Referenced by WipeTowerData(), and operator=().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ WipeTowerData() [2/2]

Slic3r::WipeTowerData::WipeTowerData ( const WipeTowerData & )

privatedelete

References WipeTowerData().

Here is the call graph for this function:

Member Function Documentation

◆ clear()

void Slic3r::WipeTowerData::clear ( )

inline

                 {
        priming.reset(nullptr);
        tool_changes.clear();
        final_purge.reset(nullptr);
        used_filament.clear();
        number_of_toolchanges = -1;
        depth = 0.f;
        width = 0.f;
        brim_width = 0.f;
        height = 0.f;
        rib_offset = Vec2f::Zero();
        wipe_tower_mesh_data  = std::nullopt;
    }

References brim_width, depth, final_purge, height, number_of_toolchanges, priming, rib_offset, tool_changes, used_filament, width, and wipe_tower_mesh_data.

Referenced by WipeTowerData().

Here is the caller graph for this function:

◆ construct_mesh()

void Slic3r::WipeTowerData::construct_mesh	(	float	width,
		float	depth,
		float	height,
		float	brim_width,
		bool	is_rib_wipe_tower,
		float	rib_width,
		float	rib_length,
		bool	fillet_wall,
		float	cone_angle = 0.f )

{
    wipe_tower_mesh_data = WipeTowerMeshData{};
    float first_layer_height=0.08; //brim height
    if (width < EPSILON || depth < EPSILON || height < EPSILON) return;
    if (cone_angle > EPSILON && (!is_rib_wipe_tower || rib_length < EPSILON)) {
        // Cone tower: the base bulges past the body box; this bottom polygon feeds the
        // containment checks, so it must carry the bulge and the brim (cone not lofted).
        wipe_tower_mesh_data->real_wipe_tower_mesh = make_cube(width, depth, height);
        wipe_tower_mesh_data->bottom               = WipeTower2::cone_base_polygon(width, depth, height, cone_angle);
        auto brim_bottom                           = offset(wipe_tower_mesh_data->bottom, scaled(brim_width));
        if (!brim_bottom.empty())
            wipe_tower_mesh_data->bottom = brim_bottom.front();
        wipe_tower_mesh_data->real_brim_mesh = WipeTower::its_make_rib_brim(wipe_tower_mesh_data->bottom, first_layer_height);
    } else if (!is_rib_wipe_tower || rib_length < EPSILON) {
        wipe_tower_mesh_data->real_wipe_tower_mesh = make_cube(width, depth, height);
        wipe_tower_mesh_data->real_brim_mesh       = make_cube(width + 2 * brim_width, depth + 2 * brim_width, first_layer_height);
        wipe_tower_mesh_data->real_brim_mesh.translate({-brim_width, -brim_width, 0});
        wipe_tower_mesh_data->bottom = {scaled(Vec2f{-brim_width, -brim_width}), scaled(Vec2f{width + brim_width, -brim_width}),
                                        scaled(Vec2f{width + brim_width, depth + brim_width}), scaled(Vec2f{-brim_width, depth + brim_width})};
    } else {
        wipe_tower_mesh_data->real_wipe_tower_mesh = WipeTower::its_make_rib_tower(width, depth, height, rib_length, rib_width, fillet_wall);
        wipe_tower_mesh_data->bottom               = WipeTower::rib_section(width, depth, rib_length, rib_width, fillet_wall);
        auto brim_bottom                           = offset(wipe_tower_mesh_data->bottom, scaled(brim_width));
        if (!brim_bottom.empty())
            wipe_tower_mesh_data->bottom               = brim_bottom.front();
        wipe_tower_mesh_data->real_brim_mesh       = WipeTower::its_make_rib_brim(wipe_tower_mesh_data->bottom, first_layer_height);
        wipe_tower_mesh_data->real_wipe_tower_mesh.translate(Vec3f(rib_offset[0], rib_offset[1],0));
        wipe_tower_mesh_data->real_brim_mesh.translate(Vec3f(rib_offset[0], rib_offset[1], 0));
        wipe_tower_mesh_data->bottom.translate(scaled(Vec2f(rib_offset[0], rib_offset[1])));
    }
    //wipe_tower_mesh_data->real_wipe_tower_mesh.write_ascii("../wipe_tower_mesh.obj");
   //wipe_tower_mesh_data->real_brim_mesh.write_ascii("../wipe_tower_brim_mesh.obj");
}