model.h

#ifndef __MODEL_H__
#define __MODEL_H__
 
#include "app.h"
#include "mesh.h"
#include "camera.h"
#include "shader.h"
#include "image.h"
#include "texture.h"
 
namespace sgltk {
 
#ifdef HAVE_ASSIMP_H
 
#ifndef BONES_PER_VERTEX
    #define BONES_PER_VERTEX 4
#endif
 

class Model {
    static std::vector<std::string> paths;
    Assimp::Importer importer;
    const aiScene *scene;
    Shader *shader;
 
    int model_matrix_buf;
    int normal_matrix_buf;
 
    glm::mat4 *view_matrix;
    glm::mat4 *projection_matrix;
 
    std::string position_name;
    std::string normal_name;
    std::string tangent_name;
    std::string color_name;
    std::string texture_coordinates_name;
    std::string bone_ids_name;
    std::string bone_weights_name;
    std::string bone_array_name;
 
    std::vector<glm::mat4> bone_offsets;
 
    double ticks_per_second;
    glm::mat4 glob_inv_transf;
 
    void set_vertex_attribute(std::unique_ptr<Mesh>& mesh);
    void traverse_scene_nodes(aiNode *start_node, aiMatrix4x4 *parent_trafo);
    void traverse_animation_nodes(float time, aiNode *node, glm::mat4 parent_transformation);
 
    std::unique_ptr<Mesh> create_mesh(unsigned int index);
    void compute_bounding_box();
 
    static aiVector3D interpolate_scaling(float time, aiNodeAnim *node);
    static aiVector3D interpolate_translation(float time, aiNodeAnim *node);
    static aiQuaternion interpolate_rotation(float time, aiNodeAnim *node);
    static glm::mat4 ai_to_glm_mat4(const aiMatrix4x4& in);
 
    public:
        glm::mat4 model_matrix;
        std::vector<glm::vec3> bounding_box;
        std::vector<std::unique_ptr<Mesh> > meshes;
        std::vector<glm::mat4> bones;
        std::map<std::string, unsigned int> bone_map;
        std::map<std::string, unsigned int> mesh_map;
 
        EXPORT Model();
        EXPORT ~Model();

        EXPORT static void add_path(std::string path);

        EXPORT bool load(const std::string& filename);
        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_position_name(const std::string& name);
        EXPORT void set_normal_name(const std::string& name);
        EXPORT void set_tangent_name(const std::string& name);
        EXPORT void set_color_name(const std::string& name);
        EXPORT void set_texture_coordinates_name(const std::string& name);
        EXPORT void set_bone_ids_name(const std::string& name);
        EXPORT void set_bone_weights_name(const std::string& name);
        EXPORT void set_bone_array_name(const std::string& name);
        EXPORT void set_animation_speed(double speed);
        EXPORT void attach_texture(const std::string& name,
                       const Texture& texture,
                       unsigned int index = 0);
        EXPORT void set_texture_parameter(GLenum name, int parameter);
        EXPORT void set_texture_parameter(GLenum name, float parameter);
        EXPORT bool animate(float time);
        EXPORT void setup_instanced_matrix(const std::vector<glm::mat4>& model_matrix,
                            GLenum usage = GL_STATIC_DRAW);
        EXPORT void set_instanced_matrix_attributes(void);
        EXPORT void draw(const glm::mat4 *model_matrix = nullptr);
        EXPORT void draw_instanced(unsigned int num_instances);
    };
 
#endif //HAVE_ASSIMP_H
 
}
 
#endif //__MODEL_H__