widget_draw_context.hpp

// Copyright Take Vos 2020-2022.
// Distributed under the Boost Software License, Version 1.0.
// (See accompanying file LICENSE_1_0.txt or copy at https://www.boost.org/LICENSE_1_0.txt)
 
#pragma once
 
#include "widget_layout.hpp"
#include "../GFX/module.hpp"
#include "../geometry/module.hpp"
#include "../unicode/module.hpp"
#include "../text/module.hpp"
#include "../font/module.hpp"
#include "../color/module.hpp"
#include "../utility/module.hpp"
#include "../vector_span.hpp"
 
namespace hi { inline namespace v1 {
struct paged_image;
 
enum class border_side {
    on,
 
    inside,
 
    outside
};
 
template<typename Context>
concept draw_attribute =
    std::same_as<Context, quad_color> or std::same_as<Context, color> or std::same_as<Context, border_side> or
    std::same_as<Context, line_end_cap> or std::same_as<Context, corner_radii> or
    std::same_as<Context, aarectangle> or std::same_as<Context, float>;
 
struct draw_attributes {
    unsigned char num_colors = 0;
    unsigned char num_line_caps = 0;
 
    quad_color fill_color = {};
 
    quad_color line_color = {};
 
    float line_width = 0.0f;
 
    hi::border_side border_side = hi::border_side::on;
 
    hi::corner_radii border_radius = {};
 
    aarectangle clipping_rectangle = aarectangle::large();
 
    line_end_cap begin_line_cap = line_end_cap::flat;
 
    line_end_cap end_line_cap = line_end_cap::flat;
 
    constexpr draw_attributes(draw_attributes const&) noexcept = default;
    constexpr draw_attributes(draw_attributes&&) noexcept = default;
    constexpr draw_attributes& operator=(draw_attributes const&) noexcept = default;
    constexpr draw_attributes& operator=(draw_attributes&&) noexcept = default;
    constexpr draw_attributes() noexcept = default;
 
    template<draw_attribute... Args>
    constexpr draw_attributes(Args const&...args) noexcept
    {
        add(args...);
    }
 
    constexpr void add() noexcept {}
 
    template<draw_attribute T>
    constexpr void add(T const& attribute) noexcept
    {
        if constexpr (std::is_same_v<T, quad_color>) {
            if (num_colors++ == 0) {
                fill_color = attribute;
            } else {
                line_color = attribute;
            }
            hi_axiom(num_colors <= 2);
 
        } else if constexpr (std::is_same_v<T, color>) {
            if (num_colors++ == 0) {
                fill_color = quad_color{attribute};
            } else {
                line_color = quad_color{attribute};
            }
            // XXX Handle 4 colors.
            // hi_axiom(num_colors <= 2);
 
        } else if constexpr (std::is_same_v<T, line_end_cap>) {
            if (num_line_caps++ == 0) {
                begin_line_cap = attribute;
                end_line_cap = attribute;
            } else {
                end_line_cap = attribute;
            }
            hi_axiom(num_line_caps <= 2);
 
        } else if constexpr (std::is_same_v<T, hi::border_side>) {
            border_side = attribute;
#ifndef NDEBUG
            hi_assert(not _has_border_side);
            _has_border_side = true;
#endif
 
        } else if constexpr (std::is_same_v<T, corner_radii>) {
            border_radius = attribute;
#ifndef NDEBUG
            hi_assert(not _has_corner_radii);
            _has_corner_radii = true;
#endif
 
        } else if constexpr (std::is_same_v<T, aarectangle>) {
            clipping_rectangle = attribute;
#ifndef NDEBUG
            hi_assert(not _has_clipping_rectangle);
            _has_clipping_rectangle = true;
#endif
 
        } else if constexpr (std::is_same_v<T, float>) {
            line_width = attribute;
#ifndef NDEBUG
            hi_assert(not _has_line_width);
            _has_line_width = true;
#endif
        } else {
            hi_static_no_default();
        }
    }
 
