mesh.h

Go to the documentation of this file.

 
#ifndef _MESH_H
#define _MESH_H
 
#include <vector>
#include <unordered_map>
 
#include "glcore.h"
 
#include "vec.h"
#include "mat.h"
#include "color.h"
#include "materials.h"
 
 
struct TriangleData
{
    vec3 a, b, c;       
    vec3 na, nb, nc;    
    vec2 ta, tb, tc;    
};
 
struct TriangleGroup
{
    int index;  
    int first;  
    int n;      
};
 
 
class Mesh
{
public:
 
    Mesh( ) : m_positions(), m_texcoords(), m_normals(), m_colors(), m_indices(), 
        m_color(White()), m_primitives(GL_POINTS), m_vao(0), m_buffer(0), m_index_buffer(0), m_vertex_buffer_size(0), m_index_buffer_size(0), m_update_buffers(false) {}
    
    Mesh( const GLenum primitives ) : m_positions(), m_texcoords(), m_normals(), m_colors(), m_indices(), 
        m_color(White()), m_primitives(primitives), m_vao(0), m_buffer(0), m_index_buffer(0), m_vertex_buffer_size(0), m_index_buffer_size(0), m_update_buffers(false) {}
    
    int create( const GLenum primitives );
    
    int create( const GLenum primitives, const std::vector<vec3>& positions );
    int create( const GLenum primitives, const std::vector<vec3>& positions, const std::vector<unsigned>& indices );
    int create( const GLenum primitives, const std::vector<vec3>& positions, 
        const std::vector<vec2>& texcoords, 
        const std::vector<vec3>& normals, 
        const std::vector<vec4>& colors, 
        const std::vector<unsigned>& indices );
    
    void release( );
    
 
    Mesh& color( const vec4& c );
    Mesh& color( const Color& c ) { return color(vec4(c.r, c.g, c.b, c.a)); }
    Mesh& color( const float r, const float g, const float b, const float a= 1) { return color(vec4(r, g, b, a)); }
    
    Mesh& normal( const vec3& n );
    Mesh& normal( const Vector& n ) { return normal(vec3(n)); }
    Mesh& normal( const float x, const float y, const float z ) { return normal(vec3(x, y, z)); }
    
    Mesh& texcoord( const vec2& uv );
    Mesh& texcoord( const float x, const float y ) { return texcoord(vec2(x, y)); }
    
    unsigned int vertex( const vec3& p );
    unsigned int vertex( const Point& p ) { return vertex(vec3(p)); }
    unsigned int vertex( const float x, const float y, const float z ) { return vertex(vec3(x, y, z)); }
    
    void clear( );
 
 
 
    Mesh& triangle( const unsigned int a, const unsigned int b, const unsigned int c );
    
    Mesh& triangle_last( const int a, const int b, const int c );
    
    Mesh& restart_strip( );
    
    Mesh& index( const int a );
    
 
    Mesh& color( const unsigned int id, const vec4& c );
    Mesh& color( const unsigned int id, const Color& c ) { return color(id, vec4(c.r, c.g, c.b, c.a)); }
    Mesh& color( const unsigned int id, const float r, const float g, const float b, const float a= 1) { return color(id, vec4(r, g, b, a)); }
 
    Mesh& normal( const unsigned int id, const vec3& n );
    Mesh& normal( const unsigned int id, const Vector& n ) { return normal(id, vec3(n)); }
    Mesh& normal( const unsigned int id, const float x, const float y, const float z ) { return normal(id, vec3(x, y, z)); }
    
    Mesh& texcoord( const unsigned int id, const vec2& uv );
    Mesh& texcoord( const unsigned int id, const float x, const float y ) { return texcoord(id, vec2(x, y)); }
    
    void vertex( const unsigned int id, const vec3& p );
    void vertex( const unsigned int id, const Point& p ) { vertex(id, vec3(p)); }
    void vertex( const unsigned int id, const float x, const float y, const float z ) { vertex(id, vec3(x, y, z)); }
    
 
    const Materials& materials( ) const;
    Materials& materials( );
    void materials( const Materials& materials );
    
