mesh.h

#ifndef __MESH_H__
#define __MESH_H__
 
#include "app.h"
#include "buffer.h"
#include "shader.h"
#include "camera.h"
#include "texture.h"
 
namespace sgltk {

typedef EXPORT struct Vertex {
    glm::vec4 position;
    glm::vec3 normal;
    glm::vec4 tangent;
    glm::vec4 bitangent;
    glm::vec4 color;
    glm::vec3 tex_coord;
 
    Vertex() {
        position = {0, 0, 0, 1};
 
        normal = {0, 0, 0};
 
        tangent = {0, 0, 0, 1};
 
        bitangent = glm::vec4(glm::cross(normal, glm::vec3(tangent)), 1);
 
        color = {0, 0, 0, 0};
    };

    Vertex(glm::vec3 p, glm::vec3 n) {
        position = glm::vec4(p, 1);
 
        normal = n;
 
        tangent = {0, 0, 0, 1};
 
        bitangent = glm::vec4(glm::cross(normal, glm::vec3(tangent)), 1);
 
        color = {0, 0, 0, 0};
 
        tex_coord = {0, 0, 0};
    };

    Vertex(glm::vec3 p, glm::vec3 n, glm::vec3 tc) {
        position = glm::vec4(p, 1);
 
        normal = n;
 
        tangent = {0, 0, 0, 1};
 
        bitangent = glm::vec4(glm::cross(normal, glm::vec3(tangent)), 1);
 
        color = {0, 0, 0, 0};
 
        tex_coord = tc;
    };

    Vertex(glm::vec3 p, glm::vec3 n, glm::vec3 t, glm::vec3 tc) {
        position = glm::vec4(p, 1);
 
        normal = n;
 
        tangent = glm::vec4(t, 1);
 
        bitangent = glm::vec4(glm::cross(normal, glm::vec3(tangent)), 1);
 
        color = {0, 0, 0, 0};
 
        tex_coord = tc;
    };

    Vertex(glm::vec3 p, glm::vec3 n, glm::vec3 t,
           glm::vec4 c, glm::vec3 tc) {
        position = glm::vec4(p, 1);
 
        normal = n;
 
        tangent = glm::vec4(t, 1);
 
        bitangent = glm::vec4(glm::cross(normal, glm::vec3(tangent)), 1);
 
        color = c;
 
        tex_coord = tc;
    };
} Vertex;
 

class Mesh {
    GLuint vao;
    GLenum tf_mode;
 
    glm::mat4 *view_matrix;
    glm::mat4 *projection_matrix;
 
    std::vector<std::unique_ptr<Buffer> > vbo;
 
    GLenum index_type;
    std::vector<std::unique_ptr<Buffer> > ibo;
 
    std::vector<Buffer*> attached_buffers;
    std::vector<GLuint> attached_buffers_targets;
    std::vector<unsigned int> attached_buffers_indices;
 
    void material_uniform();
public:
    unsigned int num_uv;
    unsigned int num_col;
    unsigned int num_vertices;
    std::string ambient_color_name;
    std::string diffuse_color_name;
    std::string specular_color_name;
    std::string shininess_name;
    std::string shininess_strength_name;

    std::string model_matrix_name;
    std::string view_matrix_name;
    std::string projection_matrix_name;
    std::string model_view_matrix_name;
    std::string view_proj_matrix_name;
    std::string model_view_projection_matrix_name;
    std::string normal_matrix_name;

    Shader *shader;
    std::vector<glm::vec3> bounding_box;
    glm::mat4 model_matrix;
    float shininess;
    float shininess_strength;
    glm::vec4 color_ambient;
    glm::vec4 color_diffuse;
    glm::vec4 color_specular;
    std::vector<std::tuple<std::string, const Texture&, unsigned int> > auto_textures;
    std::vector<std::tuple<std::string, const Texture&, unsigned int> > textures;

    bool wireframe;
    bool twosided;
 
    EXPORT Mesh();
    EXPORT ~Mesh();

