Slic3r::CoolingBuffer Class Reference

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

Collaboration diagram for Slic3r::CoolingBuffer:

Public Member Functions
	CoolingBuffer (GCode &gcodegen)
void	reset (const Vec3d &position)
void	set_current_extruder (unsigned int extruder_id, unsigned int nozzle_id)
std::string	process_layer (std::string &&gcode, size_t layer_id, bool flush)

Private Member Functions
CoolingBuffer &	operator= (const CoolingBuffer &)=delete
std::vector< PerExtruderAdjustments >	parse_layer_gcode (const std::string &gcode, std::vector< float > &current_pos) const
float	calculate_layer_slowdown (std::vector< PerExtruderAdjustments > &per_extruder_adjustments)
std::string	apply_layer_cooldown (const std::string &gcode, size_t layer_id, float layer_time, std::vector< PerExtruderAdjustments > &per_extruder_adjustments)

Private Attributes
std::string	m_gcode
std::vector< char >	m_axis
std::vector< float >	m_current_pos
int	m_fan_speed
int	m_additional_fan_speed
std::vector< unsigned int >	m_extruder_ids
unsigned int	m_num_extruders { 0 }
const std::string	m_toolchange_prefix
const PrintConfig &	m_config
const GCode &	m_gcodegen
unsigned int	m_current_extruder
unsigned int	m_current_nozzle
int	m_current_fan_speed
bool	m_belt_band_active = false

Detailed Description

Constructor & Destructor Documentation

CoolingBuffer()

Slic3r::CoolingBuffer::CoolingBuffer

(

GCode &

gcodegen

)

                                            : m_config(gcodegen.config()), m_gcodegen(gcodegen), m_toolchange_prefix(gcodegen.writer().toolchange_prefix()), m_current_extruder(0), m_current_nozzle(0)
{
    this->reset(gcodegen.writer().get_position());
 
    const std::vector<Extruder> &extruders = gcodegen.writer().extruders();
    m_extruder_ids.reserve(extruders.size());
    for (const Extruder &ex : extruders) {
        m_num_extruders = std::max(ex.id() + 1, m_num_extruders);
        m_extruder_ids.emplace_back(ex.id());
    }
 
}

References Slic3r::GCodeWriter::extruders(), Slic3r::GCodeWriter::get_position(), m_config, m_current_extruder, m_current_nozzle, m_extruder_ids, m_gcodegen, m_num_extruders, m_toolchange_prefix, reset(), and Slic3r::GCode::writer().

Referenced by operator=().

Here is the call graph for this function:

Here is the caller graph for this function:

Member Function Documentation

apply_layer_cooldown()

std::string Slic3r::CoolingBuffer::apply_layer_cooldown ( const std::string & gcode, size_t layer_id, float layer_time, std::vector< PerExtruderAdjustments > & per_extruder_adjustments )

private

