helpers.hpp

Go to the documentation of this file.

#pragma once
 
#include <glad/glad.h>
#include <GLFW/glfw3.h>
#include <glm/glm.hpp>
 
#include "core/FPSCamera.h" // As it includes OpenGL headers, import it after glad
 
#include <functional>
#include <string>
#include <vector>
#include <unordered_map>
 
namespace bonobo
{
    enum class shader_bindings : unsigned int{
        vertices = 0u, 
        normals,       
        texcoords,     
        tangents,      
        binormals      
    };
 
    using texture_bindings = std::unordered_map<std::string, GLuint>;
 
    struct material_data {
        glm::vec3 diffuse{ 0.0f };
        glm::vec3 specular{ 0.0f };
        glm::vec3 ambient{ 0.0f };
        glm::vec3 emissive{ 0.0f };
        float shininess{ 0.0f };
        float indexOfRefraction{ 1.0f };
        float opacity{ 1.0f };
    };
 
    struct mesh_data {
        GLuint vao{0u};                          
        GLuint bo{0u};                           
        GLuint ibo{0u};                          
        GLsizei vertices_nb{0};                  
        GLsizei indices_nb{0};                   
        texture_bindings bindings{};             
        material_data material{};                
        GLenum drawing_mode{GL_TRIANGLES};       
        std::string name{"un-named mesh"};       
    };
 
    enum class cull_mode_t : unsigned int {
        disabled = 0u,
        back_faces,
        front_faces
    };
 
    enum class polygon_mode_t : unsigned int {
        fill = 0u,
        line,
        point
    };
 
    void init();
 
    void deinit();
 
    std::vector<mesh_data> loadObjects(std::string const& filename);
 
    GLuint createTexture(uint32_t width, uint32_t height,
                         GLenum target = GL_TEXTURE_2D,
                         GLint internal_format = GL_RGBA,
                         GLenum format = GL_RGBA,
                         GLenum type = GL_UNSIGNED_BYTE,
                         GLvoid const* data = nullptr);
 
    GLuint loadTexture2D(std::string const& filename,
                         bool generate_mipmap = true);
 
    GLuint loadTextureCubeMap(std::string const& posx, std::string const& negx,
                                  std::string const& posy, std::string const& negy,
                                  std::string const& posz, std::string const& negz,
                                  bool generate_mipmap = true);
 
    GLuint createProgram(std::string const& vert_shader_source_path,
                         std::string const& frag_shader_source_path);
 
    void displayTexture(glm::vec2 const& lower_left,
                        glm::vec2 const& upper_right, GLuint texture,
                        GLuint sampler, glm::ivec4 const& swizzle,
                        glm::ivec2 const& window_size, bool linearise = false,
                        float nearPlane = 0.0f, float farPlane = 0.0f);
 
    GLuint createFBO(std::vector<GLuint> const& color_attachments,
                     GLuint depth_attachment = 0u);
 
    GLuint createSampler(std::function<void (GLuint)> const& setup);
 
    void drawFullscreen();
 
    GLuint getDebugTextureID();
 
    void renderBasis(float thickness_scale, float length_scale, glm::mat4 const& view_projection, glm::mat4 const& world = glm::mat4(1.0f));
 
    bool uiSelectCullMode(std::string const& label, enum cull_mode_t& cull_mode) noexcept;
 
    void changeCullMode(enum cull_mode_t const cull_mode) noexcept;
 
    bool uiSelectPolygonMode(std::string const& label, enum polygon_mode_t& polygon_mode) noexcept;
 
    void changePolygonMode(enum polygon_mode_t const polygon_mode) noexcept;
}