Mesh.hpp

#pragma once
#include "resources/Bounds.hpp"
#include "resources/Buffer.hpp"
#include "graphics/GPUTypes.hpp"
#include "Common.hpp"
 
class GPUMesh;
 
class Mesh {
public:
    
    enum class Load {
        Expanded, 
        Points,   
        Indexed   
    };
 
    struct Metrics {
        size_t vertices = 0; 
        size_t normals = 0; 
        size_t tangents = 0; 
        size_t bitangents = 0; 
        size_t colors = 0; 
        size_t texcoords = 0; 
        size_t indices = 0; 
    };
 
    Mesh(const std::string & name);
    
    Mesh(std::istream & in, Mesh::Load mode, const std::string & name);
 
    void upload();
    
    void clearGeometry();
 
    void clean();
 
    BoundingBox computeBoundingBox();
 
    void computeNormals();
 
    void computeTangentsAndBitangents(bool force);
 
    int saveAsObj(const std::string & path, bool defaultUVs);
    
    const std::string & name() const;
 
    bool hadNormals() const;
 
    bool hadTexcoords() const;
 
    bool hadColors() const;
 
    const Metrics & metrics() const;
    
    Mesh & operator=(const Mesh &) = delete;
    
    Mesh(const Mesh &) = delete;
    
    Mesh & operator=(Mesh &&);
    
    Mesh(Mesh &&);
 
    ~Mesh();
 
    Buffer& vertexBuffer();
    Buffer& indexBuffer();
    
    std::vector<glm::vec3> positions;  
    std::vector<glm::vec3> normals; 
    std::vector<glm::vec3> tangents;   
    std::vector<glm::vec3> bitangents;  
    std::vector<glm::vec3> colors;   
    std::vector<glm::vec2> texcoords;  
    std::vector<unsigned int> indices; 
    
    BoundingBox bbox;             
    std::unique_ptr<GPUMesh> gpu; 
 
private:
 
    void updateMetrics();
 
    Metrics _metrics; 
    std::string _name; 
 
};