Moved some math macros (sqr, lerp, clamp) to libslic3r.h

Added UNUSED macro to libslic3r.h, used it to reduce some compile warnings.

Split the Int128 class from Clipper library to a separate file,
extended Int128 with intrinsic types wherever possible for performance,
added new geometric predicates.

Added a draft of new FillRectilinear3, which should reduce overfill near the perimeters in the future.

xs/src/libslic3r/Fill/Fill3DHoneycomb.cpp

@@ -50,12 +50,6 @@ static std::vector<coordf_t> perpendPoints(const coordf_t offset, const size_t b
     return points;
 }
 
-template<typename T>
-static inline T clamp(T low, T high, T x)
-{
-    return std::max<T>(low, std::min<T>(high, x));
-}
-
 // Trims an array of points to specified rectangular limits. Point
 // components that are outside these limits are set to the limits.
 static inline void trim(Pointfs &pts, coordf_t minX, coordf_t minY, coordf_t maxX, coordf_t maxY)

xs/src/libslic3r/Fill/FillBase.hpp

@@ -95,21 +95,19 @@ protected:
 
     // The expolygon may be modified by the method to avoid a copy.
     virtual void    _fill_surface_single(
-        const FillParams                &params, 
-        unsigned int                     thickness_layers,
-        const std::pair<float, Point>   &direction, 
-        ExPolygon                       &expolygon, 
-        Polylines                       &polylines_out) {}
+        const FillParams                & /* params */, 
+        unsigned int                      /* thickness_layers */,
+        const std::pair<float, Point>   & /* direction */, 
+        ExPolygon                       & /* expolygon */, 
+        Polylines                       & /* polylines_out */) {};
 
-    static coord_t  _adjust_solid_spacing(const coord_t width, const coord_t distance);
-
-    virtual float _layer_angle(size_t idx) const { 
-        bool odd = idx & 1;
-        return (idx & 1) ? float(M_PI/2.) : 0;
-    }
+    virtual float _layer_angle(size_t idx) const { return (idx & 1) ? float(M_PI/2.) : 0; }
 
     virtual std::pair<float, Point> _infill_direction(const Surface *surface) const;
 
