manifold.h

// Copyright 2021 The Manifold Authors.
//
// Licensed under the Apache License, Version 2.0 (the "License");
// you may not use this file except in compliance with the License.
// You may obtain a copy of the License at
//
//      http://www.apache.org/licenses/LICENSE-2.0
//
// Unless required by applicable law or agreed to in writing, software
// distributed under the License is distributed on an "AS IS" BASIS,
// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
// See the License for the specific language governing permissions and
// limitations under the License.
 
#pragma once
#include <functional>
#include <memory>
 
#include "cross_section.h"
#include "public.h"
#include "vec_view.h"
 
namespace manifold {
 
ExecutionParams& ManifoldParams();
 
class CsgNode;
class CsgLeafNode;
 
struct MeshGL {
  uint32_t NumVert() const {
    if (vertProperties.size() / numProp >= std::numeric_limits<int>::max())
      throw std::out_of_range("mesh too large");
    return vertProperties.size() / numProp;
  };
  uint32_t NumTri() const {
    if (vertProperties.size() / numProp >= std::numeric_limits<int>::max())
      throw std::out_of_range("mesh too large");
    return triVerts.size() / 3;
  };
 
  uint32_t numProp = 3;
  std::vector<float> vertProperties;
  std::vector<uint32_t> triVerts;
  std::vector<uint32_t> mergeFromVert;
  std::vector<uint32_t> mergeToVert;
  std::vector<uint32_t> runIndex;
  std::vector<uint32_t> runOriginalID;
  std::vector<float> runTransform;
  std::vector<uint32_t> faceID;
  std::vector<float> halfedgeTangent;
  float precision = 0;
 
  MeshGL() = default;
  MeshGL(const Mesh& mesh);
 
  bool Merge();
};
class Manifold {
 public:
  Manifold();
  ~Manifold();
  Manifold(const Manifold& other);
  Manifold& operator=(const Manifold& other);
  Manifold(Manifold&&) noexcept;
  Manifold& operator=(Manifold&&) noexcept;
 
  Manifold(const MeshGL&, const std::vector<float>& propertyTolerance = {});
  Manifold(const Mesh&);
 
  static Manifold Smooth(const MeshGL&,
                         const std::vector<Smoothness>& sharpenedEdges = {});
  static Manifold Smooth(const Mesh&,
                         const std::vector<Smoothness>& sharpenedEdges = {});
  static Manifold Tetrahedron();
  static Manifold Cube(glm::vec3 size = glm::vec3(1.0f), bool center = false);
  static Manifold Cylinder(float height, float radiusLow,
                           float radiusHigh = -1.0f, int circularSegments = 0,
                           bool center = false);
  static Manifold Sphere(float radius, int circularSegments = 0);
  static Manifold Extrude(const CrossSection& crossSection, float height,
                          int nDivisions = 0, float twistDegrees = 0.0f,
                          glm::vec2 scaleTop = glm::vec2(1.0f));
  static Manifold Revolve(const CrossSection& crossSection,
                          int circularSegments = 0,
                          float revolveDegrees = 360.0f);
 
  static Manifold Compose(const std::vector<Manifold>&);
  std::vector<Manifold> Decompose() const;
 
  Mesh GetMesh() const;
  MeshGL GetMeshGL(glm::ivec3 normalIdx = glm::ivec3(0)) const;
  bool IsEmpty() const;
  enum class Error {
    NoError,
    NonFiniteVertex,
    NotManifold,
    VertexOutOfBounds,
    PropertiesWrongLength,
    MissingPositionProperties,
    MergeVectorsDifferentLengths,
    MergeIndexOutOfBounds,
    TransformWrongLength,
    RunIndexWrongLength,
    FaceIDWrongLength,
    InvalidConstruction,
  };
  Error Status() const;
  int NumVert() const;
  int NumEdge() const;
  int NumTri() const;
  int NumProp() const;
  int NumPropVert() const;
  Box BoundingBox() const;
  float Precision() const;
  int Genus() const;
  Properties GetProperties() const;
  float MinGap(const Manifold& other, float searchLength) const;
 
  int OriginalID() const;
  Manifold AsOriginal() const;
  static uint32_t ReserveIDs(uint32_t);
 
  Manifold Translate(glm::vec3) const;
  Manifold Scale(glm::vec3) const;
  Manifold Rotate(float xDegrees, float yDegrees = 0.0f,
                  float zDegrees = 0.0f) const;
  Manifold Transform(const glm::mat4x3&) const;
  Manifold Mirror(glm::vec3) const;
  Manifold Warp(std::function<void(glm::vec3&)>) const;
  Manifold WarpBatch(std::function<void(VecView<glm::vec3>)>) const;
  Manifold SetProperties(
      int, std::function<void(float*, glm::vec3, const float*)>) const;
  Manifold CalculateCurvature(int gaussianIdx, int meanIdx) const;
  Manifold CalculateNormals(int normalIdx, float minSharpAngle = 60) const;
  Manifold SmoothByNormals(int normalIdx) const;
  Manifold SmoothOut(float minSharpAngle = 60, float minSmoothness = 0) const;
  Manifold Refine(int) const;
  Manifold RefineToLength(float) const;
  // Manifold RefineToPrecision(float);
 
  Manifold Boolean(const Manifold& second, OpType op) const;
  static Manifold BatchBoolean(const std::vector<Manifold>& manifolds,
                               OpType op);
  // Boolean operation shorthand
  Manifold operator+(const Manifold&) const;  // Add (Union)
  Manifold& operator+=(const Manifold&);
  Manifold operator-(const Manifold&) const;  // Subtract (Difference)
  Manifold& operator-=(const Manifold&);
  Manifold operator^(const Manifold&) const;  // Intersect
  Manifold& operator^=(const Manifold&);
  std::pair<Manifold, Manifold> Split(const Manifold&) const;
  std::pair<Manifold, Manifold> SplitByPlane(glm::vec3 normal,
                                             float originOffset) const;
  Manifold TrimByPlane(glm::vec3 normal, float originOffset) const;
 
  CrossSection Slice(float height = 0) const;
  CrossSection Project() const;
 
  Manifold Hull() const;
  static Manifold Hull(const std::vector<Manifold>& manifolds);
  static Manifold Hull(const std::vector<glm::vec3>& pts);
 
  bool MatchesTriNormals() const;
  int NumDegenerateTris() const;
  int NumOverlaps(const Manifold& second) const;
 
  struct Impl;
 
 private:
  Manifold(std::shared_ptr<CsgNode> pNode_);
  Manifold(std::shared_ptr<Impl> pImpl_);
  static Manifold Invalid();
  mutable std::shared_ptr<CsgNode> pNode_;
 
  CsgLeafNode& GetCsgLeafNode() const;
};
}  // namespace manifold