mesh.hpp

// SPDX-License-Identifier: MIT
// Author:  Giovanni Santini
// Mail:    giovanni.santini@proton.me
// Github:  @San7o
 
#pragma once
 
#include <brenta/buffer.hpp>
#include <brenta/gl.hpp>
#include <brenta/shader.hpp>
#include <brenta/texture.hpp>
#include <brenta/vao.hpp>
 
#include <glm/glm.hpp>
#include <glm/gtc/matrix_transform.hpp>
#include <glm/gtc/type_ptr.hpp>
 
#include <string>
#include <vector>
#include <memory>
 
namespace brenta
{
 
namespace types
{
 
struct vertex
{
  glm::vec3 position;
  glm::vec3 normal;
  glm::vec2 tex_coords;
};
 
} // namespace types
 
class mesh
{
public:
  
  std::vector<types::vertex> vertices;
  std::vector<unsigned int> indices;
  std::vector<std::shared_ptr<texture>> textures;
  GLint wrapping;
  GLint filtering_min;
  GLint filtering_mag;
  GLboolean has_mipmap;
  GLint mipmap_min;
  GLint mipmap_mag;
 
  struct config;
  class builder;
  static const config default_config;
  
  mesh(config&& conf);
  
  constexpr mesh(const mesh&) = delete;
  constexpr mesh& operator=(const mesh&) = delete;
 
  constexpr mesh(mesh&&) noexcept = default;
  constexpr mesh& operator=(mesh&&) noexcept = default;
  ~mesh();
 
  void draw(shader::name_t shader_name) const;
 
private:
 
  types::vao vao;
  types::buffer vbo;
  types::buffer ebo;
 
  void init();
};
 
struct mesh::config
{
  std::vector<types::vertex> vertices;
  std::vector<unsigned int> indices;
  std::vector<std::shared_ptr<texture>> textures;
  GLint wrapping;
  GLint filtering_min;
  GLint filtering_mag;
  GLboolean has_mipmap;
  GLint mipmap_min;
  GLint mipmap_max;
};
 
class mesh::builder
{
private:
 
  mesh::config conf = mesh::default_config;
  
public:
  builder &vertices(std::vector<types::vertex> vertices);
  builder &indices(std::vector<unsigned int> indices);
  builder &textures(std::vector<std::shared_ptr<texture>> textures);
  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);
 
  mesh build();
};
 
} // namespace brenta