    template<draw_attribute First, draw_attribute Second, draw_attribute... Rest>
    constexpr void add(First const& first, Second const& second, Rest const&...rest) noexcept
    {
        add(first);
        add(second, rest...);
    }
 
private:
#ifndef NDEBUG
    bool _has_border_side = false;
    bool _has_corner_radii = false;
    bool _has_clipping_rectangle = false;
    bool _has_line_width = false;
#endif
};
 
template<typename Context>
concept draw_quad_shape = std::same_as<Context, quad> or std::same_as<Context, rectangle> or std::same_as<Context, aarectangle>;
 
class widget_draw_context {
public:
    gfx_draw_context gfx_context;
 
    utc_nanoseconds display_time_point;
 
    widget_draw_context(widget_draw_context& rhs) noexcept = delete;
    widget_draw_context(widget_draw_context&& rhs) noexcept = default;
    widget_draw_context& operator=(widget_draw_context& rhs) noexcept = delete;
    widget_draw_context& operator=(widget_draw_context&& rhs) noexcept = default;
    ~widget_draw_context() = default;
 
    widget_draw_context(gfx_draw_context&& gfx_context) noexcept : gfx_context(std::move(gfx_context)) {}
 
    void draw_box(widget_layout const& layout, quad const& box, draw_attributes const& attributes) noexcept
    {
        return _draw_box(
            layout.clipping_rectangle_on_window(attributes.clipping_rectangle), layout.to_window3() * box, attributes);
    }
 
    template<draw_quad_shape Shape, draw_attribute... Attributes>
    void draw_box(widget_layout const& layout, Shape const& shape, Attributes const&...attributes) noexcept
    {
        return draw_box(layout, make_quad(shape), draw_attributes{attributes...});
    }
 
    void draw_line(widget_layout const& layout, line_segment const& line, draw_attributes const& attributes) noexcept
    {
        hilet box = make_rectangle(line, attributes.line_width, attributes.begin_line_cap, attributes.end_line_cap);
 
        auto box_attributes = attributes;
        box_attributes.line_width = 0.0f;
        box_attributes.border_radius =
            make_corner_radii(attributes.line_width, attributes.begin_line_cap, attributes.end_line_cap);
        return draw_box(layout, box, box_attributes);
    }
 
    template<draw_attribute... Attributes>
    void draw_line(widget_layout const& layout, line_segment const& line, Attributes const&...attributes) noexcept
    {
        return draw_line(layout, line, draw_attributes{attributes...});
    }
 
    void draw_circle(widget_layout const& layout, hi::circle const& circle, draw_attributes const& attributes) noexcept
    {
        auto box_attributes = attributes;
        box_attributes.border_radius = make_corner_radii(circle);
        return draw_box(layout, make_rectangle(circle), box_attributes);
    }
 
    template<draw_attribute... Attributes>
    void draw_circle(widget_layout const& layout, hi::circle const& circle, Attributes const&...attributes) noexcept
    {
        return draw_circle(layout, circle, draw_attributes{attributes...});
    }
 
    [[nodiscard]] bool
    draw_image(widget_layout const& layout, quad const& box, paged_image& image, draw_attributes const& attributes) noexcept
    {
        return _draw_image(layout.clipping_rectangle_on_window(attributes.clipping_rectangle), layout.to_window3() * box, image);
    }
 
    template<draw_attribute... Attributes>
    [[nodiscard]] bool
    draw_image(widget_layout const& layout, draw_quad_shape auto const& box, paged_image& image, Attributes const&...attributes)
        noexcept
    {
        return draw_image(layout, make_quad(box), image, draw_attributes{attributes...});
    }
 
    void draw_glyph(
        widget_layout const& layout,
        quad const& box,
        hi::font const& font,
        glyph_id glyph,
        draw_attributes const& attributes) noexcept
    {
        return _draw_glyph(
            layout.clipping_rectangle_on_window(attributes.clipping_rectangle),
            layout.to_window3() * box,
            font,
            glyph,
            attributes);
    }
 
