Triangle3.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_TRIANGLE3_HPP
#define CUBBYFLOW_TRIANGLE3_HPP
 
#include <Core/Geometry/Surface.hpp>
 
namespace CubbyFlow
{
class Triangle3 final : public Surface3
{
 public:
    class Builder;
 
    Triangle3() : Triangle3(Transform3{})
    {
        // Do nothing
    }
 
    explicit Triangle3(const Transform3& _transform,
                       bool _isNormalFlipped = false);
 
    Triangle3(std::array<Vector3D, 3> points, std::array<Vector3D, 3> normals,
              std::array<Vector2D, 3> uvs,
              const Transform3& _transform = Transform3{},
              bool _isNormalFlipped = false);
 
    Triangle3(const Triangle3&) = default;
 
    Triangle3(Triangle3&&) noexcept = default;
 
    ~Triangle3() override = default;
 
    Triangle3& operator=(const Triangle3&) = default;
 
    Triangle3& operator=(Triangle3&&) noexcept = default;
 
    [[nodiscard]] double Area() const;
 
    void GetBarycentricCoords(const Vector3D& pt, double* b0, double* b1,
                              double* b2) const;
 
    [[nodiscard]] Vector3D FaceNormal() const;
 
    void SetNormalsToFaceNormal();
 
    [[nodiscard]] static Builder GetBuilder();
 
    std::array<Vector3D, 3> points;
 
    std::array<Vector3D, 3> normals;
 
    std::array<Vector2D, 3> uvs;
 
 protected:
    [[nodiscard]] Vector3D ClosestPointLocal(
        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;
};
 
using Triangle3Ptr = std::shared_ptr<Triangle3>;
 
class Triangle3::Builder final : public SurfaceBuilderBase3<Builder>
{
 public:
    [[nodiscard]] Builder& WithPoints(const std::array<Vector3D, 3>& _points);
 
    [[nodiscard]] Builder& WithNormals(const std::array<Vector3D, 3>& _normals);
 
    [[nodiscard]] Builder& WithUVs(const std::array<Vector2D, 3>& _uvs);
 
    [[nodiscard]] Triangle3 Build() const;
 
    [[nodiscard]] Triangle3Ptr MakeShared() const;
 
 private:
    std::array<Vector3D, 3> m_points;
    std::array<Vector3D, 3> m_normals;
    std::array<Vector2D, 3> m_uvs;
};
}  // namespace CubbyFlow
 
#endif