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

Collaboration diagram for Slic3r::FanMover:

Public Member Functions
	FanMover (const GCodeWriter &writer, const float nb_seconds_delay, const bool with_D_option, const bool relative_e, const bool only_overhangs, const float kickstart)
const std::string &	process_gcode (const std::string &gcode, bool flush)

Private Member Functions
BufferData &	put_in_buffer (BufferData &&data)
std::list< BufferData >::iterator	remove_from_buffer (std::list< BufferData >::iterator data)
void	_process_gcode_line (GCodeReader &reader, const GCodeReader::GCodeLine &line)
void	_process_T (const std::string_view command)
bool	high_precision (const BufferData &line) const
void	_put_in_middle_G1 (std::list< BufferData >::iterator item_to_split, float nb_sec, BufferData &&line_to_write)
void	_print_in_middle_G1 (BufferData &line_to_split, float nb_sec, const std::string &line_to_write)
void	_remove_slow_fan (int16_t min_speed, float past_sec)
std::string	_set_fan (int16_t speed)

Private Attributes
const std::regex	regex_fan_speed
const float	nb_seconds_delay
const bool	with_D_option
const bool	relative_e
const bool	only_overhangs
const float	kickstart
const bool	m_high_precision
GCodeReader	m_parser {}
const GCodeWriter &	m_writer
ExtrusionRole	current_role = ExtrusionRole::erCustom
double	m_current_speed = 1000 / 60.0
bool	m_is_custom_gcode = false
uint16_t	m_currrent_extruder = 0
int	m_front_buffer_fan_speed = 0
int	m_back_buffer_fan_speed = 0
BufferData	m_current_kickstart {"",-1,0}
std::list< BufferData >	m_buffer
double	m_buffer_time_size = 0
std::string	m_process_output

Detailed Description

Constructor & Destructor Documentation

◆ FanMover()

Slic3r::FanMover::FanMover	(	const GCodeWriter &	writer,
		const float	nb_seconds_delay,
		const bool	with_D_option,
		const bool	relative_e,
		const bool	only_overhangs,
		const float	kickstart )

inline

        : regex_fan_speed("S[0-9]+"), 
        nb_seconds_delay(nb_seconds_delay>0 ? std::max(0.01f,nb_seconds_delay) : 0),
        with_D_option(with_D_option)
        , relative_e(relative_e), only_overhangs(only_overhangs), kickstart(kickstart)
        , m_high_precision(writer.config.high_precision_gcode.value), m_writer(writer){
        m_parser.apply_config(writer.config);
    }

References Slic3r::GCodeWriter::config, Slic3r::high_precision_gcode(), kickstart, m_high_precision, m_parser, m_writer, nb_seconds_delay, only_overhangs, regex_fan_speed, relative_e, and with_D_option.

Here is the call graph for this function:

Member Function Documentation

◆ _print_in_middle_G1()

void Slic3r::FanMover::_print_in_middle_G1	(	BufferData &	line_to_split,
		float	nb_sec,
		const std::string &	line_to_write )

private

                                                                                                          {
    if (nb_sec < line_to_split.time * 0.1) {
        // Doesn't need to be split: the insertion point is at the start.
        m_process_output += line_to_write + (line_to_write.back() == '\n'?"":"\n");
        m_process_output += line_to_split.raw + "\n";
    } else if (nb_sec > line_to_split.time * 0.9) {
        // Doesn't need to be split: the insertion point is at the end.
        m_process_output += line_to_split.raw + "\n";
        m_process_output += line_to_write + (line_to_write.back() == '\n' ? "" : "\n");
    }else if(line_to_split.raw.size() > 2
        && line_to_split.raw[0] == 'G' && line_to_split.raw[1] == '1' && line_to_split.raw[2] == ' ') {
        float percent = nb_sec / line_to_split.time;
        const int xyz_digits = GCodeFormatter::xyz_digits(high_precision(line_to_split));
        const int e_digits   = GCodeFormatter::e_digits(high_precision(line_to_split));
        std::string before = line_to_split.raw;
        std::string& after = line_to_split.raw;
        if (line_to_split.dx != 0) {
            change_axis_value(before, 'X', line_to_split.x + line_to_split.dx * percent, xyz_digits);
        }
        if (line_to_split.dy != 0) {
            change_axis_value(before, 'Y', line_to_split.y + line_to_split.dy * percent, xyz_digits);
        }
        if (line_to_split.dz != 0) {
            change_axis_value(before, 'Z', line_to_split.z + line_to_split.dz * percent, xyz_digits);
        }
        if (line_to_split.de != 0) {
            if (relative_e) {
                change_axis_value(before, 'E', line_to_split.de * percent, e_digits);
                change_axis_value(after, 'E', line_to_split.de * (1 - percent), e_digits);
            } else {
                change_axis_value(before, 'E', line_to_split.e + line_to_split.de * percent, e_digits);
            }
        }
        m_process_output += before + "\n";
        m_process_output += line_to_write + (line_to_write.back() == '\n' ? "" : "\n");
        m_process_output += line_to_split.raw + "\n";
 
    } else {
        //not a G1, print it before
        m_process_output += line_to_write + (line_to_write.back() == '\n' ? "" : "\n");
        m_process_output += line_to_split.raw + "\n";
    }
}

