gui_renderer.hpp

#ifndef LXGUI_GUI_RENDERER_HPP
#define LXGUI_GUI_RENDERER_HPP
 
#include "lxgui/gui_code_point_range.hpp"
#include "lxgui/gui_material.hpp"
#include "lxgui/gui_matrix4.hpp"
#include "lxgui/gui_vertex_cache.hpp"
#include "lxgui/lxgui.hpp"
 
#include <array>
#include <memory>
#include <string>
#include <unordered_map>
#include <vector>
 
namespace lxgui::gui {
 
class font;
class atlas;
class render_target;
class color;
struct quad;
struct vertex;
 
class renderer {
public:
    renderer() = default;
 
    renderer(const renderer&) = delete;
 
    renderer(renderer&&) = delete;
 
    renderer& operator=(const renderer&) = delete;
 
    renderer& operator=(renderer&&) = delete;
 
    virtual ~renderer() = default;
 
    virtual std::string get_name() const = 0;
 
    virtual bool is_texture_vertex_color_supported() const = 0;
 
    bool is_quad_batching_enabled() const;
 
    void set_quad_batching_enabled(bool enabled);
 
    virtual std::size_t get_texture_max_size() const = 0;
 
    virtual bool is_texture_atlas_supported() const = 0;
 
    bool is_texture_atlas_enabled() const;
 
    void set_texture_atlas_enabled(bool enabled);
 
    std::size_t get_texture_atlas_page_size() const;
 
    void set_texture_atlas_page_size(std::size_t page_size);
 
    std::size_t get_texture_atlas_page_count() const;
 
    virtual bool is_vertex_cache_supported() const = 0;
 
    bool is_vertex_cache_enabled() const;
 
    void set_vertex_cache_enabled(bool enabled);
 
    void auto_detect_settings();
 
    void reset_counters();
 
    std::size_t get_batch_count() const;
 
    std::size_t get_vertex_count() const;
 
    void begin(std::shared_ptr<render_target> target = nullptr);
 
    void end();
 
    void flush_quad_batch();
 
    void set_view(const matrix4f& view_matrix);
 
    virtual matrix4f get_view() const = 0;
 
    void render_quad(const quad& q);
 
    void render_quads(const material* mat, const std::vector<std::array<vertex, 4>>& quad_list);
 
    void render_cache(
        const material*     mat,
        const vertex_cache& cache,
        const matrix4f&     model_transform = matrix4f::identity);
 
    std::shared_ptr<material>
    create_material(const std::string& file_name, material::filter filt = material::filter::none);
 
    std::shared_ptr<material> create_atlas_material(
        const std::string& atlas_category,
        const std::string& file_name,
        material::filter   filt = material::filter::none);
 
    virtual std::shared_ptr<material>
    create_material(std::shared_ptr<render_target> target, const bounds2f& location) = 0;
 
    std::shared_ptr<material> create_material(std::shared_ptr<render_target> target);
 
    virtual std::shared_ptr<material> create_material(
        const vector2ui& dimensions,
        const color32*   pixel_data,
        material::filter filt = material::filter::none) = 0;
 
    virtual std::shared_ptr<render_target> create_render_target(
        const vector2ui& dimensions, material::filter filt = material::filter::none) = 0;
 
    std::shared_ptr<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);
 
    std::shared_ptr<font> create_atlas_font(
        const std::string&                   atlas_category,
        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);
 
    virtual std::shared_ptr<vertex_cache> create_vertex_cache(gui::vertex_cache::type type) = 0;
 
    virtual void notify_window_resized(const vector2ui& dimensions);
 
protected:
    virtual void begin_(std::shared_ptr<render_target> target) = 0;
 
    virtual void end_() = 0;
 
    virtual void set_view_(const matrix4f& view_matrix) = 0;
 
    virtual void
    render_quads_(const material* mat, const std::vector<std::array<vertex, 4>>& quad_list) = 0;
 
    virtual void render_cache_(
        const material* mat, const vertex_cache& cache, const matrix4f& model_transform) = 0;
 
    virtual std::shared_ptr<material>
    create_material_(const std::string& file_name, material::filter filt) = 0;
 
    virtual std::shared_ptr<atlas> create_atlas_(material::filter filt) = 0;
 
    virtual std::shared_ptr<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) = 0;
 
    atlas& get_atlas_(const std::string& atlas_category, material::filter filt);
 
    std::unordered_map<std::string, std::weak_ptr<gui::material>> texture_list_;
    std::unordered_map<std::string, std::shared_ptr<gui::atlas>>  atlas_list_;
    std::unordered_map<std::string, std::weak_ptr<gui::font>>     font_list_;
 
private:
    bool uses_same_texture_(const material* mat1, const material* mat2) const;
 
    bool        texture_atlas_enabled_   = true;
    bool        vertex_cache_enabled_    = true;
    bool        quad_batching_enabled_   = true;
    std::size_t texture_atlas_page_size_ = 0u;
 
    struct quad_batcher {
        std::vector<std::array<vertex, 4>> data;
        std::shared_ptr<vertex_cache>      cache;
    };
 
    static constexpr std::size_t                        batching_cache_cycle_size = 16u;
    std::array<quad_batcher, batching_cache_cycle_size> quad_cache_;
 
    const gui::material* current_material_        = nullptr;
    std::size_t          current_quad_cache_      = 0u;
    std::size_t          batch_count_             = 0u;
    std::size_t          vertex_count_            = 0u;
    std::size_t          last_frame_batch_count_  = 0u;
    std::size_t          last_frame_vertex_count_ = 0u;
};
 
} // namespace lxgui::gui
 
#endif