Collaboration diagram for Slic3r::SurfaceFillParams:

Public Member Functions
bool	operator< (const SurfaceFillParams &rhs) const
bool	operator== (const SurfaceFillParams &rhs) const

Public Attributes
unsigned int	extruder = 0
InfillPattern	pattern = InfillPattern(0)
coordf_t	spacing = 0.
coordf_t	overlap = 0.
float	angle = 0.f
bool	fixed_angle = false
bool	bridge
float	bridge_angle = 0.f
float	density = 0.f
int	multiline = 1
float	anchor_length = 1000.f
float	anchor_length_max = 1000.f
Flow	flow
ExtrusionRole	extrusion_role = ExtrusionRole(0)
size_t	idx = 0
float	role_speed = 0
float	lateral_lattice_angle_1 = 0.f
float	lateral_lattice_angle_2 = 0.f
float	infill_lock_depth = 0
float	skin_infill_depth = 0
bool	symmetric_infill_y_axis = false
bool	infill_complete_top = false
float	infill_overhang_angle = 60.f
bool	gyroid_optimized = false
AdaptiveInfillMode	adaptive_infill_mode = AdaptiveInfillMode::Disabled
float	adaptive_infill_interior_density = 0.f
AdaptiveInfillGradient	adaptive_infill_gradient = AdaptiveInfillGradient::Linear
double	smooth_factor { 0. }
CenterOfSurfacePattern	center_of_surface_pattern {CenterOfSurfacePattern::Each_Surface}
bool	separated_infills {false}
SurfaceFillOrder	fill_order = SurfaceFillOrder::Default

Detailed Description

Member Function Documentation

◆ operator<()

bool Slic3r::SurfaceFillParams::operator< ( const SurfaceFillParams & rhs ) const

inline

                                                     {
#define RETURN_COMPARE_NON_EQUAL(KEY) if (this->KEY < rhs.KEY) return true; if (this->KEY > rhs.KEY) return false;
#define RETURN_COMPARE_NON_EQUAL_TYPED(TYPE, KEY) if (TYPE(this->KEY) < TYPE(rhs.KEY)) return true; if (TYPE(this->KEY) > TYPE(rhs.KEY)) return false;
 
    // Sort first by decreasing bridging angle, so that the bridges are processed with priority when trimming one layer by the other.
    if (this->bridge_angle > rhs.bridge_angle) return true;
    if (this->bridge_angle < rhs.bridge_angle) return false;
 
    RETURN_COMPARE_NON_EQUAL(extruder);
    RETURN_COMPARE_NON_EQUAL_TYPED(unsigned, pattern);
    RETURN_COMPARE_NON_EQUAL(spacing);
    RETURN_COMPARE_NON_EQUAL(overlap);
    RETURN_COMPARE_NON_EQUAL(angle);
    RETURN_COMPARE_NON_EQUAL(fixed_angle);
    RETURN_COMPARE_NON_EQUAL(density);
    RETURN_COMPARE_NON_EQUAL(multiline);
//    RETURN_COMPARE_NON_EQUAL_TYPED(unsigned, dont_adjust);
    RETURN_COMPARE_NON_EQUAL(anchor_length);
    RETURN_COMPARE_NON_EQUAL(anchor_length_max);
    RETURN_COMPARE_NON_EQUAL(flow.width());
    RETURN_COMPARE_NON_EQUAL(flow.height());
    RETURN_COMPARE_NON_EQUAL(flow.nozzle_diameter());
    RETURN_COMPARE_NON_EQUAL_TYPED(unsigned, bridge);
    RETURN_COMPARE_NON_EQUAL_TYPED(unsigned, extrusion_role);
    RETURN_COMPARE_NON_EQUAL(role_speed);
        RETURN_COMPARE_NON_EQUAL(lateral_lattice_angle_1);
    RETURN_COMPARE_NON_EQUAL(lateral_lattice_angle_2);
    RETURN_COMPARE_NON_EQUAL(symmetric_infill_y_axis);
    RETURN_COMPARE_NON_EQUAL(infill_complete_top);
    RETURN_COMPARE_NON_EQUAL(infill_lock_depth);
    RETURN_COMPARE_NON_EQUAL(skin_infill_depth);
        RETURN_COMPARE_NON_EQUAL(infill_overhang_angle);
    RETURN_COMPARE_NON_EQUAL(gyroid_optimized);
    RETURN_COMPARE_NON_EQUAL(adaptive_infill_mode);
    RETURN_COMPARE_NON_EQUAL(adaptive_infill_interior_density);
    RETURN_COMPARE_NON_EQUAL(adaptive_infill_gradient);
        RETURN_COMPARE_NON_EQUAL(smooth_factor);
        RETURN_COMPARE_NON_EQUAL(center_of_surface_pattern);
        RETURN_COMPARE_NON_EQUAL(separated_infills);
    RETURN_COMPARE_NON_EQUAL_TYPED(unsigned, fill_order);
 
    return false;
  }

References adaptive_infill_gradient, adaptive_infill_interior_density, adaptive_infill_mode, anchor_length, anchor_length_max, angle, bridge, bridge_angle, center_of_surface_pattern, density, extruder, extrusion_role, fill_order, fixed_angle, flow, gyroid_optimized, infill_complete_top, infill_lock_depth, infill_overhang_angle, lateral_lattice_angle_1, lateral_lattice_angle_2, multiline, overlap, pattern, RETURN_COMPARE_NON_EQUAL, RETURN_COMPARE_NON_EQUAL_TYPED, role_speed, separated_infills, skin_infill_depth, smooth_factor, spacing, and symmetric_infill_y_axis.

◆ operator==()

bool Slic3r::SurfaceFillParams::operator== ( const SurfaceFillParams & rhs ) const

inline

                                                      {
    return  this->extruder            == rhs.extruder                &&
        this->pattern             == rhs.pattern                 &&
        this->spacing             == rhs.spacing                 &&
        this->overlap             == rhs.overlap                 &&
        this->angle               == rhs.angle                   &&
        this->fixed_angle             == rhs.fixed_angle             &&
        this->bridge                  == rhs.bridge                  &&
        this->bridge_angle            == rhs.bridge_angle            &&
        this->density                 == rhs.density                 &&
        this->multiline               == rhs.multiline               &&
//        this->dont_adjust             == rhs.dont_adjust             &&
        this->anchor_length           == rhs.anchor_length           &&
        this->anchor_length_max       == rhs.anchor_length_max       &&
        this->flow                    == rhs.flow                    &&
        this->extrusion_role          == rhs.extrusion_role          &&
        this->role_speed              == rhs.role_speed              &&
                this->lateral_lattice_angle_1 == rhs.lateral_lattice_angle_1 &&
        this->lateral_lattice_angle_2 == rhs.lateral_lattice_angle_2 &&
        this->infill_lock_depth       == rhs.infill_lock_depth       &&
        this->skin_infill_depth       == rhs.skin_infill_depth       &&
                this->infill_overhang_angle   == rhs.infill_overhang_angle   &&
                this->center_of_surface_pattern == rhs.center_of_surface_pattern &&
                this->separated_infills       == rhs.separated_infills &&
                this->gyroid_optimized        == rhs.gyroid_optimized        &&
                this->adaptive_infill_mode           == rhs.adaptive_infill_mode           &&
                this->adaptive_infill_interior_density   == rhs.adaptive_infill_interior_density   &&
                this->adaptive_infill_gradient  == rhs.adaptive_infill_gradient  &&
                this->smooth_factor           == rhs.smooth_factor           &&
                this->fill_order              == rhs.fill_order;
  }