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