Misc. changes

bindings/c/include/manifold/manifoldc.h

@@ -174,9 +174,9 @@ ManifoldManifold *manifold_as_original(void *mem, ManifoldManifold *m);
 
 int manifold_is_empty(ManifoldManifold *m);
 ManifoldError manifold_status(ManifoldManifold *m);
-int manifold_num_vert(ManifoldManifold *m);
-int manifold_num_edge(ManifoldManifold *m);
-int manifold_num_tri(ManifoldManifold *m);
+size_t manifold_num_vert(ManifoldManifold *m);
+size_t manifold_num_edge(ManifoldManifold *m);
+size_t manifold_num_tri(ManifoldManifold *m);
 ManifoldBox *manifold_bounding_box(void *mem, ManifoldManifold *m);
 double manifold_precision(ManifoldManifold *m);
 int manifold_genus(ManifoldManifold *m);

bindings/c/manifoldc.cpp

@@ -504,9 +504,9 @@
   return to_c(error);
 }
 
-int manifold_num_vert(ManifoldManifold *m) { return from_c(m)->NumVert(); }
-int manifold_num_edge(ManifoldManifold *m) { return from_c(m)->NumEdge(); }
-int manifold_num_tri(ManifoldManifold *m) { return from_c(m)->NumTri(); }
+size_t manifold_num_vert(ManifoldManifold *m) { return from_c(m)->NumVert(); }
+size_t manifold_num_edge(ManifoldManifold *m) { return from_c(m)->NumEdge(); }
+size_t manifold_num_tri(ManifoldManifold *m) { return from_c(m)->NumTri(); }
 int manifold_genus(ManifoldManifold *m) { return from_c(m)->Genus(); }
 
 ManifoldProperties manifold_get_properties(ManifoldManifold *m) {

src/manifold/include/manifold/manifold.h

@@ -15,6 +15,7 @@
 #pragma once
 #include <functional>
 #include <memory>
+#include <optional>
 
 #include "manifold/common.h"
 #include "manifold/vec_view.h"
@@ -37,46 +38,36 @@ class CsgLeafNode;
  *  @{
  */
 
-template <typename Precision>
+template <typename Precision, typename I = uint32_t>
 struct MeshGLP {
   /// Number of property vertices
-  uint32_t NumVert() const {
-    ASSERT(vertProperties.size() / numProp <
-               static_cast<size_t>(std::numeric_limits<uint32_t>::max()),
-           std::out_of_range("mesh too large for MeshGL"));
-    return vertProperties.size() / numProp;
-  };
+  I NumVert() const { return vertProperties.size() / numProp; };
   /// Number of triangles
-  uint32_t NumTri() const {
-    ASSERT(triVerts.size() / 3 <
-               static_cast<size_t>(std::numeric_limits<uint32_t>::max()),
-           std::out_of_range("mesh too large for MeshGL"));
-    return triVerts.size() / 3;
-  };
+  I NumTri() const { return triVerts.size() / 3; };
   /// Number of properties per vertex, always >= 3.
-  uint32_t numProp = 3;
+  I numProp = 3;
   /// Flat, GL-style interleaved list of all vertex properties: propVal =
   /// vertProperties[vert * numProp + propIdx]. The first three properties are
   /// always the position x, y, z.
   std::vector<Precision> vertProperties;
   /// The vertex indices of the three triangle corners in CCW (from the outside)
   /// order, for each triangle.
-  std::vector<uint32_t> triVerts;
+  std::vector<I> triVerts;
   /// Optional: A list of only the vertex indicies that need to be merged to
   /// reconstruct the manifold.
-  std::vector<uint32_t> mergeFromVert;
+  std::vector<I> mergeFromVert;
   /// Optional: The same length as mergeFromVert, and the corresponding value
   /// contains the vertex to merge with. It will have an identical position, but
   /// the other properties may differ.
-  std::vector<uint32_t> mergeToVert;
+  std::vector<I> mergeToVert;
   /// Optional: Indicates runs of triangles that correspond to a particular
   /// input mesh instance. The runs encompass all of triVerts and are sorted
   /// by runOriginalID. Run i begins at triVerts[runIndex[i]] and ends at
   /// triVerts[runIndex[i+1]]. All runIndex values are divisible by 3. Returned
   /// runIndex will always be 1 longer than runOriginalID, but same length is
   /// also allowed as input: triVerts.size() will be automatically appended in
   /// this case.
-  std::vector<uint32_t> runIndex;
+  std::vector<I> runIndex;
   /// Optional: The OriginalID of the mesh this triangle run came from. This ID
   /// is ideal for reapplying materials to the output mesh. Multiple runs may
   /// have the same ID, e.g. representing different copies of the same input
@@ -95,7 +86,7 @@ struct MeshGLP {
   /// supplying faceIDs, ensure that triangles with the same ID are in fact
   /// coplanar and have consistent properties (within some tolerance) or the
   /// output will be surprising.
-  std::vector<uint32_t> faceID;
+  std::vector<I> faceID;
   /// Optional: The X-Y-Z-W weighted tangent vectors for smooth Refine(). If
   /// non-empty, must be exactly four times as long as Mesh.triVerts. Indexed
   /// as 4 * (3 * tri + i) + j, i < 3, j < 4, representing the tangent value
@@ -117,9 +108,10 @@ struct MeshGLP {
                 vertProperties[offset + 2]);
   }
 
-  ivec3 GetTriVerts(size_t i) const {
+  glm::vec<3, I> GetTriVerts(size_t i) const {
     size_t offset = 3 * i;
-    return ivec3(triVerts[offset], triVerts[offset + 1], triVerts[offset + 2]);
+    return glm::vec<3, I>(triVerts[offset], triVerts[offset + 1],
+                          triVerts[offset + 2]);
   }
 };
 
@@ -130,7 +122,7 @@ struct MeshGLP {
  * store this missing information, allowing the manifold to be reconstructed.
  */
 using MeshGL = MeshGLP<float>;
-using MeshGL64 = MeshGLP<double>;
+using MeshGL64 = MeshGLP<double, size_t>;
 /** @} */
 
 /** @defgroup Core
@@ -231,11 +223,11 @@ class Manifold {
     InvalidConstruction,
   };
   Error Status() const;
-  int NumVert() const;
-  int NumEdge() const;
-  int NumTri() const;
-  int NumProp() const;
-  int NumPropVert() const;
+  size_t NumVert() const;
+  size_t NumEdge() const;
+  size_t NumTri() const;
+  size_t NumProp() const;
+  size_t NumPropVert() const;
   Box BoundingBox() const;
   double Precision() const;
   int Genus() const;
@@ -314,8 +306,8 @@ class Manifold {
    */
   ///@{
   bool MatchesTriNormals() const;
-  int NumDegenerateTris() const;
-  int NumOverlaps(const Manifold& second) const;
+  size_t NumDegenerateTris() const;
+  size_t NumOverlaps(const Manifold& second) const;
   ///@}
 
   struct Impl;

src/manifold/src/boolean_result.cpp

@@ -671,11 +671,22 @@
   const int c3 = op == OpType::Intersect ? 1 : -1;
 
   if (inP_.IsEmpty()) {
+    if (inP_.status_ != Manifold::Error::NoError ||
+        inQ_.status_ != Manifold::Error::NoError) {
+      auto impl = Manifold::Impl();
+      impl.status_ = Manifold::Error::InvalidConstruction;
+      return impl;
+    }
     if (!inQ_.IsEmpty() && op == OpType::Add) {
       return inQ_;
     }
     return Manifold::Impl();
   } else if (inQ_.IsEmpty()) {
+    if (inQ_.status_ != Manifold::Error::NoError) {
+      auto impl = Manifold::Impl();
+      impl.status_ = Manifold::Error::InvalidConstruction;
+      return impl;
+    }
     if (op == OpType::Intersect) {
       return Manifold::Impl();
     }

src/manifold/src/constructors.cpp

@@ -479,7 +479,7 @@ std::vector<Manifold> Manifold::Decompose() const {
     Vec<int> faceNew2Old(NumTri());
     const auto& halfedge = pImpl_->halfedge_;
     const int nFace =
-        copy_if(countAt(0), countAt(NumTri()), faceNew2Old.begin(),
+        copy_if(countAt(0_uz), countAt(NumTri()), faceNew2Old.begin(),
                 [i, &vertLabel, &halfedge](int face) {
                   return vertLabel[halfedge[3 * face].startVert] == i;
                 }) -

src/manifold/src/csg_tree.cpp

@@ -183,6 +183,11 @@
   std::vector<int> propVertIndices;
   int numPropOut = 0;
   for (auto &node : nodes) {
+    if (node->pImpl_->status_ != Manifold::Error::NoError) {
+      Manifold::Impl impl;
+      impl.status_ = Manifold::Error::InvalidConstruction;
+      return impl;
+    }
     double nodeOldScale = node->pImpl_->bBox_.Scale();
     double nodeNewScale =
         node->pImpl_->bBox_.Transform(node->transform_).Scale();
@@ -478,8 +483,6 @@
           continue;
         }
         group.run([&, a, b]() {
-          const Manifold::Impl *aImpl;
-          const Manifold::Impl *bImpl;
           Boolean3 boolean(*getImplPtr(a), *getImplPtr(b), operation);
           queue.emplace(
               std::make_shared<Manifold::Impl>(boolean.Result(operation)));
@@ -507,11 +510,11 @@
     results.pop_back();
     // boolean operation
     Boolean3 boolean(*a, *b, operation);
+    auto result = std::make_shared<Manifold::Impl>(boolean.Result(operation));
     if (results.size() == 0) {
-      return std::make_shared<Manifold::Impl>(boolean.Result(operation));
+      return result;
     }
-    results.push_back(
-        std::make_shared<const Manifold::Impl>(boolean.Result(operation)));
+    results.push_back(result);
     std::push_heap(results.begin(), results.end(), cmpFn);
   }
   return std::make_shared<Manifold::Impl>(*results.front());

src/manifold/src/impl.cpp

@@ -570,6 +570,10 @@
   if (transform_ == mat4x3(1.0)) return *this;
   auto policy = autoPolicy(NumVert());
   Impl result;
+  if (status_ != Manifold::Error::NoError) {
+    result.status_ = status_;
+    return result;
+  }
   result.collider_ = collider_;
   result.meshRelation_ = meshRelation_;
   result.precision_ = precision_;

src/manifold/src/impl.h

@@ -65,8 +65,8 @@
   enum class Shape { Tetrahedron, Cube, Octahedron };
   Impl(Shape, const mat4x3 = mat4x3(1));
 
-  template <typename Precision>
-  Impl(const MeshGLP<Precision>& meshGL) {
+  template <typename Precision, typename I>
+  Impl(const MeshGLP<Precision, I>& meshGL) {
     const uint32_t numVert = meshGL.NumVert();
     const uint32_t numTri = meshGL.NumTri();
 
@@ -133,15 +133,15 @@
 
     Vec<TriRef> triRef;
     if (!meshGL.runOriginalID.empty()) {
-      std::vector<uint32_t> runIndex = meshGL.runIndex;
-      const uint32_t runEnd = meshGL.triVerts.size();
+      auto runIndex = meshGL.runIndex;
+      const auto runEnd = meshGL.triVerts.size();
       if (runIndex.empty()) {
-        runIndex = {0, runEnd};
+        runIndex = {0, static_cast<I>(runEnd)};
       } else if (runIndex.size() == meshGL.runOriginalID.size()) {
         runIndex.push_back(runEnd);
       }
       triRef.resize(meshGL.NumTri());
-      const int startID = Impl::ReserveIDs(meshGL.runOriginalID.size());
+      const auto startID = Impl::ReserveIDs(meshGL.runOriginalID.size());
       for (size_t i = 0; i < meshGL.runOriginalID.size(); ++i) {
         const int meshID = startID + i;
         const int originalID = meshGL.runOriginalID[i];
@@ -169,7 +169,7 @@
     for (size_t i = 0; i < numTri; ++i) {
       ivec3 tri;
       for (const size_t j : {0, 1, 2}) {
-        uint32_t vert = meshGL.triVerts[3 * i + j];
+        uint32_t vert = (uint32_t)meshGL.triVerts[3 * i + j];
         if (vert >= numVert) {
           MarkFailure(Error::VertexOutOfBounds);
           return;
@@ -183,8 +183,9 @@
         }
         if (numProp > 0) {
           meshRelation_.triProperties.push_back(
-              ivec3(meshGL.triVerts[3 * i], meshGL.triVerts[3 * i + 1],
-                    meshGL.triVerts[3 * i + 2]));
+              ivec3(static_cast<uint32_t>(meshGL.triVerts[3 * i]),
+                    static_cast<uint32_t>(meshGL.triVerts[3 * i + 1]),
+                    static_cast<uint32_t>(meshGL.triVerts[3 * i + 2])));
         }
       }
     }