updated manifold to latest version with double precision floating point (openscad#5282)

* updated manifold to latest version
* use tbb parallelization
* allow find_package for manifold
* update to MeshGL64
* remove shared_ptr and fix minkowski color

Author: pca006132

CMakeLists.txt

@@ -32,6 +32,7 @@ option(INFO "Display build configuration info at end of cmake config" ON)
 option(ENABLE_TESTS "Run testsuite after building." ON)
 option(EXPERIMENTAL "Enable Experimental Features" OFF)
 option(USE_MANIFOLD_TRIANGULATOR "Use Manifold's triangulator instead of CGAL's" OFF)
+option(USE_BUILTIN_MANIFOLD "Use manifold from submodule" ON)
 option(USE_LEGACY_RENDERERS "Use legacy (non-VBO) OpenGL renderers" OFF)
 option(SNAPSHOT "Create dev snapshot, uses nightly icons" OFF)
 option(HEADLESS "Build without GUI frontend" OFF)
@@ -949,15 +950,18 @@ if(EXPERIMENTAL)
   set(PYBIND11_FINDPYTHON OFF)
   set(MANIFOLD_PYBIND OFF)
   set(MANIFOLD_TEST OFF)
-
-  if(CMAKE_UNITY_BUILD)
-    set(CMAKE_UNITY_BUILD OFF)
-    add_subdirectory(submodules/manifold EXCLUDE_FROM_ALL)
-    set(CMAKE_UNITY_BUILD ON)
+  if(USE_BUILTIN_MANIFOLD)
+    if(CMAKE_UNITY_BUILD)
+      set(CMAKE_UNITY_BUILD OFF)
+      add_subdirectory(submodules/manifold EXCLUDE_FROM_ALL)
+      set(CMAKE_UNITY_BUILD ON)
+    else()
+      add_subdirectory(submodules/manifold EXCLUDE_FROM_ALL)
+    endif()
   else()
-    add_subdirectory(submodules/manifold EXCLUDE_FROM_ALL)
+    find_package(manifold REQUIRED)
   endif()
-  target_link_libraries(OpenSCAD PRIVATE manifold polygon)
+  target_link_libraries(OpenSCAD PRIVATE manifold polygon cross_section)
   add_sanitizers(manifold)
 
   target_compile_definitions(OpenSCAD PRIVATE ENABLE_MANIFOLD)

src/RenderStatistic.cc

@@ -39,7 +39,6 @@
 
 #ifdef ENABLE_MANIFOLD
 #include "ManifoldGeometry.h"
-#include "manifold.h"
 #include "manifoldutils.h"
 #endif // ENABLE_MANIFOLD
 

src/geometry/manifold/ManifoldGeometry.cc

@@ -1,9 +1,9 @@
 // Portions of this file are Copyright 2023 Google LLC, and licensed under GPL2+. See COPYING.
 #include "ManifoldGeometry.h"
 #include "Polygon2d.h"
-#include "manifold.h"
+#include "manifold/cross_section.h"
+#include "manifold/manifold.h"
 #include "PolySet.h"
-#include "Feature.h"
 #include "PolySetBuilder.h"
 #include "PolySetUtils.h"
 #include "manifoldutils.h"
@@ -23,20 +23,18 @@ Result vector_convert(V const& v) {
 
 }
 
-ManifoldGeometry::ManifoldGeometry() : manifold_(std::make_shared<const manifold::Manifold>()) {}
+ManifoldGeometry::ManifoldGeometry() : manifold_(manifold::Manifold()) {}
 
 ManifoldGeometry::ManifoldGeometry(
-  const std::shared_ptr<const manifold::Manifold>& mani,
+  manifold::Manifold mani,
   const std::set<uint32_t> & originalIDs,
   const std::map<uint32_t, Color4f> & originalIDToColor,
   const std::set<uint32_t> & subtractedIDs)
-    : manifold_(mani),
+    : manifold_(std::move(mani)),
       originalIDs_(originalIDs),
       originalIDToColor_(originalIDToColor),
       subtractedIDs_(subtractedIDs)
 {
-  assert(manifold_);
-  if (!manifold_) clear();
 }
 
 std::unique_ptr<Geometry> ManifoldGeometry::copy() const
@@ -45,8 +43,7 @@ std::unique_ptr<Geometry> ManifoldGeometry::copy() const
 }
 
 const manifold::Manifold& ManifoldGeometry::getManifold() const {
-  assert(manifold_);
-  return *manifold_;
+  return manifold_;
 }
 
 bool ManifoldGeometry::isEmpty() const {
@@ -66,11 +63,11 @@ bool ManifoldGeometry::isManifold() const {
 }
 
 bool ManifoldGeometry::isValid() const {
-  return manifold_->Status() == manifold::Manifold::Error::NoError;
+  return manifold_.Status() == manifold::Manifold::Error::NoError;
 }
 
 void ManifoldGeometry::clear() {
-  manifold_ = std::make_shared<manifold::Manifold>();
+  manifold_ = manifold::Manifold();
 }
 
 size_t ManifoldGeometry::memsize() const {
@@ -81,18 +78,18 @@ size_t ManifoldGeometry::memsize() const {
 std::string ManifoldGeometry::dump() const {
   std::ostringstream out;
   auto &manifold = getManifold();
-  auto mesh = manifold.GetMesh();
+  auto meshgl = manifold.GetMeshGL64();
   out << "Manifold:"
       << "\n status: " << ManifoldUtils::statusToString(manifold.Status())
       << "\n genus: " << manifold.Genus()
-      << "\n num vertices: " << mesh.vertPos.size()
-      << "\n num polygons: " << mesh.triVerts.size()
+      << "\n num vertices: " << meshgl.NumVert()
+      << "\n num polygons: " << meshgl.NumTri()
       << "\n polygons data:";
 
-  for (const auto &tv : mesh.triVerts) {
+  for (size_t faceid = 0; faceid < meshgl.NumTri(); faceid++) {
     out << "\n  polygon begin:";
     for (const int j : {0, 1, 2}) {
-      Vector3d v = vector_convert<Vector3d>(mesh.vertPos[tv[j]]);
+      auto v = vector_convert<Vector3d>(meshgl.GetVertPos(meshgl.GetTriVerts(faceid)[j]));
       out << "\n   vertex:" << v;
     }
   }
@@ -101,7 +98,7 @@ std::string ManifoldGeometry::dump() const {
 }
 
 std::shared_ptr<PolySet> ManifoldGeometry::toPolySet() const {
-  manifold::MeshGL mesh = getManifold().GetMeshGL();
+  manifold::MeshGL64 mesh = getManifold().GetMeshGL64();
   auto ps = std::make_shared<PolySet>(3);
   ps->setTriangular(true);
   ps->vertices.reserve(mesh.NumVert());
@@ -194,18 +191,18 @@ class CGALPolyhedronBuilderFromManifold : public CGAL::Modifier_base<typename Po
 public:
   using CGALPoint = typename CGAL_Polybuilder::Point_3;
 
-  const manifold::Mesh& mesh;
-  CGALPolyhedronBuilderFromManifold(const manifold::Mesh& mesh) : mesh(mesh) { }
+  const manifold::MeshGL64& meshgl;
+  CGALPolyhedronBuilderFromManifold(const manifold::MeshGL64& mesh) : meshgl(mesh) { }
 
   void operator()(HDS& hds) override {
     CGAL_Polybuilder B(hds, true);
 
-    B.begin_surface(mesh.vertPos.size(), mesh.triVerts.size());
-    for (const auto &v : mesh.vertPos) {
-      B.add_vertex(CGALUtils::vector_convert<CGALPoint>(v));
-    }
+    B.begin_surface(meshgl.NumVert(), meshgl.NumTri());
+    for (size_t vertid = 0; vertid < meshgl.NumVert(); vertid++)
+      B.add_vertex(CGALUtils::vector_convert<CGALPoint>(meshgl.GetVertPos(vertid)));
 
-    for (const auto &tv : mesh.triVerts) {
+    for (size_t faceid = 0; faceid < meshgl.NumTri(); faceid++) {
+      const auto tv = meshgl.GetTriVerts(faceid);
       B.begin_facet();
       for (const int j : {0, 1, 2}) {
         B.add_vertex_to_facet(tv[j]);
@@ -221,8 +218,8 @@ std::shared_ptr<Polyhedron> ManifoldGeometry::toPolyhedron() const
 {
   auto p = std::make_shared<Polyhedron>();
   try {
-    manifold::Mesh mesh = getManifold().GetMesh();
-    CGALPolyhedronBuilderFromManifold<Polyhedron> builder(mesh);
+    auto meshgl = getManifold().GetMeshGL64();
+    CGALPolyhedronBuilderFromManifold<Polyhedron> builder(meshgl);
     p->delegate(builder);
   } catch (const CGAL::Assertion_exception& e) {
     LOG(message_group::Error, "CGAL error in CGALUtils::createPolyhedronFromPolySet: %1$s", e.what());
@@ -234,7 +231,7 @@ template std::shared_ptr<CGAL::Polyhedron_3<CGAL_Kernel3>> ManifoldGeometry::toP
 #endif
 
 ManifoldGeometry ManifoldGeometry::binOp(const ManifoldGeometry& lhs, const ManifoldGeometry& rhs, manifold::OpType opType) const {
-  auto mani = std::make_shared<manifold::Manifold>(lhs.manifold_->Boolean(*rhs.manifold_, opType));
+  auto mani = lhs.manifold_.Boolean(rhs.manifold_, opType);
   auto originalIDToColor = lhs.originalIDToColor_;
   auto subtractedIDs = lhs.subtractedIDs_;
 
@@ -304,34 +301,44 @@ ManifoldGeometry ManifoldGeometry::minkowski(const ManifoldGeometry& other) cons
 }
 
 Polygon2d ManifoldGeometry::slice() const {
-  auto cross_section = manifold_->Slice();
+  auto cross_section = manifold::CrossSection(manifold_.Slice());
   return ManifoldUtils::polygonsToPolygon2d(cross_section.ToPolygons());
 }
 
 Polygon2d ManifoldGeometry::project() const {
-  auto cross_section = manifold_->Project();
+  auto cross_section = manifold::CrossSection(manifold_.Project());
   return ManifoldUtils::polygonsToPolygon2d(cross_section.ToPolygons());
 }
 
 void ManifoldGeometry::transform(const Transform3d& mat) {
-  glm::mat4x3 glMat(
+  manifold::mat4x3 glMat(
     // Column-major ordering
     mat(0, 0), mat(1, 0), mat(2, 0),
     mat(0, 1), mat(1, 1), mat(2, 1),
     mat(0, 2), mat(1, 2), mat(2, 2),
     mat(0, 3), mat(1, 3), mat(2, 3)
   );                            
-  manifold_ = std::make_shared<manifold::Manifold>(getManifold().Transform(glMat));
+  manifold_ = getManifold().Transform(glMat);
 }
 
 void ManifoldGeometry::setColor(const Color4f& c) {
-  if (manifold_->OriginalID() == -1) {
-    manifold_ = std::make_shared<manifold::Manifold>(manifold_->AsOriginal());
+  if (manifold_.OriginalID() == -1) {
+    manifold_ = manifold_.AsOriginal();
+  }
+  originalIDs_.clear();
+  originalIDs_.insert(manifold_.OriginalID());
+  originalIDToColor_.clear();
+  originalIDToColor_[manifold_.OriginalID()] = c;
+  subtractedIDs_.clear();
+}
+
+void ManifoldGeometry::toOriginal() {
+  if (manifold_.OriginalID() == -1) {
+    manifold_ = manifold_.AsOriginal();
   }
   originalIDs_.clear();
-  originalIDs_.insert(manifold_->OriginalID());
+  originalIDs_.insert(manifold_.OriginalID());
   originalIDToColor_.clear();
-  originalIDToColor_[manifold_->OriginalID()] = c;
   subtractedIDs_.clear();
 }
 
@@ -349,7 +356,7 @@ void ManifoldGeometry::resize(const Vector3d& newsize, const Eigen::Matrix<bool,
 }
 
 /*! Iterate over all vertices' points until the function returns true (for done). */
-void ManifoldGeometry::foreachVertexUntilTrue(const std::function<bool(const glm::vec3& pt)>& f) const {
+void ManifoldGeometry::foreachVertexUntilTrue(const std::function<bool(const manifold::vec3& pt)>& f) const {
   auto mesh = getManifold().GetMesh();
   for (const auto &pt : mesh.vertPos) {
     if (f(pt)) {

src/geometry/manifold/ManifoldGeometry.h

@@ -4,7 +4,7 @@
 #include "Geometry.h"
 #include <glm/glm.hpp>
 #include "linalg.h"
-#include "manifold.h"
+#include "manifold/manifold.h"
 #include <map>
 #include <set>
 
@@ -21,7 +21,7 @@ class ManifoldGeometry : public Geometry
 
   ManifoldGeometry();
   ManifoldGeometry(
-    const std::shared_ptr<const manifold::Manifold>& object,
+    manifold::Manifold object,
     const std::set<uint32_t> & originalIDs = {},
     const std::map<uint32_t, Color4f> & originalIDToColor = {},
     const std::set<uint32_t> & subtractedIDs = {});
@@ -60,17 +60,18 @@ class ManifoldGeometry : public Geometry
 
   void transform(const Transform3d& mat) override;
   void setColor(const Color4f& c) override;
+  void toOriginal();
   void resize(const Vector3d& newsize, const Eigen::Matrix<bool, 3, 1>& autosize) override;
 
   /*! Iterate over all vertices' points until the function returns true (for done). */
-  void foreachVertexUntilTrue(const std::function<bool(const glm::vec3& pt)>& f) const;
+  void foreachVertexUntilTrue(const std::function<bool(const manifold::vec3& pt)>& f) const;
 
   const manifold::Manifold& getManifold() const;
 
 private:
   ManifoldGeometry binOp(const ManifoldGeometry& lhs, const ManifoldGeometry& rhs, manifold::OpType opType) const;
 
-  std::shared_ptr<const manifold::Manifold> manifold_;
+  manifold::Manifold manifold_;
   std::set<uint32_t> originalIDs_;
   std::map<uint32_t, Color4f> originalIDToColor_;
   std::set<uint32_t> subtractedIDs_;

src/geometry/manifold/manifold-applyops-minkowski.cc

@@ -204,6 +204,7 @@ std::shared_ptr<const Geometry> applyMinkowskiManifold(const Geometry::Geometrie
       PRINTDB("Minkowski: Union done: %f s", t.time());
       t.reset();
 
+      N->toOriginal();
       operands[0] = N;
     }
 

src/geometry/manifold/manifoldutils.cc

@@ -3,7 +3,6 @@
 #include "ManifoldGeometry.h"
 #include "PolySetBuilder.h"
 #include "Feature.h"
-#include "manifold.h"
 #include "printutils.h"
 #ifdef ENABLE_CGAL
 #include "cgalutils.h"
@@ -13,7 +12,7 @@
 #endif
 #include "PolySetUtils.h"
 #include "PolySet.h"
-#include "polygon.h"
+#include "manifold/polygon.h"
 
 using Error = manifold::Manifold::Error;
 
@@ -41,15 +40,18 @@ std::shared_ptr<ManifoldGeometry> createManifoldFromSurfaceMesh(const TriangleMe
 {
   typedef typename TriangleMesh::Vertex_index vertex_descriptor;
 
-  manifold::Mesh mesh;
+  manifold::MeshGL64 meshgl;
 
-  mesh.vertPos.resize(tm.number_of_vertices());
+  meshgl.numProp = 3;
+  meshgl.vertProperties.resize(tm.number_of_vertices() * 3);
   for (vertex_descriptor vd : tm.vertices()){
     const auto &v = tm.point(vd);
-    mesh.vertPos[vd] = glm::vec3((float) v.x(), (float) v.y(), (float) v.z());
+    meshgl.vertProperties[3 * vd] = v.x();
+    meshgl.vertProperties[3 * vd + 1] = v.y();
+    meshgl.vertProperties[3 * vd + 2] = v.z();
   }
 
-  mesh.triVerts.reserve(tm.number_of_faces());
+  meshgl.triVerts.reserve(tm.number_of_faces() * 3);
   for (const auto& f : tm.faces()) {
     size_t idx[3];
     size_t i = 0;
@@ -58,20 +60,21 @@ std::shared_ptr<ManifoldGeometry> createManifoldFromSurfaceMesh(const TriangleMe
       idx[i++] = vd;
     }
     if (i < 3) continue;
-    mesh.triVerts.emplace_back(idx[0], idx[1], idx[2]);
+    for (size_t j : {0, 1, 2})
+      meshgl.triVerts.emplace_back(idx[j]);
   }
 
-  assert((mesh.triVerts.size() == tm.number_of_faces()) || !"Mesh was not triangular!");
+  assert((meshgl.triVerts.size() == tm.number_of_faces() * 3) || !"Mesh was not triangular!");
 
-  auto mani = std::make_shared<manifold::Manifold>(std::move(mesh));
-  if (mani->Status() != Error::NoError) {
+  auto mani = manifold::Manifold(meshgl).AsOriginal();
+  if (mani.Status() != Error::NoError) {
     LOG(message_group::Error,
         "[manifold] Surface_mesh -> Manifold conversion failed: %1$s", 
-        ManifoldUtils::statusToString(mani->Status()));
+        ManifoldUtils::statusToString(mani.Status()));
     return nullptr;
   }
   std::set<uint32_t> originalIDs;
-  auto id = mani->OriginalID();
+  auto id = mani.OriginalID();
   if (id >= 0) {
     originalIDs.insert(id);
   }
@@ -87,13 +90,14 @@ std::shared_ptr<ManifoldGeometry> createManifoldFromTriangularPolySet(const Poly
 {
   assert(ps.isTriangular());
 
-  manifold::MeshGL mesh;
+  manifold::MeshGL64 mesh;
 
+  mesh.numProp = 3;
   mesh.vertProperties.reserve(ps.vertices.size() * 3);
   for (const auto& v : ps.vertices) {
-    mesh.vertProperties.push_back((float)v.x());
-    mesh.vertProperties.push_back((float)v.y());
-    mesh.vertProperties.push_back((float)v.z());
+    mesh.vertProperties.push_back(v.x());
+    mesh.vertProperties.push_back(v.y());
+    mesh.vertProperties.push_back(v.z());
   }
 
   mesh.triVerts.reserve(ps.indices.size() * 3);
@@ -132,7 +136,7 @@ std::shared_ptr<ManifoldGeometry> createManifoldFromTriangularPolySet(const Poly
   }
   mesh.runIndex.push_back(mesh.triVerts.size());
 
-  auto mani = std::make_shared<const manifold::Manifold>(std::move(mesh));
+  auto mani = manifold::Manifold(mesh);
   return std::make_shared<ManifoldGeometry>(mani, originalIDs, originalIDToColor);
 }
 

src/geometry/manifold/manifoldutils.h

@@ -3,7 +3,6 @@
 #include "Geometry.h"
 #include "enums.h"
 #include "ManifoldGeometry.h"
-#include "manifold.h"
 
 namespace ManifoldUtils {