model.hpp

Go to the documentation of this file.

#pragma once
 
#include <vector>
#include <string>
#include <map>
#include <memory>
#include <optional>
#include <set>
 
#include <GL/glew.h>
#include <glm/glm.hpp>
#include <assimp/Importer.hpp>
#include <assimp/scene.h>
#include <assimp/postprocess.h>
#include "assimp/material.h"
 
#include "client/renderable.hpp"
#include "client/shader.hpp"
#include "client/util.hpp"
#include "client/bone.hpp"
 
#define MAX_BONE_INFLUENCE 4
 
struct Vertex {
    glm::vec3 position;
    glm::vec3 normal;
    glm::vec2 textureCoords;
    int m_boneIDs[MAX_BONE_INFLUENCE]; /* Bone indices which influence the vertex */
    float m_weights[MAX_BONE_INFLUENCE]; /* Weights for each bone */
    glm::vec3 tangent;
    glm::vec3 bitangent;
};
 
class Texture {
 public:
    Texture(const std::string& filepath, const aiTextureType& type);
 
    GLuint getID() const;
 
    /*
     * Get the type of texture. Either "texture_diffuse" or "texture_specular".
     */
    std::string getType() const;
 private:
    GLuint ID;
    std::string type;
};
 
struct Material {
    glm::vec3 ambient;
    glm::vec3 diffuse;
    glm::vec3 specular;
    float shininess;
};
 
struct BoneInfo {
    /*id is index in finalBoneMatrices*/
    int id;
 
    /*offset matrix transforms vertex from model space to bone space*/
    glm::mat4 offset;
};
 
class Mesh : public Renderable {
 public:
    Mesh(
        const std::vector<Vertex>& vertices,
        const std::vector<unsigned int>& indices,
        const std::vector<Texture>& textures,
        const Material& material
    );
 
    void draw(Shader* shader,
            glm::vec3 camPos, 
            bool fill) override;
 
 
    std::optional<glm::vec3> solidColor;
    Material material;
 private:
     std::vector<Vertex>       vertices;
     std::vector<unsigned int> indices;
     std::vector<Texture>      textures;
 
    //  render data opengl needs
    GLuint VAO, VBO, EBO;
    void setupNormalMaps();
};
 
 
class Model : public Renderable {
 public:
    explicit Model(const std::string& filepath, bool flip_uvs);
 
    void draw(Shader* shader,
            glm::vec3 camPos, 
            bool fill) override;
 
    void draw(Shader* shader,
            glm::vec3 camPos, 
            bool fill,
            glm::vec3 color);
 
    void translateAbsolute(const glm::vec3& new_pos) override;
 
    void translateRelative(const glm::vec3& delta) override;
 
    virtual void scaleAbsolute(const float& new_factor) override;
 
    virtual void scaleAbsolute(const glm::vec3& scale) override;
 
    void scaleRelative(const float& new_factor) override;
 
    void scaleRelative(const glm::vec3& scale) override;
 
    void rotateAbsolute(const glm::vec3& dir,  bool is_player = false, const glm::vec3& axis = glm::vec3(0.0f, 1.0f, 0.0f)) override;
 
    void rotateAbsolute(const float& angle, const glm::vec3& axis = glm::vec3(0.0f, 1.0f, 0.0f)) override;
 
    void rotateRelative(const glm::vec3& dir, const glm::vec3& axis = glm::vec3(0.0f, 1.0f, 0.0f)) override;
 
    void clear() override;
 
    void clearScale() override;
 
    void clearPosition() override;
 
    glm::vec3 getDimensions();
 
    void setDimensions(const glm::vec3& dimensions);
 
    void overrideSolidColor(std::optional<glm::vec3> color);
 
 
    auto& getBoneInfoMap() { return m_boneInfoMap; }
    int& getBoneCount() { return m_boneCounter; }
    
 
 private:
    std::vector<Mesh> meshes;
    Bbox bbox;
    glm::vec3 dimensions;
    
    std::map<std::string, BoneInfo> m_boneInfoMap;
    int m_boneCounter = 0;
 
 
    void processNode(aiNode* node, const aiScene* scene);
    Mesh processMesh(aiMesh* mesh, const aiScene* scene);
    void setDefaultVertexBoneData(Vertex& vertex);
    void setVertexBoneData(Vertex& vertex, int boneID, float weight);
    void extractBoneWeight(std::vector<Vertex>& vertices, aiMesh* mesh, const aiScene* scene);
 
    std::vector<Texture> loadMaterialTextures(aiMaterial* mat, const aiTextureType& type);
 
 
    // store the directory of the model file so that textures can be
    // loaded relative to the model file
    std::string directory;
};