    EXPORT void setup_shader(Shader *shader);
    EXPORT bool setup_camera(glm::mat4 *view_matrix,
                 glm::mat4 *projection_matrix);
    EXPORT bool setup_camera(Camera *camera);
    EXPORT void set_model_matrix_name(const std::string& name);
    EXPORT void set_view_matrix_name(const std::string& name);
    EXPORT void set_projection_matrix_name(const std::string& name);
    EXPORT void set_model_view_matrix_name(const std::string& name);
    EXPORT void set_view_proj_matrix_name(const std::string& name);
    EXPORT void set_model_view_proj_name(const std::string& name);
    EXPORT void set_normal_matrix_name(const std::string& name);
    EXPORT void set_ambient_color_name(const std::string& name);
    EXPORT void set_diffuse_color_name(const std::string& name);
    EXPORT void set_specular_color_name(const std::string& name);
    EXPORT void set_shininess_name(const std::string& name);
    EXPORT void set_shininess_strength_name(const std::string& name);
    EXPORT void attach_texture(const std::string& name,
                   const sgltk::Texture& texture,
                   unsigned int index = 0);
    EXPORT void set_transform_feedback_mode(GLenum mode);
    EXPORT void attach_buffer(const sgltk::Buffer *buffer, GLuint target, unsigned int index = 0);
    template <typename T>
    unsigned int attach_vertex_buffer(const T *vertexdata,
                      unsigned int number_elements,
                      GLenum usage = GL_STATIC_DRAW);
    template <typename T>
    unsigned int attach_vertex_buffer(const std::vector<T>& vertexdata,
                      GLenum usage = GL_STATIC_DRAW);
    template <typename T>
    bool replace_buffer_data(unsigned int buffer_index,
                 const T *data,
                 unsigned int number_elements);
    template <typename T>
    bool replace_buffer_data(unsigned int buffer_index,
                 const std::vector<T>& data);
    template <typename T>
    bool replace_partial_data(unsigned int buffer_index,
                  unsigned int offset,
                  const T *data,
                  unsigned int number_elements);
    template <typename T>
    bool replace_partial_data(unsigned int buffer_index,
                  unsigned int offset,
                  const std::vector<T>& data);
    template <typename T>
    int add_vertex_attribute(std::string attrib_name,
                 GLint number_elements,
                 GLenum type,
                 const T *data,
                 GLenum usage = GL_STATIC_DRAW);
    template <typename T>
    int add_vertex_attribute(std::string attrib_name,
                 GLint number_elements,
                 GLenum type,
                 const std::vector<T>& data,
                 GLenum usage = GL_STATIC_DRAW);
    template <typename T>
    int add_vertex_attribute(int attrib_location,
                 GLint number_elements,
                 GLenum type,
                 const T *data,
                 GLenum usage = GL_STATIC_DRAW);
    template <typename T>
    int add_vertex_attribute(int attrib_location,
                 GLint number_elements,
                 GLenum type,
                 const std::vector<T>& data,
                 GLenum usage = GL_STATIC_DRAW);
    EXPORT int set_buffer_vertex_attribute(const std::string& attrib_name,
                        sgltk::Buffer *buffer,
                        GLint number_elements,
                        GLenum type,
                        GLsizei stride,
                        const GLvoid *pointer,
                        unsigned int divisor = 0);
    EXPORT int set_buffer_vertex_attribute(int attrib_location,
                    sgltk::Buffer *buffer,
                    GLint number_elements,
                    GLenum type,
                    GLsizei stride,
                    const GLvoid *pointer,
                    unsigned int divisor = 0);
    EXPORT int set_vertex_attribute(const std::string& attrib_name,
                        unsigned int buffer_index,
                        GLint number_elements,
                        GLenum type,
                        GLsizei stride,
                        const GLvoid *pointer,
                        unsigned int divisor = 0);
    EXPORT int set_vertex_attribute(int attrib_location,
                        unsigned int buffer_index,
                        GLint number_elements,
                        GLenum type,
                        GLsizei stride,
                        const GLvoid *pointer,
                        unsigned int divisor = 0);
    template <typename T>
    int attach_index_buffer(const std::vector<T>& indices);

    template <typename T>
    void compute_bounding_box(const std::vector<T>& vertexdata, unsigned int pointer);

    EXPORT void draw(GLenum mode);

    EXPORT void draw(GLenum mode, const glm::mat4 *model_matrix);

    EXPORT void draw(GLenum mode, unsigned int index_buffer,
                    const glm::mat4 *model_matrix);

    EXPORT void draw_instanced(GLenum mode, unsigned int num_instances);

