draw_context_intf.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 "gfx_pipeline_box_vulkan_intf.hpp"
#include "gfx_pipeline_image_vulkan_intf.hpp"
#include "gfx_pipeline_SDF_vulkan_intf.hpp"
#include "gfx_pipeline_override_vulkan_intf.hpp"
#include "../settings/settings.hpp"
#include "../geometry/geometry.hpp"
#include "../unicode/unicode.hpp"
#include "../text/text.hpp"
#include "../color/color.hpp"
#include "../container/container.hpp"
#include "../utility/utility.hpp"
#include "../macros.hpp"
 
hi_export_module(hikogui.GFX : draw_context_intf);
 
hi_export namespace hi { inline namespace v1 {
class gfx_device;
class widget_layout;

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> or std::same_as<Context, int>;

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 corner_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};
            }
            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>) {
            corner_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> or std::is_same_v<T, int>) {
            line_width = narrow_cast<float>(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> or
    std::same_as<Context, aarectangle>;

class draw_context {
public:
    gfx_device *device;

    std::size_t frame_buffer_index;

    aarectangle scissor_rectangle;

    hi::subpixel_orientation subpixel_orientation;

    float saturation;

    utc_nanoseconds display_time_point;
 
    draw_context(draw_context const& rhs) noexcept = default;
    draw_context(draw_context&& rhs) noexcept = default;
    draw_context& operator=(draw_context const& rhs) noexcept = default;
    draw_context& operator=(draw_context&& rhs) noexcept = default;
    ~draw_context() = default;
 
    draw_context(
        gfx_device& device,
        vector_span<gfx_pipeline_box::vertex>& box_vertices,
        vector_span<gfx_pipeline_image::vertex>& image_vertices,
        vector_span<gfx_pipeline_SDF::vertex>& sdf_vertices,
        vector_span<gfx_pipeline_override::vertex>& override_vertices) noexcept;

    operator bool() const noexcept
    {
        return frame_buffer_index != std::numeric_limits<size_t>::max();
    }

    template<std::same_as<widget_layout> WidgetLayout>
    void draw_box(WidgetLayout const& layout, quad const& box, draw_attributes const& attributes) const noexcept
    {
        return _draw_box(
            layout.clipping_rectangle_on_window(attributes.clipping_rectangle), layout.to_window3() * box, attributes);
    }

    template<std::same_as<widget_layout> WidgetLayout, draw_quad_shape Shape, draw_attribute... Attributes>
    void draw_box(WidgetLayout const& layout, Shape const& shape, Attributes const&...attributes) const noexcept
    {
        return draw_box(layout, make_quad(shape), draw_attributes{attributes...});
    }

    template<std::same_as<widget_layout> WidgetLayout>
    void draw_line(WidgetLayout const& layout, line_segment const& line, draw_attributes const& attributes) const noexcept
    {
        auto const 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.corner_radius =
            make_corner_radii(attributes.line_width, attributes.begin_line_cap, attributes.end_line_cap);
        return draw_box(layout, box, box_attributes);
    }

    template<std::same_as<widget_layout> WidgetLayout, draw_attribute... Attributes>
    void draw_line(WidgetLayout const& layout, line_segment const& line, Attributes const&...attributes) const noexcept
    {
        return draw_line(layout, line, draw_attributes{attributes...});
    }

    template<std::same_as<widget_layout> WidgetLayout>
    void draw_circle(WidgetLayout const& layout, hi::circle const& circle, draw_attributes const& attributes) const noexcept
    {
        auto box_attributes = attributes;
        box_attributes.corner_radius = make_corner_radii(circle);
        return draw_box(layout, make_rectangle(circle), box_attributes);
    }

    template<std::same_as<widget_layout> WidgetLayout, draw_attribute... Attributes>
    void draw_circle(WidgetLayout const& layout, hi::circle const& circle, Attributes const&...attributes) const noexcept
    {
        return draw_circle(layout, circle, draw_attributes{attributes...});
    }

    template<std::same_as<widget_layout> WidgetLayout>
    [[nodiscard]] bool
    draw_image(WidgetLayout const& layout, quad const& box, gfx_pipeline_image::paged_image& image, draw_attributes const& attributes) const noexcept
    {
        return _draw_image(layout.clipping_rectangle_on_window(attributes.clipping_rectangle), layout.to_window3() * box, image);
    }

    template<std::same_as<widget_layout> WidgetLayout, draw_attribute... Attributes>
    [[nodiscard]] bool
    draw_image(WidgetLayout const& layout, draw_quad_shape auto const& box, gfx_pipeline_image::paged_image& image, Attributes const&...attributes)
        const noexcept
    {
        return draw_image(layout, make_quad(box), image, draw_attributes{attributes...});
    }

    template<std::same_as<widget_layout> WidgetLayout>
    void draw_glyph(
        WidgetLayout const& layout,
        quad const& box,
        hi::font_id font,
        glyph_id glyph,
        draw_attributes const& attributes) const noexcept
    {
        return _draw_glyph(
            layout.clipping_rectangle_on_window(attributes.clipping_rectangle), layout.to_window3() * box, font, glyph, attributes);
    }

    template<std::same_as<widget_layout> WidgetLayout, draw_quad_shape Shape, draw_attribute... Attributes>
    void draw_glyph(
        WidgetLayout const& layout,
        Shape const& box,
        hi::font_id font,
        hi::glyph_id glyph_id,
        Attributes const&...attributes) const noexcept
    {
        return draw_glyph(layout, make_quad(box), font, glyph_id, draw_attributes{attributes...});
    }

    template<std::same_as<widget_layout> WidgetLayout>
    void draw_glyph(
        WidgetLayout const& layout,
        quad const& box,
        font_glyph_ids const& glyphs,
        draw_attributes const& attributes) const noexcept
    {
        for (auto glyph_id : glyphs) {
            _draw_glyph(
                layout.clipping_rectangle_on_window(attributes.clipping_rectangle), layout.to_window3() * box, glyphs.font, glyph_id, attributes);
        }
    }

    template<std::same_as<widget_layout> WidgetLayout, draw_quad_shape Shape, draw_attribute... Attributes>
    void draw_glyph(
        WidgetLayout const& layout,
        Shape const& box,
        font_glyph_ids const& glyphs,
        Attributes const&...attributes) const noexcept
    {
        for (auto glyph_id : glyphs) {
            draw_glyph(layout, make_quad(box), glyphs.font, glyph_id, draw_attributes{attributes...});
        }
    }

    template<std::same_as<widget_layout> WidgetLayout>
    void
    draw_text(WidgetLayout const& layout, matrix3 const& transform, text_shaper const& text, draw_attributes const& attributes)
        const noexcept
    {
        return _draw_text(
            layout.clipping_rectangle_on_window(attributes.clipping_rectangle),
            layout.to_window3() * transform,
            text,
            attributes);
    }

    template<std::same_as<widget_layout> WidgetLayout, draw_attribute... Attributes>
    void draw_text(WidgetLayout const& layout, matrix3 const& transform, text_shaper const& text, Attributes const&...attributes)
        const noexcept
    {
        return draw_text(layout, transform, text, draw_attributes{attributes...});
    }

    template<std::same_as<widget_layout> WidgetLayout, draw_attribute... Attributes>
    void draw_text(WidgetLayout const& layout, text_shaper const& text, Attributes const&...attributes) const noexcept
    {
        return draw_text(layout, matrix3{}, text, draw_attributes{attributes...});
    }

    template<std::same_as<widget_layout> WidgetLayout>
    void draw_text_selection(
        WidgetLayout const& layout,
        text_shaper const& text,
        text_selection const& selection,
        draw_attributes const& attributes) const noexcept
    {
        return _draw_text_selection(
            layout.clipping_rectangle_on_window(attributes.clipping_rectangle), layout.to_window3(), text, selection, attributes);
    }

    template<std::same_as<widget_layout> WidgetLayout, draw_attribute... Attributes>
    void draw_text_selection(
        WidgetLayout const& layout,
        text_shaper const& text,
        text_selection const& selection,
        Attributes const&...attributes) const noexcept
    {
        return draw_text_selection(layout, text, selection, draw_attributes{attributes...});
    }

    template<std::same_as<widget_layout> WidgetLayout>
    void draw_text_cursors(
        WidgetLayout const& layout,
        text_shaper const& text,
        text_cursor cursor,
        bool overwrite_mode,
        bool dead_character_mode,
        draw_attributes const& attributes) const 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<std::same_as<widget_layout> WidgetLayout, draw_attribute... Attributes>
    void draw_text_cursors(
        WidgetLayout const& layout,
        text_shaper const& text,
        text_cursor cursor,
        bool overwrite_mode,
        bool dead_character_mode,
        Attributes const&...attributes) const noexcept
    {
        return draw_text_cursors(layout, text, cursor, overwrite_mode, dead_character_mode, draw_attributes{attributes...});
    }

    template<std::same_as<widget_layout> WidgetLayout>
    void draw_hole(WidgetLayout const& layout, quad const& box, draw_attributes attributes) const noexcept
    {
        // Override alpha channel.
        attributes.fill_color = color{0.0f, 0.0f, 0.0f, 0.0f};
        attributes.line_color = color{0.0f, 0.0f, 0.0f, 1.0f};
        return _draw_override(
            layout.clipping_rectangle_on_window(attributes.clipping_rectangle), layout.to_window3() * box, attributes);
    }

    template<std::same_as<widget_layout> WidgetLayout, draw_quad_shape Shape, draw_attribute... Attributes>
    void draw_hole(WidgetLayout const& layout, Shape const& box, Attributes const&...attributes) const noexcept
    {
        return draw_hole(layout, make_quad(box), draw_attributes{attributes...});
    }

    template<std::same_as<widget_layout> WidgetLayout>
    [[nodiscard]] friend bool overlaps(draw_context const& context, WidgetLayout const& layout) noexcept
    {
        return overlaps(context.scissor_rectangle, layout.clipping_rectangle_on_window());
    }
 
private:
    vector_span<gfx_pipeline_box::vertex> *_box_vertices;
    vector_span<gfx_pipeline_image::vertex> *_image_vertices;
    vector_span<gfx_pipeline_SDF::vertex> *_sdf_vertices;
    vector_span<gfx_pipeline_override::vertex> *_override_vertices;
 
    template<draw_quad_shape Shape>
    [[nodiscard]] constexpr static quad make_quad(Shape const& shape) noexcept
    {
        if constexpr (std::is_same_v<Shape, quad>) {
            return shape;
        } else {
            return quad{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();
 
        auto const radius = width * 0.5f;
        auto const n = normal(right, 0.0f);
        auto const up = n * width;
        auto const t = normalize(right);
 
        auto origin = line.origin() - n * radius;
 
        // Extend the line by the radius for rounded end-caps.
        auto const 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
    {
        auto const circle_ = f32x4{circle};
        auto const origin = point3{circle_.xyz1() - circle_.ww00()};
        auto const right = vector3{circle_.w000() * f32x4::broadcast(2.0f)};
        auto const up = vector3{circle_._0w00() * f32x4::broadcast(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 = blend<0b0101>(r, f32x4{});
        }
        if (c2 == line_end_cap::flat) {
            r = blend<0b1010>(r, f32x4{});
        }
 
        return corner_radii{r};
    }
 
    [[nodiscard]] constexpr static corner_radii make_corner_radii(hi::circle const& circle) noexcept
    {
        return corner_radii{f32x4{circle}.wwww()};
    }
 
    void _draw_override(aarectangle const& clipping_rectangle, quad box, draw_attributes const& attributes) const noexcept;
 
    void _draw_box(aarectangle const& clipping_rectangle, quad box, draw_attributes const& attributes) const noexcept;
 
    void _draw_text(
        aarectangle const& clipping_rectangle,
        matrix3 const& transform,
        text_shaper const& text,
        draw_attributes const& attributes) const noexcept;
 
    void _draw_text_selection(
        aarectangle const& clipping_rectangle,
        matrix3 const& transform,
        text_shaper const& text,
        text_selection const& selection,
        draw_attributes const& attributes) const noexcept;
 
    void _draw_text_insertion_cursor_empty(
        aarectangle const& clipping_rectangle,
        matrix3 const& transform,
        text_shaper const& text,
        draw_attributes const& attributes) const 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) const noexcept;
 
    void _draw_text_overwrite_cursor(
        aarectangle const& clipping_rectangle,
        matrix3 const& transform,
        text_shaper::char_const_iterator it,
        draw_attributes const& attributes) const 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) const noexcept;
 
    void _draw_glyph(
        aarectangle const& clipping_rectangle,
        quad const& box,
        hi::font_id font,
        glyph_id glyph,
        draw_attributes const& attributes) const noexcept;
 
    [[nodiscard]] bool
    _draw_image(aarectangle const& clipping_rectangle, quad const& box, gfx_pipeline_image::paged_image const& image) const noexcept;
};
 
}} // namespace hi::v1