Add backend setting / flag to enable manifold in prod builds (openscad#5235)

Co-authored-by: Marius Kintel <marius@kintel.net>

Author: ochafik

.github/workflows/linux-build-matrix.yml

@@ -14,10 +14,11 @@ jobs:
         os: [ ubuntu-latest ]
         headless: [ ON, OFF ]
         enable_tests: [ ON, OFF ]
+        enable_manifold: [ ON, OFF ]
 
     runs-on: ${{ matrix.os }}
 
-    name: ${{ matrix.os }}:HEADLESS=${{ matrix.headless }},ENABLE_TESTS=${{ matrix.enable_tests }}
+    name: ${{ matrix.os }}:HEADLESS=${{ matrix.headless }},ENABLE_TESTS=${{ matrix.enable_tests }},ENABLE_MANIFOLD=${{ matrix.enable_manifold }}
 
     steps:
     - uses: actions/checkout@v4
@@ -30,6 +31,7 @@ jobs:
         cmake -S . -B build -GNinja \
           -DCMAKE_BUILD_TYPE=RelWithDebInfo \
           -DHEADLESS=${{ matrix.headless }} \
+          -DENABLE_MANIFOLD=${{ matrix.enable_manifold }} \
           -DENABLE_TESTS=${{ matrix.enable_tests }}
     - name: Build OpenSCAD
       run: cmake --build build

CMakeLists.txt

@@ -55,6 +55,7 @@ option(ENABLE_SPNAV "Enable support for libspnav input driver." ON)
 option(ENABLE_HIDAPI "Enable support for HIDAPI input driver." ON)
 option(ENABLE_TBB "Enable support for oneAPI Threading Building Blocks." ON)
 option(ENABLE_CGAL "Enable CGAL." ON)
+option(ENABLE_MANIFOLD "Enable Manifold." ON)
 option(ALLOW_BUNDLED_HIDAPI "Allow usage of bundled HIDAPI library (Windows only)." OFF)
 option(ENABLE_PYTHON "Enable experimental Python Interpreter" OFF)
 option(BUILD_SHARED_LIBS "Build shared library" OFF)
@@ -944,7 +945,7 @@ if(EXPERIMENTAL AND ENABLE_TBB)
   target_link_libraries(OpenSCAD PRIVATE TBB::tbb)
 endif()
 
-if(EXPERIMENTAL)
+if(ENABLE_MANIFOLD)
 
   # Hack to find our wanted version of Python before Manifold's included googletest finds Python2
   find_package(Python3 3.4 COMPONENTS Interpreter REQUIRED)
@@ -970,12 +971,6 @@ if(EXPERIMENTAL)
   target_link_libraries(OpenSCAD PRIVATE manifold polygon cross_section)
   add_sanitizers(manifold)
 
-  target_compile_definitions(OpenSCAD PRIVATE ENABLE_MANIFOLD)
-  list(APPEND Sources ${MANIFOLD_SOURCES})
-  if (ENABLE_CGAL)
-    list(APPEND Sources ${MANIFOLD_CGAL_SOURCES})
-  endif()
-
   if (USE_MANIFOLD_TRIANGULATOR)
     target_compile_definitions(OpenSCAD PRIVATE USE_MANIFOLD_TRIANGULATOR)
   endif()
@@ -1193,9 +1188,16 @@ if("${CMAKE_CXX_COMPILER_ID}" STREQUAL "GNU")
   set_source_files_properties("src/ext/polyclipping/clipper.cpp" PROPERTIES COMPILE_FLAGS "-Wno-class-memaccess")
 endif()
 
+if (ENABLE_MANIFOLD)
+  target_compile_definitions(OpenSCAD PRIVATE ENABLE_MANIFOLD)
+  list(APPEND Sources ${MANIFOLD_SOURCES})
+endif()
 if (ENABLE_CGAL)
   list(APPEND Sources ${CGAL_SOURCES})
 endif()
+if (ENABLE_MANIFOLD AND ENABLE_CGAL)
+  list(APPEND Sources ${MANIFOLD_CGAL_SOURCES})
+endif()
 list(APPEND Sources src/openscad.cc ${CORE_SOURCES} ${OFFSCREEN_SOURCES})
 
 set_source_files_properties(

src/Feature.cc

@@ -31,7 +31,6 @@ Feature::list_t Feature::feature_list;  // Double-listed values. --^
 const Feature Feature::ExperimentalFastCsg("fast-csg", "Enable much faster CSG operations with corefinement instead of nef when possible.");
 const Feature Feature::ExperimentalFastCsgSafer("fast-csg-safer", "Don't use corefinement in cases it doesn't supports and risks crashing. This will fallback to slower operations on Nef polyhedra.");
 const Feature Feature::ExperimentalFastCsgDebug("fast-csg-debug", "Debug mode for fast-csg: adds logs with extra costly checks and dumps .off files with the last corefinement operands.");
-const Feature Feature::ExperimentalManifold("manifold", "Use the Manifold library (https://github.com/elalish/manifold) for CSG operations instead of CGAL.");
 const Feature Feature::ExperimentalRoof("roof", "Enable <code>roof</code>");
 const Feature Feature::ExperimentalInputDriverDBus("input-driver-dbus", "Enable DBus input drivers (requires restart)");
 const Feature Feature::ExperimentalLazyUnion("lazy-union", "Enable lazy unions.");

src/Feature.h

@@ -17,7 +17,6 @@ class Feature
   static const Feature ExperimentalFastCsg;
   static const Feature ExperimentalFastCsgSafer;
   static const Feature ExperimentalFastCsgDebug;
-  static const Feature ExperimentalManifold;
   static const Feature ExperimentalRoof;
   static const Feature ExperimentalInputDriverDBus;
   static const Feature ExperimentalLazyUnion;

src/geometry/GeometryEvaluator.cc

@@ -25,6 +25,7 @@
 #include "utils/printutils.h"
 #include "utils/calc.h"
 #include "io/DxfData.h"
+#include "glview/RenderSettings.h"
 #include "utils/degree_trig.h"
 #include <list>
 #include <utility>
@@ -161,7 +162,7 @@ GeometryEvaluator::ResultObject GeometryEvaluator::applyToChildren3D(const Abstr
     if (actualchildren.empty()) return {};
     if (actualchildren.size() == 1) return ResultObject::constResult(actualchildren.front().second);
 #ifdef ENABLE_MANIFOLD
-    if (Feature::ExperimentalManifold.is_enabled()) {
+    if (RenderSettings::inst()->backend3D == RenderBackend3D::ManifoldBackend) {
       return ResultObject::mutableResult(ManifoldUtils::applyOperator3DManifold(actualchildren, op));
     }
 #endif
@@ -178,7 +179,7 @@ GeometryEvaluator::ResultObject GeometryEvaluator::applyToChildren3D(const Abstr
   default:
   {
 #ifdef ENABLE_MANIFOLD
-    if (Feature::ExperimentalManifold.is_enabled()) {
+    if (RenderSettings::inst()->backend3D == RenderBackend3D::ManifoldBackend) {
       return ResultObject::mutableResult(ManifoldUtils::applyOperator3DManifold(children, op));
     }
 #endif
@@ -964,7 +965,7 @@ std::shared_ptr<const Geometry> GeometryEvaluator::projectionCut(const Projectio
   std::shared_ptr<const Geometry> newgeom = applyToChildren3D(node, OpenSCADOperator::UNION).constptr();
   if (newgeom) {
 #ifdef ENABLE_MANIFOLD
-    if (Feature::ExperimentalManifold.is_enabled()) {
+    if (RenderSettings::inst()->backend3D == RenderBackend3D::ManifoldBackend) {
       auto manifold = ManifoldUtils::createManifoldFromGeometry(newgeom);
       auto poly2d = manifold->slice();
       return std::shared_ptr<const Polygon2d>(ClipperUtils::sanitize(poly2d));
@@ -987,7 +988,7 @@ std::shared_ptr<const Geometry> GeometryEvaluator::projectionCut(const Projectio
 std::shared_ptr<const Geometry> GeometryEvaluator::projectionNoCut(const ProjectionNode& node)
 {
 #ifdef ENABLE_MANIFOLD
-  if (Feature::ExperimentalManifold.is_enabled()) {
+  if (RenderSettings::inst()->backend3D == RenderBackend3D::ManifoldBackend) {
     std::shared_ptr<const Geometry> newgeom = applyToChildren3D(node, OpenSCADOperator::UNION).constptr();
     if (newgeom) {
         auto manifold = ManifoldUtils::createManifoldFromGeometry(newgeom);

src/geometry/GeometryUtils.cc

@@ -12,6 +12,7 @@
 #include "libtess2/Include/tesselator.h"
 #include "utils/printutils.h"
 #include "geometry/Reindexer.h"
+#include "glview/RenderSettings.h"
 #include "Feature.h"
 #include "geometry/PolySet.h"
 
@@ -521,7 +522,7 @@ Transform3d GeometryUtils::getResizeTransform(const BoundingBox &bbox, const Vec
 std::shared_ptr<const Geometry> GeometryUtils::getBackendSpecificGeometry(const std::shared_ptr<const Geometry>& geom)
 {
 #if ENABLE_MANIFOLD
-  if (Feature::ExperimentalManifold.is_enabled()) {
+  if (RenderSettings::inst()->backend3D == RenderBackend3D::ManifoldBackend) {
     if (const auto ps = std::dynamic_pointer_cast<const PolySet>(geom)) {
       return ManifoldUtils::createManifoldFromPolySet(*ps);
     } else if (auto mani = std::dynamic_pointer_cast<const ManifoldGeometry>(geom)) {

src/geometry/Polygon2d.cc

@@ -177,7 +177,7 @@ std::unique_ptr<PolySet> Polygon2d::tessellate() const
 {
   PRINTDB("Polygon2d::tessellate(): %d outlines", this->outlines().size());
 #if defined(ENABLE_MANIFOLD) && defined(USE_MANIFOLD_TRIANGULATOR)
-  if (Feature::ExperimentalManifold.is_enabled()) {
+  if (RenderSettings::inst()->backend3D == RenderBackend3D::ManifoldBackend) {
     return ManifoldUtils::createTriangulatedPolySetFromPolygon2d(*this);
   }
   else

src/geometry/boolean_utils.cc

@@ -24,6 +24,7 @@
 #endif  // ENABLE_MANIFOLD
 
 #include "Feature.h"
+#include "glview/RenderSettings.h"
 #include "geometry/PolySet.h"
 #include "utils/printutils.h"
 #include "core/progress.h"
@@ -112,7 +113,7 @@ std::unique_ptr<PolySet> applyHull(const Geometry::Geometries& children)
 std::shared_ptr<const Geometry> applyMinkowski(const Geometry::Geometries& children)
 {
 #if ENABLE_MANIFOLD
-  if (Feature::ExperimentalManifold.is_enabled()) {
+  if (RenderSettings::inst()->backend3D == RenderBackend3D::ManifoldBackend) {
     return ManifoldUtils::applyMinkowskiManifold(children);
   }
 #endif  // ENABLE_MANIFOLD

src/geometry/linear_extrude.cc

@@ -9,13 +9,13 @@
 #include <boost/logic/tribool.hpp>
 
 #include "geometry/GeometryUtils.h"
+#include "glview/RenderSettings.h"
 #include "core/LinearExtrudeNode.h"
 #include "geometry/PolySet.h"
 #include "geometry/PolySetBuilder.h"
 #include "geometry/PolySetUtils.h"
 #include "utils/calc.h"
 #include "utils/degree_trig.h"
-#include "Feature.h"
 
 namespace {
 
@@ -510,7 +510,7 @@ std::unique_ptr<Geometry> extrudePolygon(const LinearExtrudeNode& node, const Po
   // the polyset from vertices using PolySetBuilder
 
 #ifdef ENABLE_MANIFOLD
-  if (Feature::ExperimentalManifold.is_enabled()) {
+  if (RenderSettings::inst()->backend3D == RenderBackend3D::ManifoldBackend) {
     return assemblePolySetForManifold(polyref, vertices, indices,
                                       node.convexity, isConvex, slice_stride * num_slices);
   }

src/glview/RenderSettings.cc

@@ -1,7 +1,35 @@
 #include "glview/RenderSettings.h"
+#include "utils/printutils.h"
 
-RenderSettings *RenderSettings::inst(bool erase)
-{
+std::string renderBackend3DToString(RenderBackend3D backend) {
+  switch (backend) {
+  case RenderBackend3D::CGALBackend:
+    return "CGAL";
+  case RenderBackend3D::ManifoldBackend:
+    return "Manifold";
+  default:
+    throw std::runtime_error("Unknown rendering backend");
+  }
+}
+
+RenderBackend3D renderBackend3DFromString(std::string backend) {
+  boost::algorithm::to_lower(backend);
+  if (backend == "cgal") {
+    return RenderBackend3D::CGALBackend;
+  } else if (backend == "manifold") {
+    return RenderBackend3D::ManifoldBackend;
+  } else {
+    if (!backend.empty()) {
+      LOG(message_group::Warning,
+          "Unknown rendering backend '%1$s'. Using default '%2$s'.",
+          backend.c_str(),
+          renderBackend3DToString(DEFAULT_RENDERING_BACKEND_3D).c_str());
+    }
+    return DEFAULT_RENDERING_BACKEND_3D;
+  }
+}
+
+RenderSettings *RenderSettings::inst(bool erase) {
   static auto instance = new RenderSettings;
   if (erase) {
     delete instance;
@@ -10,8 +38,8 @@ RenderSettings *RenderSettings::inst(bool erase)
   return instance;
 }
 
-RenderSettings::RenderSettings()
-{
+RenderSettings::RenderSettings() {
+  backend3D = DEFAULT_RENDERING_BACKEND_3D;
   openCSGTermLimit = 100000;
   far_gl_clip_limit = 100000.0;
   img_width = 512;