DrawContext.hpp

 
// Copyright 2020 Pokitec
// All rights reserved.
 
#pragma once
 
#include "TTauri/Foundation/vec.hpp"
#include "TTauri/Foundation/mat.hpp"
#include "TTauri/Foundation/aarect.hpp"
#include "TTauri/Foundation/vspan.hpp"
#include "TTauri/GUI/GUIDevice.hpp"
#include "TTauri/GUI/Window.hpp"
#include "TTauri/GUI/Theme.hpp"
#include "TTauri/GUI/PipelineImage_Image.hpp"
#include "TTauri/GUI/PipelineFlat_DeviceShared.hpp"
#include "TTauri/GUI/PipelineBox_DeviceShared.hpp"
#include "TTauri/GUI/PipelineImage_DeviceShared.hpp"
#include "TTauri/GUI/PipelineSDF_DeviceShared.hpp"
#include "TTauri/GUI/PipelineFlat_Vertex.hpp"
#include "TTauri/GUI/PipelineBox_Vertex.hpp"
#include "TTauri/GUI/PipelineImage_Vertex.hpp"
#include "TTauri/GUI/PipelineSDF_Vertex.hpp"
#include "TTauri/Text/ShapedText.hpp"
#include <type_traits>
 
namespace tt {
 
class DrawContext {
private:
    Window *_window;
    vspan<PipelineFlat::Vertex> *flatVertices;
    vspan<PipelineBox::Vertex> *boxVertices;
    vspan<PipelineImage::Vertex> *imageVertices;
    vspan<PipelineSDF::Vertex> *sdfVertices;
 
public:
    vec color = vec::color(1.0, 1.0, 1.0, 1.0);
 
    vec fillColor = vec::color(0.0, 0.0, 0.0, 0.0);
 
    float lineWidth = 1.0;
 
    vec cornerShapes = vec{0.0, 0.0, 0.0, 0.0};
 
    aarect clippingRectangle;
 
    mat transform = mat::I();
 
    DrawContext(
        Window &window,
        vspan<PipelineFlat::Vertex> &flatVertices,
        vspan<PipelineBox::Vertex> &boxVertices,
        vspan<PipelineImage::Vertex> &imageVertices,
        vspan<PipelineSDF::Vertex> &sdfVertices
    ) noexcept :
        _window(&window),
        flatVertices(&flatVertices),
        boxVertices(&boxVertices),
        imageVertices(&imageVertices),
        sdfVertices(&sdfVertices),
        color(0.0, 1.0, 0.0, 1.0),
        fillColor(1.0, 1.0, 0.0, 1.0),
        lineWidth(Theme::borderWidth),
        cornerShapes(),
        clippingRectangle(static_cast<vec>(window.currentWindowExtent))
    {
        flatVertices.clear();
        boxVertices.clear();
        imageVertices.clear();
        sdfVertices.clear();
    }
 
    DrawContext(DrawContext const &rhs) noexcept = default;
    DrawContext(DrawContext &&rhs) noexcept = default;
    DrawContext &operator=(DrawContext const &rhs) noexcept = default;
    DrawContext &operator=(DrawContext &&rhs) noexcept = default;
    ~DrawContext() = default;
 
    Window &window() const noexcept {
        tt_assume(_window);
        return *_window;
    }
    
    GUIDevice &device() const noexcept {
        auto device = window().device;
        tt_assume(device);
        return *device;
    }
 
    void drawFilledQuad(vec p1, vec p2, vec p3, vec p4) const noexcept {
        tt_assume(flatVertices != nullptr);
        flatVertices->emplace_back(transform * p1, clippingRectangle, fillColor);
        flatVertices->emplace_back(transform * p2, clippingRectangle, fillColor);
        flatVertices->emplace_back(transform * p3, clippingRectangle, fillColor);
        flatVertices->emplace_back(transform * p4, clippingRectangle, fillColor);
    }
 
    void drawFilledQuad(aarect r) const noexcept {
        drawFilledQuad(r.corner<0>(), r.corner<1>(), r.corner<2>(), r.corner<3>());
    }
 
    void drawBox(aarect box) const noexcept {
        tt_assume(boxVertices != nullptr);
 
        PipelineBox::DeviceShared::placeVertices(
            *boxVertices,
            transform * box,
            fillColor,
            lineWidth,
            color,
            cornerShapes,
            clippingRectangle
        );
    }
 
    void drawBoxIncludeBorder(aarect box) const noexcept {
 
        tt_assume(boxVertices != nullptr);
 
        ttlet shrink_value = lineWidth * 0.5f;
 
        ttlet newBox = shrink(box, shrink_value);
 
        ttlet newCornerShapes = vec{
            std::max(0.0f, cornerShapes.x() - shrink_value),
            std::max(0.0f, cornerShapes.y() - shrink_value),
            std::max(0.0f, cornerShapes.z() - shrink_value),
            std::max(0.0f, cornerShapes.w() - shrink_value)
        };
 
        PipelineBox::DeviceShared::placeVertices(
            *boxVertices,
            transform * newBox,
            fillColor,
            lineWidth,
            color,
            newCornerShapes,
            clippingRectangle
        );
    }
 
    void drawImage(PipelineImage::Image &image) const noexcept {
        tt_assume(imageVertices != nullptr);
 
        image.placeVertices(*imageVertices, transform, clippingRectangle);
    }
 
    void drawText(ShapedText const &text) const noexcept {
        tt_assume(sdfVertices != nullptr);
 
        device().SDFPipeline->placeVertices(
            *sdfVertices,
            text,
            transform,
            clippingRectangle
        );
    }
 
    void drawTextSingleColor(ShapedText const &text) const noexcept {
        tt_assume(sdfVertices != nullptr);
 
        device().SDFPipeline->placeVertices(
            *sdfVertices,
            text,
            transform,
            clippingRectangle,
            color
        );
    }
 
    void drawGlyph(FontGlyphIDs const &glyph, aarect box) const noexcept {
        tt_assume(sdfVertices != nullptr);
 
        device().SDFPipeline->placeVertices(
            *sdfVertices,
            glyph,
            transform * box,
            color,
            clippingRectangle
        );
    }
 
};
 
}