fix a bunch of warnings

Author: pca006132

bindings/c/rect.cpp

@@ -80,15 +80,13 @@ ManifoldRect *manifold_rect_transform(void *mem, ManifoldRect *r, double x1,
 
 ManifoldRect *manifold_rect_translate(void *mem, ManifoldRect *r, double x,
                                       double y) {
-  auto rect = *from_c(r);
   auto p = vec2(x, y);
   auto translated = (*from_c(r)) + p;
   return to_c(new (mem) Rect(translated));
 }
 
 ManifoldRect *manifold_rect_mul(void *mem, ManifoldRect *r, double x,
                                 double y) {
-  auto rect = *from_c(r);
   auto p = vec2(x, y);
   auto scaled = (*from_c(r)) * p;
   return to_c(new (mem) Rect(scaled));

include/manifold/linalg.h

@@ -37,14 +37,12 @@
 
 #include <array>        // For std::array
 #include <cmath>        // For various unary math functions, such as std::sqrt
-#include <cstdint>      // For implementing namespace linalg::aliases
 #include <cstdlib>      // To resolve std::abs ambiguity on clang
 #include <functional>   // For std::hash declaration
 #include <iosfwd>       // For forward definitions of std::ostream
 #include <type_traits>  // For std::enable_if, std::is_same, std::declval
 
 #ifdef MANIFOLD_DEBUG
-#include <iomanip>
 #include <iostream>
 #endif
 

src/boolean3.cpp

@@ -402,7 +402,7 @@ std::tuple<Vec<int>, Vec<vec3>> Intersect12(const Manifold::Impl &inP,
                                 a.vertPos_[tmpedges[e].second]);
              });
   Kernel12 k12{a.halfedge_, b.halfedge_, a.vertPos_, forward, k02, k11};
-  Kernel12Recorder recorder{k12, tmpedges, forward};
+  Kernel12Recorder recorder{k12, tmpedges, forward, {}};
 
   b.collider_.Collisions<false, Box, Kernel12Recorder>(AEdgeBB.cview(),
                                                        recorder);

src/boolean_result.cpp

@@ -273,8 +273,8 @@ void AddNewEdgeVerts(
     return;
   }
 #endif
-  auto processFun = std::bind(
-      process, [](size_t _) {}, [](size_t _) {}, std::placeholders::_1);
+  auto processFun =
+      std::bind(process, [](size_t) {}, [](size_t) {}, std::placeholders::_1);
   for (size_t i = 0; i < p1q2.size(); ++i) processFun(i);
 }
 

src/constructors.cpp