References Slic3r::change_axis_value(), Slic3r::BufferData::de, Slic3r::BufferData::dx, Slic3r::BufferData::dy, Slic3r::BufferData::dz, Slic3r::BufferData::e, Slic3r::GCodeFormatter::e_digits(), high_precision(), m_process_output, Slic3r::BufferData::raw, relative_e, Slic3r::BufferData::time, Slic3r::BufferData::x, Slic3r::GCodeFormatter::xyz_digits(), Slic3r::BufferData::y, and Slic3r::BufferData::z.

Referenced by _process_gcode_line().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ _process_gcode_line()

void Slic3r::FanMover::_process_gcode_line	(	GCodeReader &	reader,
		const GCodeReader::GCodeLine &	line )

private

{
    // processes 'normal' gcode lines
    bool need_flush = false;
    std::string cmd(line.cmd());
    double time = 0;
    int16_t fan_speed = -1;
    if (cmd.length() > 1) {
        if (line.has_f())
            m_current_speed = line.f() / 60.0f;
        switch (::toupper(cmd[0])) {
        case 'T':
        case 't':
            _process_T(cmd);
                break;
        case 'G':
        {
            if (::atoi(&cmd[1]) == 1 || ::atoi(&cmd[1]) == 0) {
                double distx = line.dist_X(reader);
                double disty = line.dist_Y(reader);
                double distz = line.dist_Z(reader);
                double dist = distx * distx + disty * disty + distz * distz;
                if (dist > 0) {
                    dist = std::sqrt(dist);
                    time = dist / m_current_speed;
                }
            }
            break;
        }
        case 'M':
        {
            fan_speed = get_fan_speed(line.raw(), m_writer.config.gcode_flavor);
            if (fan_speed >= 0) {
                const auto fan_baseline = 255.0;
                fan_speed = 100 * fan_speed / fan_baseline;
                //speed change: stop kickstart reverting if any
                m_current_kickstart.time = -1;
                if (!m_is_custom_gcode) {
                    // if slow down => put in the queue. if not =>
                    if (m_back_buffer_fan_speed < fan_speed) {
                        if (nb_seconds_delay > 0 && (!only_overhangs || current_role == ExtrusionRole::erOverhangPerimeter)) {
                            //don't put this command in the queue
                            time = -1;
                            // this M106 need to go in the past
                            //check if we have ( kickstart and not in slowdown )
                            if (kickstart > 0 && fan_speed > m_front_buffer_fan_speed) {
                                //stop current kickstart , it's not relevant anymore
                                if (m_current_kickstart.time > 0) {
                                    m_current_kickstart.time = (-1);
                                }
 
                                //if kickstart
                                // first erase everything lower that that value
                                _remove_slow_fan(fan_speed, m_buffer_time_size + 1);
                                // then erase everything lower that kickstart
                                _remove_slow_fan(fan_baseline, kickstart);
                                // print me
                                if (!m_buffer.empty() && (m_buffer_time_size - m_buffer.front().time * 0.1) > nb_seconds_delay) {
                                    _print_in_middle_G1(m_buffer.front(), m_buffer_time_size - nb_seconds_delay, _set_fan(100));//m_writer.set_fan(100, true)); //FIXME extruder id (or use the gcode writer, but then you have to disable the multi-thread thing
                                    remove_from_buffer(m_buffer.begin());
                                } else {
                                    m_process_output += _set_fan(100);//m_writer.set_fan(100, true)); //FIXME extruder id (or use the gcode writer, but then you have to disable the multi-thread thing
                                }
                                //write it in the queue if possible
                                const float kickstart_duration = kickstart * float(fan_speed - m_front_buffer_fan_speed) / 100.f;
                                float time_count = kickstart_duration;
                                auto it = m_buffer.begin();
                                while (it != m_buffer.end() && time_count > 0) {
                                    time_count -= it->time;
                                    if (time_count< 0) {
                                        //found something that is lower than us
                                        _put_in_middle_G1(it, it->time + time_count, BufferData(std::string(line.raw()), 0, fan_speed, true));
                                        //found, stop
                                        break;
                                    }
                                    ++it;
                                }
                                if (time_count > 0) {
                                    //can't place it in the buffer, use m_current_kickstart
                                    m_current_kickstart.fan_speed = fan_speed;
                                    m_current_kickstart.time = time_count;
                                    m_current_kickstart.raw = line.raw();
                                }
                                m_front_buffer_fan_speed = fan_speed;
                            } else {
                                // first erase everything lower that that value
                                _remove_slow_fan(fan_speed, m_buffer_time_size + 1);
                                // then write the fan command
                                if (!m_buffer.empty() && (m_buffer_time_size - m_buffer.front().time * 0.1) > nb_seconds_delay) {
                                    _print_in_middle_G1(m_buffer.front(), m_buffer_time_size - nb_seconds_delay, line.raw());
                                    remove_from_buffer(m_buffer.begin());
                                } else {
                                    m_process_output += line.raw() + "\n";
                                }
                                m_front_buffer_fan_speed = fan_speed;
                            }
                        } else {
                            if (kickstart <= 0) {
                                //nothing to do
                                //we don't put time = -1; so it will printed in the buffer as other line are done
                            } else if (m_current_kickstart.time > 0) {
                                //cherry-pick this one
                                if (m_back_buffer_fan_speed >= fan_speed) {
                                    //stop kickstart
                                    m_current_kickstart.time = -1;
                                    //this will print me just after as time >=0
                                } else {
                                    // add some duration to the kickstart and use it for me.
                                    float kickstart_duration = kickstart * float(fan_speed - m_back_buffer_fan_speed) / 100.f;
                                    m_current_kickstart.fan_speed = fan_speed;
                                    m_current_kickstart.time += kickstart_duration;
                                    m_current_kickstart.raw = line.raw();
                                    //i'm printed by the m_current_kickstart
                                    time = -1;
                                }
                            } else if(m_back_buffer_fan_speed < fan_speed - 10){ //only kickstart if more than 10% change
                                //don't write this line, as it will need to be delayed
                                time = -1;
                                //get the duration of kickstart
                                float kickstart_duration = kickstart * float(fan_speed - m_back_buffer_fan_speed) / 100.f;
                                //if kickstart, write the M106 S[fan_baseline] first
                                //set the target speed and set the kickstart flag
                                put_in_buffer(BufferData(_set_fan(100)//m_writer.set_fan(100, true)); //FIXME extruder id (or use the gcode writer, but then you have to disable the multi-thread thing
                                    , 0, fan_speed, true));
                                //kickstart!
                                //m_process_output += m_writer.set_fan(100, true);
                                //add the normal speed line for the future
                                m_current_kickstart.fan_speed = fan_speed;
                                m_current_kickstart.time = kickstart_duration;
                                m_current_kickstart.raw = line.raw();
                            }
                        }
                    }
                    //update back buffer fan speed
                    m_back_buffer_fan_speed = fan_speed;
                } else {
                    // have to flush the buffer to avoid erasing a fan command.
                    need_flush = true;
                }
            }
            break;
        }
        }
    } else {
        if(!line.raw().empty() && line.raw().front() == ';')
        {
            if (line.raw().size() > 10 && line.raw().rfind(";TYPE:", 0) == 0) {
                // get the type of the next extrusions
                std::string extrusion_string = line.raw().substr(6, line.raw().size() - 6);
                current_role = ExtrusionEntity::string_to_role(extrusion_string);
            }
            if (line.raw().rfind(";_FAN_MOVER_SKIP_", 0) == 0) {
                // Internal markers: read here, then dropped from the output.
                m_is_custom_gcode = line.raw().rfind(";_FAN_MOVER_SKIP_START", 0) == 0;
                time = -1;
            }
            if (line.raw().size() > 16) {
                if (line.raw().rfind("; custom gcode", 0) != std::string::npos) {
                    if (line.raw().rfind("; custom gcode end", 0) != std::string::npos)
                        m_is_custom_gcode = false;
                    else
                        m_is_custom_gcode = true;
                }
            }
        }
    }
 
    if (time >= 0) {
        BufferData& new_data = put_in_buffer(BufferData(line.raw(), time, fan_speed));
        new_data.role = current_role;
        if (line.has(Axis::X)) {
            new_data.x = reader.x();
            new_data.dx = line.dist_X(reader);
        }
        if (line.has(Axis::Y)) {
            new_data.y = reader.y();
            new_data.dy = line.dist_Y(reader);
        }
        if (line.has(Axis::Z)) {
            new_data.z = reader.z();
            new_data.dz = line.dist_Z(reader);
        }
        if (line.has(Axis::E)) {
            new_data.e = reader.e();
            if (relative_e)
                new_data.de = line.e();
            else
                new_data.de = line.dist_E(reader);
        }
 
        if (m_current_kickstart.time > 0 && time > 0) {
            m_current_kickstart.time -= time;
            if (m_current_kickstart.time < 0) {
                //prev is possible because we just do a emplace_back.
                _put_in_middle_G1(prev(m_buffer.end()), time + m_current_kickstart.time, BufferData{ m_current_kickstart.raw, 0, m_current_kickstart.fan_speed, true });
            }
        }
    }/* else {
        BufferData& new_data = put_in_buffer(BufferData("; del? "+line.raw(), 0, fan_speed));
        if (line.has(Axis::X)) {
            new_data.x = reader.x();
            new_data.dx = line.dist_X(reader);
        }
        if (line.has(Axis::Y)) {
            new_data.y = reader.y();
            new_data.dy = line.dist_Y(reader);
        }
        if (line.has(Axis::Z)) {
            new_data.z = reader.z();
            new_data.dz = line.dist_Z(reader);
        }
        if (line.has(Axis::E)) {
            new_data.e = reader.e();
            if (relative_e)
                new_data.de = line.e();
            else
                new_data.de = line.dist_E(reader);
        }
    }*/
    // puts the line back into the gcode
    //if buffer too big, flush it.
    if (time >= 0) {
        while (!m_buffer.empty() && (need_flush || m_buffer_time_size - m_buffer.front().time > nb_seconds_delay - EPSILON) ){
            BufferData& frontdata = m_buffer.front();
            if (frontdata.fan_speed < 0 || frontdata.fan_speed != m_front_buffer_fan_speed || frontdata.is_kickstart) {
                if (frontdata.is_kickstart && frontdata.fan_speed < m_front_buffer_fan_speed) {
                    //you have to slow down! not kickstart! rewrite the fan speed.
                    m_process_output += _set_fan(frontdata.fan_speed);//m_writer.set_fan(frontdata.fan_speed,true); //FIXME extruder id (or use the gcode writer, but then you have to disable the multi-thread thing
                        
                    m_front_buffer_fan_speed = frontdata.fan_speed;
                } else {
                    m_process_output += frontdata.raw + "\n";
                    if (frontdata.fan_speed >= 0) {
                        //note that this is the only place where the fan_speed is set and we print from the buffer, as if the fan_speed >= 0 => time == 0
                        //and as this flush all time == 0 lines from the back of the queue...
                        m_front_buffer_fan_speed = frontdata.fan_speed;
                    }
                }
            }
            remove_from_buffer(m_buffer.begin());
        }
    }
    double sum = 0;
    for (auto& data : m_buffer) sum += data.time;
    assert( std::abs(m_buffer_time_size - sum) < 0.01);
}

