mesh.h

#pragma once
#include <glm/glm.hpp>
#include <vector>
#include <string>
#include <iostream>
#include <fstream>
#include <sstream>
#include "../rendering/vao.h"
#include "../rendering/window.h"
#include "../rendering/camera.h"
#include"material.h"
#include"../rendering/shaderProgram.h"
#include <glm/gtc/matrix_transform.hpp>
#include <glm/gtc/type_ptr.hpp>
using namespace std;
#define MAX_BONE_INFLUENCE 4
namespace Aire {
 
    using MeshHandle = int;
 
    struct Vertex {
        glm::vec3 Position;
        glm::vec3 Normal;
        glm::vec2 TexCoords;
        glm::vec3 Tangent;
        glm::vec3 Bitangent;
 
        int m_BoneIDs[MAX_BONE_INFLUENCE];
        float m_Weights[MAX_BONE_INFLUENCE];
    };
 
    struct MaterialColor {
        glm::vec3 DiffuseColors = glm::vec3(0.5f, 0.5f, 0.5f);
        glm::vec3 Specular = glm::vec3(0.5f, 0.5f, 0.5f); 
        glm::vec3 Ambient = glm::vec3(0.5f, 0.5f, 0.5f);
        float Shininess = 0.0f;
    };
 
    struct meshTexture {
        unsigned int id;
        std::string type;
        std::string path;
    };
 
    class Mesh : public Resource{
       
    private:
        // render data 
        unsigned int VBO, EBO;
        MaterialPtr material;
        MeshHandle meshHandle;
        void setupMesh()
        {
            // create buffers/arrays
            glGenVertexArrays(1, &VAO);
            glGenBuffers(1, &VBO);
            glGenBuffers(1, &EBO);
 
            glBindVertexArray(VAO);
            // load data into vertex buffers
            glBindBuffer(GL_ARRAY_BUFFER, VBO);
 
            glBufferData(GL_ARRAY_BUFFER, vertices.size() * sizeof(Vertex), &vertices[0], GL_STATIC_DRAW);
 
            glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, EBO);
            glBufferData(GL_ELEMENT_ARRAY_BUFFER, indices.size() * sizeof(unsigned int), &indices[0], GL_STATIC_DRAW);
 
            // set the vertex attribute pointers
            // vertex Positions
            glEnableVertexAttribArray(0);
            glVertexAttribPointer(0, 3, GL_FLOAT, GL_FALSE, sizeof(Vertex), (void*)0);
            // vertex normals
            glEnableVertexAttribArray(1);
            glVertexAttribPointer(1, 3, GL_FLOAT, GL_FALSE, sizeof(Vertex), (void*)offsetof(Vertex, Normal));
            // vertex texture coords
            glEnableVertexAttribArray(2);
            glVertexAttribPointer(2, 2, GL_FLOAT, GL_FALSE, sizeof(Vertex), (void*)offsetof(Vertex, TexCoords));
            // vertex tangent
            glEnableVertexAttribArray(3);
            glVertexAttribPointer(3, 3, GL_FLOAT, GL_FALSE, sizeof(Vertex), (void*)offsetof(Vertex, Tangent));
            // vertex bitangent
            glEnableVertexAttribArray(4);
            glVertexAttribPointer(4, 3, GL_FLOAT, GL_FALSE, sizeof(Vertex), (void*)offsetof(Vertex, Bitangent));
            // ids
            glEnableVertexAttribArray(5);
            glVertexAttribIPointer(5, 4, GL_INT, sizeof(Vertex), (void*)offsetof(Vertex, m_BoneIDs));
 
            // weights
            glEnableVertexAttribArray(6);
            glVertexAttribPointer(6, 4, GL_FLOAT, GL_FALSE, sizeof(Vertex), (void*)offsetof(Vertex, m_Weights));
            glBindVertexArray(0);
        }
 
    public:
        std::vector<Vertex>  vertices;
        std::vector<unsigned int> indices;
        //std::vector<meshTexture>      textures;
       // MaterialColor materialColor;
        
        unsigned int VAO;
 
