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)
 
// Copyright 2020 Pokitec
// All rights reserved.
 
#pragma once
 
#include "gui_device_vulkan.hpp"
#include "gui_window.hpp"
#include "theme.hpp"
#include "pipeline_image_image.hpp"
#include "pipeline_flat_device_shared.hpp"
#include "pipeline_box_device_shared.hpp"
#include "pipeline_image_device_shared.hpp"
#include "pipeline_SDF_device_shared.hpp"
#include "pipeline_flat_vertex.hpp"
#include "pipeline_box_vertex.hpp"
#include "pipeline_image_vertex.hpp"
#include "pipeline_SDF_vertex.hpp"
#include "../numeric_array.hpp"
#include "../aarect.hpp"
#include "../vspan.hpp"
#include "../text/shaped_text.hpp"
#include "../color/color.hpp"
#include <type_traits>
 
namespace tt {
 
class draw_context {
public:
    color line_color = color(1.0, 1.0, 1.0, 1.0);
 
    color fill_color = color(0.0, 0.0, 0.0, 0.0);
 
    float line_width = 1.0;
 
    f32x4 corner_shapes = f32x4{0.0, 0.0, 0.0, 0.0};
 
    aarect clipping_rectangle;
 
    matrix3 transform = geo::identity{};
 
    draw_context(
        gui_window &window,
        aarect scissor_rectangle,
        vspan<pipeline_flat::vertex> &flatVertices,
        vspan<pipeline_box::vertex> &boxVertices,
        vspan<pipeline_image::vertex> &imageVertices,
        vspan<pipeline_SDF::vertex> &sdfVertices) noexcept :
        _window(&window),
        _scissor_rectangle(scissor_rectangle),
        _flat_vertices(&flatVertices),
        _box_vertices(&boxVertices),
        _image_vertices(&imageVertices),
        _sdf_vertices(&sdfVertices),
        line_color(0.0, 1.0, 0.0, 1.0),
        fill_color(1.0, 1.0, 0.0, 1.0),
        line_width(theme::global->borderWidth),
        corner_shapes(),
        clipping_rectangle(static_cast<f32x4>(window.extent))
    {
        _flat_vertices->clear();
        _box_vertices->clear();
        _image_vertices->clear();
        _sdf_vertices->clear();
    }
 
    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;
 
    gui_window &window() const noexcept
    {
        tt_axiom(_window);
        return *_window;
    }
 
    gui_device &device() const noexcept
    {
        auto device = window().device();
        tt_axiom(device);
        return *device;
    }
 
    void draw_filled_quad(f32x4 p1, f32x4 p2, f32x4 p3, f32x4 p4) const noexcept
    {
        tt_axiom(_flat_vertices != nullptr);
        _flat_vertices->emplace_back(transform * p1, clipping_rectangle, fill_color);
        _flat_vertices->emplace_back(transform * p2, clipping_rectangle, fill_color);
        _flat_vertices->emplace_back(transform * p3, clipping_rectangle, fill_color);
        _flat_vertices->emplace_back(transform * p4, clipping_rectangle, fill_color);
    }
 
    void draw_filled_quad(aarect r) const noexcept
    {
        draw_filled_quad(r.corner<0>(), r.corner<1>(), r.corner<2>(), r.corner<3>());
    }
 
    void draw_box(aarect box) const noexcept
    {
        tt_axiom(_box_vertices != nullptr);
 
        pipeline_box::device_shared::placeVertices(
            *_box_vertices, transform * box, fill_color, line_width, line_color, corner_shapes, clipping_rectangle);
    }
 
    void draw_box_with_border_inside(aarect rectangle) const noexcept
    {
        tt_axiom(_box_vertices != nullptr);
 
        ttlet shrink_value = line_width * 0.5f;
 
        ttlet new_rectangle = shrink(rectangle, shrink_value);
 
        ttlet new_corner_shapes =
            f32x4{std::max(0.0f, corner_shapes.x() - shrink_value),
                std::max(0.0f, corner_shapes.y() - shrink_value),
                std::max(0.0f, corner_shapes.z() - shrink_value),
                std::max(0.0f, corner_shapes.w() - shrink_value)};
 
        pipeline_box::device_shared::placeVertices(
            *_box_vertices, transform * new_rectangle, fill_color, line_width, line_color, new_corner_shapes, clipping_rectangle);
    }
 
    void draw_box_with_border_outside(aarect rectangle) const noexcept
    {
        tt_axiom(_box_vertices != nullptr);
 
        ttlet shrink_value = line_width * 0.5f;
 
        ttlet new_rectangle = expand(rectangle, shrink_value);
 
        ttlet new_corner_shapes =
            f32x4{std::max(0.0f, corner_shapes.x() - shrink_value),
                std::max(0.0f, corner_shapes.y() - shrink_value),
                std::max(0.0f, corner_shapes.z() - shrink_value),
                std::max(0.0f, corner_shapes.w() - shrink_value)};
 
        pipeline_box::device_shared::placeVertices(
            *_box_vertices, transform * new_rectangle, fill_color, line_width, line_color, new_corner_shapes, clipping_rectangle);
    }
 
    void draw_image(pipeline_image::Image &image) const noexcept
    {
        tt_axiom(_image_vertices != nullptr);
 
        image.placeVertices(*_image_vertices, transform, clipping_rectangle);
    }
 
    void draw_text(shaped_text const &text, bool useContextColor = false) const noexcept
    {
        tt_axiom(_sdf_vertices != nullptr);
 
        if (useContextColor) {
            narrow_cast<gui_device_vulkan &>(device()).SDFPipeline->placeVertices(
                *_sdf_vertices, text, transform, clipping_rectangle, line_color);
        } else {
            narrow_cast<gui_device_vulkan &>(device()).SDFPipeline->placeVertices(
                *_sdf_vertices, text, transform, clipping_rectangle);
        }
    }
 
    void draw_glyph(font_glyph_ids const &glyph, aarect box) const noexcept
    {
        tt_axiom(_sdf_vertices != nullptr);
 
        narrow_cast<gui_device_vulkan &>(device()).SDFPipeline->placeVertices(
            *_sdf_vertices, glyph, transform * box, line_color, clipping_rectangle);
    }
 
    [[nodiscard]] friend bool overlaps(draw_context const &context, aarect const &rectangle) noexcept
    {
        return overlaps(context._scissor_rectangle, rectangle);
    }
 
private:
    gui_window *_window;
public:
    aarect _scissor_rectangle;
private:
    vspan<pipeline_flat::vertex> *_flat_vertices;
    vspan<pipeline_box::vertex> *_box_vertices;
    vspan<pipeline_image::vertex> *_image_vertices;
    vspan<pipeline_SDF::vertex> *_sdf_vertices;
};
 
} // namespace tt