Referenced by process_gcode().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ _process_T()

void Slic3r::FanMover::_process_T ( const std::string_view command )

private

{
    if (command.length() > 1) {
        int eid = 0;
        if (!parse_number(command.substr(1), eid) || eid < 0 || eid > 255) {
            GCodeFlavor flavor = m_writer.config.gcode_flavor;
            // Specific to the MMU2 V2 (see https://www.help.prusa3d.com/en/article/prusa-specific-g-codes_112173):
            if ((flavor == gcfMarlinLegacy || flavor == gcfMarlinFirmware) && (command == "Tx" || command == "Tc" || command == "T?"))
                return;
 
            // T-1 is a valid gcode line for RepRap Firmwares (used to deselects all tools) see https://github.com/prusa3d/PrusaSlicer/issues/5677
            if ((flavor != gcfRepRapFirmware && flavor != gcfRepRapSprinter) || eid != -1)
                m_currrent_extruder = static_cast<uint16_t>(0);
        } else {
            m_currrent_extruder = static_cast<uint16_t>(eid);
        }
    }
}

References Slic3r::gcfMarlinFirmware, Slic3r::gcfMarlinLegacy, Slic3r::gcfRepRapFirmware, Slic3r::gcfRepRapSprinter, m_currrent_extruder, m_writer, and Slic3r::parse_number().

