gui_gl_renderer.hpp

#ifndef LXGUI_GUI_GL_RENDERER_HPP
#define LXGUI_GUI_GL_RENDERER_HPP
 
#include "lxgui/impl/gui_gl_render_target.hpp"
#if defined(LXGUI_OPENGL3)
#    include "lxgui/impl/gui_gl_vertex_cache.hpp"
#endif
 
#include "lxgui/gui_matrix4.hpp"
#include "lxgui/gui_renderer.hpp"
#include "lxgui/utils.hpp"
 
#include <array>
#include <cstdint>
#include <limits>
#include <memory>
 
namespace lxgui::gui::gl {
 
class renderer final : public gui::renderer {
public:
    explicit renderer(const vector2ui& window_dimensions, bool init_glew = true);
 
    std::string get_name() const override;
 
    matrix4f get_view() const override;
 
    std::size_t get_texture_max_size() const override;
 
    bool is_texture_atlas_supported() const override;
 
    bool is_texture_vertex_color_supported() const override;
 
    std::shared_ptr<gui::material> create_material(
        const vector2ui& dimensions,
        const color32*   pixel_data,
        material::filter filt = material::filter::none) override;
 
    std::shared_ptr<gui::material>
    create_material(std::shared_ptr<gui::render_target> target, const bounds2f& location) override;
 
    std::shared_ptr<gui::render_target> create_render_target(
        const vector2ui& dimensions, material::filter filt = material::filter::none) override;
 
    bool is_vertex_cache_supported() const override;
 
    std::shared_ptr<gui::vertex_cache> create_vertex_cache(gui::vertex_cache::type type) override;
 
    void notify_window_resized(const vector2ui& new_dimensions) override;
 
#if !defined(LXGUI_OPENGL3)
    static bool is_gl_extension_supported(const std::string& extension);
#endif
 
protected:
    std::shared_ptr<gui::material>
    create_material_(const std::string& file_name, material::filter filt) override;
 
    std::shared_ptr<gui::atlas> create_atlas_(material::filter filt) override;
 
    std::shared_ptr<gui::font> create_font_(
        const std::string&                   font_file,
        std::size_t                          size,
        std::size_t                          outline,
        const std::vector<code_point_range>& code_points,
        char32_t                             default_code_point) override;
 
    void begin_(std::shared_ptr<gui::render_target> target) override;
 
    void end_() override;
 
    void set_view_(const matrix4f& view_matrix) override;
 
    void render_quads_(
        const gui::material* mat, const std::vector<std::array<vertex, 4>>& quad_list) override;
 
    void render_cache_(
        const gui::material*     mat,
        const gui::vertex_cache& cache,
        const matrix4f&          model_transform) override;
 
private:
    void update_view_matrix_() const;
#if defined(LXGUI_OPENGL3)
    void compile_programs_();
    void setup_buffers_();
#endif
 
    std::shared_ptr<gui::material>
    create_material_png_(const std::string& file_name, material::filter filt) const;
 
    vector2ui window_dimensions_;
 
    std::shared_ptr<gui::gl::render_target> current_target_;
    matrix4f                                current_view_matrix_ = matrix4f::identity;
 
#if defined(LXGUI_OPENGL3)
    struct shader_cache {
        shader_cache()                    = default;
        shader_cache(const shader_cache&) = delete;
        shader_cache(shader_cache&&)      = delete;
        ~shader_cache();
 
        std::uint32_t program          = 0;
        int           sampler_location = 0;
        int           proj_location    = 0;
        int           model_location   = 0;
        int           type_location    = 0;
    };
 
    static thread_local std::weak_ptr<shader_cache> static_shader_cache;
    std::shared_ptr<shader_cache>                   shader_cache_;
 
    static constexpr std::size_t                                    cache_cycle_size = 1024u;
    std::array<std::shared_ptr<gl::vertex_cache>, cache_cycle_size> quad_cache_;
    std::array<std::shared_ptr<gl::vertex_cache>, cache_cycle_size> array_cache_;
    std::uint32_t                                                   quad_cycle_cache_  = 0u;
    std::uint32_t                                                   array_cycle_cache_ = 0u;
 
    std::uint32_t previous_texture_ = std::numeric_limits<std::uint32_t>::max();
#endif
};
 
} // namespace lxgui::gui::gl
 
#endif