    const std::vector<unsigned int>& material_indices( ) const;
    
    Mesh& material( const unsigned int id );
    
 
    int triangle_count( ) const;
    TriangleData triangle( const unsigned int id ) const;
    
    int triangle_material_index( const unsigned int id ) const;
    const Material &triangle_material( const unsigned int id ) const;
    
    std::vector<TriangleGroup> groups( );
    std::vector<TriangleGroup> groups( const std::vector<unsigned int>& triangle_properties );
    
    void bounds( Point& pmin, Point& pmax ) const;
    
    Color default_color( ) const { return m_color; }
    Mesh& default_color( const Color& color );
    
 
    int vertex_count( ) const { return (int) m_positions.size(); }
    int index_count( ) const { return (int) m_indices.size(); }
    
    const float *vertex_buffer( ) const { return &m_positions.front().x; }
    std::size_t vertex_buffer_size( ) const { return m_positions.size() * sizeof(vec3); }
 
    const float *normal_buffer( ) const { return &m_normals.front().x; }
    std::size_t normal_buffer_size( ) const { return m_normals.size() * sizeof(vec3); }
    
    const float *texcoord_buffer( ) const { return &m_texcoords.front().x; }
    std::size_t texcoord_buffer_size( ) const { return m_texcoords.size() * sizeof(vec2); }
    
    const float *color_buffer( ) const { return &m_colors.front().x; }
    std::size_t color_buffer_size( ) const { return m_colors.size() * sizeof(vec4); }
    
    const void *index_buffer( ) const { return &m_indices.front(); }
    std::size_t index_buffer_size( ) const { return m_indices.size() * sizeof(unsigned int); }
    
    //
    const std::vector<vec3>& positions( ) const { return m_positions; }
    const std::vector<vec2>& texcoords( ) const { return m_texcoords; }
    const std::vector<vec3>& normals( ) const { return m_normals; }
    const std::vector<vec4>& colors( ) const { return m_colors; }
    const std::vector<unsigned int>& indices( ) const { return m_indices; }
    
    bool has_position( ) const { return !m_positions.empty(); }
    bool has_texcoord( ) const { return m_texcoords.size() == m_positions.size(); }
    bool has_normal( ) const { return m_normals.size() == m_positions.size(); }
    bool has_color( ) const { return m_colors.size() == m_positions.size(); }
    bool has_material_index( ) const { return int(m_triangle_materials.size()) == triangle_count(); }
    
    GLenum primitives( ) const { return m_primitives; }
    
 
 
    static Mesh& error( )
    {
        static Mesh mesh;
        return mesh;
    }
    
    bool operator== ( const Mesh& m ) const
    {
        return (this == &m);
    }
    
    
    GLuint create_buffers( const bool use_texcoord, const bool use_normal, const bool use_color, const bool use_material_index );
    void draw( const GLuint program, const bool use_position, const bool use_texcoord, const bool use_normal, const bool use_color, const bool use_material_index );
    void draw( const int first, const int n, const GLuint program, const bool use_position, const bool use_texcoord, const bool use_normal, const bool use_color, const bool use_material_index );
    
private:
    int update_buffers( const bool use_texcoord, const bool use_normal, const bool use_color, const bool use_material_index );
    
    //
    std::vector<vec3> m_positions;
    std::vector<vec2> m_texcoords;
    std::vector<vec3> m_normals;
    std::vector<vec4> m_colors;
    
    std::vector<unsigned int> m_indices;
 
    Materials m_materials;
    std::vector<unsigned int> m_triangle_materials;
 
    Color m_color;
    
    GLenum m_primitives;
    GLuint m_vao;
    GLuint m_buffer;
    GLuint m_index_buffer;
    size_t m_vertex_buffer_size;
    size_t m_index_buffer_size;
    
    bool m_update_buffers;
};
 
 
#endif