    template<draw_quad_shape Shape, draw_attribute... Attributes>
    void draw_glyph(
        widget_layout const& layout,
        Shape const& box,
        hi::font const& font,
        glyph_id glyph,
        Attributes const&...attributes) noexcept
    {
        return draw_glyph(layout, make_quad(box), font, glyph, draw_attributes{attributes...});
    }
 
    void draw_glyph(
        widget_layout const& layout,
        quad const& box,
        font_book::font_glyph_type font_glyph,
        draw_attributes const& attributes) noexcept
    {
        return _draw_glyph(
            layout.clipping_rectangle_on_window(attributes.clipping_rectangle),
            layout.to_window3() * box,
            *font_glyph.font,
            font_glyph.glyph,
            attributes);
    }
 
    template<draw_quad_shape Shape, draw_attribute... Attributes>
    void draw_glyph(
        widget_layout const& layout,
        Shape const& box,
        font_book::font_glyph_type font_glyph,
        Attributes const&...attributes) noexcept
    {
        return draw_glyph(layout, make_quad(box), font_glyph, draw_attributes{attributes...});
    }
 
    void
    draw_text(widget_layout const& layout, matrix3 const& transform, text_shaper const& text, draw_attributes const& attributes)
        noexcept
    {
        return _draw_text(
            layout.clipping_rectangle_on_window(attributes.clipping_rectangle),
            layout.to_window3() * transform,
            text,
            attributes);
    }
 
    template<draw_attribute... Attributes>
    void draw_text(widget_layout const& layout, matrix3 const& transform, text_shaper const& text, Attributes const&...attributes)
        noexcept
    {
        return draw_text(layout, transform, text, draw_attributes{attributes...});
    }
 
    template<draw_attribute... Attributes>
    void draw_text(widget_layout const& layout, text_shaper const& text, Attributes const&...attributes) noexcept
    {
        return draw_text(layout, geo::identity{}, text, draw_attributes{attributes...});
    }
 
    void draw_text_selection(
        widget_layout const& layout,
        text_shaper const& text,
        text_selection const& selection,
        draw_attributes const& attributes) noexcept
    {
        return _draw_text_selection(
            layout.clipping_rectangle_on_window(attributes.clipping_rectangle), layout.to_window3(), text, selection, attributes);
    }
 
    template<draw_attribute... Attributes>
    void draw_text_selection(
        widget_layout const& layout,
        text_shaper const& text,
        text_selection const& selection,
        Attributes const&...attributes) noexcept
    {
        return draw_text_selection(layout, text, selection, draw_attributes{attributes...});
    }
 
    void draw_text_cursors(
        widget_layout const& layout,
        text_shaper const& text,
        text_cursor cursor,
        bool overwrite_mode,
        bool dead_character_mode,
        draw_attributes const& attributes) noexcept
    {
        return _draw_text_cursors(
            layout.clipping_rectangle_on_window(attributes.clipping_rectangle),
            layout.to_window3(),
            text,
            cursor,
            overwrite_mode,
            dead_character_mode,
            attributes);
    }
 
    template<draw_attribute... Attributes>
    void draw_text_cursors(
        widget_layout const& layout,
        text_shaper const& text,
        text_cursor cursor,
        bool overwrite_mode,
        bool dead_character_mode,
        Attributes const&...attributes) noexcept
    {
        return draw_text_cursors(layout, text, cursor, overwrite_mode, dead_character_mode, draw_attributes{attributes...});
    }
 
    void draw_hole(widget_layout const& layout, quad const& box, draw_attributes const& attributes) noexcept
    {
        return _override_alpha(
            layout.clipping_rectangle_on_window(attributes.clipping_rectangle), layout.to_window3() * box, attributes);
    }
 
    template<draw_quad_shape Shape, draw_attribute... Attributes>
    void draw_hole(widget_layout const& layout, Shape const& box, Attributes const&...attributes) noexcept
    {
        return draw_hole(layout, make_quad(box), draw_attributes{attributes...});
    }
 