@@ -173,8 +173,7 @@ Manifold Manifold::Sphere(double radius, int circularSegments) {
   int n = circularSegments > 0 ? (circularSegments + 3) / 4
                                : Quality::GetCircularSegments(radius) / 4;
   auto pImpl_ = std::make_shared<Impl>(Impl::Shape::Octahedron);
-  pImpl_->Subdivide(
-      [n](vec3 edge, vec4 tangentStart, vec4 tangentEnd) { return n - 1; });
+  pImpl_->Subdivide([n](vec3, vec4, vec4) { return n - 1; });
   for_each_n(autoPolicy(pImpl_->NumVert(), 1e5), pImpl_->vertPos_.begin(),
              pImpl_->NumVert(), [radius](vec3& v) {
                v = la::cos(kHalfPi * (1.0 - v));

src/csg_tree.cpp

@@ -24,8 +24,6 @@
 #include "./mesh_fixes.h"
 #include "./parallel.h"
 
-constexpr int kParallelThreshold = 4096;
-
 namespace {
 using namespace manifold;
 struct MeshCompare {
@@ -234,11 +232,10 @@ std::shared_ptr<CsgLeafNode> CsgLeafNode::Compose(
              combined.halfedgeTangent_.begin() + edgeIndices[i]);
         const int nextVert = vertIndices[i];
         const int nextEdge = edgeIndices[i];
-        const int nextFace = triIndices[i];
         transform(node->pImpl_->halfedge_.begin(),
                   node->pImpl_->halfedge_.end(),
                   combined.halfedge_.begin() + edgeIndices[i],
-                  [nextVert, nextEdge, nextFace](Halfedge edge) {
+                  [nextVert, nextEdge](Halfedge edge) {
                     edge.startVert += nextVert;
                     edge.endVert += nextVert;
                     edge.pairedHalfedge += nextEdge;

src/edge_op.cpp

@@ -240,7 +240,6 @@ void Manifold::Impl::SimplifyTopology(int firstNewVert) {
   }
 
   const size_t nbEdges = halfedge_.size();
-  auto policy = autoPolicy(nbEdges, 1e5);
   size_t numFlagged = 0;
 
   std::vector<int> scratchBuffer;
@@ -338,7 +337,6 @@ void Manifold::Impl::DedupeEdge(const int edge) {
       UpdateVert(newVert, current, opposite);
 
       int newHalfedge = halfedge_.size();
-      int newFace = newHalfedge / 3;
       int oldFace = current / 3;
       int outsideVert = halfedge_[current].startVert;
       halfedge_.push_back({endVert, newVert, -1});
@@ -354,7 +352,6 @@ void Manifold::Impl::DedupeEdge(const int edge) {
       if (faceNormal_.size() > 0) faceNormal_.push_back(faceNormal_[oldFace]);
 
       newHalfedge += 3;
-      ++newFace;
       oldFace = opposite / 3;
       outsideVert = halfedge_[opposite].startVert;
       halfedge_.push_back({newVert, endVert, -1});
@@ -842,8 +839,7 @@ void Manifold::Impl::DedupeEdges() {
 
         // first iteration, populate entries
         // this makes sure we always report the same set of entries
-        ForVert(i, [&local, &endVerts, &endVertSet, &results,
-                    this](int current) {
+        ForVert(i, [&local, &endVerts, &endVertSet, this](int current) {
           local[current] = true;
           if (halfedge_[current].startVert == -1 ||
               halfedge_[current].endVert == -1) {
@@ -873,8 +869,7 @@ void Manifold::Impl::DedupeEdges() {
         // second iteration, actually check for duplicates
         // we always report the same set of duplicates, excluding the smallest
         // halfedge in the set of duplicates
-        ForVert(i, [&local, &endVerts, &endVertSet, &results,
-                    this](int current) {
+        ForVert(i, [&endVerts, &endVertSet, &results, this](int current) {
           if (halfedge_[current].startVert == -1 ||
               halfedge_[current].endVert == -1) {
             return;

src/face_op.cpp

@@ -232,7 +232,7 @@ void Manifold::Impl::Face2Tri(const Vec<int>& faceEdge,
   triRef.reserve(faceEdge.size());
   auto processFace2 = std::bind(
       processFace, generalTriangulation,
-      [&](size_t _face, ivec3 tri, vec3 normal, TriRef r) {
+      [&](size_t, ivec3 tri, vec3 normal, TriRef r) {
         triVerts.push_back(tri);
         triNormal.push_back(normal);
         triRef.push_back(r);
@@ -247,9 +247,10 @@ void Manifold::Impl::Face2Tri(const Vec<int>& faceEdge,
   CreateHalfedges(triVerts);
 }
 
+constexpr uint64_t kRemove = std::numeric_limits<uint64_t>::max();
+
 void Manifold::Impl::FlattenFaces() {
   Vec<uint64_t> edgeFace(halfedge_.size());
-  constexpr uint64_t remove = std::numeric_limits<uint64_t>::max();
   const size_t numTri = NumTri();
   const auto policy = autoPolicy(numTri);
 
@@ -258,17 +259,17 @@ void Manifold::Impl::FlattenFaces() {
            [](auto& v) { v.store(0); });
 
   for_each_n(policy, countAt(0_uz), numTri,
-             [&edgeFace, &vertDegree, remove, this](size_t tri) {
+             [&edgeFace, &vertDegree, this](size_t tri) {
                for (const int i : {0, 1, 2}) {
                  const int edge = 3 * tri + i;
                  const int pair = halfedge_[edge].pairedHalfedge;
                  if (pair < 0) {
-                   edgeFace[edge] = remove;
+                   edgeFace[edge] = kRemove;
                    return;
                  }
                  const auto& ref = meshRelation_.triRef[tri];
                  if (ref.SameFace(meshRelation_.triRef[pair / 3])) {
-                   edgeFace[edge] = remove;
+                   edgeFace[edge] = kRemove;
                  } else {
                    edgeFace[edge] = (static_cast<uint64_t>(ref.meshID) << 32) +
                                     static_cast<uint64_t>(ref.faceID);
@@ -284,7 +285,7 @@ void Manifold::Impl::FlattenFaces() {
       [&edgeFace](size_t a, size_t b) { return edgeFace[a] < edgeFace[b]; });
   newHalf2Old.resize(std::find_if(countAt(0_uz), countAt(halfedge_.size()),
                                   [&](const size_t i) {
-                                    return edgeFace[newHalf2Old[i]] == remove;
+                                    return edgeFace[newHalf2Old[i]] == kRemove;
                                   }) -
                      countAt(0_uz));
 

src/impl.cpp

@@ -35,12 +35,10 @@
 namespace {
 using namespace manifold;
 
-constexpr uint64_t kRemove = std::numeric_limits<uint64_t>::max();
-
 // Absolute error <= 6.7e-5
-float acos(float x) {
+float fastacos(float x) {
   float negate = float(x < 0);
-  x = abs(x);
+  x = std::abs(x);
   float ret = -0.0187293;
   ret = ret * x;
   ret = ret + 0.0742610;
@@ -240,7 +238,6 @@ void Manifold::Impl::DedupePropVerts() {
       autoPolicy(halfedge_.size(), 1e4), countAt(0), halfedge_.size(),
       [&vert2vert, numProp, this](const int edgeIdx) {
         const Halfedge edge = halfedge_[edgeIdx];
-        const Halfedge pair = halfedge_[edge.pairedHalfedge];
         const int edgeFace = edgeIdx / 3;
         const int pairFace = edge.pairedHalfedge / 3;
 
@@ -278,6 +275,8 @@ void Manifold::Impl::DedupePropVerts() {
     for (int i : {0, 1, 2}) prop[i] = label2vert[vertLabels[prop[i]]];
 }
 
+constexpr int removedHalfedge = -2;
+
 /**
  * Create the halfedge_ data structure from an input triVerts array like Mesh.
  */
@@ -319,9 +318,7 @@ void Manifold::Impl::CreateHalfedges(const Vec<ivec3>& triVerts) {
   // which are removed later by RemoveUnreferencedVerts() and Finish().
   const int numEdge = numHalfedge / 2;
 
-  constexpr int removedHalfedge = -2;
-  const auto body = [&, removedHalfedge](int i, int consecutiveStart,
-                                         int segmentEnd) {
+  const auto body = [&](int i, int consecutiveStart, int segmentEnd) {
     const int pair0 = ids[i];
     Halfedge& h0 = halfedge_[pair0];
     int k = consecutiveStart + numEdge;
@@ -380,17 +377,16 @@ void Manifold::Impl::CreateHalfedges(const Vec<ivec3>& triVerts) {
   // Once sorted, the first half of the range is the forward halfedges, which
   // correspond to their backward pair at the same offset in the second half
   // of the range.
-  for_each_n(policy, countAt(0), numEdge,
-             [this, &ids, numEdge, removedHalfedge](int i) {
-               const int pair0 = ids[i];
-               const int pair1 = ids[i + numEdge];
-               if (halfedge_[pair0].pairedHalfedge != removedHalfedge) {
-                 halfedge_[pair0].pairedHalfedge = pair1;
-                 halfedge_[pair1].pairedHalfedge = pair0;
-               } else {
-                 halfedge_[pair0] = halfedge_[pair1] = {-1, -1, -1};
-               }
-             });
+  for_each_n(policy, countAt(0), numEdge, [this, &ids, numEdge](int i) {
+    const int pair0 = ids[i];
+    const int pair1 = ids[i + numEdge];
+    if (halfedge_[pair0].pairedHalfedge != removedHalfedge) {
+      halfedge_[pair0].pairedHalfedge = pair1;
+      halfedge_[pair1].pairedHalfedge = pair0;
+    } else {
+      halfedge_[pair0] = halfedge_[pair1] = {-1, -1, -1};
+    }
+  });
 }
 
 /**
@@ -529,7 +525,6 @@ void Manifold::Impl::CalculateNormals() {
   ZoneScoped;
   vertNormal_.resize(NumVert());
   auto policy = autoPolicy(NumTri());
-  bool calculateTriNormal = false;
 
   std::vector<std::atomic<int>> vertHalfedgeMap(NumVert());
   for_each_n(policy, countAt(0), NumVert(), [&](const size_t vert) {
@@ -544,7 +539,6 @@ void Manifold::Impl::CalculateNormals() {
   };
   if (faceNormal_.size() != NumTri()) {
     faceNormal_.resize(NumTri());
-    calculateTriNormal = true;
     for_each_n(policy, countAt(0), NumTri(), [&](const int face) {
       vec3& triNormal = faceNormal_[face];
       if (halfedge_[3 * face].startVert < 0) {
@@ -592,7 +586,7 @@ void Manifold::Impl::CalculateNormals() {
       // should just exclude it from the normal calculation...
       if (!la::isfinite(currEdge[0]) || !la::isfinite(prevEdge[0])) return;
       double dot = -la::dot(prevEdge, currEdge);
-      double phi = dot >= 1 ? 0 : (dot <= -1 ? kPi : acos(dot));
+      double phi = dot >= 1 ? 0 : (dot <= -1 ? kPi : fastacos(dot));
       normal += phi * faceNormal_[edge / 3];
     });
     vertNormal_[vert] = SafeNormalize(normal);
@@ -673,7 +667,7 @@ Manifold Manifold::ImportMeshGL64(std::istream& stream) {
           stream.get(tmp.data(), SIZE, '\n');
           if (strncmp(tmp.data(), "tolerance", SIZE) == 0) {
             // skip 3 letters
-            for (int i : {0, 1, 2}) stream.get();
+            for (int _ : {0, 1, 2}) stream.get();
             stream >> mesh.tolerance;
           } else if (strncmp(tmp.data(), "epsilon =", SIZE) == 0) {
             double tmp;
@@ -694,14 +688,14 @@ Manifold Manifold::ImportMeshGL64(std::istream& stream) {
         break;
       }
       case 'v':
-        for (int i : {0, 1, 2}) {
+        for (int _ : {0, 1, 2}) {
           double x;
           stream >> x;
           mesh.vertProperties.push_back(x);
         }
         break;
       case 'f':
-        for (int i : {0, 1, 2}) {
+        for (int _ : {0, 1, 2}) {
           uint64_t x;
           stream >> x;
           mesh.triVerts.push_back(x - 1);

src/impl.h

@@ -19,7 +19,6 @@
 #include "./shared.h"
 #include "./vec.h"
 #include "manifold/manifold.h"
-#include "manifold/polygon.h"
 
 namespace manifold {
 

src/manifold.cpp

@@ -662,9 +662,9 @@ Manifold Manifold::SetProperties(
             {pImpl->meshRelation_.properties.data(), numProp,
              oldProperties.data(), oldNumProp, pImpl->vertPos_.data(),
              triProperties.data(), pImpl->halfedge_.data(),
-             propFunc == nullptr ? [](double* newProp, vec3 position,
-                                      const double* oldProp) { *newProp = 0; }
-                                 : propFunc}));
+             propFunc == nullptr
+                 ? [](double* newProp, vec3, const double*) { *newProp = 0; }
+                 : propFunc}));
   }
 
   pImpl->meshRelation_.numProp = numProp;
@@ -784,8 +784,7 @@ Manifold Manifold::SmoothOut(double minSharpAngle, double minSmoothness) const {
 Manifold Manifold::Refine(int n) const {
   auto pImpl = std::make_shared<Impl>(*GetCsgLeafNode().GetImpl());
   if (n > 1) {
-    pImpl->Refine(
-        [n](vec3 edge, vec4 tangentStart, vec4 tangentEnd) { return n - 1; });
+    pImpl->Refine([n](vec3, vec4, vec4) { return n - 1; });
   }
   return Manifold(std::make_shared<CsgLeafNode>(pImpl));
 }
@@ -803,7 +802,7 @@ Manifold Manifold::Refine(int n) const {
 Manifold Manifold::RefineToLength(double length) const {
   length = std::abs(length);
   auto pImpl = std::make_shared<Impl>(*GetCsgLeafNode().GetImpl());
-  pImpl->Refine([length](vec3 edge, vec4 tangentStart, vec4 tangentEnd) {
+  pImpl->Refine([length](vec3 edge, vec4, vec4) {
     return static_cast<int>(la::length(edge) / length);
   });
   return Manifold(std::make_shared<CsgLeafNode>(pImpl));