Referenced by _process_gcode_line().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ _put_in_middle_G1()

void Slic3r::FanMover::_put_in_middle_G1	(	std::list< BufferData >::iterator	item_to_split,
		float	nb_sec,
		BufferData &&	line_to_write )

private

                                                                                                                                            {
    assert(item_to_split != m_buffer.end());
    if (nb_sec_since_itemtosplit_start > item_to_split->time * 0.9) {
        // doesn't really need to be split, print it after
        m_buffer.insert(next(item_to_split), line_to_write);
    } else if (nb_sec_since_itemtosplit_start < item_to_split->time * 0.1) {
        // doesn't really need to be split, print it before
        //will also print before if line_to_split.time == 0
        m_buffer.insert(item_to_split, line_to_write);
    } else if (item_to_split->raw.size() > 2
        && item_to_split->raw[0] == 'G' && item_to_split->raw[1] == '1' && item_to_split->raw[2] == ' ') {
        float percent = nb_sec_since_itemtosplit_start / item_to_split->time;
        const int xyz_digits = GCodeFormatter::xyz_digits(high_precision(*item_to_split));
        const int e_digits   = GCodeFormatter::e_digits(high_precision(*item_to_split));
        BufferData before = *item_to_split;
        before.time *= percent;
        item_to_split->time *= (1-percent);
        if (item_to_split->dx != 0) {
            before.dx = item_to_split->dx * percent;
            item_to_split->x += before.dx;
            item_to_split->dx = item_to_split->dx * (1-percent);
            change_axis_value(before.raw, 'X', before.x + before.dx, xyz_digits);
        }
        if (item_to_split->dy != 0) {
            before.dy = item_to_split->dy * percent;
            item_to_split->y += before.dy;
            item_to_split->dy = item_to_split->dy * (1 - percent);
            change_axis_value(before.raw, 'Y', before.y + before.dy, xyz_digits);
        }
        if (item_to_split->dz != 0) {
            before.dz = item_to_split->dz * percent;
            item_to_split->z += before.dz;
            item_to_split->dz = item_to_split->dz * (1 - percent);
            change_axis_value(before.raw, 'Z', before.z + before.dz, xyz_digits);
        }
        if (item_to_split->de != 0) {
            if (relative_e) {
                before.de = item_to_split->de * percent;
                change_axis_value(before.raw, 'E', before.de, e_digits);
                item_to_split->de = item_to_split->de * (1 - percent);
                change_axis_value(item_to_split->raw, 'E', item_to_split->de, e_digits);
            } else {
                before.de = item_to_split->de * percent;
                item_to_split->e += before.de;
                item_to_split->de = item_to_split->de * (1 - percent);
                change_axis_value(before.raw, 'E', before.e + before.de, e_digits);
            }
        }
        //add before then line_to_write, then there is the modified data.
        m_buffer.insert(item_to_split, before);
        m_buffer.insert(item_to_split, line_to_write);
 
    } else {
        //not a G1, print it before
        m_buffer.insert(item_to_split, line_to_write);
    }
}