{
    // First sort the adjustment lines by of multiple extruders by their position in the source G-code.
    std::vector<const CoolingLine*> lines;
    {
        size_t n_lines = 0;
        for (const PerExtruderAdjustments &adj : per_extruder_adjustments)
            n_lines += adj.lines.size();
        lines.reserve(n_lines);
        for (const PerExtruderAdjustments &adj : per_extruder_adjustments)
            for (const CoolingLine &line : adj.lines)
                lines.emplace_back(&line);
        std::sort(lines.begin(), lines.end(), [](const CoolingLine *ln1, const CoolingLine *ln2) { return ln1->line_start < ln2->line_start; } );
    }
    // Second generate the adjusted G-code.
    std::string new_gcode;
    new_gcode.reserve(gcode.size() * 2);
    // ORCA: per-printer minimum non-zero fan PWM. Applied at every part-cooling fan emission below so any
    // non-zero command is raised to at least this percent (0 disables the clamp).
    const unsigned int part_cooling_fan_min_pwm = static_cast<unsigned int>(std::max(0, m_config.part_cooling_fan_min_pwm.value));
    bool overhang_fan_control= false;
    int  overhang_fan_speed   = 0;
    bool internal_bridge_fan_control= false; // ORCA: Add support for separate internal bridge fan speed control
    int  internal_bridge_fan_speed   = 0; // ORCA: Add support for separate internal bridge fan speed control
    bool supp_interface_fan_control= false;
    int  supp_interface_fan_speed = 0;
    bool ironing_fan_control= false; // ORCA: Add support for ironing fan speed control
    int  ironing_fan_speed   = 0; // ORCA: Add support for ironing fan speed control
    auto change_extruder_set_fan = [ this, layer_id, layer_time, &new_gcode, part_cooling_fan_min_pwm,
        &overhang_fan_control, &overhang_fan_speed,
        &internal_bridge_fan_control, &internal_bridge_fan_speed,
        &supp_interface_fan_control, &supp_interface_fan_speed,
        &ironing_fan_control, &ironing_fan_speed
    ](bool immediately_apply) {
#define EXTRUDER_CONFIG(OPT) m_config.OPT.get_at(m_current_extruder)
        // The per-variant options take the extruder variant the filament prints with on this layer
        const size_t config_index = m_gcodegen.get_filament_config_index(m_current_extruder, layer_id);
        float fan_min_speed = m_config.fan_min_speed.get_at(config_index);
        float fan_speed_new = EXTRUDER_CONFIG(reduce_fan_stop_start_freq) ? fan_min_speed : 0;
        //BBS
        int additional_fan_speed_new = m_config.additional_cooling_fan_speed.get_at(config_index);
        int close_fan_the_first_x_layers = EXTRUDER_CONFIG(close_fan_the_first_x_layers);
        // Is the fan speed ramp enabled?
        int full_fan_speed_layer = EXTRUDER_CONFIG(full_fan_speed_layer);
        // ORCA: explicit per-filament first-layer override (-1 = disabled, 0-100 = forced PWM percent on layer 0).
        // The override is only honoured when the "No cooling for the first" gate is 0; otherwise the gate would
        // force layers 1..N-1 to zero while the override sets layer 0 to a non-zero value, which is confusing
        // and non-monotonic. The UI greys out and resets the value in that case, but we also guard here so
        // legacy profiles loaded with both set are neutralised at the slicer level.
        int initial_layer_fan_speed = EXTRUDER_CONFIG(initial_layer_fan_speed);
        const bool has_initial_layer_override = initial_layer_fan_speed >= 0 && close_fan_the_first_x_layers <= 0;
        supp_interface_fan_speed = EXTRUDER_CONFIG(support_material_interface_fan_speed);
 
        // ORCA: previously a silent override forced `close_fan_the_first_x_layers` from 0 up to 1 whenever a ramp
        // was configured (`full_fan_speed_layer > 0`), so the first printed layer always had the fan disabled.
        // That hid the user's literal "no cooling for the first 0 layers" setting and produced a non-zero starting
        // factor on the ramp denominator. The override has been removed: with N=0 and M>0 the ramp now genuinely
        // starts on layer 0 at a factor of 1/M and reaches 100% at layer M-1, matching the intent of the option.
        //
        // ORCA: First-layer hard override (`initial_layer_fan_speed`). When the user has set this option to a
        // value >= 0, layer 0 emits exactly that percentage so the entire first layer
        // is at one stable fan speed. The override wins over the `close_fan_the_first_x_layers` gate when
        // layer_id == 0. From layer 1 onwards the regular logic resumes. 
        if (has_initial_layer_override && layer_id == 0) {
            fan_speed_new             = initial_layer_fan_speed;
            overhang_fan_speed        = initial_layer_fan_speed;
            overhang_fan_control      = false;
            internal_bridge_fan_speed   = initial_layer_fan_speed;
            internal_bridge_fan_control = false;
            supp_interface_fan_speed    = initial_layer_fan_speed;
            supp_interface_fan_control  = false;
            ironing_fan_speed           = initial_layer_fan_speed;
            ironing_fan_control         = false;
            // additional_fan_speed_new is left at its configured value (auxiliary fan is independent of the
            // part-cooling override).
        } else if (int(layer_id) >= close_fan_the_first_x_layers) {
            float   fan_max_speed             = m_config.fan_max_speed.get_at(config_index);
            float slow_down_layer_time = float(EXTRUDER_CONFIG(slow_down_layer_time));
            float fan_cooling_layer_time      = float(EXTRUDER_CONFIG(fan_cooling_layer_time));
            //BBS: always enable the fan speed interpolation according to layer time
            //if (EXTRUDER_CONFIG(cooling)) {
                if (layer_time < slow_down_layer_time) {
                    // Layer time very short. Enable the fan to a full throttle.
                    fan_speed_new = fan_max_speed;
                } else if (layer_time < fan_cooling_layer_time) {
                    // Layer time quite short. Enable the fan proportionally according to the current layer time.
                    assert(layer_time >= slow_down_layer_time);
                    double t = (layer_time - slow_down_layer_time) / (fan_cooling_layer_time - slow_down_layer_time);
                    fan_speed_new = int(floor(t * fan_min_speed + (1. - t) * fan_max_speed) + 0.5);
                }
            //}
            overhang_fan_speed   = EXTRUDER_CONFIG(overhang_fan_speed);
            if (int(layer_id) >= close_fan_the_first_x_layers && int(layer_id) + 1 < full_fan_speed_layer) {
                if (has_initial_layer_override && close_fan_the_first_x_layers == 0 && full_fan_speed_layer > 1) {
                    // ORCA: Option-B anchored ramp. When the first-layer override is configured and there's
                    // no "no cooling" gate, the ramp interpolates linearly from `initial_layer_fan_speed` on
                    // layer 0 up to the computed target on layer `full_fan_speed_layer - 1` instead of
                    // scaling the target by `factor` from zero. Layer 0 itself is handled by the override
                    // branch above; this branch only runs for layer_id >= 1, but the formula uses t = 0 at
                    // layer 0 conceptually so the curve is continuous. Guarantees a monotonic transition
                    // even when the override is larger than the natural 1/M starting value.
                    const float anchor = float(initial_layer_fan_speed);
                    const float denom  = float(full_fan_speed_layer - 1);
                    const float t      = float(int(layer_id)) / denom;
                    fan_speed_new      = std::clamp(int(anchor + t * (float(fan_speed_new) - anchor) + 0.5f), 0, 255);
                    overhang_fan_speed = std::clamp(int(anchor + t * (float(overhang_fan_speed) - anchor) + 0.5f), 0, 255);
                } else {
                    // Ramp up the fan speed from close_fan_the_first_x_layers to full_fan_speed_layer.
                    float factor = float(int(layer_id + 1) - close_fan_the_first_x_layers) / float(full_fan_speed_layer - close_fan_the_first_x_layers);
                    fan_speed_new    = std::clamp(int(float(fan_speed_new) * factor + 0.5f), 0, 255);
                    overhang_fan_speed = std::clamp(int(float(overhang_fan_speed) * factor + 0.5f), 0, 255);
                }
            }
            supp_interface_fan_speed = EXTRUDER_CONFIG(support_material_interface_fan_speed);
            supp_interface_fan_control = supp_interface_fan_speed >= 0;
 
            overhang_fan_control = overhang_fan_speed > fan_speed_new;
            
            // ORCA: Add support for separate internal bridge fan speed control
            internal_bridge_fan_speed   = EXTRUDER_CONFIG(internal_bridge_fan_speed);
            internal_bridge_fan_control = internal_bridge_fan_speed >=0;
            
            if( internal_bridge_fan_speed < 0 ) { // ORCA: Backwards compatibility setting for Orca internal bridge fan speed setting - if set at -1 (which is the default) use the overhang fan speed settings.
                internal_bridge_fan_speed = overhang_fan_speed;
                internal_bridge_fan_control = overhang_fan_control;
            }
 
            // ORCA: Add support for ironing fan speed control
            ironing_fan_speed   = EXTRUDER_CONFIG(ironing_fan_speed);
            ironing_fan_control = ironing_fan_speed >= 0;
#undef EXTRUDER_CONFIG
            
        } else {
            overhang_fan_control = false;
            overhang_fan_speed   = 0;
            fan_speed_new      = 0;
            additional_fan_speed_new = 0;
            supp_interface_fan_control = false; 
            supp_interface_fan_speed   = 0;
            internal_bridge_fan_control = false; // ORCA: Add support for separate internal bridge fan speed control
            internal_bridge_fan_speed = 0; // ORCA: Add support for separate internal bridge fan speed control
            ironing_fan_control = false; // ORCA: Add support for ironing fan speed control
            ironing_fan_speed = 0; // ORCA: Add support for ironing fan speed control
        }
        // A tool change may keep the same configured base fan speed while the physical fan is
        // still running at the previous filament's overhang speed. Restore the base speed before
        // emitting G-code for the new tool in that case.
        if (fan_speed_new != m_fan_speed || (immediately_apply && m_current_fan_speed != fan_speed_new)) {
            m_fan_speed = fan_speed_new;
            m_current_fan_speed = fan_speed_new;
            if (immediately_apply)
                new_gcode  += GCodeWriter::set_fan(m_config.gcode_flavor, m_fan_speed, part_cooling_fan_min_pwm);
        }
        //BBS
        if (additional_fan_speed_new != m_additional_fan_speed) {
            m_additional_fan_speed = additional_fan_speed_new;
            if (immediately_apply && m_config.auxiliary_fan.value)
                new_gcode += GCodeWriter::set_additional_fan(m_additional_fan_speed);
        }
    };
 
    const char         *pos               = gcode.c_str();
    int                 current_feedrate  = 0;
    change_extruder_set_fan(true);
 
    // Orca: Reduce set fan commands by deferring the GCodeWriter::set_fan calls. Inspired by SuperSlicer
    // define fan_speed_change_requests and initialize it with all possible types fan speed change requests
    std::unordered_map<int, bool> fan_speed_change_requests = {{CoolingLine::TYPE_OVERHANG_FAN_START, false},
                                                               {CoolingLine::TYPE_INTERNAL_BRIDGE_FAN_START, false}, // ORCA: Add support for separate internal bridge fan speed control
                                                               {CoolingLine::TYPE_SUPPORT_INTERFACE_FAN_START, false},
                                                               {CoolingLine::TYPE_IRONING_FAN_START, false}, // ORCA: Add support for ironing fan speed control
                                                               {CoolingLine::TYPE_FORCE_RESUME_FAN, false}};
    // Belt printers: a band still open from the previous layer has to take the fan back from
    // the layer-level speed issued just above.
    bool need_set_fan = m_belt_band_active;
 
    for (const CoolingLine *line : lines) {
        const char *line_start  = gcode.c_str() + line->line_start;
        const char *line_end    = gcode.c_str() + line->line_end;
        if (line_start > pos)
            new_gcode.append(pos, line_start - pos);
        if (line->type & CoolingLine::TYPE_SET_TOOL) {
            unsigned int new_extruder = 0;
            auto ret = std::from_chars(line_start + m_toolchange_prefix.size(), line_end, new_extruder);
            if (std::errc::invalid_argument != ret.ec) {
                if (new_extruder != m_current_extruder) {
                    m_current_extruder = new_extruder;
                    change_extruder_set_fan(true);
                    if (m_belt_band_active)
                        need_set_fan = true;
                }
            }
            new_gcode.append(line_start, line_end - line_start);
        } else if (line->type & CoolingLine::TYPE_OVERHANG_FAN_START) {
            if (overhang_fan_control && !fan_speed_change_requests[CoolingLine::TYPE_OVERHANG_FAN_START]) {
                need_set_fan = true;
                fan_speed_change_requests[CoolingLine::TYPE_OVERHANG_FAN_START] = true;
           }
        } else if (line->type & CoolingLine::TYPE_OVERHANG_FAN_END) {
            if (overhang_fan_control && fan_speed_change_requests[CoolingLine::TYPE_OVERHANG_FAN_START]) {
                fan_speed_change_requests[CoolingLine::TYPE_OVERHANG_FAN_START] = false;
            }
            need_set_fan = true;
        } else if (line->type & CoolingLine::TYPE_INTERNAL_BRIDGE_FAN_START) { // ORCA: Add support for separate internal bridge fan speed control
            if (internal_bridge_fan_control && !fan_speed_change_requests[CoolingLine::TYPE_INTERNAL_BRIDGE_FAN_START]) {
                need_set_fan = true;
                fan_speed_change_requests[CoolingLine::TYPE_INTERNAL_BRIDGE_FAN_START] = true;
           }
        } else if (line->type & CoolingLine::TYPE_INTERNAL_BRIDGE_FAN_END) { // ORCA: Add support for separate internal bridge fan speed control
            if (internal_bridge_fan_control && fan_speed_change_requests[CoolingLine::TYPE_INTERNAL_BRIDGE_FAN_START]) {
                fan_speed_change_requests[CoolingLine::TYPE_INTERNAL_BRIDGE_FAN_START] = false;
            }
            need_set_fan = true;
        } else if (line->type & CoolingLine::TYPE_SUPPORT_INTERFACE_FAN_START) {
            if (supp_interface_fan_control && !fan_speed_change_requests[CoolingLine::TYPE_SUPPORT_INTERFACE_FAN_START]) {
                fan_speed_change_requests[CoolingLine::TYPE_SUPPORT_INTERFACE_FAN_START] = true;
                need_set_fan = true;
            }
        } else if (line->type & CoolingLine::TYPE_SUPPORT_INTERFACE_FAN_END && fan_speed_change_requests[CoolingLine::TYPE_SUPPORT_INTERFACE_FAN_START]) {
            if (supp_interface_fan_control) {
                fan_speed_change_requests[CoolingLine::TYPE_SUPPORT_INTERFACE_FAN_START] = false;
            }
            need_set_fan = true;
        } else if (line->type & CoolingLine::TYPE_IRONING_FAN_START) {
            if (ironing_fan_control && !fan_speed_change_requests[CoolingLine::TYPE_IRONING_FAN_START]) {
                fan_speed_change_requests[CoolingLine::TYPE_IRONING_FAN_START] = true;
                need_set_fan = true;
            }
        } else if (line->type & CoolingLine::TYPE_IRONING_FAN_END) {
            if (ironing_fan_control && fan_speed_change_requests[CoolingLine::TYPE_IRONING_FAN_START]) {
                fan_speed_change_requests[CoolingLine::TYPE_IRONING_FAN_START] = false;
            }
            need_set_fan = true;
        } else if (line->type & CoolingLine::TYPE_FORCE_RESUME_FAN) {
            // check if any fan speed change request is active
            if (m_fan_speed != -1 && !std::any_of(fan_speed_change_requests.begin(), fan_speed_change_requests.end(), [](const std::pair<int, bool>& p) { return p.second; })){
                fan_speed_change_requests[CoolingLine::TYPE_FORCE_RESUME_FAN] = true;
                need_set_fan = true;
            }
            if (m_additional_fan_speed != -1 && m_config.auxiliary_fan.value)
                new_gcode += GCodeWriter::set_additional_fan(m_additional_fan_speed);
        }
        else if (line->type & CoolingLine::TYPE_BELT_BAND_START) {
            m_belt_band_active = true;
            need_set_fan       = true;
        } else if (line->type & CoolingLine::TYPE_BELT_BAND_END) {
            m_belt_band_active = false;
            need_set_fan       = true;
        }
        else if (line->type & CoolingLine::TYPE_EXTRUDE_END) {
            // Just remove this comment.
        } else if (line->type & (CoolingLine::TYPE_ADJUSTABLE | CoolingLine::TYPE_EXTERNAL_PERIMETER | CoolingLine::TYPE_WIPE | CoolingLine::TYPE_HAS_F)) {
            // Find the start of a comment, or roll to the end of line.
            const char *end = line_start;
            for (; end < line_end && *end != ';'; ++ end);
            // Find the 'F' word.
            const char *fpos            = strstr(line_start + 2, " F") + 2;
            int         new_feedrate    = current_feedrate;
            // Modify the F word of the current G-code line.
            bool        modify          = false;
            // Remove the F word from the current G-code line.
            bool        remove          = false;
            assert(fpos != nullptr);
            new_feedrate = line->slowdown ? int(floor(60. * line->feedrate + 0.5)) : atoi(fpos);
            if (new_feedrate == current_feedrate) {
                // No need to change the F value.
                if ((line->type & (CoolingLine::TYPE_ADJUSTABLE | CoolingLine::TYPE_EXTERNAL_PERIMETER | CoolingLine::TYPE_WIPE)) || line->length == 0.)
                    // Feedrate does not change and this line does not move the print head. Skip the complete G-code line including the G-code comment.
                    end = line_end;
                else
                    // Remove the feedrate from the G0/G1 line. The G-code line may become empty!
                    remove = true;
            } else if (line->slowdown) {
                // The F value will be overwritten.
                modify = true;
            } else {
                // The F value is different from current_feedrate, but not slowed down, thus the G-code line will not be modified.
                // Emit the line without the comment.
                new_gcode.append(line_start, end - line_start);
                current_feedrate = new_feedrate;
            }
            if (modify || remove) {
                if (modify) {
                    // Replace the feedrate.
                    new_gcode.append(line_start, fpos - line_start);
                    current_feedrate = new_feedrate;
                    char buf[64];
                    sprintf(buf, "%d", int(current_feedrate));
                    new_gcode += buf;
                } else {
                    // Remove the feedrate word.
                    const char *f = fpos;
                    // Roll the pointer before the 'F' word.
                    for (f -= 2; f > line_start && (*f == ' ' || *f == '\t'); -- f);
 
                    if ((f - line_start == 1) && *line_start == 'G' && (*f == '1' || *f == '0')) {
                        // BBS: only remain "G1" or "G0" of this line after remove 'F' part, don't save
                    } else {
                        // Append up to the F word, without the trailing whitespace.
                        new_gcode.append(line_start, f - line_start + 1);
                    }
                }
                // Skip the non-whitespaces of the F parameter up the comment or end of line.
                for (; fpos != end && *fpos != ' ' && *fpos != ';' && *fpos != '\n'; ++ fpos);
                // Append the rest of the line without the comment.
                if (fpos < end)
                    // The G-code line is not empty yet. Emit the rest of it.
                    new_gcode.append(fpos, end - fpos);
                else if (remove && new_gcode == "G1") {
                    // The G-code line only contained the F word, now it is empty. Remove it completely including the comments.
                    new_gcode.resize(new_gcode.size() - 2);
                    end = line_end;
                }
            }
            // Process the rest of the line.
            if (end < line_end) {
                if (line->type & (CoolingLine::TYPE_ADJUSTABLE | CoolingLine::TYPE_EXTERNAL_PERIMETER | CoolingLine::TYPE_WIPE)) {
                    // Process comments, remove ";_EXTRUDE_SET_SPEED", ";_EXTERNAL_PERIMETER", ";_WIPE"
                    std::string comment(end, line_end);
                    boost::replace_all(comment, ";_EXTRUDE_SET_SPEED", "");
                    if (line->type & CoolingLine::TYPE_EXTERNAL_PERIMETER)
                        boost::replace_all(comment, ";_EXTERNAL_PERIMETER", "");
                    if (line->type & CoolingLine::TYPE_WIPE)
                        boost::replace_all(comment, ";_WIPE", "");
                    new_gcode += comment;
                } else {
                    // Just attach the rest of the source line.
                    new_gcode.append(end, line_end - end);
                }
            }
        } else {
            new_gcode.append(line_start, line_end - line_start);
        }
 
        if (need_set_fan) {
            const auto set_fan = [&](int speed) {
                if (m_current_fan_speed != speed) {
                    new_gcode += GCodeWriter::set_fan(m_config.gcode_flavor, speed, part_cooling_fan_min_pwm);
                    m_current_fan_speed = speed;
                }
            };
            if (m_belt_band_active) {
                // Belt printers: a tilted layer runs from the belt to the top of the part, so
                // "the first layers" are a band along the belt rather than the first slicing
                // layers. Extrusions GCode::_extrude() marks as inside that band print with the
                // fan off, whatever overhang, bridge or resume request is pending, as the first
                // layers of a flat bed do. Leaving the band falls through to the branches below.
                set_fan(0);
                fan_speed_change_requests[CoolingLine::TYPE_FORCE_RESUME_FAN] = false;
            } else if (fan_speed_change_requests[CoolingLine::TYPE_OVERHANG_FAN_START]){
                set_fan(overhang_fan_speed);
            } else if (fan_speed_change_requests[CoolingLine::TYPE_INTERNAL_BRIDGE_FAN_START]){ // ORCA: Add support for separate internal bridge fan speed control
                set_fan(internal_bridge_fan_speed);
            }
            else if (fan_speed_change_requests[CoolingLine::TYPE_SUPPORT_INTERFACE_FAN_START]){
                set_fan(supp_interface_fan_speed);
            }
            else if (fan_speed_change_requests[CoolingLine::TYPE_IRONING_FAN_START]){
                set_fan(ironing_fan_speed);
            }
            else if(fan_speed_change_requests[CoolingLine::TYPE_FORCE_RESUME_FAN] && m_current_fan_speed != -1){
                new_gcode += GCodeWriter::set_fan(m_config.gcode_flavor, m_current_fan_speed, part_cooling_fan_min_pwm);
                fan_speed_change_requests[CoolingLine::TYPE_FORCE_RESUME_FAN] = false;
            }
            else {
                set_fan(m_fan_speed);
            }
            need_set_fan = false;
        }
        pos = line_end;
    }
    const char *gcode_end = gcode.c_str() + gcode.size();
    if (pos < gcode_end)
        new_gcode.append(pos, gcode_end - pos);
 
    return new_gcode;
}

