Model.h

#pragma once
 
#include <string>
#include <unordered_map>
#include <vector>
#include <assimp/scene.h>
#include <assimp/Importer.hpp>
#include <assimp/postprocess.h>
#include "../utils/rigidbodyHandler.h"
 
 
#include "Mesh.h"
#include "../res-management/animationData.h"
 
namespace Aire {
 
using ModelHandle = int;
using BoneInfoMap = std::map<string, BoneInfo>;
 
struct ModelData
{
    BoneInfoMap boneMap;
    int boneCounter = 0;
    std::vector<MeshPtr> meshes;
};
 
class Model:public Resource
{
public:
    bool isStatic = true;
    std::vector<MeshPtr> meshes;
    bool gammaCorrection;
    glm::mat4 modelMatrix;
    Rigidbody* rb = nullptr;
 
    Model(std::vector<MeshPtr> meshes ,std::map<string, BoneInfo> m_BoneInfoMap, //
    int m_BoneCounter = 0)
    {
        //directory = dir;
        this->meshes = meshes;
        this->gammaCorrection = false;
        this->m_BoneInfoMap = m_BoneInfoMap;
        this->m_BoneCounter = m_BoneCounter;
        this->modelMatrix = glm::mat4(1.0);
    }
 
    void AssignRigidbodyBox(float aWidth, float aHeight, float aDepth);
 
    void AssignRigidbodyBall(float aRadius);
 
    void SetGravity(bool gravityOn, float gravityValue);
 
    void SetCollision(bool aCollidable);
 
    void SetStatic(bool aStatic);
 
    auto& GetBoneInfoMap() { return m_BoneInfoMap; }
 
    int& GetBoneCount() { return m_BoneCounter; }
 
    void translate(glm::vec3 direction);
 
    void scale(glm::vec3 val);
 
    void rotate(float degree, glm::vec3 axis);
 
    glm::vec3 getPosition();
 
    void renderInstanced(ShaderProgram& shader, Aire::Camera& camera, glm::mat4 transform);
 
    void render(ShaderProgram& shader, Aire::Camera& camera);
 
    uint32_t getSize();
 
 
private:
 
    BoneInfoMap m_BoneInfoMap; //
    int m_BoneCounter = 0;
 
    void loadModel(std::string path);
    Mesh processMesh(aiMesh* mesh, const aiScene* scene, BoneInfoMap& map, int& count);
 
};
 
using ModelPtr = std::shared_ptr<Model>;
 
}