Renamed create_face_neighbors_index() to its_face_edge_ids().

Renamed its_create_neighbors_index() / its_create_neighbors_index_par() to its_face_neighbors() / its_face_neighbors_par().
New variant of its_face_edge_ids() to create edge IDs from face neighbors.
Fixed some incorrect use of _NDEBUG, it should be NDEBUG.
PrintObject::slice_support_volumes() returns newly Polygons, which are cheaper than ExPolygons.
Updated SeamPlacer and SupportMaterial to use regions defined as Polygons, not ExPolygons.
TriangleSelector::get_facets_strict() returning a patch with T-joints retriangulated.
New slice_mesh_slabs() - slicing projections of a triangle patch into top / bottom layers of slices, for MMU top / bottom segmentation.
TriangleMeshSlicer - use 64 mutexes instead of one when scattering sliced triangles into layers. This makes a big difference on modern many core desktop computers.
When applying MM segmented regions to input regions, the split regions are now re-merged with 10x higher positive offset epsilon to avoid creating gaps.
When testing for existence of paint-on supports or seam, use a more efficient has_facets() test, which does not deserialize into the expensive TriangleSelector tree structure.
GLIndexedVertexArray newly uses Eigen::AlignedBox<float, 3> for efficiency instead of our double based BoundingBoxf3.
Improved MMU painting refresh speed by optimizing generation of the vertex buffers.
Refactored MMU segmentation - projection of painted surfaces from top / bottom.
	1) Parallelized.
	2) Using the new slice_mesh_slabs() instead of projecting one triangle by the other and merging them with Clipper.

src/slic3r/GUI/3DScene.hpp

@@ -39,26 +39,22 @@ enum ModelInstanceEPrintVolumeState : unsigned char;
 // possibly indexed by triangles and / or quads.
 class GLIndexedVertexArray {
 public:
-    GLIndexedVertexArray() : 
-        vertices_and_normals_interleaved_VBO_id(0),
-        triangle_indices_VBO_id(0),
-        quad_indices_VBO_id(0)
-        {}
+    // Only Eigen types of Nx16 size are vectorized. This bounding box will not be vectorized.
+    static_assert(sizeof(Eigen::AlignedBox<float, 3>) == 24, "Eigen::AlignedBox<float, 3> is not being vectorized, thus it does not need to be aligned");
+    using BoundingBox = Eigen::AlignedBox<float, 3>;
+
+    GLIndexedVertexArray() { m_bounding_box.setEmpty(); }
     GLIndexedVertexArray(const GLIndexedVertexArray &rhs) :
         vertices_and_normals_interleaved(rhs.vertices_and_normals_interleaved),
         triangle_indices(rhs.triangle_indices),
         quad_indices(rhs.quad_indices),
-        vertices_and_normals_interleaved_VBO_id(0),
-        triangle_indices_VBO_id(0),
-        quad_indices_VBO_id(0)
-        { assert(! rhs.has_VBOs()); }
+        m_bounding_box(rhs.m_bounding_box)
+        { assert(! rhs.has_VBOs()); m_bounding_box.setEmpty(); }
     GLIndexedVertexArray(GLIndexedVertexArray &&rhs) :
         vertices_and_normals_interleaved(std::move(rhs.vertices_and_normals_interleaved)),
         triangle_indices(std::move(rhs.triangle_indices)),
         quad_indices(std::move(rhs.quad_indices)),
-        vertices_and_normals_interleaved_VBO_id(0),
-        triangle_indices_VBO_id(0),
-        quad_indices_VBO_id(0)
+        m_bounding_box(rhs.m_bounding_box)
         { assert(! rhs.has_VBOs()); }
 
     ~GLIndexedVertexArray() { release_geometry(); }
@@ -92,7 +88,7 @@ public:
         this->vertices_and_normals_interleaved 		 = std::move(rhs.vertices_and_normals_interleaved);
         this->triangle_indices                 		 = std::move(rhs.triangle_indices);
         this->quad_indices                     		 = std::move(rhs.quad_indices);
-        this->m_bounding_box                   		 = std::move(rhs.m_bounding_box);
+        this->m_bounding_box                   		 = rhs.m_bounding_box;
         this->vertices_and_normals_interleaved_size  = rhs.vertices_and_normals_interleaved_size;
         this->triangle_indices_size                  = rhs.triangle_indices_size;
         this->quad_indices_size                      = rhs.quad_indices_size;
@@ -147,7 +143,7 @@ public:
         this->vertices_and_normals_interleaved.emplace_back(z);
 
         this->vertices_and_normals_interleaved_size = this->vertices_and_normals_interleaved.size();
-        m_bounding_box.merge(Vec3f(x, y, z).cast<double>());
+        m_bounding_box.extend(Vec3f(x, y, z));
     };
 
     inline void push_geometry(double x, double y, double z, double nx, double ny, double nz) {
@@ -203,10 +199,12 @@ public:
         this->vertices_and_normals_interleaved.clear();
         this->triangle_indices.clear();
         this->quad_indices.clear();
-        this->m_bounding_box.reset();
         vertices_and_normals_interleaved_size = 0;
         triangle_indices_size = 0;
         quad_indices_size = 0;
+        static const float min = std::numeric_limits<float>::lowest();
+        static const float max = std::numeric_limits<float>::max();
+        m_bounding_box.setEmpty();
     }
 
     // Shrink the internal storage to tighly fit the data stored.
@@ -216,7 +214,7 @@ public:
         this->quad_indices.shrink_to_fit();
     }
 
-    const BoundingBoxf3& bounding_box() const { return m_bounding_box; }
+    const BoundingBox& bounding_box() const { return m_bounding_box; }
 
     // Return an estimate of the memory consumed by this class.
     size_t cpu_memory_used() const { return sizeof(*this) + vertices_and_normals_interleaved.capacity() * sizeof(float) + triangle_indices.capacity() * sizeof(int) + quad_indices.capacity() * sizeof(int); }
@@ -235,7 +233,7 @@ public:
     size_t total_memory_used() const { return this->cpu_memory_used() + this->gpu_memory_used(); }
 
 private:
-    BoundingBoxf3 m_bounding_box;
+    BoundingBox m_bounding_box;
 };
 
 class GLVolume {
@@ -355,7 +353,14 @@ public:
     std::vector<size_t>         offsets;
 
     // Bounding box of this volume, in unscaled coordinates.
-    const BoundingBoxf3& bounding_box() const { return this->indexed_vertex_array.bounding_box(); }
+    BoundingBoxf3 bounding_box() const { 
+        BoundingBoxf3 out;
+        if (! this->indexed_vertex_array.bounding_box().isEmpty()) {
+            out.min = this->indexed_vertex_array.bounding_box().min().cast<double>();
+            out.max = this->indexed_vertex_array.bounding_box().max().cast<double>();
+        };
+        return out;
+    }
 
     void set_render_color(float r, float g, float b, float a);
     void set_render_color(const float* rgba, unsigned int size);