References Slic3r::close_fan_the_first_x_layers(), EXTRUDER_CONFIG, Slic3r::f(), Slic3r::fan_max_speed(), Slic3r::fan_min_speed(), Slic3r::full_fan_speed_layer(), Slic3r::ironing_fan_speed(), m_additional_fan_speed, m_belt_band_active, m_config, m_current_extruder, m_current_fan_speed, m_fan_speed, m_gcodegen, m_toolchange_prefix, Slic3r::overhang_fan_speed(), Slic3r::part_cooling_fan_min_pwm(), Slic3r::GCodeWriter::set_additional_fan(), Slic3r::GCodeWriter::set_fan(), Slic3r::slow_down_layer_time(), Slic3r::support_material_interface_fan_speed(), Slic3r::CoolingLine::TYPE_ADJUSTABLE, Slic3r::CoolingLine::TYPE_BELT_BAND_END, Slic3r::CoolingLine::TYPE_BELT_BAND_START, Slic3r::CoolingLine::TYPE_EXTERNAL_PERIMETER, Slic3r::CoolingLine::TYPE_EXTRUDE_END, Slic3r::CoolingLine::TYPE_FORCE_RESUME_FAN, Slic3r::CoolingLine::TYPE_HAS_F, Slic3r::CoolingLine::TYPE_INTERNAL_BRIDGE_FAN_END, Slic3r::CoolingLine::TYPE_INTERNAL_BRIDGE_FAN_START, Slic3r::CoolingLine::TYPE_IRONING_FAN_END, Slic3r::CoolingLine::TYPE_IRONING_FAN_START, Slic3r::CoolingLine::TYPE_OVERHANG_FAN_END, Slic3r::CoolingLine::TYPE_OVERHANG_FAN_START, Slic3r::CoolingLine::TYPE_SET_TOOL, Slic3r::CoolingLine::TYPE_SUPPORT_INTERFACE_FAN_END, Slic3r::CoolingLine::TYPE_SUPPORT_INTERFACE_FAN_START, and Slic3r::CoolingLine::TYPE_WIPE.