        Mesh(std::vector<Vertex> vertices, std::vector<unsigned int> indices,MaterialPtr& handle)
        {
            this->vertices = vertices;
            this->indices = indices;
            this->material = handle;
            this->meshHandle = 0;
            this->EBO = NULL;
            this->VBO = NULL;
            this->VAO = NULL;
        }
 
        Mesh(std::vector<Vertex> vertices, std::vector<unsigned int> indices, MaterialPtr& handle,MeshHandle& meshHandle)
        {
            this->vertices = vertices;
            this->indices = indices;
            this->material = handle;
            this->meshHandle = meshHandle;
            this->EBO = NULL;
            this->VBO = NULL;
            this->VAO = NULL;
        }
 
        ~Mesh();
 
        void render(ShaderProgram& shader)
        //void Draw(ShaderProgram& shader, Aire::Camera& camera, glm::mat4 modelMatrix)
        {
            glm::vec3* diffuseCol = material->getColor(DIFFUSE_COLOR);
            glm::vec3* specularCol = material->getColor(SPECULAR_COLOR);
            glm::vec3* ambientCol = material->getColor(AMBIENT_COLOR);
            float* shininessValue = material->getShininess();
 
            TexturePtr diffuseMap = material->getTexture(DIFFUSE_MAP);
            TexturePtr specularMap = material->getTexture(SPECULAR_MAP);
            TexturePtr normalMap = material->getTexture(HEIGHT_MAP);
            TexturePtr heightMap = material->getTexture(NORMAL_MAP);
 
            glUniform1f(glGetUniformLocation(shader.getProgramId(), "shininessValue"), *shininessValue);
 
            int countTexturesAssigned = 0;
            if (diffuseMap != nullptr) {
                glUniform1i(glGetUniformLocation(shader.getProgramId(), "hasDiffuseMap"), 1);
                shader.set2DTextureUniform("diffuseMap", diffuseMap->getHandle());
                countTexturesAssigned++;
            }
            else {
                glUniform1i(glGetUniformLocation(shader.getProgramId(), "hasDiffuseMap"), 0);
                glUniform3f(glGetUniformLocation(shader.getProgramId(), "diffuseColor"), diffuseCol->x, diffuseCol->y, diffuseCol->z);
            }
 
            if (specularMap != nullptr) {
                glUniform1i(glGetUniformLocation(shader.getProgramId(), "hasSpecularMap"), 1);
                shader.set2DTextureUniform("specularMap", specularMap->getHandle());
                countTexturesAssigned++;
            }
            else {
                glUniform1i(glGetUniformLocation(shader.getProgramId(), "hasSpecularMap"), 0);
                glUniform3f(glGetUniformLocation(shader.getProgramId(), "specularColor"), specularCol->x, specularCol->y, specularCol->z);
            }
 
            if (normalMap != nullptr) {
                glUniform1i(glGetUniformLocation(shader.getProgramId(), "hasNormalMap"), 1);
                shader.set2DTextureUniform("normalMap", normalMap->getHandle());
                countTexturesAssigned++;
            }
            else {
                glUniform1i(glGetUniformLocation(shader.getProgramId(), "hasNormalMap"), 0);
            }
 
            // draw mesh
            glBindVertexArray(VAO);
            glDrawElements(GL_TRIANGLES, static_cast<unsigned int>(indices.size()), GL_UNSIGNED_INT, 0);
 
            shader.unbind2DTextures(countTexturesAssigned);
        }
 
        unsigned int* getVBO();
 
        unsigned int* getEB0();
 
        std::vector<Vertex> getVertice();
 
        std::vector<unsigned int> getIndices();
 
        MaterialPtr getMaterial();
 
        uint32_t getSize();
 
        MeshHandle getMeshHandle();
 
        void translate(glm::mat4& modelMatrix, glm::vec3 direction);
 
        void scale(glm::mat4& modelMatrix, float val);
 
        void rotate(glm::mat4& modelMatrix, float degree,glm::vec3 direction);
 
 
 
        
    };
    using MeshPtr = shared_ptr<Mesh>;
 
}