References Slic3r::change_axis_value(), Slic3r::BufferData::de, Slic3r::BufferData::dx, Slic3r::BufferData::dy, Slic3r::BufferData::dz, Slic3r::BufferData::e, Slic3r::GCodeFormatter::e_digits(), high_precision(), m_buffer, Slic3r::BufferData::raw, relative_e, Slic3r::BufferData::time, Slic3r::BufferData::x, Slic3r::GCodeFormatter::xyz_digits(), Slic3r::BufferData::y, and Slic3r::BufferData::z.

Referenced by _process_gcode_line().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ _remove_slow_fan()

void Slic3r::FanMover::_remove_slow_fan	(	int16_t	min_speed,
		float	past_sec )

private

                                                                 {
    //erase fan in the buffer -> don't slowdown if you are in the process of step-up.
    //we began at the "recent" side , and remove as long as we don't push past_sec to 0
    auto it = m_buffer.begin();
    while (it != m_buffer.end() && past_sec > 0) {
        past_sec -= it->time;
        if (it->fan_speed >= 0 && it->fan_speed < min_speed){
            //found something that is lower than us
            it = remove_from_buffer(it);
 
        } else {
            ++it;
        }
    }
 
}

References m_buffer, and remove_from_buffer().

Referenced by _process_gcode_line().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ _set_fan()

