model.hpp

// SPDX-License-Identifier: MIT
// Author:  Giovanni Santini
// Mail:    giovanni.santini@proton.me
// Github:  @San7o
 
#pragma once
 
#include <assimp/Importer.hpp>
#include <assimp/postprocess.h>
#include <assimp/scene.h>
#include <brenta/mesh.hpp>
#include <brenta/shader.hpp>
#include <glad/glad.h>
#include <string>
#include <vector>
 
namespace brenta
{
 
class model
{
public:
  
  GLint wrapping;
  GLint filtering_min;
  GLint filtering_mag;
  GLboolean has_mipmap;
  GLint mipmap_min;
  GLint mipmap_mag;
  bool flip;
 
  struct config;
  class builder;
 
  static const config default_config;
  
  model()
  {
  }
  
  model(config conf);
  
  void draw(types::shader_name_t shader);
 
private:
 
  std::vector<mesh> meshes;
  std::vector<types::texture> textures_loaded;
  std::string directory;
 
  void load_model(std::string path);
  void process_node(aiNode *node, const aiScene *scene);
  mesh process_mesh(aiMesh *mesh, const aiScene *scene);
  std::vector<types::texture> load_material_textures(aiMaterial *mat,
                                                     aiTextureType type,
                                                     std::string type_name);
};
 
struct model::config
{
  std::string path;
  GLint wrapping;
  GLint filtering_min;
  GLint filtering_mag;
  GLboolean has_mipmap;
  GLint mipmap_min;
  GLint mipmap_mag;
  bool flip;
};
  
class model::builder
{
private:
 
  model::config conf = model::default_config;
  
public:
  builder &path(std::string path);
  builder &wrapping(GLint wrapping);
  builder &filtering_min(GLint filtering_min);
  builder &filtering_mag(GLint filtering_mag);
  builder &has_mipmap(GLboolean has_mipmap);
  builder &mipmap_min(GLint mipmap_min);
  builder &mipmap_mag(GLint mipmap_mag);
  builder &flip(bool flip);
 
  model build();
};
 
} // namespace brenta