draw_context.hpp

// Copyright Take Vos 2020.
// 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 "pipeline_box_vertex.hpp"
#include "pipeline_image_vertex.hpp"
#include "pipeline_SDF_vertex.hpp"
#include "subpixel_orientation.hpp"
#include "../geometry/axis_aligned_rectangle.hpp"
#include "../geometry/matrix.hpp"
#include "../geometry/corner_radii.hpp"
#include "../geometry/identity.hpp"
#include "../geometry/transform.hpp"
#include "../geometry/circle.hpp"
#include "../geometry/line_end_cap.hpp"
#include "../text/text_cursor.hpp"
#include "../text/text_selection.hpp"
#include "../text/text_shaper.hpp"
#include "../color/color.hpp"
#include "../color/quad_color.hpp"
#include "../widgets/widget_layout.hpp"
#include "../vspan.hpp"
 
namespace hi::inline v1 {
class gfx_device;
class gfx_device_vulkan;
class shaped_text;
class glyph_ids;
struct paged_image;
 
enum class border_side {
    on,
 
    inside,
 
    outside
};
 
class draw_context {
public:
    gfx_device_vulkan &device;
 
    std::size_t frame_buffer_index;
 
    aarectangle scissor_rectangle;
 
    color background_color;
 
    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_vulkan &device,
        vspan<pipeline_box::vertex> &boxVertices,
        vspan<pipeline_image::vertex> &imageVertices,
        vspan<pipeline_SDF::vertex> &sdfVertices) noexcept;
 
    operator bool() const noexcept
    {
        return frame_buffer_index != std::numeric_limits<size_t>::max();
    }
 
    void draw_box(
        widget_layout const &layout,
        quad const &box,
        quad_color const &fill_color,
        quad_color const &border_color,
        float border_width,
        hi::border_side border_side,
        hi::corner_radii const &corner_radius = {}) const noexcept
    {
        // clang-format off
        hilet border_radius = border_width * 0.5f;
        hilet box_ =
            border_side == hi::border_side::inside ? box - border_radius :
            border_side == hi::border_side::outside ? box + border_radius :
            box;
        hilet corner_radius_ =
            border_side == hi::border_side::inside ? corner_radius - border_radius :
            border_side == hi::border_side::outside ? corner_radius + border_radius :
            corner_radius;
        // clang-format on
 
        return _draw_box(
            layout.window_clipping_rectangle(),
            layout.to_window * box_,
            fill_color,
            border_color,
            layout.to_window * border_width,
            layout.to_window * corner_radius_);
    }
 
    void draw_box(
        widget_layout const &layout,
        aarectangle const &clipping_rectangle,
        quad const &box,
        quad_color const &fill_color,
        quad_color const &border_color,
        float border_width,
        hi::border_side border_side,
        hi::corner_radii const &corner_radius = {}) const noexcept
    {
        // clang-format off
        hilet border_radius = border_width * 0.5f;
        hilet box_ =
            border_side == hi::border_side::inside ? box - border_radius :
            border_side == hi::border_side::outside ? box + border_radius :
            box;
        hilet corner_radius_ =
            border_side == hi::border_side::inside ? corner_radius - border_radius :
            border_side == hi::border_side::outside ? corner_radius + border_radius :
            corner_radius;
        // clang-format on
 
        return _draw_box(
            layout.window_clipping_rectangle(clipping_rectangle),
            layout.to_window * box_,
            fill_color,
            border_color,
            layout.to_window * border_width,
            layout.to_window * corner_radius_);
    }
    void draw_box(
        widget_layout const &layout,
        quad const &box,
        quad_color const &fill_color,
        hi::corner_radii const &corner_radius = {}) const noexcept
    {
        return _draw_box(
            layout.window_clipping_rectangle(),
            layout.to_window * box,
            fill_color,
            fill_color,
            0.0f,
            layout.to_window * corner_radius);
    }
 
    void draw_box(
        widget_layout const &layout,
        aarectangle const &clipping_rectangle,
        quad const &box,
        quad_color const &fill_color,
        hi::corner_radii const &corner_radius = {}) const noexcept
    {
        return _draw_box(
            layout.window_clipping_rectangle(clipping_rectangle),
            layout.to_window * box,
            fill_color,
            fill_color,
            0.0f,
            layout.to_window * corner_radius);
    }
 
    [[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 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 = zero<0b0101>(r);
        }
        if (c2 == line_end_cap::flat) {
            r = zero<0b1010>(r);
        }
 
        return corner_radii{r};
    }
 
    void draw_line(
        widget_layout const &layout,
        line_segment const &line,
        float width,
        quad_color const &fill_color,
        line_end_cap c1 = line_end_cap::flat,
        line_end_cap c2 = line_end_cap::flat) const noexcept
    {
        hilet line_ = layout.to_window * line;
        hilet width_ = layout.to_window * width;
 
        hilet box = make_rectangle(line_, width_, c1, c2);
        hilet corners = make_corner_radii(width_, c1, c2);
 
        return _draw_box(layout.window_clipping_rectangle(), box, fill_color, fill_color, 0.0f, corners);
    }
 