Referenced by process_layer().

Here is the call graph for this function:

Here is the caller graph for this function:

calculate_layer_slowdown()

float Slic3r::CoolingBuffer::calculate_layer_slowdown ( std::vector< PerExtruderAdjustments > & per_extruder_adjustments )

private

{
    // Sort the extruders by an increasing slow_down_layer_time.
    // The layers with a lower slow_down_layer_time are slowed down
    // together with all the other layers with slow_down_layer_time above.
    std::vector<PerExtruderAdjustments*> by_slowdown_time;
    by_slowdown_time.reserve(per_extruder_adjustments.size());
    // Only insert entries, which are adjustable (have cooling enabled and non-zero stretchable time).
    // Collect total print time of non-adjustable extruders.
    float elapsed_time_total0 = 0.f;
    for (PerExtruderAdjustments &adj : per_extruder_adjustments) {
        // Curren total time for this extruder.
        adj.time_total  = adj.elapsed_time_total();
        // Maximum time for this extruder, when all extrusion moves are slowed down to min_extrusion_speed.
        adj.time_maximum = adj.maximum_time_after_slowdown(true);
        if (adj.cooling_slow_down_enabled && adj.lines.size() > 0) {
            by_slowdown_time.emplace_back(&adj);
            // sorts the lines, also sets adj.time_non_adjustable
            adj.sort_lines_by_decreasing_feedrate();
        } else
            elapsed_time_total0 += adj.elapsed_time_total();
    }
 
    std::sort(by_slowdown_time.begin(), by_slowdown_time.end(),
        [](const PerExtruderAdjustments *adj1, const PerExtruderAdjustments *adj2)
            { return adj1->slow_down_layer_time < adj2->slow_down_layer_time; });
 
    for (auto cur_begin = by_slowdown_time.begin(); cur_begin != by_slowdown_time.end(); ++ cur_begin) {
        PerExtruderAdjustments &adj = *(*cur_begin);
        // Calculate the current adjusted elapsed_time_total over the non-finalized extruders.
        float total = elapsed_time_total0;
        for (auto it = cur_begin; it != by_slowdown_time.end(); ++ it)
            total += (*it)->time_total;
        float slow_down_layer_time = adj.slow_down_layer_time * 1.001f;
        if (total > slow_down_layer_time) {
            // The current total time is above the minimum threshold of the rest of the extruders, don't adjust anything.
        } else {
            // Adjust this and all the following (higher m_config.slow_down_layer_time) extruders.
            // Sum maximum slow down time as if everything was slowed down including the external perimeters.
            float max_time = elapsed_time_total0;
            for (auto it = cur_begin; it != by_slowdown_time.end(); ++ it)
                max_time += (*it)->time_maximum;
            if (max_time > slow_down_layer_time) {
                extruder_range_slow_down_non_proportional(cur_begin, by_slowdown_time.end(), slow_down_layer_time - total);
            } else {
                // Slow down to maximum possible.
                for (auto it = cur_begin; it != by_slowdown_time.end(); ++ it)
                    (*it)->slowdown_to_minimum_feedrate(true);
            }
        }
        elapsed_time_total0 += adj.elapsed_time_total();
    }
 
    return elapsed_time_total0;
}

