Merge branch 'master' into lm_tm_hollowing

src/libslic3r/CMakeLists.txt

@@ -119,6 +119,8 @@ add_library(libslic3r STATIC
     Line.hpp
     Model.cpp
     Model.hpp
+    CustomGCode.cpp
+    CustomGCode.hpp
     Arrange.hpp
     Arrange.cpp
     MotionPlanner.cpp

src/libslic3r/CustomGCode.cpp

@@ -0,0 +1,72 @@
+#include "CustomGCode.hpp"
+#include "Config.hpp"
+#include "GCode/PreviewData.hpp"
+#include "GCodeWriter.hpp"
+
+namespace Slic3r {
+
+namespace CustomGCode {
+
+// If loaded configuration has a "colorprint_heights" option (if it was imported from older Slicer), 
+// and if CustomGCode::Info.gcodes is empty (there is no color print data available in a new format
+// then CustomGCode::Info.gcodes should be updated considering this option.
+extern void update_custom_gcode_per_print_z_from_config(Info& info, DynamicPrintConfig* config)
+{
+	auto *colorprint_heights = config->option<ConfigOptionFloats>("colorprint_heights");
+    if (colorprint_heights == nullptr)
+        return;
+    if (info.gcodes.empty() && ! colorprint_heights->values.empty()) {
+		// Convert the old colorprint_heighs only if there is no equivalent data in a new format.
+	    const std::vector<std::string>& colors = GCodePreviewData::ColorPrintColors();
+	    const auto& colorprint_values = colorprint_heights->values;
+        info.gcodes.clear();
+        info.gcodes.reserve(colorprint_values.size());
+        int i = 0;
+        for (auto val : colorprint_values)
+            info.gcodes.emplace_back(Item{ val, ColorChangeCode, 1, colors[(++i)%7] });
+
+        info.mode = SingleExtruder;
+	}
+
+	// The "colorprint_heights" config value has been deprecated. At this point of time it has been converted
+	// to a new format and therefore it shall be erased.
+    config->erase("colorprint_heights");
+}
+
+// If information for custom Gcode per print Z was imported from older Slicer, mode will be undefined.
+// So, we should set CustomGCode::Info.mode should be updated considering code values from items.
+extern void check_mode_for_custom_gcode_per_print_z(Info& info)
+{
+    if (info.mode != Undef)
+        return;
+
+    bool is_single_extruder = true;
+    for (auto item : info.gcodes) 
+    {
+        if (item.gcode == ToolChangeCode) {
+            info.mode = MultiAsSingle;
+            return;
+        }
+        if (item.gcode == ColorChangeCode && item.extruder > 1)
+            is_single_extruder = false;
+    }
+
+    info.mode = is_single_extruder ? SingleExtruder : MultiExtruder;
+}
+
+// Return pairs of <print_z, 1-based extruder ID> sorted by increasing print_z from custom_gcode_per_print_z.
+// print_z corresponds to the first layer printed with the new extruder.
+std::vector<std::pair<double, unsigned int>> custom_tool_changes(const Info& custom_gcode_per_print_z, size_t num_extruders)
+{
+    std::vector<std::pair<double, unsigned int>> custom_tool_changes;
+    for (const Item& custom_gcode : custom_gcode_per_print_z.gcodes)
+        if (custom_gcode.gcode == ToolChangeCode) {
+            // If extruder count in PrinterSettings was changed, use default (0) extruder for extruders, more than num_extruders
+            custom_tool_changes.emplace_back(custom_gcode.print_z, static_cast<unsigned int>(custom_gcode.extruder > num_extruders ? 1 : custom_gcode.extruder));
+        }
+    return custom_tool_changes;
+}
+
+} // namespace CustomGCode
+
+} // namespace Slic3r

src/libslic3r/CustomGCode.hpp

@@ -0,0 +1,86 @@
+#ifndef slic3r_CustomGCode_hpp_
+#define slic3r_CustomGCode_hpp_
+
+#include <string>
+#include <vector>
+
+namespace Slic3r {
+
+class DynamicPrintConfig;
+
+// Additional Codes which can be set by user using DoubleSlider
+static constexpr char ColorChangeCode[] = "M600";
+static constexpr char PausePrintCode[]  = "M601";
+static constexpr char ToolChangeCode[]  = "tool_change";
+
+namespace CustomGCode {
+
+struct Item
+{
+    bool operator<(const Item& rhs) const { return this->print_z < rhs.print_z; }
+    bool operator==(const Item& rhs) const
+    {
+        return (rhs.print_z   == this->print_z    ) &&
+               (rhs.gcode     == this->gcode      ) &&
+               (rhs.extruder  == this->extruder   ) &&
+               (rhs.color     == this->color      );
+    }
+    bool operator!=(const Item& rhs) const { return ! (*this == rhs); }
+    
+    double      print_z;
+    std::string gcode;
+    int         extruder;   // Informative value for ColorChangeCode and ToolChangeCode
+                            // "gcode" == ColorChangeCode   => M600 will be applied for "extruder" extruder
+                            // "gcode" == ToolChangeCode    => for whole print tool will be switched to "extruder" extruder
+    std::string color;      // if gcode is equal to PausePrintCode, 
+                            // this field is used for save a short message shown on Printer display 
+};
+
+enum Mode
+{
+    Undef,
+    SingleExtruder,   // Single extruder printer preset is selected
+    MultiAsSingle,    // Multiple extruder printer preset is selected, but 
+                      // this mode works just for Single extruder print 
+                      // (For all print from objects settings is used just one extruder) 
+    MultiExtruder     // Multiple extruder printer preset is selected
+};
+
+// string anlogue of custom_code_per_height mode
+static constexpr char SingleExtruderMode[] = "SingleExtruder";
+static constexpr char MultiAsSingleMode [] = "MultiAsSingle";
+static constexpr char MultiExtruderMode [] = "MultiExtruder";
+
+struct Info
+{
+    Mode mode = Undef;
+    std::vector<Item> gcodes;
+
+    bool operator==(const Info& rhs) const
+    {
+        return  (rhs.mode   == this->mode   ) &&
+                (rhs.gcodes == this->gcodes );
+    }
+    bool operator!=(const Info& rhs) const { return !(*this == rhs); }
+};
+
+// If loaded configuration has a "colorprint_heights" option (if it was imported from older Slicer), 
+// and if CustomGCode::Info.gcodes is empty (there is no color print data available in a new format
+// then CustomGCode::Info.gcodes should be updated considering this option.
+extern void update_custom_gcode_per_print_z_from_config(Info& info, DynamicPrintConfig* config);
+
+// If information for custom Gcode per print Z was imported from older Slicer, mode will be undefined.
+// So, we should set CustomGCode::Info.mode should be updated considering code values from items.
+extern void check_mode_for_custom_gcode_per_print_z(Info& info);
+
+// Return pairs of <print_z, 1-based extruder ID> sorted by increasing print_z from custom_gcode_per_print_z.
+// print_z corresponds to the first layer printed with the new extruder.
+std::vector<std::pair<double, unsigned int>> custom_tool_changes(const Info& custom_gcode_per_print_z, size_t num_extruders);
+
+} // namespace CustomGCode
+
+} // namespace Slic3r
+
+
+
+#endif /* slic3r_CustomGCode_hpp_ */

src/libslic3r/Format/3mf.cpp

@@ -1191,6 +1191,14 @@ namespace Slic3r {
 
             for (const auto& code : code_tree)
             {
+                if (code.first == "mode")
+                {
+                    pt::ptree tree = code.second;
+                    std::string mode = tree.get<std::string>("<xmlattr>.value");
+                    m_model->custom_gcode_per_print_z.mode = mode == CustomGCode::SingleExtruderMode ? CustomGCode::Mode::SingleExtruder :
+                                                             mode == CustomGCode::MultiAsSingleMode  ? CustomGCode::Mode::MultiAsSingle  :
+                                                             CustomGCode::Mode::MultiExtruder;
+                }
                 if (code.first != "code")
                     continue;
                 pt::ptree tree = code.second;
@@ -1199,7 +1207,7 @@ namespace Slic3r {
                 int extruder        = tree.get<int>         ("<xmlattr>.extruder"   );
                 std::string color   = tree.get<std::string> ("<xmlattr>.color"      );
 
-                m_model->custom_gcode_per_print_z.gcodes.push_back(Model::CustomGCode{print_z, gcode, extruder, color}) ;
+                m_model->custom_gcode_per_print_z.gcodes.push_back(CustomGCode::Item{print_z, gcode, extruder, color}) ;
             }
         }
     }
@@ -2767,7 +2775,7 @@ bool _3MF_Exporter::_add_custom_gcode_per_print_z_file_to_archive( mz_zip_archiv
         pt::ptree tree;
         pt::ptree& main_tree = tree.add("custom_gcodes_per_print_z", "");
 
-        for (const Model::CustomGCode& code : model.custom_gcode_per_print_z.gcodes)
+        for (const CustomGCode::Item& code : model.custom_gcode_per_print_z.gcodes)
         {
             pt::ptree& code_tree = main_tree.add("code", "");
             // store minX and maxZ
@@ -2775,7 +2783,13 @@ bool _3MF_Exporter::_add_custom_gcode_per_print_z_file_to_archive( mz_zip_archiv
             code_tree.put("<xmlattr>.gcode"     , code.gcode    );
             code_tree.put("<xmlattr>.extruder"  , code.extruder );
             code_tree.put("<xmlattr>.color"     , code.color    );
-        }       
+        }
+
+        pt::ptree& mode_tree = main_tree.add("mode", "");
+        // store mode of a custom_gcode_per_print_z 
+        mode_tree.put("<xmlattr>.value", model.custom_gcode_per_print_z.mode == CustomGCode::Mode::SingleExtruder ? CustomGCode::SingleExtruderMode :
+                                         model.custom_gcode_per_print_z.mode == CustomGCode::Mode::MultiAsSingle ?  CustomGCode::MultiAsSingleMode :
+                                         CustomGCode::MultiExtruderMode);
 
         if (!tree.empty())
         {

src/libslic3r/Format/AMF.cpp

@@ -13,6 +13,7 @@
 #include "../Utils.hpp"
 #include "../I18N.hpp"
 #include "../Geometry.hpp"
+#include "../CustomGCode.hpp"
 
 #include "AMF.hpp"
 
@@ -156,6 +157,7 @@ struct AMFParserContext
         NODE_TYPE_PRINTABLE,            // amf/constellation/instance/mirrorz
         NODE_TYPE_CUSTOM_GCODE,         // amf/custom_code_per_height
         NODE_TYPE_GCODE_PER_HEIGHT,     // amf/custom_code_per_height/code
+        NODE_TYPE_CUSTOM_GCODE_MODE,    // amf/custom_code_per_height/mode
         NODE_TYPE_METADATA,             // anywhere under amf/*/metadata
     };
 
@@ -308,12 +310,18 @@ void AMFParserContext::startElement(const char *name, const char **atts)
             else
                 this->stop();
         } 
-        else if (strcmp(name, "code") == 0 && m_path[1] == NODE_TYPE_CUSTOM_GCODE) {
-            node_type_new = NODE_TYPE_GCODE_PER_HEIGHT;
-            m_value[0] = get_attribute(atts, "height");
-            m_value[1] = get_attribute(atts, "gcode");
-            m_value[2] = get_attribute(atts, "extruder");
-            m_value[3] = get_attribute(atts, "color");
+        else if (m_path[1] == NODE_TYPE_CUSTOM_GCODE) {
+            if (strcmp(name, "code") == 0) {
+                node_type_new = NODE_TYPE_GCODE_PER_HEIGHT;
+                m_value[0] = get_attribute(atts, "print_z");
+                m_value[1] = get_attribute(atts, "gcode");
+                m_value[2] = get_attribute(atts, "extruder");
+                m_value[3] = get_attribute(atts, "color");
+            }
+            else if (strcmp(name, "mode") == 0) {
+                node_type_new = NODE_TYPE_CUSTOM_GCODE_MODE;
+                m_value[0] = get_attribute(atts, "value");
+            }
         }
         break;
     case 3:
@@ -632,18 +640,29 @@ void AMFParserContext::endElement(const char * /* name */)
         break;
 
     case NODE_TYPE_GCODE_PER_HEIGHT: {
-        double height = double(atof(m_value[0].c_str()));
+        double print_z = double(atof(m_value[0].c_str()));
         const std::string& gcode = m_value[1];
         int extruder = atoi(m_value[2].c_str());
         const std::string& color = m_value[3];
 
-        m_model.custom_gcode_per_print_z.gcodes.push_back(Model::CustomGCode{height, gcode, extruder, color});
+        m_model.custom_gcode_per_print_z.gcodes.push_back(CustomGCode::Item{print_z, gcode, extruder, color});
 
         for (std::string& val: m_value)
             val.clear();
         break;
         }
 
+    case NODE_TYPE_CUSTOM_GCODE_MODE: {
+        const std::string& mode = m_value[0];
+
+        m_model.custom_gcode_per_print_z.mode = mode == CustomGCode::SingleExtruderMode ? CustomGCode::Mode::SingleExtruder :
+                                                mode == CustomGCode::MultiAsSingleMode  ? CustomGCode::Mode::MultiAsSingle  :
+                                                                                          CustomGCode::Mode::MultiExtruder;
+        for (std::string& val: m_value)
+            val.clear();
+        break;
+        }
+
     case NODE_TYPE_METADATA:
         if ((m_config != nullptr) && strncmp(m_value[0].c_str(), SLIC3R_CONFIG_TYPE, strlen(SLIC3R_CONFIG_TYPE)) == 0)
             m_config->load_from_gcode_string(m_value[1].c_str());
@@ -1237,16 +1256,23 @@ bool store_amf(const char *path, Model *model, const DynamicPrintConfig *config)
 
         pt::ptree& main_tree = tree.add("custom_gcodes_per_height", "");
 
-        for (const Model::CustomGCode& code : model->custom_gcode_per_print_z.gcodes)
+        for (const CustomGCode::Item& code : model->custom_gcode_per_print_z.gcodes)
         {
             pt::ptree& code_tree = main_tree.add("code", "");
-            // store minX and maxZ
+            // store custom_gcode_per_print_z gcodes information 
             code_tree.put("<xmlattr>.print_z"   , code.print_z  );
             code_tree.put("<xmlattr>.gcode"     , code.gcode    );
             code_tree.put("<xmlattr>.extruder"  , code.extruder );
             code_tree.put("<xmlattr>.color"     , code.color    );
         }
 
+        pt::ptree& mode_tree = main_tree.add("mode", "");
+        // store mode of a custom_gcode_per_print_z 
+        mode_tree.put("<xmlattr>.value", 
+                      model->custom_gcode_per_print_z.mode == CustomGCode::Mode::SingleExtruder ? CustomGCode::SingleExtruderMode : 
+                      model->custom_gcode_per_print_z.mode == CustomGCode::Mode::MultiAsSingle  ?
+                      CustomGCode::MultiAsSingleMode  : CustomGCode::MultiExtruderMode);
+
         if (!tree.empty())
         {
             std::ostringstream oss;
@@ -1259,6 +1285,7 @@ bool store_amf(const char *path, Model *model, const DynamicPrintConfig *config)
 
             // Post processing("beautification") of the output string
             boost::replace_all(out, "><code", ">\n  <code");
+            boost::replace_all(out, "><mode", ">\n  <mode");
             boost::replace_all(out, "><", ">\n<");
 
             stream << out << "\n";

src/libslic3r/GCode.cpp

@@ -8,6 +8,7 @@
 #include "GCode/WipeTower.hpp"
 #include "ShortestPath.hpp"
 #include "Utils.hpp"
+#include "libslic3r.h"
 
 #include <algorithm>
 #include <cstdlib>
@@ -164,12 +165,12 @@ Polygons AvoidCrossingPerimeters::collect_contours_all_layers(const PrintObjectP
              cnt = (cnt + 1) / 2;
          }
          // And collect copies of the objects.
-        for (const Point &copy : object->copies()) {
+        for (const PrintInstance &instance : object->instances()) {
             // All the layers were reduced to the 1st item of polygons_per_layer.
              size_t i = islands.size();
              polygons_append(islands, polygons_per_layer.front());
              for (; i < islands.size(); ++ i)
-                islands[i].translate(copy);
+                islands[i].translate(instance.shift);
         }
     }
     return islands;
@@ -199,7 +200,7 @@ std::string OozePrevention::pre_toolchange(GCode &gcodegen)
     if (gcodegen.config().standby_temperature_delta.value != 0) {
         // we assume that heating is always slower than cooling, so no need to block
         gcode += gcodegen.writer().set_temperature
-            (this->_get_temp(gcodegen) + gcodegen.config().standby_temperature_delta.value, false);
+            (this->_get_temp(gcodegen) + gcodegen.config().standby_temperature_delta.value, false, gcodegen.writer().extruder()->id());
     }
     
     return gcode;
@@ -208,7 +209,7 @@ std::string OozePrevention::pre_toolchange(GCode &gcodegen)
 std::string OozePrevention::post_toolchange(GCode &gcodegen)
 {
     return (gcodegen.config().standby_temperature_delta.value != 0) ?
-        gcodegen.writer().set_temperature(this->_get_temp(gcodegen), true) :
+        gcodegen.writer().set_temperature(this->_get_temp(gcodegen), true, gcodegen.writer().extruder()->id()) :
         std::string();
 }
 
@@ -1086,6 +1087,41 @@ namespace DoExport {
 	}
 }
 
+// Sort the PrintObjects by their increasing Z, likely useful for avoiding colisions on Deltas during sequential prints.
+static inline std::vector<const PrintInstance*> sort_object_instances_by_max_z(const Print &print)
+{
+    std::vector<const PrintObject*> objects(print.objects().begin(), print.objects().end());
+	std::sort(objects.begin(), objects.end(), [](const PrintObject *po1, const PrintObject *po2) { return po1->size(2) < po2->size(2); });
+	std::vector<const PrintInstance*> instances;
+	instances.reserve(objects.size());
+	for (const PrintObject *object : objects)
+		for (size_t i = 0; i < object->instances().size(); ++ i)
+			instances.emplace_back(&object->instances()[i]);
+	return instances;
+}
+
+// Produce a vector of PrintObjects in the order of their respective ModelObjects in print.model().
+static inline std::vector<const PrintInstance*> sort_object_instances_by_model_order(const Print &print)
+{
+    // Build up map from ModelInstance* to PrintInstance*
+    std::vector<std::pair<const ModelInstance*, const PrintInstance*>> model_instance_to_print_instance;
+    model_instance_to_print_instance.reserve(print.num_object_instances());
+    for (const PrintObject *print_object : print.objects())
+        for (const PrintInstance &print_instance : print_object->instances())
+            model_instance_to_print_instance.emplace_back(print_instance.model_instance, &print_instance);
+    std::sort(model_instance_to_print_instance.begin(), model_instance_to_print_instance.end(), [](auto &l, auto &r) { return l.first < r.first; });
+
+    std::vector<const PrintInstance*> instances;
+    instances.reserve(model_instance_to_print_instance.size());
+    for (const ModelObject *model_object : print.model().objects)
+        for (const ModelInstance *model_instance : model_object->instances) {
+            auto it = std::lower_bound(model_instance_to_print_instance.begin(), model_instance_to_print_instance.end(), std::make_pair(model_instance, nullptr), [](auto &l, auto &r) { return l.first < r.first; });
+            if (it != model_instance_to_print_instance.end() && it->first == model_instance)
+                instances.emplace_back(it->second);
+        }
+    return instances;
+}
+
 #if ENABLE_THUMBNAIL_GENERATOR
 void GCode::_do_export(Print& print, FILE* file, ThumbnailsGeneratorCallback thumbnail_cb)
 #else
@@ -1117,7 +1153,7 @@ void GCode::_do_export(Print& print, FILE* file)
             for (auto layer : object->support_layers())
                 zs.push_back(layer->print_z);
             std::sort(zs.begin(), zs.end());
-            m_layer_count += (unsigned int)(object->copies().size() * (std::unique(zs.begin(), zs.end()) - zs.begin()));
+            m_layer_count += (unsigned int)(object->instances().size() * (std::unique(zs.begin(), zs.end()) - zs.begin()));
         }
     } else {
         // Print all objects with the same print_z together.
@@ -1210,13 +1246,18 @@ void GCode::_do_export(Print& print, FILE* file)
     ToolOrdering tool_ordering;
     unsigned int initial_extruder_id = (unsigned int)-1;
     unsigned int final_extruder_id   = (unsigned int)-1;
-    size_t       initial_print_object_id = 0;
     bool         has_wipe_tower      = false;
+    std::vector<const PrintInstance*> 					print_object_instances_ordering;
+    std::vector<const PrintInstance*>::const_iterator 	print_object_instance_sequential_active;
     if (print.config().complete_objects.value) {
+        // Order object instances for sequential print.
+        print_object_instances_ordering = sort_object_instances_by_model_order(print);
+//        print_object_instances_ordering = sort_object_instances_by_max_z(print);
         // Find the 1st printing object, find its tool ordering and the initial extruder ID.
-        for (; initial_print_object_id < print.objects().size(); ++initial_print_object_id) {
-            tool_ordering = ToolOrdering(*print.objects()[initial_print_object_id], initial_extruder_id);
-            if ((initial_extruder_id = tool_ordering.first_extruder()) != (unsigned int)-1)
+        print_object_instance_sequential_active = print_object_instances_ordering.begin();
+        for (; print_object_instance_sequential_active != print_object_instances_ordering.end(); ++ print_object_instance_sequential_active) {
+            tool_ordering = ToolOrdering(*(*print_object_instance_sequential_active)->print_object, initial_extruder_id);
+            if ((initial_extruder_id = tool_ordering.first_extruder()) != static_cast<unsigned int>(-1))
                 break;
         }
         // We don't allow switching of extruders per layer by Model::custom_gcode_per_print_z in sequential mode.
@@ -1236,6 +1277,8 @@ void GCode::_do_export(Print& print, FILE* file)
         // In non-sequential print, the printing extruders may have been modified by the extruder switches stored in Model::custom_gcode_per_print_z.
         // Therefore initialize the printing extruders from there.
     	this->set_extruders(tool_ordering.all_extruders());
+        // Order object instances using a nearest neighbor search.
+        print_object_instances_ordering = chain_print_object_instances(print);
     }
     if (initial_extruder_id == (unsigned int)-1) {
         // Nothing to print!
@@ -1316,72 +1359,64 @@ void GCode::_do_export(Print& print, FILE* file)
 
     // Do all objects for each layer.
     if (print.config().complete_objects.value) {
-        // Print objects from the smallest to the tallest to avoid collisions
-        // when moving onto next object starting point.
-        std::vector<PrintObject*> objects(print.objects());
-        std::sort(objects.begin(), objects.end(), [](const PrintObject* po1, const PrintObject* po2) { return po1->size(2) < po2->size(2); });       
         size_t finished_objects = 0;
-        for (size_t object_id = initial_print_object_id; object_id < objects.size(); ++ object_id) {
-            const PrintObject &object = *objects[object_id];
-            for (const Point &copy : object.copies()) {
-                // Get optimal tool ordering to minimize tool switches of a multi-exruder print.
-                if (object_id != initial_print_object_id || &copy != object.copies().data()) {
-                    // Don't initialize for the first object and first copy.
-                    tool_ordering = ToolOrdering(object, final_extruder_id);
-                    unsigned int new_extruder_id = tool_ordering.first_extruder();
-                    if (new_extruder_id == (unsigned int)-1)
-                        // Skip this object.
-                        continue;
-                    initial_extruder_id = new_extruder_id;
-                    final_extruder_id   = tool_ordering.last_extruder();
-                    assert(final_extruder_id != (unsigned int)-1);
-                }
-                print.throw_if_canceled();
-                this->set_origin(unscale(copy));
-                if (finished_objects > 0) {
-                    // Move to the origin position for the copy we're going to print.
-                    // This happens before Z goes down to layer 0 again, so that no collision happens hopefully.
-                    m_enable_cooling_markers = false; // we're not filtering these moves through CoolingBuffer
-                    m_avoid_crossing_perimeters.use_external_mp_once = true;
-                    _write(file, this->retract());
-                    _write(file, this->travel_to(Point(0, 0), erNone, "move to origin position for next object"));
-                    m_enable_cooling_markers = true;
-                    // Disable motion planner when traveling to first object point.
-                    m_avoid_crossing_perimeters.disable_once = true;
-                    // Ff we are printing the bottom layer of an object, and we have already finished
-                    // another one, set first layer temperatures. This happens before the Z move
-                    // is triggered, so machine has more time to reach such temperatures.
-                    m_placeholder_parser.set("current_object_idx", int(finished_objects));
-                    std::string between_objects_gcode = this->placeholder_parser_process("between_objects_gcode", print.config().between_objects_gcode.value, initial_extruder_id);
-                    // Set first layer bed and extruder temperatures, don't wait for it to reach the temperature.
-                    this->_print_first_layer_bed_temperature(file, print, between_objects_gcode, initial_extruder_id, false);
-                    this->_print_first_layer_extruder_temperatures(file, print, between_objects_gcode, initial_extruder_id, false);
-                    _writeln(file, between_objects_gcode);
-                }
-                // Reset the cooling buffer internal state (the current position, feed rate, accelerations).
-                m_cooling_buffer->reset();
-                m_cooling_buffer->set_current_extruder(initial_extruder_id);
-                // Pair the object layers with the support layers by z, extrude them.
-                std::vector<LayerToPrint> layers_to_print = collect_layers_to_print(object);
-                for (const LayerToPrint &ltp : layers_to_print) {
-                    std::vector<LayerToPrint> lrs;
-                    lrs.emplace_back(std::move(ltp));
-                    this->process_layer(file, print, lrs, tool_ordering.tools_for_layer(ltp.print_z()), nullptr, &copy - object.copies().data());
-                    print.throw_if_canceled();
-                }
-#ifdef HAS_PRESSURE_EQUALIZER
-                if (m_pressure_equalizer)
-                    _write(file, m_pressure_equalizer->process("", true));
-#endif /* HAS_PRESSURE_EQUALIZER */
-                ++ finished_objects;
-                // Flag indicating whether the nozzle temperature changes from 1st to 2nd layer were performed.
-                // Reset it when starting another object from 1st layer.
-                m_second_layer_things_done = false;
+        const PrintObject *prev_object = (*print_object_instance_sequential_active)->print_object;
+        for (; print_object_instance_sequential_active != print_object_instances_ordering.end(); ++ print_object_instance_sequential_active) {
+            const PrintObject &object = *(*print_object_instance_sequential_active)->print_object;
+            if (&object != prev_object || tool_ordering.first_extruder() != final_extruder_id) {
+                tool_ordering = ToolOrdering(object, final_extruder_id);
+                unsigned int new_extruder_id = tool_ordering.first_extruder();
+                if (new_extruder_id == (unsigned int)-1)
+                    // Skip this object.
+                    continue;
+                initial_extruder_id = new_extruder_id;
+                final_extruder_id   = tool_ordering.last_extruder();
+                assert(final_extruder_id != (unsigned int)-1);
             }
+            print.throw_if_canceled();
+            this->set_origin(unscale((*print_object_instance_sequential_active)->shift));
+            if (finished_objects > 0) {
+                // Move to the origin position for the copy we're going to print.
+                // This happens before Z goes down to layer 0 again, so that no collision happens hopefully.
+                m_enable_cooling_markers = false; // we're not filtering these moves through CoolingBuffer
+                m_avoid_crossing_perimeters.use_external_mp_once = true;
+                _write(file, this->retract());
+                _write(file, this->travel_to(Point(0, 0), erNone, "move to origin position for next object"));
+                m_enable_cooling_markers = true;
+                // Disable motion planner when traveling to first object point.
+                m_avoid_crossing_perimeters.disable_once = true;
+                // Ff we are printing the bottom layer of an object, and we have already finished
+                // another one, set first layer temperatures. This happens before the Z move
+                // is triggered, so machine has more time to reach such temperatures.
+                m_placeholder_parser.set("current_object_idx", int(finished_objects));
+                std::string between_objects_gcode = this->placeholder_parser_process("between_objects_gcode", print.config().between_objects_gcode.value, initial_extruder_id);
+                // Set first layer bed and extruder temperatures, don't wait for it to reach the temperature.
+                this->_print_first_layer_bed_temperature(file, print, between_objects_gcode, initial_extruder_id, false);
+                this->_print_first_layer_extruder_temperatures(file, print, between_objects_gcode, initial_extruder_id, false);
+                _writeln(file, between_objects_gcode);
+            }
+            // Reset the cooling buffer internal state (the current position, feed rate, accelerations).
+            m_cooling_buffer->reset();
+            m_cooling_buffer->set_current_extruder(initial_extruder_id);
+            // Pair the object layers with the support layers by z, extrude them.
+            std::vector<LayerToPrint> layers_to_print = collect_layers_to_print(object);
+            for (const LayerToPrint &ltp : layers_to_print) {
+                std::vector<LayerToPrint> lrs;
+                lrs.emplace_back(std::move(ltp));
+                this->process_layer(file, print, lrs, tool_ordering.tools_for_layer(ltp.print_z()), nullptr, *print_object_instance_sequential_active - object.instances().data());
+                print.throw_if_canceled();
+            }
+#ifdef HAS_PRESSURE_EQUALIZER
+            if (m_pressure_equalizer)
+                _write(file, m_pressure_equalizer->process("", true));
+#endif /* HAS_PRESSURE_EQUALIZER */
+            ++ finished_objects;
+            // Flag indicating whether the nozzle temperature changes from 1st to 2nd layer were performed.
+            // Reset it when starting another object from 1st layer.
+            m_second_layer_things_done = false;
+            prev_object = &object;
         }
     } else {
-        // Order object instances using a nearest neighbor search.
-        std::vector<std::pair<size_t, size_t>> print_object_instances_ordering = chain_print_object_instances(print);
         // Sort layers by Z.
         // All extrusion moves with the same top layer height are extruded uninterrupted.
         std::vector<std::pair<coordf_t, std::vector<LayerToPrint>>> layers_to_print = collect_layers_to_print(print);
@@ -1683,12 +1718,12 @@ inline std::vector<GCode::ObjectByExtruder::Island>& object_islands_by_extruder(
 }
 
 std::vector<GCode::InstanceToPrint> GCode::sort_print_object_instances(
-	std::vector<GCode::ObjectByExtruder> 			&objects_by_extruder,
-	const std::vector<LayerToPrint> 				&layers,
+	std::vector<GCode::ObjectByExtruder> 		&objects_by_extruder,
+	const std::vector<LayerToPrint> 			&layers,
 	// Ordering must be defined for normal (non-sequential print).
-	const std::vector<std::pair<size_t, size_t>> 	*ordering,
+	const std::vector<const PrintInstance*> 	*ordering,
 	// For sequential print, the instance of the object to be printing has to be defined.
-	const size_t                     				 single_object_instance_idx)
+	const size_t                     		 	 single_object_instance_idx)
 {
     std::vector<InstanceToPrint> out;
 
@@ -1715,13 +1750,13 @@ std::vector<GCode::InstanceToPrint> GCode::sort_print_object_instances(
 		if (! sorted.empty()) {
 			const Print &print = *sorted.front().first->print();
 		    out.reserve(sorted.size());
-		    for (const std::pair<size_t, size_t> &instance_id : *ordering) {
-		    	const PrintObject &print_object = *print.objects()[instance_id.first];
+		    for (const PrintInstance *instance : *ordering) {
+		    	const PrintObject &print_object = *instance->print_object;
 		    	std::pair<const PrintObject*, ObjectByExtruder*> key(&print_object, nullptr);
 		    	auto it = std::lower_bound(sorted.begin(), sorted.end(), key);
 		    	if (it != sorted.end() && it->first == &print_object)
 		    		// ObjectByExtruder for this PrintObject was found.
-					out.emplace_back(*it->second, it->second - objects_by_extruder.data(), print_object, instance_id.second);
+					out.emplace_back(*it->second, it->second - objects_by_extruder.data(), print_object, instance - print_object.instances().data());
 		    }
 		}
 	}
@@ -1732,7 +1767,7 @@ namespace ProcessLayer
 {
 
     static std::string emit_custom_gcode_per_print_z(
-    	const Model::CustomGCode 								*custom_gcode,
+    	const CustomGCode::Item 								*custom_gcode,
         // ID of the first extruder printing this layer.
         unsigned int                                             first_extruder_id,
 		bool  											         single_material_print)
@@ -1865,16 +1900,16 @@ namespace Skirt {
 // and performing the extruder specific extrusions together.
 void GCode::process_layer(
     // Write into the output file.
-    FILE                            *file,
-    const Print                     &print,
+    FILE                            		*file,
+    const Print                    			&print,
     // Set of object & print layers of the same PrintObject and with the same print_z.
-    const std::vector<LayerToPrint> &layers,
-    const LayerTools                &layer_tools,
+    const std::vector<LayerToPrint> 		&layers,
+    const LayerTools        		        &layer_tools,
 	// Pairs of PrintObject index and its instance index.
-	const std::vector<std::pair<size_t, size_t>> *ordering,
+	const std::vector<const PrintInstance*> *ordering,
     // If set to size_t(-1), then print all copies of all objects.
     // Otherwise print a single copy of a single object.
-    const size_t                     single_object_instance_idx)
+    const size_t                     		 single_object_instance_idx)
 {
     assert(! layers.empty());
 //    assert(! layer_tools.extruders.empty());
@@ -2083,7 +2118,7 @@ void GCode::process_layer(
 	                            // by last extruder on this layer (could happen e.g. when a wiping object is taller than others - dontcare extruders are eradicated from layer_tools)
 	                            correct_extruder_id = layer_tools.extruders.back();
 	                        }
-                        	entity_overrides = const_cast<LayerTools&>(layer_tools).wiping_extrusions().get_extruder_overrides(extrusions, correct_extruder_id, layer_to_print.object()->copies().size());
+                        	entity_overrides = const_cast<LayerTools&>(layer_tools).wiping_extrusions().get_extruder_overrides(extrusions, correct_extruder_id, layer_to_print.object()->instances().size());
 	                        if (entity_overrides == nullptr) {
 	                        	printing_extruders.emplace_back(correct_extruder_id);
 	                        } else {
@@ -2197,7 +2232,7 @@ void GCode::process_layer(
                 if (this->config().gcode_label_objects)
                     gcode += std::string("; printing object ") + instance_to_print.print_object.model_object()->name + " id:" + std::to_string(instance_to_print.layer_id) + " copy " + std::to_string(instance_to_print.instance_id) + "\n";
                 // When starting a new object, use the external motion planner for the first travel move.
-                const Point &offset = instance_to_print.print_object.copies()[instance_to_print.instance_id];
+                const Point &offset = instance_to_print.print_object.instances()[instance_to_print.instance_id].shift;
                 std::pair<const PrintObject*, Point> this_object_copy(&instance_to_print.print_object, offset);
                 if (m_last_obj_copy != this_object_copy)
                     m_avoid_crossing_perimeters.use_external_mp_once = true;

src/libslic3r/GCode.hpp

@@ -226,7 +226,7 @@ private:
         const std::vector<LayerToPrint> &layers,
         const LayerTools  				&layer_tools,
 		// Pairs of PrintObject index and its instance index.
-		const std::vector<std::pair<size_t, size_t>> *ordering,
+		const std::vector<const PrintInstance*> *ordering,
         // If set to size_t(-1), then print all copies of all objects.
         // Otherwise print a single copy of a single object.
         const size_t                     single_object_idx = size_t(-1));
@@ -300,7 +300,7 @@ private:
 		// Object and Support layers for the current print_z, collected for a single object, or for possibly multiple objects with multiple instances.
 		const std::vector<LayerToPrint> 				&layers,
 		// Ordering must be defined for normal (non-sequential print).
-		const std::vector<std::pair<size_t, size_t>> 	*ordering,
+		const std::vector<const PrintInstance*>     	*ordering,
 		// For sequential print, the instance of the object to be printing has to be defined.
 		const size_t                     				 single_object_instance_idx);
 

src/libslic3r/GCode/PrintExtents.cpp

@@ -121,9 +121,9 @@ BoundingBoxf get_print_object_extrusions_extents(const PrintObject &print_object
         if (support_layer)
             for (const ExtrusionEntity *extrusion_entity : support_layer->support_fills.entities)
                 bbox_this.merge(extrusionentity_extents(extrusion_entity));
-        for (const Point &offset : print_object.copies()) {
+        for (const PrintInstance &instance : print_object.instances()) {
             BoundingBoxf bbox_translated(bbox_this);
-            bbox_translated.translate(unscale(offset));
+            bbox_translated.translate(unscale(instance.shift));
             bbox.merge(bbox_translated);
         }
     }

src/libslic3r/GCode/ToolOrdering.cpp

@@ -133,7 +133,7 @@ ToolOrdering::ToolOrdering(const Print &print, unsigned int first_extruder, bool
 		num_extruders > 1 && print.object_extruders().size() == 1) {
 		// Printing a single extruder platter on a printer with more than 1 extruder (or single-extruder multi-material).
 		// There may be custom per-layer tool changes available at the model.
-		per_layer_extruder_switches = custom_tool_changes(print.model(), num_extruders);
+		per_layer_extruder_switches = custom_tool_changes(print.model().custom_gcode_per_print_z, num_extruders);
 	}
 
     // Collect extruders reuqired to print the layers.
@@ -462,7 +462,7 @@ void ToolOrdering::assign_custom_gcodes(const Print &print)
 	// Only valid for non-sequential print.
 	assert(! print.config().complete_objects.value);
 
-	const Model::CustomGCodeInfo	&custom_gcode_per_print_z = print.model().custom_gcode_per_print_z;
+	const CustomGCode::Info	&custom_gcode_per_print_z = print.model().custom_gcode_per_print_z;
 	if (custom_gcode_per_print_z.gcodes.empty())
 		return;
 
@@ -483,7 +483,7 @@ void ToolOrdering::assign_custom_gcodes(const Print &print)
 			// 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;
+		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())
@@ -491,7 +491,7 @@ void ToolOrdering::assign_custom_gcodes(const Print &print)
 		if (custom_gcode.print_z > print_z_below + 0.5 * EPSILON) {
 			// The custom G-code applies to the current layer.
 			if ( tool_changes_as_color_changes || custom_gcode.gcode != ColorChangeCode || 
-                (custom_gcode.extruder <= num_extruders && extruder_printing_above[unsigned(custom_gcode.extruder - 1)]))
+                (custom_gcode.extruder <= int(num_extruders) && 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.
@@ -602,7 +602,7 @@ float WipingExtrusions::mark_wiping_extrusions(const Print& print, unsigned int
         const Layer* this_layer = object->get_layer_at_printz(lt.print_z, EPSILON);
         if (this_layer == nullptr)
         	continue;
-        size_t num_of_copies = object->copies().size();
+        size_t num_of_copies = object->instances().size();
 
         // iterate through copies (aka PrintObject instances) first, so that we mark neighbouring infills to minimize travel moves
         for (unsigned int copy = 0; copy < num_of_copies; ++copy) {
@@ -677,7 +677,7 @@ void WipingExtrusions::ensure_perimeters_infills_order(const Print& print)
         const Layer* this_layer = object->get_layer_at_printz(lt.print_z, EPSILON);
         if (this_layer == nullptr)
         	continue;
-        size_t num_of_copies = object->copies().size();
+        size_t num_of_copies = object->instances().size();
 
         for (size_t copy = 0; copy < num_of_copies; ++copy) {    // iterate through copies first, so that we mark neighbouring infills to minimize travel moves
             for (size_t region_id = 0; region_id < object->region_volumes.size(); ++ region_id) {

src/libslic3r/GCode/ToolOrdering.hpp

@@ -114,7 +114,7 @@ public:
     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;
+    const CustomGCode::Item    *custom_gcode = nullptr;
 
     WipingExtrusions& wiping_extrusions() {
         m_wiping_extrusions.set_layer_tools_ptr(this);

src/libslic3r/GCodeWriter.cpp

@@ -1,4 +1,5 @@
 #include "GCodeWriter.hpp"
+#include "CustomGCode.hpp"
 #include <algorithm>
 #include <iomanip>
 #include <iostream>

src/libslic3r/GCodeWriter.hpp

@@ -10,11 +10,6 @@
 
 namespace Slic3r {
 
-// Additional Codes which can be set by user using DoubleSlider
-static constexpr char ColorChangeCode[]     = "M600";
-static constexpr char PausePrintCode[]      = "M601";
-static constexpr char ToolChangeCode[]  = "tool_change";
-
 class GCodeWriter {
 public:
     GCodeConfig config;

src/libslic3r/Model.cpp

@@ -126,7 +126,8 @@ Model Model::read_from_file(const std::string& input_file, DynamicPrintConfig* c
     if (add_default_instances)
         model.add_default_instances();
 
-    update_custom_gcode_per_print_z_from_config(model.custom_gcode_per_print_z.gcodes, config);
+    CustomGCode::update_custom_gcode_per_print_z_from_config(model.custom_gcode_per_print_z, config);
+    CustomGCode::check_mode_for_custom_gcode_per_print_z(model.custom_gcode_per_print_z);
 
     return model;
 }
@@ -163,7 +164,8 @@ Model Model::read_from_archive(const std::string& input_file, DynamicPrintConfig
     if (add_default_instances)
         model.add_default_instances();
 
-    update_custom_gcode_per_print_z_from_config(model.custom_gcode_per_print_z.gcodes, config);
+    CustomGCode::update_custom_gcode_per_print_z_from_config(model.custom_gcode_per_print_z, config);
+    CustomGCode::check_mode_for_custom_gcode_per_print_z(model.custom_gcode_per_print_z);
 
     return model;
 }
@@ -1848,19 +1850,6 @@ arrangement::ArrangePolygon ModelInstance::get_arrange_polygon() const
     return ret;
 }
 
-// Return pairs of <print_z, 1-based extruder ID> sorted by increasing print_z from custom_gcode_per_print_z.
-// print_z corresponds to the first layer printed with the new extruder.
-std::vector<std::pair<double, unsigned int>> custom_tool_changes(const Model &model, size_t num_extruders)
-{
-    std::vector<std::pair<double, unsigned int>> custom_tool_changes;
-    for (const Model::CustomGCode &custom_gcode : model.custom_gcode_per_print_z.gcodes)
-        if (custom_gcode.gcode == ToolChangeCode) {
-            // If extruder count in PrinterSettings was changed, use default (0) extruder for extruders, more than num_extruders
-            custom_tool_changes.emplace_back(custom_gcode.print_z, static_cast<unsigned int>(custom_gcode.extruder > num_extruders ? 1 : custom_gcode.extruder));
-        }
-    return custom_tool_changes;
-}
-
 // Test whether the two models contain the same number of ModelObjects with the same set of IDs
 // ordered in the same order. In that case it is not necessary to kill the background processing.
 bool model_object_list_equal(const Model &model_old, const Model &model_new)
@@ -1949,28 +1938,6 @@ extern bool model_has_advanced_features(const Model &model)
     return false;
 }
 
-extern void update_custom_gcode_per_print_z_from_config(std::vector<Model::CustomGCode>& custom_gcode_per_print_z, DynamicPrintConfig* config)
-{
-	auto *colorprint_heights = config->option<ConfigOptionFloats>("colorprint_heights");
-    if (colorprint_heights == nullptr)
-        return;
-
-	if (custom_gcode_per_print_z.empty() && ! colorprint_heights->values.empty()) {
-		// Convert the old colorprint_heighs only if there is no equivalent data in a new format.
-	    const std::vector<std::string>& colors = GCodePreviewData::ColorPrintColors();
-	    const auto& colorprint_values = colorprint_heights->values;
-        custom_gcode_per_print_z.clear();
-        custom_gcode_per_print_z.reserve(colorprint_values.size());
-        int i = 0;
-        for (auto val : colorprint_values)
-            custom_gcode_per_print_z.emplace_back(Model::CustomGCode{ val, ColorChangeCode, 1, colors[(++i)%7] });
-	}
-
-	// The "colorprint_heights" config value has been deprecated. At this point of time it has been converted
-	// to a new format and therefore it shall be erased.
-    config->erase("colorprint_heights");
-}
-
 #ifndef NDEBUG
 // Verify whether the IDs of Model / ModelObject / ModelVolume / ModelInstance / ModelMaterial are valid and unique.
 void check_model_ids_validity(const Model &model)

src/libslic3r/Model.hpp

@@ -12,6 +12,7 @@
 #include "SLA/Hollowing.hpp"
 #include "TriangleMesh.hpp"
 #include "Arrange.hpp"
+#include "CustomGCode.hpp"
 
 #include <map>
 #include <memory>
@@ -753,48 +754,7 @@ public:
     ModelWipeTower	    wipe_tower;
 
     // Extensions for color print
-    struct CustomGCode
-    {
-        bool operator<(const CustomGCode& rhs) const { return this->print_z < rhs.print_z; }
-        bool operator==(const CustomGCode& rhs) const
-        {
-            return (rhs.print_z   == this->print_z    ) && 
-                   (rhs.gcode     == this->gcode      ) && 
-                   (rhs.extruder  == this->extruder   ) && 
-                   (rhs.color     == this->color      );
-        }
-        bool operator!=(const CustomGCode& rhs) const { return ! (*this == rhs); }
-        
-        double      print_z;
-        std::string gcode;
-        int         extruder;   // Informative value for ColorChangeCode and ToolChangeCode
-                                // "gcode" == ColorChangeCode   => M600 will be applied for "extruder" extruder
-                                // "gcode" == ToolChangeCode    => for whole print tool will be switched to "extruder" extruder
-        std::string color;      // if gcode is equal to PausePrintCode, 
-                                // this field is used for save a short message shown on Printer display 
-    };
-    
-    struct CustomGCodeInfo
-    {
-        enum MODE
-        {
-            SingleExtruder,   // single extruder printer preset is selected
-            MultiAsSingle,    // multiple extruder printer preset is selected, but 
-                              // this mode works just for Single extruder print 
-                              // (For all print from objects settings is used just one extruder) 
-            MultiExtruder     // multiple extruder printer preset is selected
-        } mode;
-        
-        std::vector<CustomGCode> gcodes;
-
-        bool operator==(const CustomGCodeInfo& rhs) const
-        {
-            return  (rhs.mode   == this->mode   ) &&
-                    (rhs.gcodes == this->gcodes );
-        }
-        bool operator!=(const CustomGCodeInfo& rhs) const { return !(*this == rhs); }
-    } 
-    custom_gcode_per_print_z;
+    CustomGCode::Info custom_gcode_per_print_z;
     
     // Default constructor assigns a new ID to the model.
     Model() { assert(this->id().valid()); }
@@ -876,10 +836,6 @@ private:
 #undef OBJECTBASE_DERIVED_COPY_MOVE_CLONE
 #undef OBJECTBASE_DERIVED_PRIVATE_COPY_MOVE
 
-// Return pairs of <print_z, 1-based extruder ID> sorted by increasing print_z from custom_gcode_per_print_z.
-// print_z corresponds to the first layer printed with the new extruder.
-extern std::vector<std::pair<double, unsigned int>> custom_tool_changes(const Model &model, size_t num_extruders);
-
 // Test whether the two models contain the same number of ModelObjects with the same set of IDs
 // ordered in the same order. In that case it is not necessary to kill the background processing.
 extern bool model_object_list_equal(const Model &model_old, const Model &model_new);
@@ -897,10 +853,6 @@ extern bool model_volume_list_changed(const ModelObject &model_object_old, const
 extern bool model_has_multi_part_objects(const Model &model);
 // If the model has advanced features, then it cannot be processed in simple mode.
 extern bool model_has_advanced_features(const Model &model);
-// If loaded configuration has a "colorprint_heights" option (if it was imported from older Slicer), 
-// and if model.custom_gcode_per_print_z is empty (there is no color print data available in a new format
-// then model.custom_gcode_per_print_z should be updated considering this option.
-extern void update_custom_gcode_per_print_z_from_config(std::vector<Model::CustomGCode>& custom_gcode_per_print_z, DynamicPrintConfig* config);
 
 #ifndef NDEBUG
 // Verify whether the IDs of Model / ModelObject / ModelVolume / ModelInstance / ModelMaterial are valid and unique.

src/libslic3r/PlaceholderParser.cpp

@@ -338,7 +338,7 @@ namespace client
             case TYPE_INT :
                 return expr<Iterator>(this->i(), start_pos, this->it_range.end());
             case TYPE_DOUBLE:
-                return expr<Iterator>((int)(this->d()), start_pos, this->it_range.end()); 
+                return expr<Iterator>(static_cast<int>(this->d()), start_pos, this->it_range.end()); 
             default:
                 this->throw_exception("Cannot convert to integer.");
             }
@@ -418,7 +418,7 @@ namespace client
         {
             this->throw_if_not_numeric("Cannot divide a non-numeric type.");
             rhs.throw_if_not_numeric("Cannot divide with a non-numeric type.");
-            if ((this->type == TYPE_INT) ? (rhs.i() == 0) : (rhs.d() == 0.))
+            if ((rhs.type == TYPE_INT) ? (rhs.i() == 0) : (rhs.d() == 0.))
                 rhs.throw_exception("Division by zero");
             if (this->type == TYPE_DOUBLE || rhs.type == TYPE_DOUBLE) {
                 double d = this->as_d() / rhs.as_d();
@@ -434,7 +434,7 @@ namespace client
         {
             this->throw_if_not_numeric("Cannot divide a non-numeric type.");
             rhs.throw_if_not_numeric("Cannot divide with a non-numeric type.");
-            if ((this->type == TYPE_INT) ? (rhs.i() == 0) : (rhs.d() == 0.))
+            if ((rhs.type == TYPE_INT) ? (rhs.i() == 0) : (rhs.d() == 0.))
                 rhs.throw_exception("Division by zero");
             if (this->type == TYPE_DOUBLE || rhs.type == TYPE_DOUBLE) {
                 double d = std::fmod(this->as_d(), rhs.as_d());
@@ -845,7 +845,7 @@ namespace client
                 } else {
                     // Use the human readable error message.
                     msg += ". ";
-                    msg + it->second;
+                    msg += it->second;
                 }
             }
             msg += '\n';
@@ -1134,7 +1134,7 @@ namespace client
                 static void string_(boost::iterator_range<Iterator> &it_range, expr<Iterator> &out)
                         { out = expr<Iterator>(std::string(it_range.begin() + 1, it_range.end() - 1), it_range.begin(), it_range.end()); }
                 static void expr_(expr<Iterator> &value, Iterator &end_pos, expr<Iterator> &out)
-                        { out = expr<Iterator>(std::move(value), out.it_range.begin(), end_pos); }
+                        { auto begin_pos = out.it_range.begin(); out = expr<Iterator>(std::move(value), begin_pos, end_pos); }
                 static void minus_(expr<Iterator> &value, expr<Iterator> &out)
                         { out = value.unary_minus(out.it_range.begin()); }
                 static void not_(expr<Iterator> &value, expr<Iterator> &out)
@@ -1152,8 +1152,7 @@ namespace client
                                                                     [ px::bind(&expr<Iterator>::min, _val, _2) ]
                 |   (kw["max"] > '(' > conditional_expression(_r1) [_val = _1] > ',' > conditional_expression(_r1) > ')') 
                                                                     [ px::bind(&expr<Iterator>::max, _val, _2) ]
-                                                                    //FIXME this is likley not correct
-                |   (kw["int"] > '(' > unary_expression(_r1) /* > ')' */   )  [ px::bind(&FactorActions::to_int,  _1,     _val) ]
+                |   (kw["int"] > '(' > unary_expression(_r1) > ')') [ px::bind(&FactorActions::to_int,  _1,     _val) ]
                 |   (strict_double > iter_pos)                      [ px::bind(&FactorActions::double_, _1, _2, _val) ]
                 |   (int_      > iter_pos)                          [ px::bind(&FactorActions::int_,    _1, _2, _val) ]
                 |   (kw[bool_] > iter_pos)                          [ px::bind(&FactorActions::bool_,   _1, _2, _val) ]
@@ -1181,6 +1180,7 @@ namespace client
             keywords.add
                 ("and")
                 ("if")
+                ("int")
                 //("inf")
                 ("else")
                 ("elsif")

src/libslic3r/Print.cpp

@@ -326,7 +326,7 @@ unsigned int Print::num_object_instances() const
 {
 	unsigned int instances = 0;
     for (const PrintObject *print_object : m_objects)
-        instances += (unsigned int)print_object->copies().size();
+        instances += (unsigned int)print_object->instances().size();
     return instances;
 }
 
@@ -447,33 +447,30 @@ static inline bool transform3d_equal(const Transform3d &lhs, const Transform3d &
     return true;
 }
 
-struct PrintInstances
+struct PrintObjectTrafoAndInstances
 {
-    Transform3d     trafo;
-    Points          copies;
-    bool operator<(const PrintInstances &rhs) const { return transform3d_lower(this->trafo, rhs.trafo); }
+    Transform3d    	trafo;
+    PrintInstances	instances;
+    bool operator<(const PrintObjectTrafoAndInstances &rhs) const { return transform3d_lower(this->trafo, rhs.trafo); }
 };
 
 // Generate a list of trafos and XY offsets for instances of a ModelObject
-static std::vector<PrintInstances> print_objects_from_model_object(const ModelObject &model_object)
+static std::vector<PrintObjectTrafoAndInstances> print_objects_from_model_object(const ModelObject &model_object)
 {
-    std::set<PrintInstances> trafos;
-    PrintInstances           trafo;
-    trafo.copies.assign(1, Point());
+    std::set<PrintObjectTrafoAndInstances> trafos;
+    PrintObjectTrafoAndInstances           trafo;
     for (ModelInstance *model_instance : model_object.instances)
         if (model_instance->is_printable()) {
             trafo.trafo = model_instance->get_matrix();
+            auto shift = Point::new_scale(trafo.trafo.data()[12], trafo.trafo.data()[13]);
             // Set the Z axis of the transformation.
-            trafo.copies.front() = Point::new_scale(trafo.trafo.data()[12], trafo.trafo.data()[13]);
             trafo.trafo.data()[12] = 0;
             trafo.trafo.data()[13] = 0;
-            auto it = trafos.find(trafo);
-            if (it == trafos.end())
-                trafos.emplace(trafo);
-            else
-                const_cast<PrintInstances&>(*it).copies.emplace_back(trafo.copies.front());
+            // Search or insert a trafo.
+            auto it = trafos.emplace(trafo).first;
+            const_cast<PrintObjectTrafoAndInstances&>(*it).instances.emplace_back(PrintInstance{ nullptr, model_instance, shift });
         }
-    return std::vector<PrintInstances>(trafos.begin(), trafos.end());
+    return std::vector<PrintObjectTrafoAndInstances>(trafos.begin(), trafos.end());
 }
 
 // Compare just the layer ranges and their layer heights, not the associated configs.
@@ -494,7 +491,7 @@ static bool layer_height_ranges_equal(const t_layer_config_ranges &lr1, const t_
 }
 
 // Returns true if va == vb when all CustomGCode items that are not ToolChangeCode are ignored.
-static bool custom_per_printz_gcodes_tool_changes_differ(const std::vector<Model::CustomGCode> &va, const std::vector<Model::CustomGCode> &vb)
+static bool custom_per_printz_gcodes_tool_changes_differ(const std::vector<CustomGCode::Item> &va, const std::vector<CustomGCode::Item> &vb)
 {
 	auto it_a = va.begin();
 	auto it_b = vb.begin();
@@ -891,12 +888,27 @@ Print::ApplyStatus Print::apply(const Model &model, DynamicPrintConfig new_full_
             // Copy the ModelObject name, input_file and instances. The instances will be compared against PrintObject instances in the next step.
             model_object.name       = model_object_new.name;
             model_object.input_file = model_object_new.input_file;
-            model_object.clear_instances();
-            model_object.instances.reserve(model_object_new.instances.size());
-            for (const ModelInstance *model_instance : model_object_new.instances) {
-                model_object.instances.emplace_back(new ModelInstance(*model_instance));
-                model_object.instances.back()->set_model_object(&model_object);
-            }
+            // Only refresh ModelInstances if there is any change.
+            if (model_object.instances.size() != model_object_new.instances.size() || 
+            	! std::equal(model_object.instances.begin(), model_object.instances.end(), model_object_new.instances.begin(), [](auto l, auto r){ return l->id() == r->id(); })) {
+            	// G-code generator accesses model_object.instances to generate sequential print ordering matching the Plater object list.
+            	update_apply_status(this->invalidate_step(psGCodeExport));
+	            model_object.clear_instances();
+	            model_object.instances.reserve(model_object_new.instances.size());
+	            for (const ModelInstance *model_instance : model_object_new.instances) {
+	                model_object.instances.emplace_back(new ModelInstance(*model_instance));
+	                model_object.instances.back()->set_model_object(&model_object);
+	            }
+	        } else {
+	        	// Just synchronize the content of the instances. This avoids memory allocation and it does not invalidate ModelInstance pointers,
+	        	// which may be accessed by G-code export in the meanwhile to deduce sequential print order.
+                auto new_instance = model_object_new.instances.begin();
+				for (auto old_instance = model_object.instances.begin(); old_instance != model_object.instances.end(); ++ old_instance, ++ new_instance) {
+					(*old_instance)->set_transformation((*new_instance)->get_transformation());
+                    (*old_instance)->print_volume_state = (*new_instance)->print_volume_state;
+                    (*old_instance)->printable 		    = (*new_instance)->printable;
+  				}
+	        }
         }
     }
 
@@ -917,13 +929,12 @@ Print::ApplyStatus Print::apply(const Model &model, DynamicPrintConfig new_full_
             }
             // Generate a list of trafos and XY offsets for instances of a ModelObject
             PrintObjectConfig config = PrintObject::object_config_from_model_object(m_default_object_config, *model_object, num_extruders);
-            std::vector<PrintInstances> new_print_instances = print_objects_from_model_object(*model_object);
+            std::vector<PrintObjectTrafoAndInstances> new_print_instances = print_objects_from_model_object(*model_object);
             if (old.empty()) {
                 // Simple case, just generate new instances.
-                for (const PrintInstances &print_instances : new_print_instances) {
+                for (PrintObjectTrafoAndInstances &print_instances : new_print_instances) {
                     PrintObject *print_object = new PrintObject(this, model_object, false);
-					print_object->set_trafo(print_instances.trafo);
-                    print_object->set_copies(print_instances.copies);
+					print_object->set_trafo_and_instances(print_instances.trafo, std::move(print_instances.instances));
                     print_object->config_apply(config);
                     print_objects_new.emplace_back(print_object);
                     // print_object_status.emplace(PrintObjectStatus(print_object, PrintObjectStatus::New));
@@ -936,13 +947,12 @@ Print::ApplyStatus Print::apply(const Model &model, DynamicPrintConfig new_full_
             std::sort(old.begin(), old.end(), [](const PrintObjectStatus *lhs, const PrintObjectStatus *rhs){ return transform3d_lower(lhs->trafo, rhs->trafo); });
             // Merge the old / new lists.
             auto it_old = old.begin();
-            for (const PrintInstances &new_instances : new_print_instances) {
+            for (PrintObjectTrafoAndInstances &new_instances : new_print_instances) {
 				for (; it_old != old.end() && transform3d_lower((*it_old)->trafo, new_instances.trafo); ++ it_old);
 				if (it_old == old.end() || ! transform3d_equal((*it_old)->trafo, new_instances.trafo)) {
                     // This is a new instance (or a set of instances with the same trafo). Just add it.
                     PrintObject *print_object = new PrintObject(this, model_object, false);
-                    print_object->set_trafo(new_instances.trafo);
-                    print_object->set_copies(new_instances.copies);
+					print_object->set_trafo_and_instances(new_instances.trafo, std::move(new_instances.instances));
                     print_object->config_apply(config);
                     print_objects_new.emplace_back(print_object);
                     // print_object_status.emplace(PrintObjectStatus(print_object, PrintObjectStatus::New));
@@ -951,7 +961,7 @@ Print::ApplyStatus Print::apply(const Model &model, DynamicPrintConfig new_full_
                         const_cast<PrintObjectStatus*>(*it_old)->status = PrintObjectStatus::Deleted;
                 } else {
                     // The PrintObject already exists and the copies differ.
-					PrintBase::ApplyStatus status = (*it_old)->print_object->set_copies(new_instances.copies);
+					PrintBase::ApplyStatus status = (*it_old)->print_object->set_instances(std::move(new_instances.instances));
                     if (status != PrintBase::APPLY_STATUS_UNCHANGED)
 						update_apply_status(status == PrintBase::APPLY_STATUS_INVALIDATED);
 					print_objects_new.emplace_back((*it_old)->print_object);
@@ -1159,7 +1169,7 @@ std::string Print::validate() const
             Polygons convex_hulls_other;
             for (const PrintObject *print_object : m_objects) {
                 assert(! print_object->model_object()->instances.empty());
-                assert(! print_object->copies().empty());
+                assert(! print_object->instances().empty());
                 // Get convex hull of all meshes assigned to this print object.
                 ModelInstance *model_instance0 = print_object->model_object()->instances.front();
                 Vec3d          rotation        = model_instance0->get_rotation();
@@ -1174,9 +1184,9 @@ std::string Print::validate() const
                         Geometry::assemble_transform(Vec3d::Zero(), rotation, model_instance0->get_scaling_factor(), model_instance0->get_mirror())),
                     float(scale_(0.5 * m_config.extruder_clearance_radius.value)), jtRound, float(scale_(0.1))).front();
                 // Now we check that no instance of convex_hull intersects any of the previously checked object instances.
-                for (const Point &copy : print_object->copies()) {
+                for (const PrintInstance &instance : print_object->instances()) {
                     Polygon convex_hull = convex_hull0;
-                    convex_hull.translate(copy);
+                    convex_hull.translate(instance.shift);
                     if (! intersection(convex_hulls_other, convex_hull).empty())
                         return L("Some objects are too close; your extruder will collide with them.");
                     polygons_append(convex_hulls_other, convex_hull);
@@ -1187,7 +1197,7 @@ std::string Print::validate() const
         {
             std::vector<coord_t> object_height;
             for (const PrintObject *object : m_objects)
-                object_height.insert(object_height.end(), object->copies().size(), object->size(2));
+                object_height.insert(object_height.end(), object->instances().size(), object->size(2));
             std::sort(object_height.begin(), object_height.end());
             // Ignore the tallest *copy* (this is why we repeat height for all of them):
             // it will be printed as last one so its height doesn't matter.
@@ -1200,7 +1210,7 @@ std::string Print::validate() const
     if (m_config.spiral_vase) {
         size_t total_copies_count = 0;
         for (const PrintObject *object : m_objects)
-            total_copies_count += object->copies().size();
+            total_copies_count += object->instances().size();
         // #4043
         if (total_copies_count > 1 && ! m_config.complete_objects.value)
             return L("The Spiral Vase option can only be used when printing a single object.");
@@ -1417,10 +1427,9 @@ BoundingBox Print::bounding_box() const
 {
     BoundingBox bb;
     for (const PrintObject *object : m_objects)
-        for (Point copy : object->m_copies) {
-            bb.merge(copy);
-            copy += to_2d(object->size);
-            bb.merge(copy);
+        for (const PrintInstance &instance : object->instances()) {
+            bb.merge(instance.shift);
+            bb.merge(instance.shift + to_2d(object->size));
         }
     return bb;
 }
@@ -1657,10 +1666,10 @@ void Print::_make_skirt()
                 append(object_points, extrusion_entity->as_polyline().points);
         }
         // Repeat points for each object copy.
-        for (const Point &shift : object->m_copies) {
+        for (const PrintInstance &instance : object->instances()) {
             Points copy_points = object_points;
             for (Point &pt : copy_points)
-                pt += shift;
+                pt += instance.shift;
             append(points, copy_points);
         }
     }
@@ -1778,11 +1787,11 @@ void Print::_make_brim()
             object_islands.push_back(expoly.contour);
         if (! object->support_layers().empty())
             object->support_layers().front()->support_fills.polygons_covered_by_spacing(object_islands, float(SCALED_EPSILON));
-        islands.reserve(islands.size() + object_islands.size() * object->m_copies.size());
-        for (const Point &pt : object->m_copies)
+        islands.reserve(islands.size() + object_islands.size() * object->instances().size());
+        for (const PrintInstance &instance : object->instances())
             for (Polygon &poly : object_islands) {
                 islands.push_back(poly);
-                islands.back().translate(pt);
+                islands.back().translate(instance.shift);
             }
     }
     Polygons loops;

src/libslic3r/Print.hpp

@@ -92,6 +92,21 @@ typedef std::vector<Layer*> LayerPtrs;
 typedef std::vector<SupportLayer*> SupportLayerPtrs;
 class BoundingBoxf3;        // TODO: for temporary constructor parameter
 
+// Single instance of a PrintObject.
+// As multiple PrintObjects may be generated for a single ModelObject (their instances differ in rotation around Z),
+// ModelObject's instancess will be distributed among these multiple PrintObjects.
+struct PrintInstance
+{
+    // Parent PrintObject
+    PrintObject 		*print_object;
+    // Source ModelInstance of a ModelObject, for which this print_object was created.
+	const ModelInstance *model_instance;
+	// Shift of this instance towards its PrintObject
+	Point 				 shift;
+};
+
+typedef std::vector<PrintInstance> PrintInstances;
+
 class PrintObject : public PrintObjectBaseWithState<Print, PrintObjectStep, posCount>
 {
 private: // Prevents erroneous use by other classes.
@@ -111,8 +126,8 @@ public:
     const LayerPtrs&        layers() const          { return m_layers; }
     const SupportLayerPtrs& support_layers() const  { return m_support_layers; }
     const Transform3d&      trafo() const           { return m_trafo; }
-    const Points&           copies() const          { return m_copies; }
-    const Point 			copy_center(size_t idx) const { return m_copies[idx] + m_copies_shift + Point(this->size.x() / 2, this->size.y() / 2); }
+    const PrintInstances&   instances() const       { return m_instances; }
+    const Point 			instance_center(size_t idx) const { return m_instances[idx].shift + m_copies_shift + Point(this->size.x() / 2, this->size.y() / 2); }
 
     // since the object is aligned to origin, bounding box coincides with size
     BoundingBox bounding_box() const { return BoundingBox(Point(0,0), to_2d(this->size)); }
@@ -126,9 +141,9 @@ public:
     // This is the *total* layer count (including support layers)
     // this value is not supposed to be compared with Layer::id
     // since they have different semantics.
-    size_t total_layer_count() const { return this->layer_count() + this->support_layer_count(); }
-    size_t layer_count() const { return m_layers.size(); }
-    void clear_layers();
+    size_t 			total_layer_count() const { return this->layer_count() + this->support_layer_count(); }
+    size_t 			layer_count() const { return m_layers.size(); }
+    void 			clear_layers();
     const Layer* 	get_layer(int idx) const { return m_layers[idx]; }
     Layer* 			get_layer(int idx) 		 { return m_layers[idx]; }
     // Get a layer exactly at print_z.
@@ -177,7 +192,7 @@ public:
     std::vector<ExPolygons>     slice_support_blockers() const { return this->slice_support_volumes(ModelVolumeType::SUPPORT_BLOCKER); }
     std::vector<ExPolygons>     slice_support_enforcers() const { return this->slice_support_volumes(ModelVolumeType::SUPPORT_ENFORCER); }
 
-protected:
+private:
     // to be called from Print only.
     friend class Print;
 
@@ -187,7 +202,8 @@ protected:
     void                    config_apply(const ConfigBase &other, bool ignore_nonexistent = false) { this->m_config.apply(other, ignore_nonexistent); }
     void                    config_apply_only(const ConfigBase &other, const t_config_option_keys &keys, bool ignore_nonexistent = false) { this->m_config.apply_only(other, keys, ignore_nonexistent); }
     void                    set_trafo(const Transform3d& trafo) { m_trafo = trafo; }
-    PrintBase::ApplyStatus  set_copies(const Points &points);
+    PrintBase::ApplyStatus  set_instances(PrintInstances &&instances);
+    void 					set_trafo_and_instances(const Transform3d& trafo, PrintInstances &&instances) { this->set_trafo(trafo); this->set_instances(std::move(instances)); }
     // Invalidates the step, and its depending steps in PrintObject and Print.
     bool                    invalidate_step(PrintObjectStep step);
     // Invalidates all PrintObject and Print steps.
@@ -223,7 +239,7 @@ private:
     // Translation in Z + Rotation + Scaling / Mirroring.
     Transform3d                             m_trafo = Transform3d::Identity();
     // Slic3r::Point objects in scaled G-code coordinates
-    Points                                  m_copies;
+    std::vector<PrintInstance>              m_instances;
     // scaled coordinates to add to copies (to compensate for the alignment
     // operated when creating the object but still preserving a coherent API
     // for external callers)

src/libslic3r/PrintObject.cpp

@@ -60,32 +60,32 @@ PrintObject::PrintObject(Print* print, ModelObject* model_object, bool add_insta
     }
     
     if (add_instances) {
-        Points copies;
-        copies.reserve(m_model_object->instances.size());
+        PrintInstances instances;
+        instances.reserve(m_model_object->instances.size());
         for (const ModelInstance *mi : m_model_object->instances) {
             assert(mi->is_printable());
-            const Vec3d& offset = mi->get_offset();
-            copies.emplace_back(Point::new_scale(offset(0), offset(1)));
+            const Vec3d &offset = mi->get_offset();
+            instances.emplace_back(PrintInstance{ nullptr, mi, Point::new_scale(offset(0), offset(1)) });
         }
-        this->set_copies(copies);
+        this->set_instances(std::move(instances));
     }
 }
 
-PrintBase::ApplyStatus PrintObject::set_copies(const Points &points)
+PrintBase::ApplyStatus PrintObject::set_instances(PrintInstances &&instances)
 {
-    // Order copies with a nearest-neighbor search.
-    std::vector<Point> copies;
-    copies.reserve(points.size());
-    for (const Point &pt : points)
-        copies.emplace_back(pt + m_copies_shift);
     // Invalidate and set copies.
     PrintBase::ApplyStatus status = PrintBase::APPLY_STATUS_UNCHANGED;
-    if (copies != m_copies) {
+    bool equal_length = instances.size() == m_instances.size();
+    bool equal = equal_length && std::equal(instances.begin(), instances.end(), m_instances.begin(), 
+    	[](const PrintInstance& lhs, const PrintInstance& rhs) { return lhs.model_instance == rhs.model_instance && lhs.shift == rhs.shift; });
+    if (! equal) {
         status = PrintBase::APPLY_STATUS_CHANGED;
         if (m_print->invalidate_steps({ psSkirt, psBrim, psGCodeExport }) ||
-            (copies.size() != m_copies.size() && m_print->invalidate_step(psWipeTower)))
+            (! equal_length && m_print->invalidate_step(psWipeTower)))
             status = PrintBase::APPLY_STATUS_INVALIDATED;
-        m_copies = copies;
+        m_instances = instances;
+	    for (PrintInstance &i : m_instances)
+	    	i.print_object = this;
     }
     return status;
 }
@@ -669,7 +669,7 @@ void PrintObject::detect_surfaces_type()
                     m_print->throw_if_canceled();
                     // BOOST_LOG_TRIVIAL(trace) << "Detecting solid surfaces for region " << idx_region << " and layer " << layer->print_z;
                     Layer       *layer  = m_layers[idx_layer];
-                    LayerRegion *layerm = layer->get_region(idx_region);
+                    LayerRegion *layerm = layer->m_regions[idx_region];
                     // comparison happens against the *full* slices (considering all regions)
                     // unless internal shells are requested
                     Layer       *upper_layer = (idx_layer + 1 < this->layer_count()) ? m_layers[idx_layer + 1] : nullptr;
@@ -684,7 +684,7 @@ void PrintObject::detect_surfaces_type()
                     Surfaces top;
                     if (upper_layer) {
                         Polygons upper_slices = interface_shells ? 
-                            to_polygons(upper_layer->get_region(idx_region)->slices.surfaces) : 
+                            to_polygons(upper_layer->m_regions[idx_region]->slices.surfaces) : 
                             to_polygons(upper_layer->lslices);
                         surfaces_append(top,
                             //FIXME implement offset2_ex working over ExPolygons, that should be a bit more efficient than calling offset_ex twice.
@@ -727,7 +727,7 @@ void PrintObject::detect_surfaces_type()
                                 offset2_ex(
                                     diff(
                                         intersection(layerm_slices_surfaces, to_polygons(lower_layer->lslices)), // supported
-                                        to_polygons(lower_layer->get_region(idx_region)->slices.surfaces), 
+                                        to_polygons(lower_layer->m_regions[idx_region]->slices.surfaces), 
                                         true), 
                                     -offset, offset),
                                 stBottom);
@@ -796,7 +796,7 @@ void PrintObject::detect_surfaces_type()
         if (interface_shells) {
             // Move surfaces_new to layerm->slices.surfaces
             for (size_t idx_layer = 0; idx_layer < m_layers.size(); ++ idx_layer)
-                m_layers[idx_layer]->get_region(idx_region)->slices.surfaces = std::move(surfaces_new[idx_layer]);
+                m_layers[idx_layer]->m_regions[idx_region]->slices.surfaces = std::move(surfaces_new[idx_layer]);
         }
 
         BOOST_LOG_TRIVIAL(debug) << "Detecting solid surfaces for region " << idx_region << " - clipping in parallel - start";
@@ -806,7 +806,7 @@ void PrintObject::detect_surfaces_type()
             [this, idx_region, interface_shells, &surfaces_new](const tbb::blocked_range<size_t>& range) {
                 for (size_t idx_layer = range.begin(); idx_layer < range.end(); ++ idx_layer) {
                     m_print->throw_if_canceled();
-                    LayerRegion *layerm = m_layers[idx_layer]->get_region(idx_region);
+                    LayerRegion *layerm = m_layers[idx_layer]->m_regions[idx_region];
                     layerm->slices_to_fill_surfaces_clipped();
 #ifdef SLIC3R_DEBUG_SLICE_PROCESSING
                     layerm->export_region_fill_surfaces_to_svg_debug("1_detect_surfaces_type-final");

src/libslic3r/ShortestPath.cpp

@@ -1946,24 +1946,26 @@ ClipperLib::PolyNodes chain_clipper_polynodes(const Points &points, const Clippe
 	return chain_path_items(points, items);
 }
 
-std::vector<std::pair<size_t, size_t>> chain_print_object_instances(const Print &print)
+std::vector<const PrintInstance*> chain_print_object_instances(const Print &print)
 {
     // Order objects using a nearest neighbor search.
     Points object_reference_points;
     std::vector<std::pair<size_t, size_t>> instances;
     for (size_t i = 0; i < print.objects().size(); ++ i) {
     	const PrintObject &object = *print.objects()[i];
-    	for (size_t j = 0; j < object.copies().size(); ++ j) {
-        	object_reference_points.emplace_back(object.copy_center(j));
+    	for (size_t j = 0; j < object.instances().size(); ++ j) {
+        	object_reference_points.emplace_back(object.instance_center(j));
         	instances.emplace_back(i, j);
         }
     }
 	auto segment_end_point = [&object_reference_points](size_t idx, bool /* first_point */) -> const Point& { return object_reference_points[idx]; };
 	std::vector<std::pair<size_t, bool>> ordered = chain_segments_greedy<Point, decltype(segment_end_point)>(segment_end_point, instances.size(), nullptr);
-    std::vector<std::pair<size_t, size_t>> out;
+    std::vector<const PrintInstance*> out;
 	out.reserve(instances.size());
-	for (auto &segment_and_reversal : ordered)
-		out.emplace_back(instances[segment_and_reversal.first]);
+	for (auto &segment_and_reversal : ordered) {
+		const std::pair<size_t, size_t> &inst = instances[segment_and_reversal.first];
+		out.emplace_back(&print.objects()[inst.first]->instances()[inst.second]);
+	}
 	return out;
 }
 

src/libslic3r/ShortestPath.hpp

@@ -30,7 +30,8 @@ std::vector<ClipperLib::PolyNode*>	 chain_clipper_polynodes(const Points &points
 // Chain instances of print objects by an approximate shortest path.
 // Returns pairs of PrintObject idx and instance of that PrintObject.
 class Print;
-std::vector<std::pair<size_t, size_t>> chain_print_object_instances(const Print &print);
+struct PrintInstance;
+std::vector<const PrintInstance*> 	 chain_print_object_instances(const Print &print);
 
 
 } // namespace Slic3r

src/libslic3r/Technologies.hpp

@@ -59,4 +59,8 @@
 // Enable 6 degrees of freedom camera
 #define ENABLE_6DOF_CAMERA (1 && ENABLE_2_2_0_BETA1)
 
+// Enhance reload from disk to be able to work with 3mf/amf files saved with PrusaSlicer 2.1.0 and earlier
+#define ENABLE_BACKWARD_COMPATIBLE_RELOAD_FROM_DISK (1 && ENABLE_2_2_0_BETA1)
+
+
 #endif // _technologies_h_

src/libslic3r/utils.cpp

@@ -449,7 +449,7 @@ int copy_file(const std::string &from, const std::string &to, const bool with_ch
             ret_val = check_copy(from, to_temp);
 
         if (ret_val == 0 && rename_file(to_temp, to))
-        	ret_val = -1;
+        	ret_val = -3;
 	}
 	return ret_val;
 }
@@ -460,11 +460,11 @@ int check_copy(const std::string &origin, const std::string &copy)
 	std::ifstream f2(copy, std::ifstream::in | std::ifstream::binary | std::ifstream::ate);
 
 	if (f1.fail() || f2.fail())
-		return -1;
+		return -2;
 
 	std::streampos fsize = f1.tellg();
 	if (fsize != f2.tellg())
-		return -1;
+		return -2;
 
 	f1.seekg(0, std::ifstream::beg);
 	f2.seekg(0, std::ifstream::beg);
@@ -481,12 +481,12 @@ int check_copy(const std::string &origin, const std::string &copy)
 		if (origin_cnt != copy_cnt ||
 			(origin_cnt > 0 && std::memcmp(buffer_origin.data(), buffer_copy.data(), origin_cnt) != 0))
 			// Files are different.
-			return -1;
+			return -2;
 		fsize -= origin_cnt;
     } while (f1.good() && f2.good());
 
     // All data has been read and compared equal.
-    return (f1.eof() && f2.eof() && fsize == 0) ? 0 : -1;
+    return (f1.eof() && f2.eof() && fsize == 0) ? 0 : -2;
 }
 
 // Ignore system and hidden files, which may be created by the DropBox synchronisation process.