text: #ifndef LEARNOPENGL_MESH_H
  #define LEARNOPENGL_MESH_H
  
  #include "glad.h"
  #include <GLFW/glfw3.h>
  #include <glm/glm.hpp>
  #include <glm/gtc/matrix_transform.hpp>
  #include <glm/gtc/type_ptr.hpp>
  #include <assimp/Importer.hpp>
  #include <assimp/scene.h>
  #include <assimp/postprocess.h>
  #include <iostream>
  #include <fstream>
  #include <sstream>
  #include <string>
  #include <vector>
  
  struct Vertex {
      glm::vec3 Position;
      glm::vec3 Normal;
      glm::vec2 TexCoords;
  //    float Position[3];
  //    float Normal[3];
  //    float TexCoords[2];
  };
  
  struct Material {
      glm::vec3 ambient;
      glm::vec3 diffuse;
      glm::vec3 specular;
      float shininess;
  };
  
  struct Texture {
      unsigned int id;
      std::string type;
      std::string path;  // we store the path of the texture to compare with other textures
  };
  
  class Shader {
  public:
      // the program ID
      unsigned int ID;
  
      // constructor reads and builds the shader
      Shader(const char* vertexPath, const char* fragmentPath);
      // use/activate the shader
      void use();
      // utility uniform functions
      void setBool(const std::string &name, bool value) const;
      void setInt(const std::string &name, int value) const;
      void setFloat(const std::string &name, float value) const;
      void setVec3(const std::string &name, float value0, float value1, float value2) const;
      void setMat4(const std::string &name, const float* value) const;
  };
  
  class Mesh {
      public:
          /*  Mesh Data  */
          std::vector<Vertex> vertices;
          std::vector<unsigned int> indices;
          std::vector<Texture> textures;
          Material material;
          /*  Functions  */
          Mesh(std::vector<Vertex> vertices, std::vector<unsigned int> indices, std::vector<Texture> textures, Material material);
          void Draw(Shader shader);
      private:
          /*  Render data  */
          unsigned int VAO, VBO, EBO;
          /*  Functions    */
          void setupMesh();
  };
  
  void printMaterialsMetadata(const aiScene *scene);
  
  class Model {
      public:
          /*  Functions   */
          Model(std::string path) {
              loadModel(path);
          }
          void Draw(Shader shader);
  
      private:
          /*  Model Data  */
          std::vector<Mesh> meshes;
          std::string directory;
          std::vector<Texture> textures_loaded;
          /*  Functions   */
          void loadModel(std::string path);
          void processNode(aiNode *node, const aiScene *scene);
          Mesh processMesh(aiMesh *mesh, const aiScene *scene);
          std::vector<Texture> loadMaterialTextures(aiMaterial *mat, aiTextureType type,
                                               std::string typeName);
  };
  
  unsigned int TextureFromFile(const char *path, const std::string &directory);
  
  
  #endif // LEARNOPENGL_MESH_H
  