References Slic3r::PerExtruderAdjustments::elapsed_time_total(), Slic3r::extruder_range_slow_down_non_proportional(), Slic3r::PerExtruderAdjustments::slow_down_layer_time, Slic3r::slow_down_layer_time(), and Slic3r::PerExtruderAdjustments::time_total.

Referenced by process_layer().

Here is the call graph for this function:

Here is the caller graph for this function:

operator=()

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

privatedelete

References CoolingBuffer().

Here is the call graph for this function:

parse_layer_gcode()

std::vector< PerExtruderAdjustments > Slic3r::CoolingBuffer::parse_layer_gcode ( const std::string & gcode, std::vector< float > & current_pos ) const

private

{
    std::vector<PerExtruderAdjustments> per_extruder_adjustments(m_extruder_ids.size());
    std::vector<size_t>                 map_extruder_to_per_extruder_adjustment(m_num_extruders, 0);
    for (size_t i = 0; i < m_extruder_ids.size(); ++ i) {
        PerExtruderAdjustments &adj         = per_extruder_adjustments[i];
        unsigned int            extruder_id = m_extruder_ids[i];
        adj.extruder_id               = extruder_id;
        adj.cooling_slow_down_enabled = m_config.slow_down_for_layer_cooling.get_at(extruder_id);
        adj.slow_down_layer_time = float(m_config.slow_down_layer_time.get_at(extruder_id));
        adj.slow_down_min_speed           = float(m_config.slow_down_min_speed.get_at(extruder_id));
        // ORCA: To enable dont slow down external perimeters feature per filament (extruder)
        adj.dont_slow_down_outer_wall   = m_config.dont_slow_down_outer_wall.get_at(extruder_id);
        map_extruder_to_per_extruder_adjustment[extruder_id] = i;
    }
 
    unsigned int      current_extruder  = m_current_extruder;
    PerExtruderAdjustments *adjustment  = &per_extruder_adjustments[map_extruder_to_per_extruder_adjustment[current_extruder]];
    const char       *line_start = gcode.c_str();
    const char       *line_end   = line_start;
    // Index of an existing CoolingLine of the current adjustment, which holds the feedrate setting command
    // for a sequence of extrusion moves.
    size_t            active_speed_modifier = size_t(-1);
 
    // Orca: Whether we had our first extrusion in this layer.
    // Time of any other movements before the first extrusion will be excluded from the layer time.
    bool layer_had_extrusion = false;
 
    for (; *line_start != 0; line_start = line_end)
    {
        while (*line_end != '\n' && *line_end != 0)
            ++ line_end;
        // sline will not contain the trailing '\n'.
        std::string sline(line_start, line_end);
        // CoolingLine will contain the trailing '\n'.
        if (*line_end == '\n')
            ++ line_end;
        CoolingLine line(0, line_start - gcode.c_str(), line_end - gcode.c_str());
        if (boost::starts_with(sline, "G0 "))
            line.type = CoolingLine::TYPE_G0;
        else if (boost::starts_with(sline, "G1 "))
            line.type = CoolingLine::TYPE_G1;
        else if (boost::starts_with(sline, "G92 "))
            line.type = CoolingLine::TYPE_G92;
        else if (boost::starts_with(sline, "G2 "))
            line.type = CoolingLine::TYPE_G2;
        else if (boost::starts_with(sline, "G3 "))
            line.type = CoolingLine::TYPE_G3;
        if (line.type) {
            // G0, G1 or G92
            // Parse the G-code line.
            std::vector<float> new_pos(current_pos);
            const char *c = sline.data() + 3;
            for (;;) {
                // Skip whitespaces.
                for (; *c == ' ' || *c == '\t'; ++ c);
                if (*c == 0 || *c == ';')
                    break;
 
                //BBS: Parse the axis.
                size_t axis = (*c >= 'X' && *c <= 'Z') ? (*c - 'X') :
                              (*c == 'E') ? 3 : (*c == 'F') ? 4 :
                              (*c == 'I') ? 5 : (*c == 'J') ? 6 : size_t(-1);
                if (axis != size_t(-1)) {
                    ++ c;
                    new_pos[axis] = float(atof_decimal_point(std::string_view(c, sline.data() + sline.size() - c)));
                    if (axis == 4) {
                        // Convert mm/min to mm/sec.
                        new_pos[4] /= 60.f;
                        if ((line.type & CoolingLine::TYPE_G92) == 0)
                            // This is G0 or G1 line and it sets the feedrate. This mark is used for reducing the duplicate F calls.
                            line.type |= CoolingLine::TYPE_HAS_F;
                    } else if (axis == 5 || axis == 6) {
                        // BBS: get position of arc center
                        new_pos[axis] += current_pos[axis - 5];
                    }
                }
                // Skip this word.
                for (; *c != ' ' && *c != '\t' && *c != 0; ++ c);
            }
            bool external_perimeter = boost::contains(sline, ";_EXTERNAL_PERIMETER");
            bool wipe               = boost::contains(sline, ";_WIPE");
            if (external_perimeter)
                line.type |= CoolingLine::TYPE_EXTERNAL_PERIMETER;
            if (wipe)
                line.type |= CoolingLine::TYPE_WIPE;
 
            // Orca: only slow down movements since the first extrusion
            if (boost::contains(sline, ";_EXTRUDE_SET_SPEED"))
                layer_had_extrusion = true;
            
            // ORCA: Dont slowdown external perimeters for layer time feature
            // use the adjustment pointer to ensure the value for the current extruder (filament) is used.
            bool adjust_external = true;
            if(adjustment->dont_slow_down_outer_wall && external_perimeter) adjust_external = false;
            
            // ORCA: Dont slowdown external perimeters for layer time works by not marking the external perimeter as adjustable, 
            // hence the slowdown algorithm ignores it.
            if (boost::contains(sline, ";_EXTRUDE_SET_SPEED") && ! wipe && adjust_external) {
                line.type |= CoolingLine::TYPE_ADJUSTABLE;
                active_speed_modifier = adjustment->lines.size();
            }
            if ((line.type & CoolingLine::TYPE_G92) == 0) {
                //BBS: G0, G1, G2, G3. Calculate the duration.
                if (m_config.use_relative_e_distances.value)
                    // Reset extruder accumulator.
                    current_pos[3] = 0.f;
                float dif[4];
                for (size_t i = 0; i < 4; ++ i)
                    dif[i] = new_pos[i] - current_pos[i];
                float dxy2 = 0;
                //BBS: support to calculate length of arc
                if (line.type & CoolingLine::TYPE_G2 || line.type & CoolingLine::TYPE_G3) {
                    Vec3f start(current_pos[0], current_pos[1], 0);
                    Vec3f end(new_pos[0], new_pos[1], 0);
                    Vec3f center(new_pos[5], new_pos[6], 0);
                    bool is_ccw = line.type & CoolingLine::TYPE_G3;
                    float dxy = ArcSegment::calc_arc_length(start, end, center, is_ccw);
                    dxy2 = dxy * dxy;
                } else {
                    dxy2 = dif[0] * dif[0] + dif[1] * dif[1];
                }
                float dxyz2 = dxy2 + dif[2] * dif[2];
                if (dxyz2 > 0.f) {
                    // Movement in xyz, calculate time from the xyz Euclidian distance.
                    line.length = sqrt(dxyz2);
                } else if (std::abs(dif[3]) > 0.f) {
                    // Movement in the extruder axis.
                    line.length = std::abs(dif[3]);
                }
                line.feedrate = new_pos[4];
                assert((line.type & CoolingLine::TYPE_ADJUSTABLE) == 0 || line.feedrate > 0.f);
                if (line.length > 0)
                    line.time = line.length / line.feedrate;
                line.time_max = line.time;
                if ((line.type & CoolingLine::TYPE_ADJUSTABLE) || active_speed_modifier != size_t(-1))
                    line.time_max = (adjustment->slow_down_min_speed == 0.f) ? FLT_MAX : std::max(line.time, line.length / adjustment->slow_down_min_speed);
                // BBS: add G2 and G3 support
                if (active_speed_modifier < adjustment->lines.size() && ((line.type & CoolingLine::TYPE_G1) ||
                                                                         (line.type & CoolingLine::TYPE_G2) ||
                                                                         (line.type & CoolingLine::TYPE_G3))) {
                    // Inside the ";_EXTRUDE_SET_SPEED" blocks, there must not be a G1 Fxx entry.
                    assert((line.type & CoolingLine::TYPE_HAS_F) == 0);
                    CoolingLine &sm = adjustment->lines[active_speed_modifier];
                    assert(sm.feedrate > 0.f);
                    sm.length   += line.length;
                    sm.time     += line.time;
                    if (sm.time_max != FLT_MAX) {
                        if (line.time_max == FLT_MAX)
                            sm.time_max = FLT_MAX;
                        else
                            sm.time_max += line.time_max;
                    }
                    // Don't store this line.
                    line.type = 0;
                }
            }
            current_pos = std::move(new_pos);
        } else if (boost::starts_with(sline, ";_EXTRUDE_END")) {
            line.type = CoolingLine::TYPE_EXTRUDE_END;
            active_speed_modifier = size_t(-1);
        } else if (boost::starts_with(sline, m_toolchange_prefix)) {
            unsigned int new_extruder = 0;
            auto ret = std::from_chars(sline.data() + m_toolchange_prefix.size(), sline.data() + sline.size(), new_extruder);
            if (std::errc::invalid_argument != ret.ec) {
                // Only change extruder in case the number is meaningful. User could provide an out-of-range index through custom gcodes -
                // those shall be ignored.
                if (new_extruder < map_extruder_to_per_extruder_adjustment.size()) {
                    if (new_extruder != current_extruder) {
                        // Switch the tool.
                        line.type        = CoolingLine::TYPE_SET_TOOL;
                        current_extruder = new_extruder;
                        adjustment       = &per_extruder_adjustments[map_extruder_to_per_extruder_adjustment[current_extruder]];
                    }
                } else {
                    // Only log the error in case of MM printer. Single extruder printers likely ignore any T anyway.
                    if (map_extruder_to_per_extruder_adjustment.size() > 1)
                        BOOST_LOG_TRIVIAL(error) << "CoolingBuffer encountered an invalid toolchange, maybe from a custom gcode: " << sline;
                }
            }
        } else if (boost::starts_with(sline, ";_OVERHANG_FAN_START")) {
            line.type = CoolingLine::TYPE_OVERHANG_FAN_START;
        } else if (boost::starts_with(sline, ";_OVERHANG_FAN_END")) {
            line.type = CoolingLine::TYPE_OVERHANG_FAN_END;
        } else if (boost::starts_with(sline, ";_INTERNAL_BRIDGE_FAN_START")) { // ORCA: Add support for separate internal bridge fan speed control
            line.type = CoolingLine::TYPE_INTERNAL_BRIDGE_FAN_START;
        } else if (boost::starts_with(sline, ";_INTERNAL_BRIDGE_FAN_END")) { // ORCA: Add support for separate internal bridge fan speed control
            line.type = CoolingLine::TYPE_INTERNAL_BRIDGE_FAN_END;
        } else if (boost::starts_with(sline, ";_SUPP_INTERFACE_FAN_START")) {
            line.type = CoolingLine::TYPE_SUPPORT_INTERFACE_FAN_START;
        } else if (boost::starts_with(sline, ";_SUPP_INTERFACE_FAN_END")) {
            line.type = CoolingLine::TYPE_SUPPORT_INTERFACE_FAN_END;
        } else if (boost::starts_with(sline, ";_IRONING_FAN_START")) { // ORCA: Add support for ironing fan speed control
            line.type = CoolingLine::TYPE_IRONING_FAN_START;
        } else if (boost::starts_with(sline, ";_IRONING_FAN_END")) { // ORCA: Add support for ironing fan speed control
            line.type = CoolingLine::TYPE_IRONING_FAN_END;
        } else if (boost::starts_with(sline, ";_BELT_BAND_START")) {
            line.type = CoolingLine::TYPE_BELT_BAND_START;
        } else if (boost::starts_with(sline, ";_BELT_BAND_END")) {
            line.type = CoolingLine::TYPE_BELT_BAND_END;
        } else if (boost::starts_with(sline, "G4 ")) {
            // Parse the wait time.
            line.type = CoolingLine::TYPE_G4;
            size_t pos_S = sline.find('S', 3);
            size_t pos_P = sline.find('P', 3);
            line.time = line.time_max = float(
                (pos_S > 0) ? atof_decimal_point(sline.c_str() + pos_S + 1) :
                (pos_P > 0) ? atof_decimal_point(sline.c_str() + pos_P + 1) * 0.001 : 0.);
        } else if (boost::starts_with(sline, ";_FORCE_RESUME_FAN_SPEED")) {
            line.type = CoolingLine::TYPE_FORCE_RESUME_FAN;
        }
 
        // Orca: For any movements before this layer's first ever extrusion, we exclude them from the layer time calculation.
        if (!layer_had_extrusion) {
            assert((line.type & CoolingLine::TYPE_ADJUSTABLE) == 0);
            line.time = line.time_max = 0;
        }
 
        if (line.type != 0)
            adjustment->lines.emplace_back(std::move(line));
    }
 
    return per_extruder_adjustments;
}

