TriangleMesh3.hpp

Go to the documentation of this file.

// This code is based on Jet framework.
// Copyright (c) 2018 Doyub Kim
// CubbyFlow is voxel-based fluid simulation engine for computer games.
// Copyright (c) 2020 CubbyFlow Team
// Core Part: Chris Ohk, Junwoo Hwang, Jihong Sin, Seungwoo Yoo
// AI Part: Dongheon Cho, Minseo Kim
// We are making my contributions/submissions to this project solely in our
// personal capacity and are not conveying any rights to any intellectual
// property of any third parties.
 
#ifndef CUBBYFLOW_TRIANGLE_MESH3_HPP
#define CUBBYFLOW_TRIANGLE_MESH3_HPP
 
#include <Core/Array/Array.hpp>
#include <Core/Geometry/BVH.hpp>
#include <Core/Geometry/Surface.hpp>
#include <Core/Geometry/Triangle3.hpp>
 
namespace CubbyFlow
{
class TriangleMesh3 final : public Surface3
{
 public:
    class Builder;
 
    using Vector2DArray = Array1<Vector2D>;
    using Vector3DArray = Array1<Vector3D>;
    using IndexArray = Array1<Vector3UZ>;
 
    using PointArray = Vector3DArray;
    using NormalArray = Vector3DArray;
    using UVArray = Vector2DArray;
 
    TriangleMesh3(const Transform3& _transform = Transform3{},
                  bool _isNormalFlipped = false);
 
    TriangleMesh3(PointArray points, NormalArray normals, UVArray uvs,
                  IndexArray pointIndices, IndexArray normalIndices,
                  IndexArray uvIndices,
                  const Transform3& _transform = Transform3{},
                  bool _isNormalFlipped = false);
 
    TriangleMesh3(const TriangleMesh3& other);
 
    TriangleMesh3(TriangleMesh3&& other) noexcept = delete;
 
    // Default virtual destructor.
    ~TriangleMesh3() override = default;
 
    TriangleMesh3& operator=(const TriangleMesh3& other);
 
    TriangleMesh3& operator=(TriangleMesh3&& other) noexcept = delete;
 
    void UpdateQueryEngine() override;
 
    void UpdateQueryEngine() const;
 
    void Clear();
 
    void Set(const TriangleMesh3& other);
 
    void Swap(TriangleMesh3& other);
 
    [[nodiscard]] double Area() const;
 
    [[nodiscard]] double Volume() const;
 
    [[nodiscard]] const Vector3D& Point(size_t i) const;
 
    [[nodiscard]] Vector3D& Point(size_t i);
 
    [[nodiscard]] const Vector3D& Normal(size_t i) const;
 
    [[nodiscard]] Vector3D& Normal(size_t i);
 
    [[nodiscard]] const Vector2D& UV(size_t i) const;
 
    [[nodiscard]] Vector2D& UV(size_t i);
 
    [[nodiscard]] const Vector3UZ& PointIndex(size_t i) const;
 
    [[nodiscard]] Vector3UZ& PointIndex(size_t i);
 
    [[nodiscard]] const Vector3UZ& NormalIndex(size_t i) const;
 
    [[nodiscard]] Vector3UZ& NormalIndex(size_t i);
 
    [[nodiscard]] const Vector3UZ& UVIndex(size_t i) const;
 
    [[nodiscard]] Vector3UZ& UVIndex(size_t i);
 
    [[nodiscard]] Triangle3 Triangle(size_t i) const;
 
    [[nodiscard]] size_t NumberOfPoints() const;
 
    [[nodiscard]] size_t NumberOfNormals() const;
 
    [[nodiscard]] size_t NumberOfUVs() const;
 
    [[nodiscard]] size_t NumberOfTriangles() const;
 
    [[nodiscard]] bool HasNormals() const;
 
    [[nodiscard]] bool HasUVs() const;
 
    void AddPoint(const Vector3D& pt);
 
    void AddNormal(const Vector3D& n);
 
