Merge some BS1.7 changes:

internal_solid_infill_pattern

src/libslic3r/Fill/Fill.cpp

@@ -157,7 +157,9 @@ std::vector<SurfaceFill> group_fills(const Layer &layer)
 		        if (surface.is_solid()) {
 		            params.density = 100.f;
 					//FIXME for non-thick bridges, shall we allow a bottom surface pattern?
-                    if (surface.is_external() && ! is_bridge) {
+					if (surface.is_solid_infill())
+                        params.pattern = region_config.internal_solid_infill_pattern.value;
+                    else if (surface.is_external() && ! is_bridge) {
                         if(surface.is_top())
                             params.pattern = region_config.top_surface_pattern.value;
                         else
@@ -199,7 +201,6 @@ std::vector<SurfaceFill> group_fills(const Layer &layer)
 					// so that internall infill will be aligned over all layers of the current region.
 		            params.spacing = layerm.region().flow(*layer.object(), frInfill, layer.object()->config().layer_height, false).spacing();
 		            // Anchor a sparse infill to inner perimeters with the following anchor length:
-					// Anchor a sparse infill to inner perimeters with the following anchor length:
 			        params.anchor_length = float(region_config.infill_anchor);
 					if (region_config.infill_anchor.percent)
 						params.anchor_length = float(params.anchor_length * 0.01 * params.spacing);
@@ -492,8 +493,9 @@ void Layer::make_fills(FillAdaptive::Octree* adaptive_fill_octree, FillAdaptive:
 		params.using_internal_flow = using_internal_flow;
 		params.no_extrusion_overlap = surface_fill.params.overlap;
 		params.with_loop = surface_fill.params.with_loop;
-
 		params.config = &layerm->region().config();
+		if (surface_fill.params.pattern == ipGrid)
+			params.can_reverse = false;
 		for (ExPolygon& expoly : surface_fill.expolygons) {
             f->no_overlap_expolygons = intersection_ex(surface_fill.no_overlap_expolygons, ExPolygons() = {expoly}, ApplySafetyOffset::Yes);
 			// Spacing is modified by the filler to indicate adjustments. Reset it for each expolygon.
@@ -538,6 +540,7 @@ void Layer::make_ironing()
 
 	// First classify regions based on the extruder used.
 	struct IroningParams {
+		InfillPattern pattern;
 		int 		extruder 	= -1;
 		bool 		just_infill = false;
 		// Spacing of the ironing lines, also to calculate the extrusion flow from.
@@ -577,8 +580,7 @@ void Layer::make_ironing()
 
 		bool operator==(const IroningParams &rhs) const {
 			return this->extruder == rhs.extruder && this->just_infill == rhs.just_infill &&
-				   this->line_spacing == rhs.line_spacing && this->height == rhs.height && this->speed == rhs.speed &&
-				   this->angle == rhs.angle;
+				   this->line_spacing == rhs.line_spacing && this->height == rhs.height && this->speed == rhs.speed && this->angle == rhs.angle && this->pattern == rhs.pattern;
 		}
 
 		LayerRegion *layerm		= nullptr;
@@ -625,24 +627,36 @@ void Layer::make_ironing()
 				ironing_params.height 		= default_layer_height * 0.01 * config.ironing_flow;
 				ironing_params.speed 		= config.ironing_speed;
 				ironing_params.angle 		= config.infill_direction * M_PI / 180.;
+				ironing_params.pattern      = config.ironing_pattern;
 				ironing_params.layerm 		= layerm;
 				by_extruder.emplace_back(ironing_params);
 			}
 		}
 	std::sort(by_extruder.begin(), by_extruder.end());
 
-    FillRectilinear 	fill;
     FillParams 			fill_params;
-	fill.set_bounding_box(this->object()->bounding_box());
-	fill.layer_id 			 = this->id();
-    fill.z 					 = this->print_z;
-    fill.overlap 			 = 0;
     fill_params.density 	 = 1.;
     fill_params.monotonic    = true;
-
+    InfillPattern         f_pattern = ipRectilinear;
+    std::unique_ptr<Fill> f         = std::unique_ptr<Fill>(Fill::new_from_type(f_pattern));
+    f->set_bounding_box(this->object()->bounding_box());
+    f->layer_id = this->id();
+    f->z        = this->print_z;
+    f->overlap  = 0;
 	for (size_t i = 0; i < by_extruder.size();) {
 		// Find span of regions equivalent to the ironing operation.
 		IroningParams &ironing_params = by_extruder[i];
+		// Create the filler object.
+		if( f_pattern != ironing_params.pattern )
+		{
+            f_pattern               = ironing_params.pattern;
+            f = std::unique_ptr<Fill>(Fill::new_from_type(f_pattern));
+            f->set_bounding_box(this->object()->bounding_box());
+            f->layer_id = this->id();
+            f->z        = this->print_z;
+            f->overlap  = 0;
+		}
+
 		size_t j = i;
 		for (++ j; j < by_extruder.size() && ironing_params == by_extruder[j]; ++ j) ;
 
@@ -704,10 +718,10 @@ void Layer::make_ironing()
 		}
 
         // Create the filler object.
-        fill.spacing = ironing_params.line_spacing;
-        fill.angle = float(ironing_params.angle + 0.25 * M_PI);
-        fill.link_max_length = (coord_t)scale_(3. * fill.spacing);
-		double extrusion_height = ironing_params.height * fill.spacing / nozzle_dmr;
+        f->spacing = ironing_params.line_spacing;
+        f->angle = float(ironing_params.angle + 0.25 * M_PI);
+        f->link_max_length = (coord_t) scale_(3. * f->spacing);
+		double  extrusion_height = ironing_params.height * f->spacing / nozzle_dmr;
 		float  extrusion_width  = Flow::rounded_rectangle_extrusion_width_from_spacing(float(nozzle_dmr), float(extrusion_height));
 		double flow_mm3_per_mm = nozzle_dmr * extrusion_height;
         Surface surface_fill(stTop, ExPolygon());
@@ -715,7 +729,7 @@ void Layer::make_ironing()
 			surface_fill.expolygon = std::move(expoly);
 			Polylines polylines;
 			try {
-				polylines = fill.fill_surface(&surface_fill, fill_params);
+				polylines = f->fill_surface(&surface_fill, fill_params);
 			} catch (InfillFailedException &) {
 			}
 	        if (! polylines.empty()) {

src/libslic3r/Fill/FillBase.cpp

@@ -192,6 +192,7 @@ void Fill::fill_surface_extrusion(const Surface* surface, const FillParams& para
         out.push_back(eec = new ExtrusionEntityCollection());
         // Only concentric fills are not sorted.
         eec->no_sort = this->no_sort();
+        size_t idx   = eec->entities.size();
         if (params.use_arachne) {
             Flow new_flow = params.flow.with_spacing(float(this->spacing));
             variable_width(thick_polylines, params.extrusion_role, new_flow, eec->entities);
@@ -203,6 +204,10 @@ void Fill::fill_surface_extrusion(const Surface* surface, const FillParams& para
                 params.extrusion_role,
                 flow_mm3_per_mm, float(flow_width), params.flow.height());
         }
+        if (!params.can_reverse) {
+            for (size_t i = idx; i < eec->entities.size(); i++)
+                eec->entities[i]->set_reverse();
+        }
     }
 }
 

src/libslic3r/Fill/FillBase.hpp

@@ -78,6 +78,7 @@ struct FillParams
     float           no_extrusion_overlap{ 0.0 };
     const           PrintRegionConfig* config{ nullptr };
     bool            dont_sort{ false }; // do not sort the lines, just simply connect them
+    bool            can_reverse{true};
 };
 static_assert(IsTriviallyCopyable<FillParams>::value, "FillParams class is not POD (and it should be - see constructor).");
 

src/libslic3r/Fill/FillRectilinear.cpp

@@ -2994,6 +2994,10 @@ Polylines FillGrid::fill_surface(const Surface *surface, const FillParams &param
             { { 0.f, 0.f }, { float(M_PI / 2.), 0.f } },
             polylines_out))
         BOOST_LOG_TRIVIAL(error) << "FillGrid::fill_surface() failed to fill a region.";
+
+    if (this->layer_id % 2 == 1)
+        for (int i = 0; i < polylines_out.size(); i++)
+            std::reverse(polylines_out[i].begin(), polylines_out[i].end());
     return polylines_out;
 }