    void draw_line(
        widget_layout const &layout,
        aarectangle const &clipping_rectangle,
        line_segment const &line,
        float width,
        quad_color const &fill_color,
        line_end_cap c1 = line_end_cap::flat,
        line_end_cap c2 = line_end_cap::flat) const noexcept
    {
        hi_axiom(width != 0.0f);
        hilet line_ = layout.to_window * line;
        hilet width_ = layout.to_window * width;
 
        hilet box = make_rectangle(line_, width_, c1, c2);
        hilet corners = make_corner_radii(width_, c1, c2);
 
        return _draw_box(layout.window_clipping_rectangle(clipping_rectangle), box, fill_color, fill_color, 0.0f, corners);
    }
 
    [[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(hi::circle const &circle) noexcept
    {
        return corner_radii{f32x4{circle}.wwww()};
    }
 
    void draw_circle(widget_layout const &layout, hi::circle const &circle, quad_color const &fill_color) const noexcept
    {
        hilet box = layout.to_window * make_rectangle(circle);
        hilet corners = layout.to_window * make_corner_radii(circle);
        return _draw_box(layout.window_clipping_rectangle(), box, fill_color, fill_color, 0.0f, corners);
    }
 
    void draw_circle(
        widget_layout const &layout,
        aarectangle const clipping_rectangle,
        hi::circle const &circle,
        quad_color const &fill_color) const
    {
        hilet box = layout.to_window * make_rectangle(circle);
        hilet corners = layout.to_window * make_corner_radii(circle);
        return _draw_box(layout.window_clipping_rectangle(clipping_rectangle), box, fill_color, fill_color, 0.0f, corners);
    }
 
    void draw_circle(
        widget_layout const &layout,
        hi::circle const &circle,
        quad_color const &fill_color,
        quad_color const &border_color,
        float border_width,
        hi::border_side border_side) const noexcept
    {
        // clang-format off
        hilet circle_ =
            border_side == hi::border_side::inside ? circle - border_width * 0.5f :
            border_side == hi::border_side::outside ? circle + border_width * 0.5f :
            circle;
        // clang-format on
 
        hilet box = layout.to_window * make_rectangle(circle_);
        hilet corners = layout.to_window * make_corner_radii(circle_);
        return _draw_box(layout.window_clipping_rectangle(), box, fill_color, border_color, border_width, corners);
    }
 
    void draw_circle(
        widget_layout const &layout,
        aarectangle const &clipping_rectangle,
        hi::circle const &circle,
        quad_color const &fill_color,
        quad_color const &border_color,
        float border_width,
        hi::border_side border_side) const noexcept
    {
        // clang-format off
        hilet circle_ =
            border_side == hi::border_side::inside ? circle - border_width * 0.5f :
            border_side == hi::border_side::outside ? circle + border_width * 0.5f :
            circle;
        // clang-format on
 
        hilet box = layout.to_window * make_rectangle(circle_);
        hilet corners = layout.to_window * make_corner_radii(circle_);
        return _draw_box(
            layout.window_clipping_rectangle(clipping_rectangle), box, fill_color, border_color, border_width, corners);
    }
 
    [[nodiscard]] bool draw_image(widget_layout const &layout, quad const &box, paged_image &image) const noexcept
    {
        return _draw_image(layout.window_clipping_rectangle(), layout.to_window * box, image);
    }
 
    [[nodiscard]] bool
    draw_image(widget_layout const &layout, aarectangle const &clipping_rectangle, quad const &box, paged_image &image)
        const noexcept
    {
        return _draw_image(layout.window_clipping_rectangle(clipping_rectangle), layout.to_window * box, image);
    }
 
    void draw_glyph(widget_layout const &layout, quad const &box, quad_color const &color, glyph_ids const &glyph) const noexcept
    {
        return _draw_glyph(layout.window_clipping_rectangle(), layout.to_window * box, color, glyph);
    }
 
    void draw_glyph(
        widget_layout const &layout,
        aarectangle clipping_rectangle,
        quad const &box,
        quad_color const &color,
        glyph_ids const &glyph) const noexcept
    {
        return _draw_glyph(layout.window_clipping_rectangle(clipping_rectangle), layout.to_window * box, color, glyph);
    }
 
    void draw_text(widget_layout const &layout, matrix3 const &transform, quad_color const &color, shaped_text const &text)
        const noexcept
    {
        return _draw_text(layout.window_clipping_rectangle(), layout.to_window * transform, text, color);
    }
 
    void draw_text(
        widget_layout const &layout,
        aarectangle const &clipping_rectangle,
        matrix3 const &transform,
        quad_color const &color,
        shaped_text const &text) const noexcept
    {
        return _draw_text(layout.window_clipping_rectangle(clipping_rectangle), layout.to_window * transform, text, color);
    }
 
    void draw_text(widget_layout const &layout, matrix3 const &transform, shaped_text const &text) const noexcept
    {
        return _draw_text(layout.window_clipping_rectangle(), layout.to_window * transform, text);
    }
 
    void draw_text(widget_layout const &layout, matrix3 const &transform, quad_color const &color, text_shaper const &text)
        const noexcept
    {
        return _draw_text(layout.window_clipping_rectangle(), layout.to_window * transform, text, color);
    }
 
    void draw_text(widget_layout const &layout, quad_color const &color, text_shaper const &text) const noexcept
    {
        return _draw_text(layout.window_clipping_rectangle(), layout.to_window, text, color);
    }
 
    void draw_text(
        widget_layout const &layout,
        aarectangle const &clipping_rectangle,
        matrix3 const &transform,
        quad_color const &color,
        text_shaper const &text) const noexcept
    {
        return _draw_text(layout.window_clipping_rectangle(clipping_rectangle), layout.to_window * transform, text, color);
    }
 
    void draw_text(
        widget_layout const &layout,
        aarectangle const &clipping_rectangle,
        quad_color const &color,
        text_shaper const &text) const noexcept
    {
        return _draw_text(layout.window_clipping_rectangle(clipping_rectangle), layout.to_window, text, color);
    }
 
    void draw_text(widget_layout const &layout, matrix3 const &transform, text_shaper const &text) const noexcept
    {
        return _draw_text(layout.window_clipping_rectangle(), layout.to_window * transform, text);
    }
 
    void draw_text(widget_layout const &layout, text_shaper const &text) const noexcept
    {
        return _draw_text(layout.window_clipping_rectangle(), layout.to_window, text);
    }
 
    void
    draw_text_selection(widget_layout const &layout, text_shaper const &text, text_selection const &selection, hi::color color)
        const noexcept
    {
        return _draw_text_selection(layout.window_clipping_rectangle(), layout.to_window, text, selection, color);
    }
 
    void draw_text_cursors(
        widget_layout const &layout,
        text_shaper const &text,
        text_cursor cursor,
        hi::color primary_color,
        hi::color secondary_color,
        bool overwrite_mode,
        bool dead_character_mode) const noexcept
    {
        return _draw_text_cursors(
            layout.window_clipping_rectangle(),
            layout.to_window,
            text,
            cursor,
            primary_color,
            secondary_color,
            overwrite_mode,
            dead_character_mode);
    }
 
    [[nodiscard]] friend bool overlaps(draw_context const &context, widget_layout const &layout) noexcept
    {
        return overlaps(context.scissor_rectangle, layout.window_clipping_rectangle());
    }
 
private:
    vspan<pipeline_box::vertex> *_box_vertices;
    vspan<pipeline_image::vertex> *_image_vertices;
    vspan<pipeline_SDF::vertex> *_sdf_vertices;
 
    void _draw_box(
        aarectangle const &clipping_rectangle,
        quad box,
        quad_color const &fill_color,
        quad_color const &border_color,
        float border_width,
        hi::corner_radii corner_radius) const noexcept;
 
    void _draw_text(
        aarectangle const &clipping_rectangle,
        matrix3 const &transform,
        shaped_text const &text,
        std::optional<quad_color> color = {}) const noexcept;
 
    void _draw_text(
        aarectangle const &clipping_rectangle,
        matrix3 const &transform,
        text_shaper const &text,
        std::optional<quad_color> color = {}) const noexcept;
 
    void _draw_text_selection(
        aarectangle const &clipping_rectangle,
        matrix3 const &transform,
        text_shaper const &text,
        text_selection const &selection,
        hi::color) const noexcept;
 
    void _draw_text_insertion_cursor_empty(
        aarectangle const &clipping_rectangle,
        matrix3 const &transform,
        text_shaper const &text,
        hi::color color) const noexcept;
 
    void _draw_text_insertion_cursor(
        aarectangle const &clipping_rectangle,
        matrix3 const &transform,
        text_shaper const &text,
        text_cursor cursor,
        hi::color color,
        bool show_flag) const noexcept;
 
    void _draw_text_overwrite_cursor(
        aarectangle const &clipping_rectangle,
        matrix3 const &transform,
        text_shaper::char_const_iterator it,
        hi::color color) const noexcept;
 
    void _draw_text_cursors(
        aarectangle const &clipping_rectangle,
        matrix3 const &transform,
        text_shaper const &text,
        text_cursor cursor,
        hi::color primary_color,
        hi::color secondary_color,
        bool overwrite_mode,
        bool dead_character_mode) const noexcept;
 
    void _draw_glyph(aarectangle const &clipping_rectangle, quad const &box, quad_color const &color, glyph_ids const &glyph)
        const noexcept;
 
    [[nodiscard]] bool _draw_image(aarectangle const &clipping_rectangle, quad const &box, paged_image &image) const noexcept;
};
 
} // namespace hi::inline v1