    void AddUV(const Vector2D& t);
 
    void AddPointTriangle(const Vector3UZ& newPointIndices);
 
    void AddNormalTriangle(const Vector3UZ& newNormalIndices);
 
    void AddUVTriangle(const Vector3UZ& newUVIndices);
 
    void AddTriangle(const Triangle3& tri);
 
    void SetFaceNormal();
 
    void SetAngleWeightedVertexNormal();
 
    void Scale(double factor);
 
    void Translate(const Vector3D& t);
 
    void Rotate(const QuaternionD& q);
 
    void WriteObj(std::ostream* stream) const;
 
    [[nodiscard]] bool WriteObj(const std::string& fileName) const;
 
    [[nodiscard]] bool ReadObj(std::istream* stream);
 
    [[nodiscard]] bool ReadObj(const std::string& fileName);
 
    [[nodiscard]] static Builder GetBuilder();
 
 protected:
    [[nodiscard]] Vector3D ClosestPointLocal(
        const Vector3D& otherPoint) const override;
 
    [[nodiscard]] double ClosestDistanceLocal(
        const Vector3D& otherPoint) const override;
 
    [[nodiscard]] bool IntersectsLocal(const Ray3D& ray) const override;
 
    [[nodiscard]] BoundingBox3D BoundingBoxLocal() const override;
 
    [[nodiscard]] Vector3D ClosestNormalLocal(
        const Vector3D& otherPoint) const override;
 
    [[nodiscard]] SurfaceRayIntersection3 ClosestIntersectionLocal(
        const Ray3D& ray) const override;
 
    [[nodiscard]] bool IsInsideLocal(const Vector3D& otherPoint) const override;
 
 private:
    void InvalidateCache() const;
 
    void InvalidateBVH() const;
 
    void BuildBVH() const;
 
    void BuildWindingNumbers() const;
 
    [[nodiscard]] double GetWindingNumber(const Vector3D& queryPoint,
                                          size_t triIndex) const;
 
    [[nodiscard]] double GetFastWindingNumber(const Vector3D& queryPoint,
                                              double accuracy) const;
 
    [[nodiscard]] double GetFastWindingNumber(const Vector3D& queryPoint,
                                              size_t rootNodeIndex,
                                              double accuracy) const;
 
    PointArray m_points;
    NormalArray m_normals;
    UVArray m_uvs;
    IndexArray m_pointIndices;
    IndexArray m_normalIndices;
    IndexArray m_uvIndices;
 
    mutable BVH3<size_t> m_bvh;
    mutable bool m_bvhInvalidated = true;
 
    mutable Array1<Vector3D> m_wnAreaWeightedNormalSums;
    mutable Array1<Vector3D> m_wnAreaWeightedAvgPositions;
    mutable bool m_wnInvalidated = true;
};
 
using TriangleMesh3Ptr = std::shared_ptr<TriangleMesh3>;
 
class TriangleMesh3::Builder final : public SurfaceBuilderBase3<Builder>
{
 public:
    [[nodiscard]] Builder& WithPoints(const PointArray& points);
 
    [[nodiscard]] Builder& WithNormals(const NormalArray& normals);
 
    [[nodiscard]] Builder& WithUVs(const UVArray& uvs);
 
    [[nodiscard]] Builder& WithPointIndices(const IndexArray& pointIndices);
 
    [[nodiscard]] Builder& WithNormalIndices(const IndexArray& normalIndices);
 
    [[nodiscard]] Builder& WithUVIndices(const IndexArray& uvIndices);
 
    [[nodiscard]] TriangleMesh3 Build() const;
 
    [[nodiscard]] TriangleMesh3Ptr MakeShared() const;
 
 private:
    PointArray m_points;
    NormalArray m_normals;
    UVArray m_uvs;
    IndexArray m_pointIndices;
    IndexArray m_normalIndices;
    IndexArray m_uvIndices;
};
}  // namespace CubbyFlow
 
#endif