References Slic3r::atof_decimal_point(), Slic3r::ArcSegment::calc_arc_length(), Slic3r::center(), Slic3r::PerExtruderAdjustments::cooling_slow_down_enabled, Slic3r::PerExtruderAdjustments::dont_slow_down_outer_wall, Slic3r::PerExtruderAdjustments::extruder_id, Slic3r::CoolingLine::feedrate, Slic3r::Geometry::is_ccw(), Slic3r::CoolingLine::length, Slic3r::PerExtruderAdjustments::lines, m_config, m_current_extruder, m_extruder_ids, m_num_extruders, m_toolchange_prefix, Slic3r::PerExtruderAdjustments::slow_down_layer_time, Slic3r::PerExtruderAdjustments::slow_down_min_speed, Slic3r::CoolingLine::time, Slic3r::CoolingLine::time_max, Slic3r::CoolingLine::type, Slic3r::CoolingLine::TYPE_ADJUSTABLE, Slic3r::CoolingLine::TYPE_BELT_BAND_END, Slic3r::CoolingLine::TYPE_BELT_BAND_START, Slic3r::CoolingLine::TYPE_EXTERNAL_PERIMETER, Slic3r::CoolingLine::TYPE_EXTRUDE_END, Slic3r::CoolingLine::TYPE_FORCE_RESUME_FAN, Slic3r::CoolingLine::TYPE_G0, Slic3r::CoolingLine::TYPE_G1, Slic3r::CoolingLine::TYPE_G2, Slic3r::CoolingLine::TYPE_G3, Slic3r::CoolingLine::TYPE_G4, Slic3r::CoolingLine::TYPE_G92, Slic3r::CoolingLine::TYPE_HAS_F, Slic3r::CoolingLine::TYPE_INTERNAL_BRIDGE_FAN_END, Slic3r::CoolingLine::TYPE_INTERNAL_BRIDGE_FAN_START, Slic3r::CoolingLine::TYPE_IRONING_FAN_END, Slic3r::CoolingLine::TYPE_IRONING_FAN_START, Slic3r::CoolingLine::TYPE_OVERHANG_FAN_END, Slic3r::CoolingLine::TYPE_OVERHANG_FAN_START, Slic3r::CoolingLine::TYPE_SET_TOOL, Slic3r::CoolingLine::TYPE_SUPPORT_INTERFACE_FAN_END, Slic3r::CoolingLine::TYPE_SUPPORT_INTERFACE_FAN_START, Slic3r::CoolingLine::TYPE_WIPE, and Slic3r::wipe().