+public:
+    static coord_t  _adjust_solid_spacing(const coord_t width, const coord_t distance);
+
     // Align a coordinate to a grid. The coordinate may be negative,
     // the aligned value will never be bigger than the original one.
     static coord_t _align_to_grid(const coord_t coord, const coord_t spacing) {

xs/src/libslic3r/Fill/FillConcentric.cpp

@@ -38,8 +38,8 @@ void FillConcentric::_fill_surface_single(
     // split paths using a nearest neighbor search
     size_t iPathFirst = polylines_out.size();
     Point last_pos(0, 0);
-    for (Polygons::const_iterator it_loop = loops.begin(); it_loop != loops.end(); ++ it_loop) {
-        polylines_out.push_back(it_loop->split_at_index(last_pos.nearest_point_index(*it_loop)));
+    for (const Polygon &loop : loops) {
+        polylines_out.push_back(loop.split_at_index(last_pos.nearest_point_index(loop)));
         last_pos = polylines_out.back().last_point();
     }
 
@@ -50,13 +50,15 @@ void FillConcentric::_fill_surface_single(
         polylines_out[i].clip_end(this->loop_clipping);
         if (polylines_out[i].is_valid()) {
             if (j < i)
-                std::swap(polylines_out[j], polylines_out[i]);
+                polylines_out[j] = std::move(polylines_out[i]);
             ++ j;
         }
     }
     if (j < polylines_out.size())
         polylines_out.erase(polylines_out.begin() + j, polylines_out.end());
-    // TODO: return ExtrusionLoop objects to get better chained paths
+    //TODO: return ExtrusionLoop objects to get better chained paths,
+    // otherwise the outermost loop starts at the closest point to (0, 0).
+    // We want the loops to be split inside the G-code generator to get optimum path planning.
 }
 
 } // namespace Slic3r

xs/src/libslic3r/Fill/FillRectilinear2.cpp

@@ -33,36 +33,6 @@
 
 namespace Slic3r {
 
-#ifndef clamp
-template<typename T>
-static inline T clamp(T low, T high, T x)
-{
-    return std::max<T>(low, std::min<T>(high, x));
-}
-#endif /* clamp */
-
-#ifndef sqr
-template<typename T>
-static inline T sqr(T x)
-{
-    return x * x;
-}
-#endif /* sqr */
-
-#ifndef mag2
-static inline coordf_t mag2(const Point &p)
-{
-    return sqr(coordf_t(p.x)) + sqr(coordf_t(p.y));
-}
-#endif /* mag2 */
-
-#ifndef mag
-static inline coordf_t mag(const Point &p)
-{
-    return std::sqrt(mag2(p));
-}
-#endif /* mag */
-
 // Having a segment of a closed polygon, calculate its Euclidian length.
 // The segment indices seg1 and seg2 signify an end point of an edge in the forward direction of the loop,
 // therefore the point p1 lies on poly.points[seg1-1], poly.points[seg1] etc.

xs/src/libslic3r/Fill/FillRectilinear3.hpp

@@ -0,0 +1,83 @@
+#ifndef slic3r_FillRectilinear2_hpp_
+#define slic3r_FillRectilinear2_hpp_
+
+#include "../libslic3r.h"
+
+#include "FillBase.hpp"
+
+namespace Slic3r {
+
+class Surface;
+
+class FillRectilinear3 : public Fill
+{
+public:
+    virtual Fill* clone() const { return new FillRectilinear3(*this); };
+    virtual ~FillRectilinear3() {}
+    virtual Polylines fill_surface(const Surface *surface, const FillParams &params);
+
+    struct FillDirParams
+    {
+        FillDirParams(coordf_t spacing, double angle, coordf_t pattern_shift = 0.f) : 
+            spacing(spacing), angle(angle), pattern_shift(pattern_shift) {}
+        coordf_t    spacing;
+        double      angle;
+        coordf_t    pattern_shift;
+    };
+
+protected:
+	bool fill_surface_by_lines(const Surface *surface, const FillParams &params, std::vector<FillDirParams> &fill_dir_params, Polylines &polylines_out);
+};
+
+class FillGrid3 : public FillRectilinear3
+{
+public:
+    virtual Fill* clone() const { return new FillGrid3(*this); };
+    virtual ~FillGrid3() {}
+    virtual Polylines fill_surface(const Surface *surface, const FillParams &params);
+
+protected:
+	// The grid fill will keep the angle constant between the layers, see the implementation of Slic3r::Fill.
+    virtual float _layer_angle(size_t /* idx */) const { return 0.f; }
+};
+
+class FillTriangles3 : public FillRectilinear3
+{
+public:
+    virtual Fill* clone() const { return new FillTriangles3(*this); };
+    virtual ~FillTriangles3() {}
+    virtual Polylines fill_surface(const Surface *surface, const FillParams &params);
+
+protected:
+	// The grid fill will keep the angle constant between the layers, see the implementation of Slic3r::Fill.
+    virtual float _layer_angle(size_t /* idx */) const { return 0.f; }
+};
+
+class FillStars3 : public FillRectilinear3
+{
+public:
+    virtual Fill* clone() const { return new FillStars3(*this); };
+    virtual ~FillStars3() {}
+    virtual Polylines fill_surface(const Surface *surface, const FillParams &params);
+
+protected:
+    // The grid fill will keep the angle constant between the layers, see the implementation of Slic3r::Fill.
+    virtual float _layer_angle(size_t /* idx */) const { return 0.f; }
+};
+
+class FillCubic3 : public FillRectilinear3
+{
+public:
+    virtual Fill* clone() const { return new FillCubic3(*this); };
+    virtual ~FillCubic3() {}
+    virtual Polylines fill_surface(const Surface *surface, const FillParams &params);
+
+protected:
+	// The grid fill will keep the angle constant between the layers, see the implementation of Slic3r::Fill.
+    virtual float _layer_angle(size_t /* idx */) const { return 0.f; }
+};
+
+
+}; // namespace Slic3r
+
+#endif // slic3r_FillRectilinear2_hpp_