std::string Slic3r::FanMover::_set_fan ( int16_t speed )

private

                                          {
    //const Tool* tool = m_writer.get_tool(m_currrent_extruder < 20 ? m_currrent_extruder : 0);
    // ORCA: apply the per-printer non-zero fan PWM floor so reposted fan commands respect the clamp too.
    const int floor_pct = m_writer.config.part_cooling_fan_min_pwm.value;
    const unsigned int part_cooling_fan_min_pwm = floor_pct > 0 ? static_cast<unsigned int>(floor_pct) : 0u;
    return GCodeWriter::set_fan(m_writer.config.gcode_flavor.value, speed, part_cooling_fan_min_pwm);
}

References m_writer, Slic3r::part_cooling_fan_min_pwm(), and Slic3r::GCodeWriter::set_fan().

Referenced by _process_gcode_line().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ high_precision()

bool Slic3r::FanMover::high_precision ( const BufferData & line ) const

inlineprivate

97{ return m_high_precision && !is_support(line.role); }

Slic3r::is_support

bool is_support(ExtrusionRole role)

Definition ExtrusionEntity.hpp:113

References Slic3r::is_support(), m_high_precision, and Slic3r::BufferData::role.

Referenced by _print_in_middle_G1(), and _put_in_middle_G1().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ process_gcode()

const std::string & Slic3r::FanMover::process_gcode	(	const std::string &	gcode,
		bool	flush )

{
    m_process_output = "";
 
    // recompute buffer time to recover from rounding
    m_buffer_time_size = 0;
    for (auto& data : m_buffer) m_buffer_time_size += data.time;
 
    if(!gcode.empty())
        m_parser.parse_buffer(gcode,
            [this](GCodeReader& reader, const GCodeReader::GCodeLine& line) { /*m_process_output += line.raw() + "\n";*/ this->_process_gcode_line(reader, line); });
 
    if (flush) {
        while (!m_buffer.empty()) {
            BufferData &front = m_buffer.front();
            m_process_output += front.raw + "\n";
            // Orca: Keep the emitted fan state in sync when flushing buffered fan commands.
            if (front.fan_speed >= 0)
                m_front_buffer_fan_speed = front.fan_speed;
            remove_from_buffer(m_buffer.begin());
        }
    }
 
    return m_process_output;
}

References _process_gcode_line(), Slic3r::BufferData::fan_speed, m_buffer, m_buffer_time_size, m_front_buffer_fan_speed, m_parser, m_process_output, Slic3r::BufferData::raw, and remove_from_buffer().

Here is the call graph for this function:

◆ put_in_buffer()

BufferData & Slic3r::FanMover::put_in_buffer ( BufferData && data )

inlineprivate

                                                 {
        m_buffer_time_size += data.time;
        m_buffer.emplace_back(data);
        return m_buffer.back();
    }

References m_buffer, and m_buffer_time_size.

Referenced by _process_gcode_line().

Here is the caller graph for this function:

◆ remove_from_buffer()

std::list< BufferData >::iterator Slic3r::FanMover::remove_from_buffer ( std::list< BufferData >::iterator data )

inlineprivate

                                                                                     {
        m_buffer_time_size -= data->time;
        return m_buffer.erase(data);
    }

References m_buffer, and m_buffer_time_size.

Referenced by _process_gcode_line(), _remove_slow_fan(), and process_gcode().

Here is the caller graph for this function: