gui_texture.hpp

#ifndef LXGUI_GUI_TEXTURE_HPP
#define LXGUI_GUI_TEXTURE_HPP
 
#include "lxgui/gui_gradient.hpp"
#include "lxgui/gui_layered_region.hpp"
#include "lxgui/gui_quad.hpp"
#include "lxgui/lxgui.hpp"
#include "lxgui/utils.hpp"
 
#include <limits>
#include <variant>
 
namespace lxgui::gui {
 
class renderer;
class render_target;
 
class texture : public layered_region {
public:
    using base = layered_region;
 
    enum class blend_mode { none, blend, key, add, mod };
 
    explicit texture(utils::control_block& block, manager& mgr, const region_core_attributes& attr);
 
    std::string serialize(const std::string& tab) const override;
 
    void render() const override;
 
    void copy_from(const region& obj) override;
 
    blend_mode get_blend_mode() const;
 
    material::filter get_filter_mode() const;
 
    bool has_solid_color() const;
 
    const color& get_solid_color() const;
 
    bool has_gradient() const;
 
    const gradient& get_gradient() const;
 
    std::array<float, 8> get_tex_coord() const;
 
    bool get_texture_stretching() const;
 
    bool has_texture_file() const;
 
    const std::string& get_texture_file() const;
 
    color get_vertex_color(std::size_t index) const;
 
    bool is_desaturated() const;
 
    void set_blend_mode(blend_mode mode);
 
    void set_filter_mode(material::filter filt);
 
    void set_desaturated(bool is_desaturated);
 
    void set_gradient(const gradient& g);
 
    void set_tex_rect(const std::array<float, 4>& texture_rect);
 
    void set_tex_coord(const std::array<float, 8>& texture_coords);
 
    void set_texture_stretching(bool texture_stretching);
 
    void set_texture(const std::string& file_name);
 
    void set_texture(std::shared_ptr<render_target> target);
 
    void set_solid_color(const color& c);
 
    void set_quad(const quad& q);
 
    void
    set_vertex_color(const color& c, std::size_t index = std::numeric_limits<std::size_t>::max());
 
    void parse_layout(const layout_node& node) override;
 
    static void register_on_lua(sol::state& lua);
 
    static constexpr const char* class_name = "Texture";
 
private:
    void parse_attributes_(const layout_node& node) override;
    void parse_tex_coords_node_(const layout_node& node);
    void parse_gradient_node_(const layout_node& node);
 
    const std::vector<std::string>& get_type_list_() const override;
 
    void update_dimensions_from_tex_coord_();
    void update_borders_() override;
 
    using content    = std::variant<color, std::string, gradient>;
    content content_ = color::white;
 
    blend_mode       blend_mode_                    = blend_mode::blend;
    material::filter filter_                        = material::filter::none;
    bool             is_desaturated_                = false;
    bool             is_texture_stretching_enabled_ = true;
 
    renderer& renderer_;
    quad      quad_;
};
 
} // namespace lxgui::gui
 
#endif