[CURA-10407] Introduce fractional layer-height support gaps

include/GCodePathConfig.h

@@ -18,6 +18,7 @@ namespace cura
  */
 struct GCodePathConfig
 {
+    coord_t z_offset{};
     PrintFeatureType type{}; //!< name of the feature type
     coord_t line_width{}; //!< width of the line extruded
     coord_t layer_thickness{}; //!< current layer height in micron

include/LayerPlan.h

@@ -117,10 +117,11 @@ class LayerPlan : public NoCopy
      */
     GCodePath* getLatestPathWithConfig(
         const GCodePathConfig& config,
-        SpaceFillType space_fill_type,
+        const coord_t z_offset,
+        const SpaceFillType space_fill_type,
         const Ratio flow = 1.0_r,
         const Ratio width_factor = 1.0_r,
-        bool spiralize = false,
+        const bool spiralize = false,
         const Ratio speed_factor = 1.0_r);
 
 public:
@@ -281,7 +282,7 @@ class LayerPlan : public NoCopy
      * \param p The point to travel to.
      * \param force_retract Whether to force a retraction to occur.
      */
-    GCodePath& addTravel(const Point p, const bool force_retract = false);
+    GCodePath& addTravel(const Point p, const bool force_retract = false, const coord_t z_offset = 0);
 
     /*!
      * Add a travel path to a certain point and retract if needed.
@@ -291,7 +292,7 @@ class LayerPlan : public NoCopy
      * \param p The point to travel to
      * \param path (optional) The travel path to which to add the point \p p
      */
-    GCodePath& addTravel_simple(Point p, GCodePath* path = nullptr);
+    GCodePath& addTravel_simple(const Point p, GCodePath* path = nullptr);
 
     /*!
      * Plan a prime blob at the current location.
@@ -317,14 +318,14 @@ class LayerPlan : public NoCopy
      * \param fan_speed Fan speed override for this path.
      */
     void addExtrusionMove(
-        Point p,
+        const Point p,
         const GCodePathConfig& config,
-        SpaceFillType space_fill_type,
+        const SpaceFillType space_fill_type,
         const Ratio& flow = 1.0_r,
         const Ratio width_factor = 1.0_r,
-        bool spiralize = false,
-        Ratio speed_factor = 1.0_r,
-        double fan_speed = GCodePathConfig::FAN_SPEED_DEFAULT);
+        const bool spiralize = false,
+        const Ratio speed_factor = 1.0_r,
+        const double fan_speed = GCodePathConfig::FAN_SPEED_DEFAULT);
 
     /*!
      * Add polygon to the gcode starting at vertex \p startIdx

include/pathPlanning/GCodePath.h

@@ -29,6 +29,7 @@ namespace cura
  */
 struct GCodePath
 {
+    coord_t z_offset{};
     GCodePathConfig config{}; //!< The configuration settings of the path.
     std::shared_ptr<const SliceMeshStorage> mesh; //!< Which mesh this path belongs to, if any. If it's not part of any mesh, the mesh should be nullptr;
     SpaceFillType space_fill_type{}; //!< The type of space filling of which this path is a part

include/sliceDataStorage.h

@@ -212,6 +212,8 @@ class SupportLayer
     std::vector<SupportInfillPart> support_infill_parts; //!< a list of support infill parts
     Polygons support_bottom; //!< Piece of support below the support and above the model. This must not overlap with any of the support_infill_parts or support_roof.
     Polygons support_roof; //!< Piece of support above the support and below the model. This must not overlap with any of the support_infill_parts or support_bottom.
+    Polygons support_fractional_roof_top; //!< If the support distance is less than a multiple of the layer height,
+                                          //   the first part of support just underneath the model needs to be printed at a fracional layer height.
     Polygons support_mesh_drop_down; //!< Areas from support meshes which should be supported by more support
     Polygons support_mesh; //!< Areas from support meshes which should NOT be supported by more support
     Polygons anti_overhang; //!< Areas where no overhang should be detected.

src/FffGcodeWriter.cpp

@@ -2287,7 +2287,7 @@ bool FffGcodeWriter::processInsets(
         if (mesh_group_settings.get<bool>("support_enable"))
         {
             const coord_t z_distance_top = mesh.settings.get<coord_t>("support_top_distance");
-            const size_t z_distance_top_layers = round_up_divide(z_distance_top, layer_height) + 1;
+            const size_t z_distance_top_layers = round_up_divide(z_distance_top, layer_height); // Previously '... +1', but now there is an extra fractional layer on top.
             const int support_layer_nr = gcode_layer.getLayerNr() - z_distance_top_layers;
 
             if (support_layer_nr > 0)
@@ -2596,7 +2596,7 @@ void FffGcodeWriter::processTopBottom(
     {
         const coord_t layer_height = mesh_config.inset0_config.getLayerThickness();
         const coord_t z_distance_top = mesh.settings.get<coord_t>("support_top_distance");
-        const size_t z_distance_top_layers = round_up_divide(z_distance_top, layer_height) + 1;
+        const size_t z_distance_top_layers = round_up_divide(z_distance_top, layer_height); // Previously '... +1', but now there is an extra fractional layer on top.
         support_layer_nr = layer_nr - z_distance_top_layers;
     }
 
@@ -3327,89 +3327,103 @@ bool FffGcodeWriter::addSupportRoofsToGCode(const SliceDataStorage& storage, Lay
         support_roof_line_distance *= roof_extruder.settings.get<Ratio>("initial_layer_line_width_factor");
     }
 
-    Polygons infill_outline = support_layer.support_roof;
-    Polygons wall;
-    // make sure there is a wall if this is on the first layer
-    if (gcode_layer.getLayerNr() == 0)
-    {
-        wall = support_layer.support_roof.offset(-support_roof_line_width / 2);
-        infill_outline = wall.offset(-support_roof_line_width / 2);
-    }
+    const auto layer_height = Application::getInstance().current_slice->scene.current_mesh_group->settings.get<coord_t>("layer_height");
+    const auto support_top_distance = Application::getInstance().current_slice->scene.current_mesh_group->settings.get<coord_t>("support_top_distance");
+    const coord_t leftover_support_distance = support_top_distance % layer_height;
 
-    Infill roof_computation(
-        pattern,
-        zig_zaggify_infill,
-        connect_polygons,
-        infill_outline,
-        gcode_layer.configs_storage.support_roof_config.getLineWidth(),
-        support_roof_line_distance,
-        support_roof_overlap,
-        infill_multiplier,
-        fill_angle,
-        gcode_layer.z,
-        extra_infill_shift,
-        max_resolution,
-        max_deviation,
-        wall_line_count,
-        small_area_width,
-        infill_origin,
-        skip_stitching,
-        fill_gaps,
-        connected_zigzags,
-        use_endpieces,
-        skip_some_zags,
-        zag_skip_count,
-        pocket_size);
-    Polygons roof_polygons;
-    std::vector<VariableWidthLines> roof_paths;
-    Polygons roof_lines;
-    roof_computation.generate(roof_paths, roof_polygons, roof_lines, roof_extruder.settings, gcode_layer.getLayerNr(), SectionType::SUPPORT);
-    if ((gcode_layer.getLayerNr() == 0 && wall.empty()) || (gcode_layer.getLayerNr() > 0 && roof_paths.empty() && roof_polygons.empty() && roof_lines.empty()))
-    {
-        return false; // We didn't create any support roof.
-    }
-    gcode_layer.setIsInside(false); // going to print stuff outside print object, i.e. support
-    if (gcode_layer.getLayerNr() == 0)
-    {
-        gcode_layer.addPolygonsByOptimizer(wall, gcode_layer.configs_storage.support_roof_config);
-    }
-    if (! roof_polygons.empty())
-    {
-        constexpr bool force_comb_retract = false;
-        gcode_layer.addTravel(roof_polygons[0][0], force_comb_retract);
-        gcode_layer.addPolygonsByOptimizer(roof_polygons, gcode_layer.configs_storage.support_roof_config);
-    }
-    if (! roof_paths.empty())
+    std::vector<Polygons> infill_outlines = { Simplify(roof_extruder.settings).polygon(support_layer.support_roof.difference(support_layer.support_fractional_roof_top)),
+                                              Simplify(roof_extruder.settings).polygon(support_layer.support_fractional_roof_top) };
+    auto current_roof_config = gcode_layer.configs_storage.support_roof_config; // copy!
+    bool generated_something = false;
+    for (auto& infill_outline : infill_outlines)
     {
-        const GCodePathConfig& config = gcode_layer.configs_storage.support_roof_config;
-        constexpr bool retract_before_outer_wall = false;
-        constexpr coord_t wipe_dist = 0;
-        const ZSeamConfig z_seam_config(EZSeamType::SHORTEST, gcode_layer.getLastPlannedPositionOrStartingPosition(), EZSeamCornerPrefType::Z_SEAM_CORNER_PREF_NONE, false);
+        Polygons wall;
+        // make sure there is a wall if this is on the first layer
+        if (gcode_layer.getLayerNr() == 0)
+        {
+            wall = support_layer.support_roof.offset(-support_roof_line_width / 2);
+            infill_outline = wall.offset(-support_roof_line_width / 2);
+        }
 
-        InsetOrderOptimizer wall_orderer(
-            *this,
-            storage,
-            gcode_layer,
-            roof_extruder.settings,
-            roof_extruder_nr,
-            config,
-            config,
-            config,
-            config,
-            retract_before_outer_wall,
-            wipe_dist,
-            wipe_dist,
-            roof_extruder_nr,
-            roof_extruder_nr,
-            z_seam_config,
-            roof_paths);
-        wall_orderer.addToLayer();
+        Infill roof_computation(
+            pattern,
+            zig_zaggify_infill,
+            connect_polygons,
+            infill_outline,
+            current_roof_config.getLineWidth(),
+            support_roof_line_distance,
+            support_roof_overlap,
+            infill_multiplier,
+            fill_angle,
+            gcode_layer.z + current_roof_config.z_offset,
+            extra_infill_shift,
+            max_resolution,
+            max_deviation,
+            wall_line_count,
+            small_area_width,
+            infill_origin,
+            skip_stitching,
+            fill_gaps,
+            connected_zigzags,
+            use_endpieces,
+            skip_some_zags,
+            zag_skip_count,
+            pocket_size);
+        Polygons roof_polygons;
+        std::vector<VariableWidthLines> roof_paths;
+        Polygons roof_lines;
+        roof_computation.generate(roof_paths, roof_polygons, roof_lines, roof_extruder.settings, gcode_layer.getLayerNr(), SectionType::SUPPORT);
+        if ((gcode_layer.getLayerNr() == 0 && wall.empty()) || (gcode_layer.getLayerNr() > 0 && roof_paths.empty() && roof_polygons.empty() && roof_lines.empty()))
+        {
+            continue; // We didn't create any support roof.
+        }
+        generated_something = true; // We _did_ create at least some support roof.
+        gcode_layer.setIsInside(false); // going to print stuff outside print object, i.e. support
+        if (gcode_layer.getLayerNr() == 0)
+        {
+            gcode_layer.addPolygonsByOptimizer(wall, current_roof_config);
+        }
+        if (! roof_polygons.empty())
+        {
+            constexpr bool force_comb_retract = false;
+            gcode_layer.addTravel(roof_polygons[0][0], force_comb_retract);
+            gcode_layer.addPolygonsByOptimizer(roof_polygons, current_roof_config);
+        }
+        if (! roof_paths.empty())
+        {
+            const GCodePathConfig& config = current_roof_config;
+            constexpr bool retract_before_outer_wall = false;
+            constexpr coord_t wipe_dist = 0;
+            const ZSeamConfig z_seam_config(EZSeamType::SHORTEST, gcode_layer.getLastPlannedPositionOrStartingPosition(), EZSeamCornerPrefType::Z_SEAM_CORNER_PREF_NONE, false);
+
+            InsetOrderOptimizer wall_orderer(
+                *this,
+                storage,
+                gcode_layer,
+                roof_extruder.settings,
+                roof_extruder_nr,
+                config,
+                config,
+                config,
+                config,
+                retract_before_outer_wall,
+                wipe_dist,
+                wipe_dist,
+                roof_extruder_nr,
+                roof_extruder_nr,
+                z_seam_config,
+                roof_paths);
+            wall_orderer.addToLayer();
+        }
+        gcode_layer.addLinesByOptimizer(
+            roof_lines,
+            gcode_layer.configs_storage.support_roof_config,
+            (pattern == EFillMethod::ZIG_ZAG) ? SpaceFillType::PolyLines : SpaceFillType::Lines);
+
+        current_roof_config.z_offset = -leftover_support_distance;
+        current_roof_config.flow *= Ratio(layer_height - leftover_support_distance, layer_height);
     }
-    gcode_layer.addLinesByOptimizer(
-        roof_lines,
-        gcode_layer.configs_storage.support_roof_config,
-        (pattern == EFillMethod::ZIG_ZAG) ? SpaceFillType::PolyLines : SpaceFillType::Lines);
-    return true;
+    return generated_something;
 }
 
 bool FffGcodeWriter::addSupportBottomsToGCode(const SliceDataStorage& storage, LayerPlan& gcode_layer) const

src/LayerPlan.cpp

@@ -38,19 +38,22 @@ constexpr int MINIMUM_SQUARED_LINE_LENGTH = MINIMUM_LINE_LENGTH * MINIMUM_LINE_L
 
 GCodePath* LayerPlan::getLatestPathWithConfig(
     const GCodePathConfig& config,
-    SpaceFillType space_fill_type,
+    const coord_t z_offset,
+    const SpaceFillType space_fill_type,
     const Ratio flow,
     const Ratio width_factor,
-    bool spiralize,
+    const bool spiralize,
     const Ratio speed_factor)
 {
     std::vector<GCodePath>& paths = extruder_plans.back().paths;
     if (paths.size() > 0 && paths.back().config == config && ! paths.back().done && paths.back().flow == flow && paths.back().width_factor == width_factor
-        && paths.back().speed_factor == speed_factor && paths.back().mesh == current_mesh) // spiralize can only change when a travel path is in between
+        && paths.back().speed_factor == speed_factor && paths.back().z_offset == z_offset
+        && paths.back().mesh == current_mesh) // spiralize can only change when a travel path is in between
     {
         return &paths.back();
     }
-    paths.emplace_back(GCodePath{ .config = config,
+    paths.emplace_back(GCodePath{ .z_offset = z_offset,
+                                  .config = config,
                                   .mesh = current_mesh,
                                   .space_fill_type = space_fill_type,
                                   .flow = flow,
@@ -326,14 +329,14 @@ std::optional<std::pair<Point, bool>> LayerPlan::getFirstTravelDestinationState(
     return ret;
 }
 
-GCodePath& LayerPlan::addTravel(const Point p, const bool force_retract)
+GCodePath& LayerPlan::addTravel(const Point p, const bool force_retract, const coord_t z_offset)
 {
     const GCodePathConfig& travel_config = configs_storage.travel_config_per_extruder[getExtruder()];
 
     const RetractionConfig& retraction_config
         = current_mesh ? current_mesh->retraction_wipe_config.retraction_config : storage.retraction_wipe_config_per_extruder[getExtruder()].retraction_config;
 
-    GCodePath* path = getLatestPathWithConfig(travel_config, SpaceFillType::None);
+    GCodePath* path = getLatestPathWithConfig(travel_config, z_offset, SpaceFillType::None);
 
     bool combed = false;
 
@@ -478,7 +481,7 @@ GCodePath& LayerPlan::addTravel(const Point p, const bool force_retract)
     return ret;
 }
 
-GCodePath& LayerPlan::addTravel_simple(Point p, GCodePath* path)
+GCodePath& LayerPlan::addTravel_simple(const Point p, GCodePath* path)
 {
     bool is_first_travel_of_layer = ! static_cast<bool>(last_planned_position);
     if (is_first_travel_of_layer)
@@ -488,7 +491,7 @@ GCodePath& LayerPlan::addTravel_simple(Point p, GCodePath* path)
     }
     if (path == nullptr)
     {
-        path = getLatestPathWithConfig(configs_storage.travel_config_per_extruder[getExtruder()], SpaceFillType::None);
+        path = getLatestPathWithConfig(configs_storage.travel_config_per_extruder[getExtruder()], 0, SpaceFillType::None);
     }
     path->points.push_back(p);
     last_planned_position = p;
@@ -506,16 +509,16 @@ void LayerPlan::planPrime(const float& prime_blob_wipe_length)
 }
 
 void LayerPlan::addExtrusionMove(
-    Point p,
+    const Point p,
     const GCodePathConfig& config,
-    SpaceFillType space_fill_type,
+    const SpaceFillType space_fill_type,
     const Ratio& flow,
     const Ratio width_factor,
-    bool spiralize,
-    Ratio speed_factor,
-    double fan_speed)
+    const bool spiralize,
+    const Ratio speed_factor,
+    const double fan_speed)
 {
-    GCodePath* path = getLatestPathWithConfig(config, space_fill_type, flow, width_factor, spiralize, speed_factor);
+    GCodePath* path = getLatestPathWithConfig(config, config.z_offset, space_fill_type, flow, width_factor, spiralize, speed_factor);
     path->points.push_back(p);
     path->setFanSpeed(fan_speed);
     if (! static_cast<bool>(first_extrusion_acc_jerk))
@@ -537,7 +540,7 @@ void LayerPlan::addPolygon(
 {
     constexpr Ratio width_ratio = 1.0_r; // Not printed with variable line width.
     Point p0 = polygon[start_idx];
-    addTravel(p0, always_retract);
+    addTravel(p0, always_retract, config.z_offset);
     const int direction = backwards ? -1 : 1;
     for (size_t point_idx = 1; point_idx < polygon.size(); point_idx++)
     {
@@ -1250,7 +1253,7 @@ void LayerPlan::addLinesInGivenOrder(
         }
         else
         {
-            addTravel(start);
+            addTravel(start, false, config.z_offset);
         }
 
         Point p0 = start;
@@ -1947,7 +1950,12 @@ void LayerPlan::writeGCode(GCodeExport& gcode)
                 gcode.writeRetraction(retraction_config->retraction_config);
             }
 
-            if (! path.retract && path.config.isTravelPath() && path.points.size() == 1 && path.points[0] == gcode.getPositionXY() && z == gcode.getPositionZ())
+            if (z > 0)
+            {
+                gcode.setZ(z + path.z_offset);
+            }
+
+            if (! path.retract && path.config.isTravelPath() && path.points.size() == 1 && path.points[0] == gcode.getPositionXY() && (z + path.z_offset) == gcode.getPositionZ())
             {
                 // ignore travel moves to the current location to avoid needless change of acceleration/jerk
                 continue;