mesh.hpp

Go to the documentation of this file.

 
#pragma once
 
#include "lmgl/renderer/shader.hpp"
#include "lmgl/renderer/vertex_array.hpp"
#include "lmgl/scene/frustum.hpp"
#include "lmgl/scene/material.hpp"
 
#include <memory>
 
namespace lmgl {
 
namespace scene {

struct Vertex {

    glm::vec3 position;

    glm::vec3 normal;

    glm::vec4 color;

    glm::vec2 uvs;

    glm::vec3 tangent;

    glm::vec3 bitangent;

    Vertex(const glm::vec3 &pos = glm::vec3(0.0f), const glm::vec3 &norm = glm::vec3(0.0f, 1.0f, 0.0f),
           const glm::vec4 &col = glm::vec4(1.0f), const glm::vec2 &uv = glm::vec2(0.0f))
        : position(pos), normal(norm), color(col), uvs(uv) {}
};

class Mesh {
  public:
    Mesh(const std::vector<Vertex> &vert, const std::vector<unsigned int> &indices,
         std::shared_ptr<renderer::Shader> shader);

    Mesh(std::shared_ptr<renderer::VertexArray> vao, std::shared_ptr<renderer::Shader> shader, unsigned int idx_count);

    ~Mesh() = default;

    void bind() const;

    void unbind() const;

    void render() const;

    inline std::shared_ptr<renderer::VertexArray> get_vertex_array() const { return m_vertex_array; }

    inline std::shared_ptr<renderer::Shader> get_shader() const { return m_shader; }

    inline void set_shader(std::shared_ptr<renderer::Shader> shader) { m_shader = shader; }

    inline unsigned int get_index_count() const { return m_index_count; }

    inline const std::vector<Vertex> &get_vertices() const { return m_vertices; }

    inline const std::vector<unsigned int> &get_indices() const { return m_indices; }

    inline bool has_vert_data() const { return !m_vertices.empty() && !m_indices.empty(); }

    inline std::shared_ptr<Material> get_material() const { return m_material; }

    inline void set_material(std::shared_ptr<Material> material) { m_material = material; }

    inline const AABB &get_bounding_box() const { return m_bounding_box; }

    inline const BoundingSphere &get_bounding_sphere() const { return m_bounding_sphere; }
 
    // Factory Methods

    static std::shared_ptr<Mesh> create_cube(std::shared_ptr<renderer::Shader> shader, unsigned int subdivs = 1);

    static std::shared_ptr<Mesh> create_quad(std::shared_ptr<renderer::Shader> shader, float width = 1.0f,
                                             float height = 1.0f);

    static std::shared_ptr<Mesh> create_sphere(std::shared_ptr<renderer::Shader> shader, float radius = 0.5f,
                                               unsigned int lonsegs = 32, unsigned int latsegs = 32);
 
  private:
    std::shared_ptr<Material> m_material;

    std::shared_ptr<renderer::VertexArray> m_vertex_array;

    std::shared_ptr<renderer::Shader> m_shader;

    unsigned int m_index_count;

    std::vector<Vertex> m_vertices;

    std::vector<unsigned int> m_indices;

    AABB m_bounding_box;

    BoundingSphere m_bounding_sphere;

    void setup_mesh();

    void calculate_bounds();
};
 
} // namespace scene
} // namespace lmgl