TriangleMesh3.h

Go to the documentation of this file.

/*************************************************************************
> File Name: TriangleMesh3.h
> Project Name: CubbyFlow
> Author: Chan-Ho Chris Ohk
> Purpose: 3-D triangle mesh geometry.
> Created Time: 2017/04/04
> Copyright (c) 2018, Chan-Ho Chris Ohk
*************************************************************************/
#ifndef CUBBYFLOW_TRIANGLE_MESH3_H
#define CUBBYFLOW_TRIANGLE_MESH3_H

#include <Core/Array/Array1.h>
#include <Core/Geometry/BVH3.h>
#include <Core/Geometry/Triangle3.h>
#include <Core/Point/Point3.h>
#include <Core/Surface/Surface3.h>

namespace CubbyFlow
{
    class TriangleMesh3 final : public Surface3
    {
    public:
        class Builder;

        using Vector2DArray = Array1<Vector2D>;
        using Vector3DArray = Array1<Vector3D>;
        using IndexArray = Array1<Point3UI>;

        using PointArray = Vector3DArray;
        using NormalArray = Vector3DArray;
        using UVArray = Vector2DArray;

        TriangleMesh3(
            const Transform3& transform = Transform3(),
            bool isNormalFlipped = false);

        TriangleMesh3(
            const PointArray& points,
            const NormalArray& normals,
            const UVArray& uvs,
            const IndexArray& pointIndices,
            const IndexArray& normalIndices,
            const IndexArray& uvIndices,
            const Transform3& transform_ = Transform3(),
            bool isNormalFlipped_ = false);

        TriangleMesh3(const TriangleMesh3& other);

        void UpdateQueryEngine() override;

        void Clear();

        void Set(const TriangleMesh3& other);

        void Swap(TriangleMesh3& other);

        double Area() const;

        double Volume() const;

        const Vector3D& Point(size_t i) const;

        Vector3D& Point(size_t i);

        const Vector3D& Normal(size_t i) const;

        Vector3D& Normal(size_t i);

        const Vector2D& UV(size_t i) const;

        Vector2D& UV(size_t i);

        const Point3UI& PointIndex(size_t i) const;

        Point3UI& PointIndex(size_t i);

        const Point3UI& NormalIndex(size_t i) const;

        Point3UI& NormalIndex(size_t i);

        const Point3UI& UVIndex(size_t i) const;

        Point3UI& UVIndex(size_t i);

        Triangle3 Triangle(size_t i) const;

        size_t NumberOfPoints() const;

        size_t NumberOfNormals() const;

        size_t NumberOfUVs() const;

        size_t NumberOfTriangles() const;

        bool HasNormals() const;

        bool HasUVs() const;

        void AddPoint(const Vector3D& pt);

        void AddNormal(const Vector3D& n);

        void AddUV(const Vector2D& t);

        void AddPointTriangle(const Point3UI& newPointIndices);

        void AddPointNormalTriangle(
            const Point3UI& newPointIndices,
            const Point3UI& newNormalIndices);

        void AddPointUVNormalTriangle(
            const Point3UI& newPointIndices,
            const Point3UI& newUVIndices,
            const Point3UI& newNormalIndices);

        void AddPointUVTriangle(
            const Point3UI& newPointIndices,
            const Point3UI& 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;

        bool WriteObj(const std::string& fileName) const;

        bool ReadObj(std::istream* stream);

        bool ReadObj(const std::string& fileName);

        TriangleMesh3& operator=(const TriangleMesh3& other);

        static Builder GetBuilder();

    protected:
        Vector3D ClosestPointLocal(const Vector3D& otherPoint) const override;

        double ClosestDistanceLocal(const Vector3D& otherPoint) const override;

        bool IntersectsLocal(const Ray3D& ray) const override;

        BoundingBox3D BoundingBoxLocal() const override;

        Vector3D ClosestNormalLocal(const Vector3D& otherPoint) const override;

        SurfaceRayIntersection3 ClosestIntersectionLocal(const Ray3D& ray) const override;

    private:
        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;

        void InvalidateBVH() const;

        void BuildBVH() const;
    };

    using TriangleMesh3Ptr = std::shared_ptr<TriangleMesh3>;

    class TriangleMesh3::Builder final : public SurfaceBuilderBase3<TriangleMesh3::Builder>
    {
    public:
        Builder& WithPoints(const PointArray& points);

        Builder& WithNormals(const NormalArray& normals);

        Builder& WithUVs(const UVArray& uvs);

        Builder& WithPointIndices(const IndexArray& pointIndices);

        Builder& WithNormalIndices(const IndexArray& normalIndices);

        Builder& WithUVIndices(const IndexArray& uvIndices);

        TriangleMesh3 Build() const;

        TriangleMesh3Ptr MakeShared() const;

    private:
        PointArray m_points;
        NormalArray m_normals;
        UVArray m_uvs;
        IndexArray m_pointIndices;
        IndexArray m_normalIndices;
        IndexArray m_uvIndices;
    };
}

#endif