Referenced by process_layer().

Here is the call graph for this function:

Here is the caller graph for this function:

process_layer()

std::string Slic3r::CoolingBuffer::process_layer	(	std::string &&	gcode,
		size_t	layer_id,
		bool	flush )

{
    // Cache the input G-code.
    if (m_gcode.empty())
        m_gcode = std::move(gcode);
    else
        m_gcode += gcode;
 
    std::string out;
    if (flush) {
        // This is either an object layer or the very last print layer. Calculate cool down over the collected support layers
        // and one object layer.
        std::vector<PerExtruderAdjustments> per_extruder_adjustments = this->parse_layer_gcode(m_gcode, m_current_pos);
        float layer_time_stretched = this->calculate_layer_slowdown(per_extruder_adjustments);
        out = this->apply_layer_cooldown(m_gcode, layer_id, layer_time_stretched, per_extruder_adjustments);
        m_gcode.clear();
    }
    return out;
}

References apply_layer_cooldown(), calculate_layer_slowdown(), m_current_pos, m_gcode, and parse_layer_gcode().

Here is the call graph for this function:

reset()

void Slic3r::CoolingBuffer::reset

(

const Vec3d &

position

)

{
    m_belt_band_active = false;
    // BBS: add I and J axis to store center of arc
    m_current_pos.assign(7, 0.f);
    m_current_pos[0] = float(position.x());
    m_current_pos[1] = float(position.y());
    m_current_pos[2] = float(position.z());
    m_current_pos[4] = float(m_config.travel_speed.get_at(m_current_nozzle));
    m_fan_speed = -1;
    m_additional_fan_speed = -1;
    m_current_fan_speed = -1;
}

