meshinfo.h

Go to the documentation of this file.

#pragma once
#ifndef HF_MESHINFO
#define HF_MESHINFO
 
#include <Dense>
#include <array>
 
//#define EIGEN_DONT_ALIGN_STATICALLY
//#define EIGEN_DONT_VECTORIZE
 
// [nanoRT]
namespace HF::nanoGeom {
    struct Mesh {
        size_t num_vertices;
        size_t num_faces;
        double* vertices;              
        double* facevarying_normals;   
        double* facevarying_tangents;  
        double* facevarying_binormals; 
        double* facevarying_uvs;       
        double* facevarying_vertex_colors;   
        unsigned int* faces;         
        unsigned int* material_ids;   
    };
}
// end [nanoRT]
 
namespace std {
 
    template <typename SizeT>
    inline void array_hash_combine_impl(SizeT& seed, SizeT value)
    {
        seed ^= value + 0x9e3779b9 + (seed << 6) + (seed >> 2);
    }
 
    template <typename T>
    struct hash<std::array<T, 3>>
    {
 
        inline std::size_t operator()(const std::array<T, 3>& k) const
        {
            size_t seed = std::hash<T>()(k[0]);
            array_hash_combine_impl(seed, std::hash<T>()(k[1]));
            array_hash_combine_impl(seed, std::hash<T>()(k[2]));
            return seed;
        }
    };
}
 
namespace HF::Geometry {
 
    template <typename ptr_type>
    struct array_and_size {
        int size; 
        ptr_type* data; 
 
        /* \brief Copy the contents of the array pointed to by this struct. */
        inline std::vector<ptr_type> CopyArray() const {
            return std::vector<ptr_type>(data, data + size);
        }
    };
 
    template <typename numeric_type = float>
    class MeshInfo {
    public:
        int meshid;                     
        std::string name = "";          
    private:
 
        using VertMatrix = Eigen::Matrix3X<numeric_type>;
        VertMatrix verts;   
        Eigen::Matrix3X<int> indices;   
 
 
 
        void SetVert(int index, numeric_type x, numeric_type y, numeric_type z);
 
 
        void VectorsToBuffers(const std::vector<std::array<numeric_type, 3>>& vertices);
    public:
 
 
        MeshInfo() { meshid = 0; verts.resize(3, 0); name = "INVALID"; };
 
 
        MeshInfo(
            const std::vector<std::array<numeric_type, 3>>& vertices,
            int id,
            std::string name = ""
        );
 
 
        MeshInfo(
            const std::vector<numeric_type>& in_vertices, 
            const std::vector<int>& in_indexes,
            int id, 
            std::string name = ""
        );
 
        void AddVerts(const std::vector<std::array<numeric_type, 3>>& verts);
    
 
        int NumVerts() const;
 
 
        int NumTris() const;
 
        void ConvertToRhinoCoordinates();
 
        void ConvertToOBJCoordinates();
 
        /*
            \details 
            Uses Eigen's geometry module to create a rotation matrix, then applies it to 
            this mesh's vertex matrix. 
 
            \code
                // be sure to #include "meshinfo.h", and #include <vector>
 
                // Prepare the vertices
                std::array<numeric_type, 3> vertex_0 = { 34.1, 63.9, 16.5 };
                std::array<numeric_type, 3> vertex_1 = { 23.5, 85.7, 45.2 };
                std::array<numeric_type, 3> vertex_2 = { 12.0, 24.6, 99.4 };
 
                // Create an array of vertices
                std::vector<std::array<numeric_type, 3>> vertices{ vertex_0, vertex_1, vertex_2 };
 
                // Create the MeshInfo
                HF::Geometry::MeshInfo mesh(vertices, 3451, "My Mesh");
 
                // Perform rotation
                numeric_type rot_x = 10.0;
                numeric_type rot_y = 20.0;
                numeric_type rot_z = 30.0;
 
                mesh.PerformRotation(rot_x, rot_y, rot_z);
 
                // Display the vertices for mesh
                std::cout << "Vertices in mesh with ID " << mesh.GetMeshID() << ": " << std::endl;
                for (auto vertex : mesh.GetVertsAsArrays()) {
                    std::cout << "(" << vertex[0] << ", " << vertex[1] << ", " << vertex[2] << ")" << std::endl;
                }
            \endcode
        */
        void PerformRotation(numeric_type rx, numeric_type ry, numeric_type rz);
 
 
        int GetMeshID() const;
 
 
 
        std::vector<numeric_type> GetIndexedVertices() const;
        
 
        std::vector<int> getRawIndices() const;
 
 
        std::vector<std::array<numeric_type, 3>> GetUnindexedVertices() const;
 
 
        void SetMeshID(int new_id);
 
 
        bool operator==(const MeshInfo& M2) const;
        
 
        std::array<numeric_type, 3> operator[](int i) const;
 
        const array_and_size<numeric_type> GetVertexPointer() const;
 
        const array_and_size<int> GetIndexPointer() const;
    };
 
    template <typename T> MeshInfo()->MeshInfo<float>;
}
#endif