Mesh.h

#pragma once
// ===========================================================================
// Copyright (c) 2015 Toolchefs Ltd. All rights reserved.
//
// Use of this software is subject to the terms of the Toolchefs license
// agreement provided at the time of installation or download, or which
// otherwise accompanies this software in either electronic or hard copy form.
// ===========================================================================
 
#include <AtomsUtils/Globals.h>
#include <AtomsUtils/AtomsMath.h>
#include <AtomsUtils/Triangle.h>
#include <vector>
#include <map>
 
//#define ATOMS_USE_MESH_BVH 1
 
namespace AtomsUtils
{
    class Bvh;
    class KdTreeAccel;
 
 
    class ATOMSUTILS_EXPORT Mesh
    {
    public:
 
        enum GridMode
        {
            kKdtree = 0,
            kBvh = 1
        };
 
        struct UVData
        {
            std::string name;
            std::vector<AtomsMath::Vector2f> uvs;
            std::vector<unsigned int> uvIndices;
        };
 
        Mesh();
 
        virtual ~Mesh();
 
        Mesh(const Mesh& rhs);
 
        Mesh& operator=(const Mesh& rhs);
 
        bool hasGrid() { return m_grid != nullptr; };
 
        inline std::vector<AtomsMath::Vector3f>& points();
 
        inline const std::vector<AtomsMath::Vector3f>& points() const;
 
        inline std::vector<AtomsMath::Vector3f>& normals();
 
        inline const std::vector<AtomsMath::Vector3f>& normals() const;
 
        inline std::vector<unsigned int>& indices();
 
        inline const std::vector<unsigned int>& indices() const;
 
        inline std::vector<unsigned int>& vertexCount();
 
        inline const std::vector<unsigned int>& vertexCount() const;
 
        inline std::vector<AtomsMath::Vector2f>& uvs();
 
        inline const std::vector<AtomsMath::Vector2f>& uvs() const;
 
        inline unsigned int numberOfFaces() const;
 
        inline unsigned int numberOfVertices() const;
 
        inline std::vector<AtomsMath::Vector3f>& jointWeights();
 
        inline const std::vector<AtomsMath::Vector3f>& jointWeights() const;
 
        inline std::vector<AtomsMath::Vector3i>& jointIndices();
 
        inline const std::vector<AtomsMath::Vector3i>& jointIndices() const;
 
        inline std::vector<UVData>& uvSets();
 
        inline const std::vector<UVData>& uvSets() const;
 
        void buildIntersectionGrid(short gridMode = kKdtree);
 
        void multiplyPointsByMatrix(const AtomsMath::Matrix &matrix);
 
        virtual bool intersect(const AtomsMath::Vector3f &orig, const AtomsMath::Vector3f &dir, float &param, unsigned int &outFaceId, float& outU, float &outV, bool bothDirection = false) const;
 
        virtual bool closestPoint(const AtomsMath::Vector3f& inP, AtomsMath::Vector3f& outP, unsigned int& outFaceId, float& outU, float& outV, float& sqrDistance) const;
 
        virtual bool isInside(const AtomsMath::Vector3f& point) const;
 
        void clear();
 
        void computeSoftEdgeNormals();
 
        void clearIntersectionGrid();
 
        void triangulate();
 
        void transform(const AtomsMath::Matrixf &matrix);
 
        void merge(Mesh& inMesh);
 
        void createBox(const AtomsMath::Box3f& b);
 
        void createPlane(const AtomsMath::Box2f& b, const AtomsMath::Vector2i& divisions);
 
    public:
 
        static void triangulateMesh(const Mesh& input, Mesh& output);
 
    private:
 
        std::vector<AtomsMath::Vector3f> m_points;
 
        std::vector<AtomsMath::Vector3f> m_normal;
 
        std::vector<unsigned int> m_indices;
 
        std::vector<unsigned int> m_vertexCount;
 
        std::vector<AtomsMath::Vector2f> m_uvs;
 
        std::vector<AtomsMath::Vector3f> m_jointWeights;
 
        std::vector<AtomsMath::Vector3i> m_jointIndices;
 
        std::vector<UVData> m_uvSets;
 
        void* m_grid;
 
        short m_gridMode;
 
    };
 
}
 
#include "Mesh.impl.h"