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

Collaboration diagram for Slic3r::GCodeProcessor::TimeBlock:

Classes
struct	Flags

Public Member Functions
void	calculate_trapezoid ()
float	time () const

Public Attributes
EMoveType	move_type { EMoveType::Noop }
ExtrusionRole	role { erNone }
SkipType	skippable_type { SkipType::stNone }
unsigned int	move_id { 0 }
unsigned int	g1_line_id { 0 }
unsigned int	remaining_internal_g1_lines { 0 }
unsigned int	layer_id { 0 }
float	distance { 0.0f }
float	acceleration { 0.0f }
float	max_entry_speed { 0.0f }
float	safe_feedrate { 0.0f }
float	junction_deviation { 0.0f }
float	max_mcr_entry_speed_sqr { 0.0f }
float	mcr_delta_v2 { 0.0f }
float	peak_cruise_v2 { 0.0f }
Flags	flags
FeedrateProfile	feedrate_profile
Trapezoid	trapezoid

Detailed Description

Class Documentation

◆ Slic3r::GCodeProcessor::TimeBlock::Flags

struct Slic3r::GCodeProcessor::TimeBlock::Flags

Class Members
bool	nominal_length { false }
bool	prepare_stage { false }
bool	recalculate { false }

Member Function Documentation

◆ calculate_trapezoid()

void Slic3r::GCodeProcessor::TimeBlock::calculate_trapezoid ( )

{
    float accelerate_distance = std::max(0.0f, estimated_acceleration_distance(feedrate_profile.entry, feedrate_profile.cruise, acceleration));
    const float decelerate_distance = std::max(0.0f, estimated_acceleration_distance(feedrate_profile.cruise, feedrate_profile.exit, -acceleration));
    float cruise_distance = distance - accelerate_distance - decelerate_distance;
 
    // Not enough space to reach the nominal feedrate.
    // This means no cruising, and we'll have to use intersection_distance() to calculate when to abort acceleration
    // and start braking in order to reach the exit_feedrate exactly at the end of this block.
    if (cruise_distance < 0.0f) {
        accelerate_distance = std::clamp(intersection_distance(feedrate_profile.entry, feedrate_profile.exit, acceleration, distance), 0.0f, distance);
        cruise_distance = 0.0f;
        trapezoid.cruise_feedrate = speed_from_distance(feedrate_profile.entry, accelerate_distance, acceleration);
    }
    else
        trapezoid.cruise_feedrate = feedrate_profile.cruise;
 
    trapezoid.accelerate_until = accelerate_distance;
    trapezoid.decelerate_after = accelerate_distance + cruise_distance;
}

References acceleration, distance, Slic3r::estimated_acceleration_distance(), feedrate_profile, Slic3r::intersection_distance(), Slic3r::speed_from_distance(), and trapezoid.

Referenced by Slic3r::GCodeProcessor::process_filament_change(), Slic3r::GCodeProcessor::process_filament_change(), Slic3r::GCodeProcessor::process_G1(), Slic3r::GCodeProcessor::process_VG1(), and Slic3r::recalculate_trapezoids().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ time()

float Slic3r::GCodeProcessor::TimeBlock::time ( ) const

inline

                               {
                return trapezoid.acceleration_time(feedrate_profile.entry, acceleration) +
                       trapezoid.cruise_time() + trapezoid.deceleration_time(distance, acceleration);
            }