QIDITECH/QIDIStudio
1
0
Fork 0
mirror of https://github.com/QIDITECH/QIDIStudio.git synced 2026-02-07 04:11:50 +03:00
Code Issues Packages Projects Releases Wiki Activity

update libslic3r

Browse Source
This commit is contained in:
QIDI TECH
2024-11-28 15:12:18 +08:00
parent 459e7822db
commit a26696f35e
115 changed files with 15117 additions and 4090 deletions
Download Patch File Download Diff File Expand all files Collapse all files

1
src/libslic3r/GCode/CoolingBuffer.hpp
View File

@@ -4,6 +4,7 @@
#include "../libslic3r.h"
#include <map>
#include <string>
#include <cfloat>
namespace Slic3r {

18
src/libslic3r/GCode/GCodeProcessor.cpp
View File

@@ -967,7 +967,6 @@ void GCodeProcessorResult::reset() {
filament_costs = std::vector<float>(MIN_EXTRUDERS_COUNT, DEFAULT_FILAMENT_COST);
custom_gcode_per_print_z = std::vector<CustomGCode::Item>();
spiral_vase_layers = std::vector<std::pair<float, std::pair<size_t, size_t>>>();
bed_match_result = BedMatchResult(true);
warnings.clear();
//QDS: add mutex for protection of gcode result
@@ -1961,12 +1960,14 @@ void GCodeProcessor::process_gcode_line(const GCodeReader::GCodeLine& line, bool
case '0': { process_M140(line); break; } // Set bed temperature
default: break;
}
break;
case '9':
switch (cmd[3]) {
case '0': { process_M190(line); break; } // Wait bed temperature
case '1': { process_M191(line); break; } // Wait chamber temperature
default: break;
}
}
break;
default:
break;
}
@@ -3257,6 +3258,16 @@ void GCodeProcessor::process_G1(const GCodeReader::GCodeLine& line)
m_seams_detector.set_first_vertex(m_result.moves.back().position - m_extruder_offsets[m_extruder_id] - plate_offset);
}
//QDS: some layer may only has G3/G3, update right layer height
if (m_detect_layer_based_on_tag && !m_result.spiral_vase_layers.empty()) {
if (delta_pos[Z] >= 0.0 && type == EMoveType::Extrude && m_result.spiral_vase_layers.back().first == FLT_MAX) {
// replace layer height placeholder with correct value
m_result.spiral_vase_layers.back().first = static_cast<float>(m_end_position[Z]);
}
if (!m_result.moves.empty())
m_result.spiral_vase_layers.back().second.second = m_result.moves.size() - 1 - m_seams_count;
}
if (m_detect_layer_based_on_tag && !m_result.spiral_vase_layers.empty()) {
if (delta_pos[Z] >= 0.0 && type == EMoveType::Extrude) {
const float current_z = static_cast<float>(m_end_position[Z]);
@@ -3706,7 +3717,8 @@ void GCodeProcessor::process_G29(const GCodeReader::GCodeLine& line)
{
//QDS: hardcode 260 seconds for G29
//Todo: use a machine related setting when we have second kind of QDT printer
const float value_s = 260.0;
//w39
const float value_s = 0.0;
simulate_st_synchronize(value_s);
}

26
src/libslic3r/GCode/GCodeProcessor.hpp
View File

@@ -117,23 +117,23 @@ namespace Slic3r {
ConflictResult() = default;
};
struct BedMatchResult
{
bool match;
std::string bed_type_name;
int extruder_id;
BedMatchResult():match(true),bed_type_name(""),extruder_id(-1) {}
BedMatchResult(bool _match,const std::string& _bed_type_name="",int _extruder_id=-1)
:match(_match),bed_type_name(_bed_type_name),extruder_id(_extruder_id)
{}
};
using ConflictResultOpt = std::optional<ConflictResult>;
struct FilamentPrintableResult
{
std::vector<int> conflict_filament;
std::string plate_name;
FilamentPrintableResult(){};
FilamentPrintableResult(std::vector<int> &conflict_filament, std::string plate_name) : conflict_filament(conflict_filament), plate_name(plate_name) {}
bool has_value(){
return !conflict_filament.empty();
};
};
struct GCodeProcessorResult
{
ConflictResultOpt conflict_result;
BedMatchResult bed_match_result;
FilamentPrintableResult filament_printable_reuslt;
struct SettingsIds
{
@@ -252,7 +252,7 @@ namespace Slic3r {
spiral_vase_layers = other.spiral_vase_layers;
warnings = other.warnings;
bed_type = other.bed_type;
bed_match_result = other.bed_match_result;
filament_printable_reuslt = other.filament_printable_reuslt;
#if ENABLE_GCODE_VIEWER_STATISTICS
time = other.time;
#endif

117
src/libslic3r/GCode/ToolOrdering.cpp
View File

@@ -954,7 +954,7 @@ void ToolOrdering::mark_skirt_layers(const PrintConfig &config, coordf_t max_lay
// QDS: replace model custom gcode with current plate custom gcode
static CustomGCode::Info custom_gcode_per_print_z;
void ToolOrdering::assign_custom_gcodes(const Print &print)
void ToolOrdering::assign_custom_gcodes(const Print& print)
{
// Only valid for non-sequential print.
assert(print.config().print_sequence == PrintSequence::ByLayer);
@@ -964,54 +964,75 @@ void ToolOrdering::assign_custom_gcodes(const Print &print)
return;
// QDS
auto num_filaments = unsigned(print.config().filament_diameter.size());
CustomGCode::Mode mode =
(num_filaments == 1) ? CustomGCode::SingleExtruder :
print.object_extruders().size() == 1 ? CustomGCode::MultiAsSingle : CustomGCode::MultiExtruder;
CustomGCode::Mode model_mode = print.model().get_curr_plate_custom_gcodes().mode;
std::vector<unsigned char> extruder_printing_above(num_filaments, false);
auto custom_gcode_it = custom_gcode_per_print_z.gcodes.rbegin();
// Tool changes and color changes will be ignored, if the model's tool/color changes were entered in mm mode and the print is in non mm mode
// or vice versa.
bool ignore_tool_and_color_changes = (mode == CustomGCode::MultiExtruder) != (model_mode == CustomGCode::MultiExtruder);
// If printing on a single extruder machine, make the tool changes trigger color change (M600) events.
bool tool_changes_as_color_changes = mode == CustomGCode::SingleExtruder && model_mode == CustomGCode::MultiAsSingle;
auto num_filaments = unsigned(print.config().filament_diameter.size());
CustomGCode::Mode mode =
(num_filaments == 1) ? CustomGCode::SingleExtruder :
print.object_extruders().size() == 1 ? CustomGCode::MultiAsSingle : CustomGCode::MultiExtruder;
CustomGCode::Mode model_mode = print.model().get_curr_plate_custom_gcodes().mode;
auto custom_gcode_it = custom_gcode_per_print_z.gcodes.rbegin();
// Tool changes and color changes will be ignored, if the model's tool/color changes were entered in mm mode and the print is in non mm mode
// or vice versa.
bool ignore_tool_and_color_changes = (mode == CustomGCode::MultiExtruder) != (model_mode == CustomGCode::MultiExtruder);
// If printing on a single extruder machine, make the tool changes trigger color change (M600) events.
bool tool_changes_as_color_changes = mode == CustomGCode::SingleExtruder && model_mode == CustomGCode::MultiAsSingle;
// From the last layer to the first one:
for (auto it_lt = m_layer_tools.rbegin(); it_lt != m_layer_tools.rend(); ++ it_lt) {
LayerTools &lt = *it_lt;
// Add the extruders of the current layer to the set of extruders printing at and above this print_z.
for (unsigned int i : lt.extruders)
extruder_printing_above[i] = true;
// Skip all custom G-codes above this layer and skip all extruder switches.
for (; custom_gcode_it != custom_gcode_per_print_z.gcodes.rend() && (custom_gcode_it->print_z > lt.print_z + EPSILON || custom_gcode_it->type == CustomGCode::ToolChange); ++ custom_gcode_it);
if (custom_gcode_it == custom_gcode_per_print_z.gcodes.rend())
// Custom G-codes were processed.
break;
// Some custom G-code is configured for this layer or a layer below.
const CustomGCode::Item &custom_gcode = *custom_gcode_it;
// print_z of the layer below the current layer.
coordf_t print_z_below = 0.;
if (auto it_lt_below = it_lt; ++ it_lt_below != m_layer_tools.rend())
print_z_below = it_lt_below->print_z;
if (custom_gcode.print_z > print_z_below + 0.5 * EPSILON) {
// The custom G-code applies to the current layer.
bool color_change = custom_gcode.type == CustomGCode::ColorChange;
bool tool_change = custom_gcode.type == CustomGCode::ToolChange;
bool pause_or_custom_gcode = ! color_change && ! tool_change;
bool apply_color_change = ! ignore_tool_and_color_changes &&
// If it is color change, it will actually be useful as the exturder above will print.
// QDS
(color_change ?
mode == CustomGCode::SingleExtruder ||
(custom_gcode.extruder <= int(num_filaments) && extruder_printing_above[unsigned(custom_gcode.extruder - 1)]) :
tool_change && tool_changes_as_color_changes);
if (pause_or_custom_gcode || apply_color_change)
lt.custom_gcode = &custom_gcode;
// Consume that custom G-code event.
++ custom_gcode_it;
}
}
auto apply_custom_gcode_to_layer = [mode,
ignore_tool_and_color_changes,
tool_changes_as_color_changes,
num_filaments](LayerTools& lt, const std::vector<unsigned char>& extruder_printing_above, const CustomGCode::Item& item)
{
bool color_change = item.type == CustomGCode::ColorChange;
bool tool_change = item.type == CustomGCode::ToolChange;
bool pause_or_custom_gcode = !color_change && !tool_change;
bool apply_color_change = !ignore_tool_and_color_changes &&
// If it is color change, it will actually be useful as the exturder above will print.
// BBS
(color_change ?
mode == CustomGCode::SingleExtruder ||
(item.extruder <= int(num_filaments) && extruder_printing_above[unsigned(item.extruder - 1)]) :
tool_change && tool_changes_as_color_changes);
if (pause_or_custom_gcode || apply_color_change)
lt.custom_gcode = &item;
};
std::unordered_map<int, std::vector<unsigned char>> extruder_print_above_by_layer;
{
std::vector<unsigned char> extruder_printing_above(num_filaments, false);
for (auto iter = m_layer_tools.rbegin(); iter != m_layer_tools.rend(); ++iter) {
for (unsigned int i : iter->extruders)
extruder_printing_above[i] = true;
int layer_idx = m_layer_tools.rend() - iter - 1;
extruder_print_above_by_layer.emplace(layer_idx, extruder_printing_above);
}
}
for (auto custom_gcode_it = custom_gcode_per_print_z.gcodes.rbegin(); custom_gcode_it != custom_gcode_per_print_z.gcodes.rend(); ++custom_gcode_it) {
if (custom_gcode_it->type == CustomGCode::ToolChange)
continue;
auto layer_it_upper = std::upper_bound(m_layer_tools.begin(), m_layer_tools.end(), custom_gcode_it->print_z, [](double z,const LayerTools& lt) {
return z < lt.print_z;
});
int upper_layer_idx = layer_it_upper - m_layer_tools.begin();
if (layer_it_upper == m_layer_tools.begin()) {
apply_custom_gcode_to_layer(*layer_it_upper, extruder_print_above_by_layer[0], *custom_gcode_it);
}
else if (layer_it_upper == m_layer_tools.end()) {
auto layer_it_lower = std::prev(layer_it_upper);
int lower_layer_idx = layer_it_lower - m_layer_tools.begin();
apply_custom_gcode_to_layer(*layer_it_lower, extruder_print_above_by_layer[lower_layer_idx], *custom_gcode_it);
}
else {
auto layer_it_lower = std::prev(layer_it_upper);
int lower_layer_idx = layer_it_lower - m_layer_tools.begin();
double gap_to_lower = std::fabs(custom_gcode_it->print_z - layer_it_lower->print_z);
double gap_to_upper = std::fabs(custom_gcode_it->print_z - layer_it_upper->print_z);
if (gap_to_lower < gap_to_upper)
apply_custom_gcode_to_layer(*layer_it_lower, extruder_print_above_by_layer[lower_layer_idx], *custom_gcode_it);
else
apply_custom_gcode_to_layer(*layer_it_upper, extruder_print_above_by_layer[upper_layer_idx], *custom_gcode_it);
}
}
}
const LayerTools& ToolOrdering::tools_for_layer(coordf_t print_z) const

95
src/libslic3r/GCode/WipeTower.cpp
View File

@@ -14,6 +14,7 @@
namespace Slic3r
{
static const double wipe_tower_wall_infill_overlap = 0.0;
inline float align_round(float value, float base)
{
@@ -115,7 +116,7 @@ public:
WipeTowerWriter& set_initial_tool(size_t tool) { m_current_tool = tool; return *this; }
WipeTowerWriter& set_z(float z)
WipeTowerWriter& set_z(float z)
{ m_current_z = z; return *this; }
WipeTowerWriter& set_extrusion_flow(float flow)
@@ -171,7 +172,7 @@ public:
// Extrude with an explicitely provided amount of extrusion.
WipeTowerWriter& extrude_explicit(float x, float y, float e, float f = 0.f, bool record_length = false, bool limit_volumetric_flow = true)
{
if (x == m_current_pos.x() && y == m_current_pos.y() && e == 0.f && (f == 0.f || f == m_current_feedrate))
if ((std::abs(x - m_current_pos.x()) <= (float)EPSILON) && (std::abs(y - m_current_pos.y()) < (float)EPSILON) && e == 0.f && (f == 0.f || f == m_current_feedrate))
// Neither extrusion nor a travel move.
return *this;
@@ -234,7 +235,7 @@ public:
WipeTowerWriter& travel(float x, float y, float f = 0.f)
{ return extrude_explicit(x, y, 0.f, f); }
WipeTowerWriter& travel(const Vec2f &dest, float f = 0.f)
WipeTowerWriter& travel(const Vec2f &dest, float f = 0.f)
{ return extrude_explicit(dest.x(), dest.y(), 0.f, f); }
// Extrude a line from current position to x, y with the extrusion amount given by m_extrusion_flow.
@@ -245,7 +246,7 @@ public:
return extrude_explicit(x, y, std::sqrt(dx*dx+dy*dy) * m_extrusion_flow, f, true);
}
WipeTowerWriter& extrude(const Vec2f &dest, const float f = 0.f)
WipeTowerWriter& extrude(const Vec2f &dest, const float f = 0.f)
{ return extrude(dest.x(), dest.y(), f); }
WipeTowerWriter& rectangle(const Vec2f& ld,float width,float height,const float f = 0.f)
@@ -296,7 +297,7 @@ public:
do {
++i;
if (i == 4) i = 0;
if (need_change_flow) {
if (need_change_flow) {
if (i == 1) {
// using bridge flow in bridge area, and add notes for gcode-check when flow changed
set_extrusion_flow(wipe_tower->extrusion_flow(0.2));
@@ -355,7 +356,7 @@ public:
// Elevate the extruder head above the current print_z position.
WipeTowerWriter& z_hop(float hop, float f = 0.f)
{
{
m_gcode += std::string("G1") + set_format_Z(m_current_z + hop);
if (f != 0 && f != m_current_feedrate)
m_gcode += set_format_F(f);
@@ -364,7 +365,7 @@ public:
}
// Lower the extruder head back to the current print_z position.
WipeTowerWriter& z_hop_reset(float f = 0.f)
WipeTowerWriter& z_hop_reset(float f = 0.f)
{ return z_hop(0, f); }
// Move to x1, +y_increment,
@@ -415,26 +416,22 @@ public:
return *this;
}
// Let the firmware back up the active speed override value.
WipeTowerWriter& speed_override_backup()
// Let the firmware back up the active speed override value.
WipeTowerWriter& speed_override_backup()
{
// QDS: QDT machine don't support speed backup
#if 0
if (m_gcode_flavor == gcfMarlinLegacy || m_gcode_flavor == gcfMarlinFirmware)
m_gcode += "M220 B\n";
#endif
return *this;
return *this;
}
// Let the firmware restore the active speed override value.
WipeTowerWriter& speed_override_restore()
{
// QDS: QDT machine don't support speed restore
#if 0
// Let the firmware restore the active speed override value.
WipeTowerWriter& speed_override_restore()
{
// QDS: QDT machine don't support speed restore
if (m_gcode_flavor == gcfMarlinLegacy || m_gcode_flavor == gcfMarlinFirmware)
m_gcode += "M220 R\n";
#endif
return *this;
return *this;
}
// Set digital trimpot motor
@@ -452,14 +449,14 @@ public:
}
WipeTowerWriter& flush_planner_queue()
{
{
m_gcode += "G4 S0\n";
return *this;
}
// Reset internal extruder counter.
WipeTowerWriter& reset_extruder()
{
{
m_gcode += "G92 E0\n";
return *this;
}
@@ -722,7 +719,7 @@ void WipeTower::set_extruder(size_t idx, const PrintConfig& config)
// Returns gcode to prime the nozzles at the front edge of the print bed.
std::vector<WipeTower::ToolChangeResult> WipeTower::prime(
// print_z of the first layer.
float initial_layer_print_height,
float initial_layer_print_height,
// Extruder indices, in the order to be primed. The last extruder will later print the wipe tower brim, print brim and the object.
const std::vector<unsigned int> &tools,
// If true, the last priming are will be the same as the other priming areas, and the rest of the wipe will be performed inside the wipe tower.
@@ -739,7 +736,7 @@ WipeTower::ToolChangeResult WipeTower::tool_change(size_t tool, bool extrude_per
float wipe_depth = 0.f;
float wipe_length = 0.f;
float purge_volume = 0.f;
// Finds this toolchange info
if (tool != (unsigned int)(-1))
{
@@ -776,7 +773,7 @@ WipeTower::ToolChangeResult WipeTower::tool_change(size_t tool, bool extrude_per
.append(";--------------------\n");
writer.speed_override_backup();
writer.speed_override(100);
writer.speed_override(100);
Vec2f initial_position = cleaning_box.ld + Vec2f(0.f, m_depth_traversed);
writer.set_initial_position(initial_position, m_wipe_tower_width, m_wipe_tower_depth, m_internal_rotation);
@@ -799,12 +796,30 @@ WipeTower::ToolChangeResult WipeTower::tool_change(size_t tool, bool extrude_per
box_coordinates wt_box(Vec2f(0.f, (m_current_shape == SHAPE_REVERSED) ? m_layer_info->toolchanges_depth() - m_layer_info->depth : 0.f),
m_wipe_tower_width, m_layer_info->depth + m_perimeter_width);
// align the perimeter
Vec2f pos = initial_position;
switch (m_cur_layer_id % 4){
case 0:
pos = wt_box.ld;
break;
case 1:
pos = wt_box.rd;
break;
case 2:
pos = wt_box.ru;
break;
case 3:
pos = wt_box.lu;
break;
default: break;
}
writer.set_initial_position(pos, m_wipe_tower_width, m_wipe_tower_depth, m_internal_rotation);
wt_box = align_perimeter(wt_box);
writer.rectangle(wt_box);
writer.travel(initial_position);
}
if (first_toolchange_to_nonsoluble) {
{
writer.travel(Vec2f(0, 0));
writer.travel(initial_position);
}
@@ -819,7 +834,7 @@ WipeTower::ToolChangeResult WipeTower::tool_change(size_t tool, bool extrude_per
//QDS
//if (m_set_extruder_trimpot)
// writer.set_extruder_trimpot(550); // Reset the extruder current to a normal value.
writer.speed_override_restore();
writer.speed_override_restore();
writer.feedrate(m_travel_speed * 60.f)
.flush_planner_queue()
.reset_extruder()
@@ -846,7 +861,7 @@ void WipeTower::toolchange_Unload(
#if 0
float xl = cleaning_box.ld.x() + 1.f * m_perimeter_width;
float xr = cleaning_box.rd.x() - 1.f * m_perimeter_width;
const float line_width = m_perimeter_width * m_filpar[m_current_tool].ramming_line_width_multiplicator; // desired ramming line thickness
const float y_step = line_width * m_filpar[m_current_tool].ramming_step_multiplicator * m_extra_spacing; // spacing between lines in mm
@@ -1086,7 +1101,7 @@ void WipeTower::toolchange_Wipe(
if (m_depth_traversed != 0)
writer.travel(xl, writer.y() + dy);
#endif
bool need_change_flow = false;
// now the wiping itself:
for (int i = 0; true; ++i) {
@@ -1105,9 +1120,9 @@ void WipeTower::toolchange_Wipe(
}
if (m_left_to_right)
writer.extrude(xr + 0.25f * m_perimeter_width, writer.y(), wipe_speed);
writer.extrude(xr + wipe_tower_wall_infill_overlap * m_perimeter_width, writer.y(), wipe_speed);
else
writer.extrude(xl - 0.25f * m_perimeter_width, writer.y(), wipe_speed);
writer.extrude(xl - wipe_tower_wall_infill_overlap * m_perimeter_width, writer.y(), wipe_speed);
// QDS: recover the flow in non-bridging area
if (need_change_flow) {
@@ -1136,7 +1151,7 @@ void WipeTower::toolchange_Wipe(
//writer.add_wipe_point(writer.x(), writer.y())
// .add_wipe_point(writer.x(), writer.y() - dy)
// .add_wipe_point(! m_left_to_right ? m_wipe_tower_width : 0.f, writer.y() - dy);
// QDS: modify the wipe_path after toolchange
// QDS: modify the wipe_path after toolchange
writer.add_wipe_point(writer.x(), writer.y())
.add_wipe_point(! m_left_to_right ? m_wipe_tower_width : 0.f, writer.y());
@@ -1193,6 +1208,7 @@ WipeTower::ToolChangeResult WipeTower::finish_layer(bool extrude_perimeter, bool
bool first_layer = is_first_layer();
// QDS: speed up perimeter speed to 90mm/s for non-first layer
float feedrate = first_layer ? std::min(m_first_layer_speed * 60.f, 5400.f) : std::min(60.0f * m_filpar[m_current_tool].max_e_speed / m_extrusion_flow, 5400.f);
writer.feedrate(feedrate);
float fill_box_y = m_layer_info->toolchanges_depth() + m_perimeter_width;
box_coordinates fill_box(Vec2f(m_perimeter_width, fill_box_y),
m_wipe_tower_width - 2 * m_perimeter_width, m_layer_info->depth - fill_box_y);
@@ -1470,7 +1486,7 @@ void WipeTower::plan_tower()
m_wipe_tower_depth = 0.f;
for (auto& layer : m_plan)
layer.depth = 0.f;
float max_depth_for_all = 0;
for (int layer_index = int(m_plan.size()) - 1; layer_index >= 0; --layer_index)
{
@@ -1479,7 +1495,7 @@ void WipeTower::plan_tower()
this_layer_depth = min_wipe_tower_depth;
m_plan[layer_index].depth = this_layer_depth;
if (this_layer_depth > m_wipe_tower_depth - m_perimeter_width)
m_wipe_tower_depth = this_layer_depth + m_perimeter_width;
@@ -1489,7 +1505,7 @@ void WipeTower::plan_tower()
m_plan[i].depth = this_layer_depth;
}
if (m_enable_timelapse_print && layer_index == 0)
if (m_enable_timelapse_print && layer_index == 0)
max_depth_for_all = m_plan[0].depth;
}
@@ -1551,7 +1567,7 @@ static WipeTower::ToolChangeResult merge_tcr(WipeTower::ToolChangeResult& first,
if (first.end_pos != second.start_pos)
out.gcode += "G1 X" + Slic3r::float_to_string_decimal_point(second.start_pos.x(), 3)
+ " Y" + Slic3r::float_to_string_decimal_point(second.start_pos.y(), 3)
+ " F7200\n";
+ "\n";
out.gcode += second.gcode;
out.extrusions.insert(out.extrusions.end(), second.extrusions.begin(), second.extrusions.end());
out.end_pos = second.end_pos;
@@ -1597,10 +1613,11 @@ void WipeTower::generate(std::vector<std::vector<WipeTower::ToolChangeResult>> &
used = 0.f;
m_old_temperature = -1; // reset last temperature written in the gcode
int index = 0;
std::vector<WipeTower::ToolChangeResult> layer_result;
for (auto layer : m_plan)
{
m_cur_layer_id = index++;
set_layer(layer.z, layer.height, 0, false/*layer.z == m_plan.front().z*/, layer.z == m_plan.back().z);
// QDS
//m_internal_rotation += 180.f;
@@ -1624,14 +1641,14 @@ void WipeTower::generate(std::vector<std::vector<WipeTower::ToolChangeResult>> &
// if there is no toolchange switching to non-soluble, finish layer
// will be called at the very beginning. That's the last possibility
// where a nonsoluble tool can be.
if (m_enable_timelapse_print) {
if (m_enable_timelapse_print) {
timelapse_wall = only_generate_out_wall();
}
finish_layer_tcr = finish_layer(m_enable_timelapse_print ? false : true, layer.extruder_fill);
}
for (int i=0; i<int(layer.tool_changes.size()); ++i) {
if (i == 0 && m_enable_timelapse_print) {
if (i == 0 && m_enable_timelapse_print) {
timelapse_wall = only_generate_out_wall();
}

2
src/libslic3r/GCode/WipeTower.hpp
View File

@@ -300,7 +300,7 @@ private:
float m_travel_speed = 0.f;
float m_first_layer_speed = 0.f;
size_t m_first_layer_idx = size_t(-1);
size_t m_cur_layer_id;
// G-code generator parameters.
// QDS: remove useless config
//float m_cooling_tube_retraction = 0.f;