References m_additional_fan_speed, m_belt_band_active, m_config, m_current_fan_speed, m_current_nozzle, m_current_pos, and m_fan_speed.

Referenced by CoolingBuffer().

Here is the caller graph for this function:

set_current_extruder()

void Slic3r::CoolingBuffer::set_current_extruder ( unsigned int extruder_id, unsigned int nozzle_id )

inline

{ m_current_extruder = extruder_id; m_current_nozzle = nozzle_id; }

References m_current_extruder, and m_current_nozzle.

Member Data Documentation

m_additional_fan_speed

int Slic3r::CoolingBuffer::m_additional_fan_speed

private

Referenced by apply_layer_cooldown(), and reset().

m_axis

std::vector<char> Slic3r::CoolingBuffer::m_axis

private

m_belt_band_active

bool Slic3r::CoolingBuffer::m_belt_band_active = false

private

Referenced by apply_layer_cooldown(), and reset().

m_config

const PrintConfig& Slic3r::CoolingBuffer::m_config

private

Referenced by CoolingBuffer(), apply_layer_cooldown(), parse_layer_gcode(), and reset().

m_current_extruder

unsigned int Slic3r::CoolingBuffer::m_current_extruder

private

Referenced by CoolingBuffer(), apply_layer_cooldown(), parse_layer_gcode(), and set_current_extruder().

m_current_fan_speed

int Slic3r::CoolingBuffer::m_current_fan_speed

private

Referenced by apply_layer_cooldown(), and reset().

m_current_nozzle

unsigned int Slic3r::CoolingBuffer::m_current_nozzle

private

Referenced by CoolingBuffer(), reset(), and set_current_extruder().

m_current_pos

std::vector<float> Slic3r::CoolingBuffer::m_current_pos

private

Referenced by process_layer(), and reset().

m_extruder_ids

std::vector<unsigned int> Slic3r::CoolingBuffer::m_extruder_ids

private

Referenced by CoolingBuffer(), and parse_layer_gcode().

m_fan_speed

int Slic3r::CoolingBuffer::m_fan_speed

private

Referenced by apply_layer_cooldown(), and reset().

m_gcode

std::string Slic3r::CoolingBuffer::m_gcode

private

Referenced by process_layer().

m_gcodegen

const GCode& Slic3r::CoolingBuffer::m_gcodegen

private

Referenced by CoolingBuffer(), and apply_layer_cooldown().

m_num_extruders

unsigned int Slic3r::CoolingBuffer::m_num_extruders { 0 }

private

{ 0 };

Referenced by CoolingBuffer(), and parse_layer_gcode().

m_toolchange_prefix

const std::string Slic3r::CoolingBuffer::m_toolchange_prefix

private

Referenced by CoolingBuffer(), apply_layer_cooldown(), and parse_layer_gcode().

---

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

• /home/runner/work/OrcaSlicer/OrcaSlicer/src/libslic3r/GCode/CoolingBuffer.hpp
• /home/runner/work/OrcaSlicer/OrcaSlicer/src/libslic3r/GCode/CoolingBuffer.cpp