    [[nodiscard]] friend bool overlaps(widget_draw_context const& context, widget_layout const& layout) noexcept
    {
        return overlaps(context.gfx_context.scissor_rectangle, layout.clipping_rectangle_on_window());
    }
 
private:
    template<draw_quad_shape Shape>
    [[nodiscard]] constexpr static quad make_quad(Shape const& shape) noexcept
    {
        if constexpr (std::is_same_v<Shape, aarectangle>) {
            return narrow_cast<aarectangle>(shape);
        } else {
            return shape;
        }
    }
 
    [[nodiscard]] constexpr static rectangle
    make_rectangle(line_segment const& line, float width, line_end_cap c1, line_end_cap c2) noexcept
    {
        auto right = line.direction();
 
        hilet radius = width * 0.5f;
        hilet n = normal(right, 0.0f);
        hilet up = n * width;
        hilet t = normalize(right);
 
        auto origin = line.origin() - n * radius;
 
        // Extend the line by the radius for rounded end-caps.
        hilet radius_offset = t * radius;
        if (c1 == line_end_cap::round) {
            origin -= radius_offset;
            right += radius_offset;
        }
        if (c2 == line_end_cap::round) {
            right += radius_offset;
        }
 
        return rectangle{origin, right, up};
    }
 
    [[nodiscard]] constexpr static rectangle make_rectangle(hi::circle const& circle) noexcept
    {
        hilet circle_ = f32x4{circle};
        hilet origin = point3{circle_.xyz1() - circle_.ww00()};
        hilet right = vector3{circle_.w000() * 2.0f};
        hilet up = vector3{circle_._0w00() * 2.0f};
        return rectangle{origin, right, up};
    }
 
    [[nodiscard]] constexpr static corner_radii make_corner_radii(float width, line_end_cap c1, line_end_cap c2) noexcept
    {
        auto r = f32x4::broadcast(width * 0.5f);
 
        if (c1 == line_end_cap::flat) {
            r = set_zero<0b0101>(r);
        }
        if (c2 == line_end_cap::flat) {
            r = set_zero<0b1010>(r);
        }
 
        return corner_radii{r};
    }
 
    [[nodiscard]] constexpr static corner_radii make_corner_radii(hi::circle const& circle) noexcept
    {
        return corner_radii{f32x4{circle}.wwww()};
    }
 
    void _override_alpha(aarectangle const& clipping_rectangle, quad box, draw_attributes const& attributes) noexcept;
 
    void _draw_box(aarectangle const& clipping_rectangle, quad box, draw_attributes const& attributes) noexcept;
 
    void _draw_text(
        aarectangle const& clipping_rectangle,
        matrix3 const& transform,
        text_shaper const& text,
        draw_attributes const& attributes) noexcept;
 
    void _draw_text_selection(
        aarectangle const& clipping_rectangle,
        matrix3 const& transform,
        text_shaper const& text,
        text_selection const& selection,
        draw_attributes const& attributes) noexcept;
 
    void _draw_text_insertion_cursor_empty(
        aarectangle const& clipping_rectangle,
        matrix3 const& transform,
        text_shaper const& text,
        draw_attributes const& attributes) noexcept;
 
    void _draw_text_insertion_cursor(
        aarectangle const& clipping_rectangle,
        matrix3 const& transform,
        text_shaper const& text,
        text_cursor cursor,
        bool show_flag,
        draw_attributes const& attributes) noexcept;
 
    void _draw_text_overwrite_cursor(
        aarectangle const& clipping_rectangle,
        matrix3 const& transform,
        text_shaper::char_const_iterator it,
        draw_attributes const& attributes) noexcept;
 
    void _draw_text_cursors(
        aarectangle const& clipping_rectangle,
        matrix3 const& transform,
        text_shaper const& text,
        text_cursor cursor,
        bool overwrite_mode,
        bool dead_character_mode,
        draw_attributes const& attributes) noexcept;
 
    void _draw_glyph(
        aarectangle const& clipping_rectangle,
        quad const& box,
        hi::font const& font,
        glyph_id const& glyph,
        draw_attributes const& attributes) noexcept;
 
    [[nodiscard]] bool
    _draw_image(aarectangle const& clipping_rectangle, quad const& box, paged_image const& image) noexcept;
};
 
}} // namespace hi::v1