    EXPORT void draw_instanced(GLenum mode, unsigned int index_buffer,
                        unsigned int num_instances);
};
 
template <typename T>
int Mesh::add_vertex_attribute(std::string attrib_name,
                   GLint number_elements,
                   GLenum type,
                   const T *data,
                   GLenum usage) {
 
    std::vector<T> tmp(data, data + number_elements);
    unsigned int buffer_index = attach_vertex_buffer<T>(tmp, usage);
    return set_vertex_attribute(attrib_name, buffer_index, number_elements, type, 0, 0);
}
 
template <typename T>
int Mesh::add_vertex_attribute(std::string attrib_name,
                   GLint number_elements,
                   GLenum type,
                   const std::vector<T>& data,
                   GLenum usage) {
 
    unsigned int buffer_index = attach_vertex_buffer<T>(data, usage);
    return set_vertex_attribute(attrib_name, buffer_index, number_elements, type, 0, 0);
}
 
template <typename T>
int Mesh::add_vertex_attribute(int attrib_location,
                   GLint number_elements,
                   GLenum type,
                   const T *data,
                   GLenum usage) {
 
    std::vector<T> tmp(data, data + number_elements);
    unsigned int buffer_index = attach_vertex_buffer<T>(tmp, usage);
    return set_vertex_attribute(attrib_location, buffer_index, number_elements, type, 0, 0);
}
 
template <typename T>
int Mesh::add_vertex_attribute(int attrib_location,
                   GLint number_elements,
                   GLenum type,
                   const std::vector<T>& data,
                   GLenum usage) {
 
    unsigned int buffer_index = attach_vertex_buffer<T>(data, usage);
    return set_vertex_attribute(attrib_location, buffer_index, number_elements, type, 0, 0);
}
 
template <typename T>
unsigned int Mesh::attach_vertex_buffer(const T *vertexdata,
                    unsigned int number_elements,
                    GLenum usage) {
 
    std::vector<T> tmp(vertexdata, vertexdata + number_elements);
    return attach_vertex_buffer<T>(tmp, usage);
}
 
template <typename T>
unsigned int Mesh::attach_vertex_buffer(const std::vector<T>& vertexdata,
                    GLenum usage) {
 
    std::unique_ptr<Buffer> buf = std::make_unique<Buffer>(GL_ARRAY_BUFFER);
    buf->load<T>(vertexdata, usage);
    vbo.push_back(std::move(buf));
 
    return vbo.size() - 1;
}
 
template <typename T>
bool Mesh::replace_buffer_data(unsigned int buffer_index,
                   const T *data,
                   unsigned int number_elements) {
 
    std::vector<T> tmp(data, data + number_elements);
    return replace_buffer_data<T>(buffer_index, tmp);
}
 
template <typename T>
bool Mesh::replace_buffer_data(unsigned int buffer_index,
                   const std::vector<T>& data) {
 
    if(buffer_index >= vbo.size()) {
        App::error_string.push_back("The value of the variable"
                "buffer_index if greater than the number"
                "of vertex buffers.");
        return false;
    }
 
    vbo[buffer_index]->replace_data(data);
 
    return true;
}
 
template <typename T>
bool Mesh::replace_partial_data(unsigned int buffer_index,
                unsigned int offset,
                const T *data,
                unsigned int number_elements) {
 
    std::vector<T> tmp(data, data + number_elements);
    return replace_partial_data<T>(buffer_index, offset, tmp);
}
 
template <typename T>
bool Mesh::replace_partial_data(unsigned int buffer_index,
                unsigned int offset,
                const std::vector<T>& data) {
 
    if(buffer_index >= vbo.size()) {
        App::error_string.push_back("The value of the variable"
                "buffer_index if greater than the number"
                "of vertex buffers.");
        return false;
    }
 
    return vbo[buffer_index]->replace_partial_data(offset, data);
}
 
 
template <>
inline int Mesh::attach_index_buffer<unsigned char>(const std::vector<unsigned char>& indices) {
    if(index_type && index_type != GL_UNSIGNED_BYTE)
        return -1;
 
    index_type = GL_UNSIGNED_BYTE;
    std::unique_ptr<Buffer> index = std::make_unique<Buffer>(GL_ELEMENT_ARRAY_BUFFER);
    index->load<unsigned char>(indices, GL_STATIC_DRAW);
    ibo.push_back(std::move(index));
    return ibo.size() - 1;
}
 
template <>
inline int Mesh::attach_index_buffer<unsigned short>(const std::vector<unsigned short>& indices) {
    if(index_type && index_type != GL_UNSIGNED_SHORT)
        return -1;
 
    index_type = GL_UNSIGNED_SHORT;
    std::unique_ptr<Buffer> index = std::make_unique<Buffer>(GL_ELEMENT_ARRAY_BUFFER);
    index->load<unsigned short>(indices, GL_STATIC_DRAW);
    ibo.push_back(std::move(index));
    return ibo.size() - 1;
}
 
template <>
inline int Mesh::attach_index_buffer<unsigned int>(const std::vector<unsigned int>& indices) {
    if(index_type && index_type != GL_UNSIGNED_INT)
        return -1;
 
    index_type = GL_UNSIGNED_INT;
    std::unique_ptr<Buffer> index = std::make_unique<Buffer>(GL_ELEMENT_ARRAY_BUFFER);
    index->load<unsigned int>(indices, GL_STATIC_DRAW);
    ibo.push_back(std::move(index));
    return ibo.size() - 1;
}
 
template <typename T>
void Mesh::compute_bounding_box(const std::vector<T>& vertexdata, unsigned int pointer) {
    glm::vec3 *pos = (glm::vec3 *)(&(vertexdata)[0] + pointer);
    bounding_box[0] = *pos;
    bounding_box[1] = *pos;
    for(size_t i = 1; i < vertexdata.size(); i++) {
        pos = (glm::vec3 *)(&(vertexdata)[i] + pointer);
        if(pos->x < bounding_box[0].x)
            bounding_box[0].x = pos->x;
        if(pos->y < bounding_box[0].y)
            bounding_box[0].y = pos->y;
        if(pos->z < bounding_box[0].z)
            bounding_box[0].z = pos->z;
        if(pos->x > bounding_box[1].x)
            bounding_box[1].x = pos->x;
        if(pos->y > bounding_box[1].y)
            bounding_box[1].y = pos->y;
        if(pos->z > bounding_box[1].z)
            bounding_box[1].z = pos->z;
    }
}
}
 
#endif