Custom G-code references are now being assigned to ToolOrdering::LayerTools()

and the superfluous M600 (color change) events are filtered out there.

Fixed a handful of compiler warnings.

src/libslic3r/GCode/Analyzer.cpp

@@ -956,7 +956,7 @@ void GCodeAnalyzer::_calc_gcode_preview_extrusion_layers(GCodePreviewData& previ
 				GCodePreviewData::Extrusion::Path &path = paths.back();
                 path.polyline = polyline;
 				path.extrusion_role = data.extrusion_role;
-				path.mm3_per_mm = data.mm3_per_mm;
+				path.mm3_per_mm = float(data.mm3_per_mm);
 				path.width = data.width;
 				path.height = data.height;
                 path.feedrate = data.feedrate;

src/libslic3r/GCode/CoolingBuffer.cpp

@@ -303,8 +303,8 @@ std::vector<PerExtruderAdjustments> CoolingBuffer::parse_layer_gcode(const std::
         unsigned int            extruder_id = extruders[i].id();
         adj.extruder_id               = extruder_id;
         adj.cooling_slow_down_enabled = config.cooling.get_at(extruder_id);
-        adj.slowdown_below_layer_time = config.slowdown_below_layer_time.get_at(extruder_id);
-        adj.min_print_speed           = config.min_print_speed.get_at(extruder_id);
+        adj.slowdown_below_layer_time = float(config.slowdown_below_layer_time.get_at(extruder_id));
+        adj.min_print_speed           = float(config.min_print_speed.get_at(extruder_id));
         map_extruder_to_per_extruder_adjustment[extruder_id] = i;
     }
 

src/libslic3r/GCode/PrintExtents.cpp

@@ -29,7 +29,7 @@ static inline BoundingBox extrusion_polyline_extents(const Polyline &polyline, c
 
 static inline BoundingBoxf extrusionentity_extents(const ExtrusionPath &extrusion_path)
 {
-    BoundingBox bbox = extrusion_polyline_extents(extrusion_path.polyline, scale_(0.5 * extrusion_path.width));
+    BoundingBox bbox = extrusion_polyline_extents(extrusion_path.polyline, coord_t(scale_(0.5 * extrusion_path.width)));
     BoundingBoxf bboxf;
     if (! empty(bbox)) {
         bboxf.min = unscale(bbox.min);
@@ -43,7 +43,7 @@ static inline BoundingBoxf extrusionentity_extents(const ExtrusionLoop &extrusio
 {
     BoundingBox bbox;
     for (const ExtrusionPath &extrusion_path : extrusion_loop.paths)
-        bbox.merge(extrusion_polyline_extents(extrusion_path.polyline, scale_(0.5 * extrusion_path.width)));
+        bbox.merge(extrusion_polyline_extents(extrusion_path.polyline, coord_t(scale_(0.5 * extrusion_path.width))));
     BoundingBoxf bboxf;
     if (! empty(bbox)) {
         bboxf.min = unscale(bbox.min);
@@ -57,7 +57,7 @@ static inline BoundingBoxf extrusionentity_extents(const ExtrusionMultiPath &ext
 {
     BoundingBox bbox;
     for (const ExtrusionPath &extrusion_path : extrusion_multi_path.paths)
-        bbox.merge(extrusion_polyline_extents(extrusion_path.polyline, scale_(0.5 * extrusion_path.width)));
+        bbox.merge(extrusion_polyline_extents(extrusion_path.polyline, coord_t(scale_(0.5 * extrusion_path.width))));
     BoundingBoxf bboxf;
     if (! empty(bbox)) {
         bboxf.min = unscale(bbox.min);

src/libslic3r/GCode/ToolOrdering.cpp

@@ -15,6 +15,8 @@
 
 #include <libslic3r.h>
 
+#include "../GCodeWriter.hpp"
+
 namespace Slic3r {
 
 
@@ -99,7 +101,7 @@ ToolOrdering::ToolOrdering(const PrintObject &object, unsigned int first_extrude
 
 // For the use case when all objects are printed at once.
 // (print.config().complete_objects is false).
-ToolOrdering::ToolOrdering(const Print &print, unsigned int first_extruder, bool prime_multi_material, const std::vector<std::pair<double, unsigned int>> *per_layer_extruder_switches)
+ToolOrdering::ToolOrdering(const Print &print, unsigned int first_extruder, bool prime_multi_material)
 {
     m_print_config_ptr = &print.config();
 
@@ -124,9 +126,16 @@ ToolOrdering::ToolOrdering(const Print &print, unsigned int first_extruder, bool
         this->initialize_layers(zs);
     }
 
+	// Use the extruder switches from Model::custom_gcode_per_print_z to override the extruder to print the object.
+	// Do it only if all the objects were configured to be printed with a single extruder.
+	const std::vector<std::pair<double, unsigned int>> *per_layer_extruder_switches = (print.object_extruders().size() == 1) ? 
+		&custom_tool_changes(print.model(), (unsigned int)print.config().nozzle_diameter.size()) : nullptr;
+	if (per_layer_extruder_switches != nullptr && per_layer_extruder_switches->empty())
+		per_layer_extruder_switches = nullptr;
+
     // Collect extruders reuqired to print the layers.
     for (auto object : print.objects())
-        this->collect_extruders(*object, (per_layer_extruder_switches != nullptr && ! per_layer_extruder_switches->empty()) ? per_layer_extruder_switches : nullptr);
+        this->collect_extruders(*object, per_layer_extruder_switches);
 
     // Reorder the extruders to minimize tool switches.
     this->reorder_extruders(first_extruder);
@@ -134,6 +143,11 @@ ToolOrdering::ToolOrdering(const Print &print, unsigned int first_extruder, bool
     this->fill_wipe_tower_partitions(print.config(), object_bottom_z);
 
     this->collect_extruder_statistics(prime_multi_material);
+
+    // Assign custom G-code actions from Model::custom_gcode_per_print_z to their respecive layers,
+    // ignoring the extruder switches, which were processed above, and ignoring color changes for extruders,
+    // that do not print above their respective print_z.
+    this->assign_custom_gcodes(print);
 }
 
 void ToolOrdering::initialize_layers(std::vector<coordf_t> &zs)
@@ -444,6 +458,46 @@ void ToolOrdering::collect_extruder_statistics(bool prime_multi_material)
     }
 }
 
+// Assign a pointer to a custom G-code to the respective ToolOrdering::LayerTools.
+// Ignore color changes, which are performed on a layer and for such an extruder, that the extruder will not be printing above that layer.
+// If multiple events are planned over a span of a single layer, use the last one.
+void ToolOrdering::assign_custom_gcodes(const Print &print)
+{
+	const std::vector<Model::CustomGCode>	&custom_gcode_per_print_z = print.model().custom_gcode_per_print_z;
+	if (custom_gcode_per_print_z.empty())
+		return;
+
+	unsigned int 							 num_extruders = *std::max_element(m_all_printing_extruders.begin(), m_all_printing_extruders.end()) + 1;
+	std::vector<unsigned char> 				 extruder_printing_above(num_extruders, false);
+	auto 									 custom_gcode_it = custom_gcode_per_print_z.rbegin();
+	// 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.rend() && (custom_gcode_it->print_z > lt.print_z + EPSILON || custom_gcode_it->gcode == ExtruderChangeCode); ++ custom_gcode_it);
+		if (custom_gcode_it == custom_gcode_per_print_z.rend())
+			// Custom G-codes were processed.
+			break;
+		// Some custom G-code is configured for this layer or a layer below.
+		const Model::CustomGCode &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 - EPSILON) {
+			// The custom G-code applies to the current layer.
+			if (custom_gcode.gcode != ColorChangeCode || extruder_printing_above[unsigned(custom_gcode.extruder - 1)])
+				// If it is color change, it will actually be useful as the exturder above will print.
+        		lt.custom_gcode = &custom_gcode;
+			// Consume that custom G-code event.
+			-- custom_gcode_it;
+		}
+	}
+}
+
 const LayerTools& ToolOrdering::tools_for_layer(coordf_t print_z) const
 {
     auto it_layer_tools = std::lower_bound(m_layer_tools.begin(), m_layer_tools.end(), LayerTools(print_z - EPSILON));

src/libslic3r/GCode/ToolOrdering.hpp

@@ -80,14 +80,7 @@ private:
 class LayerTools
 {
 public:
-    LayerTools(const coordf_t z) :
-        print_z(z),
-        has_object(false),
-        has_support(false),
-        extruder_override(0),
-        has_wipe_tower(false),
-        wipe_tower_partitions(0),
-        wipe_tower_layer_height(0.) {}
+    LayerTools(const coordf_t z) : print_z(z) {}
 
     // Changing these operators to epsilon version can make a problem in cases where support and object layers get close to each other.
     // In case someone tries to do it, make sure you know what you're doing and test it properly (slice multiple objects at once with supports).
@@ -104,22 +97,24 @@ public:
 	// Returns a zero based extruder this eec should be printed with, according to PrintRegion config or extruder_override if overriden.
 	unsigned int extruder(const ExtrusionEntityCollection &extrusions, const PrintRegion &region) const;
 
-    coordf_t 					print_z;
-    bool 						has_object;
-    bool						has_support;
+    coordf_t 					print_z	= 0.;
+    bool 						has_object = false;
+    bool						has_support = false;
     // Zero based extruder IDs, ordered to minimize tool switches.
     std::vector<unsigned int> 	extruders;
     // If per layer extruder switches are inserted by the G-code preview slider, this value contains the new (1 based) extruder, with which the whole object layer is being printed with.
     // If not overriden, it is set to 0.
-    unsigned int 				extruder_override;
+    unsigned int 				extruder_override = 0;
     // Will there be anything extruded on this layer for the wipe tower?
     // Due to the support layers possibly interleaving the object layers,
     // wipe tower will be disabled for some support only layers.
-    bool 						has_wipe_tower;
+    bool 						has_wipe_tower = false;
     // Number of wipe tower partitions to support the required number of tool switches
     // and to support the wipe tower partitions above this one.
-    size_t                      wipe_tower_partitions;
-    coordf_t 					wipe_tower_layer_height;
+    size_t                      wipe_tower_partitions = 0;
+    coordf_t 					wipe_tower_layer_height = 0.;
+    // Custom G-code (color change, extruder switch, pause) to be performed before this layer starts to print.
+    const Model::CustomGCode   *custom_gcode = nullptr;
 
     WipingExtrusions& wiping_extrusions() {
         m_wiping_extrusions.set_layer_tools_ptr(this);
@@ -144,7 +139,7 @@ public:
 
     // For the use case when all objects are printed at once.
     // (print.config.complete_objects is false).
-    ToolOrdering(const Print &print, unsigned int first_extruder, bool prime_multi_material = false, const std::vector<std::pair<double, unsigned int>> *per_layer_extruder_switches = nullptr);
+    ToolOrdering(const Print &print, unsigned int first_extruder, bool prime_multi_material = false);
 
     void 				clear() { m_layer_tools.clear(); }
 
@@ -175,6 +170,7 @@ private:
     void				reorder_extruders(unsigned int last_extruder_id);
     void 				fill_wipe_tower_partitions(const PrintConfig &config, coordf_t object_bottom_z);
     void 				collect_extruder_statistics(bool prime_multi_material);
+	void 				assign_custom_gcodes(const Print &print);
 
     std::vector<LayerTools>    m_layer_tools;
     // First printing extruder, including the multi-material priming sequence.
@@ -184,7 +180,6 @@ private:
     // All extruders, which extrude some material over m_layer_tools.
     std::vector<unsigned int>  m_all_printing_extruders;
 
-
     const PrintConfig*         m_print_config_ptr = nullptr;
 };