IRenderer.h

/*
 * AUI Framework - Declarative UI toolkit for modern C++20
 * Copyright (C) 2020-2024 Alex2772 and Contributors
 *
 * SPDX-License-Identifier: MPL-2.0
 *
 * This Source Code Form is subject to the terms of the Mozilla Public
 * License, v. 2.0. If a copy of the MPL was not distributed with this
 * file, You can obtain one at http://mozilla.org/MPL/2.0/.
 */
 
#pragma once
 
#include <glm/glm.hpp>
#include <AUI/Reflect/AEnumerate.h>
#include <AUI/Common/ASide.h>
#include <AUI/Common/AColor.h>
#include <AUI/Render/ABrush.h>
#include <AUI/Util/APool.h>
#include <AUI/Util/AArrayView.h>
#include "AUI/Font/AFontStyle.h"
#include "AUI/Render/ABorderStyle.h"
#include "AUI/ASS/Property/Backdrop.h"
#include "AUI/Util/AMetric.h"
#include "ITexture.h"
#include "ATextLayoutHelper.h"
#include "IRenderViewToTexture.h"
 
class AColor;
class AWindowBase;
 
 

enum class Blending {
    NORMAL,
 

    ADDITIVE,

    INVERSE_DST,

    INVERSE_SRC,
};

class IRenderer: public aui::noncopyable {
public:
    class IPrerenderedString {
    public:
        virtual void draw() = 0;
        virtual ~IPrerenderedString() = default;
        virtual int getWidth() = 0;
        virtual int getHeight() = 0;
    };
    class IMultiStringCanvas {
    private:
        AOptional<ATextLayoutHelper::Symbols> mSymbols;
 
    protected:

        void notifySymbolAdded(const ATextLayoutHelper::Boundary& symbol) noexcept {
            if (mSymbols) mSymbols->last().push_back(symbol);
        }
 
    public:
        virtual ~IMultiStringCanvas() = default;

        void enableCachingForTextLayoutHelper() noexcept {
            mSymbols = ATextLayoutHelper::Symbols{};
            nextLine();
        }

        void nextLine() noexcept {
            if (mSymbols) mSymbols->push_back({});
        }

        virtual void addString(const glm::ivec2& position, const AString& text) noexcept = 0;

        virtual _<IRenderer::IPrerenderedString> finalize() noexcept = 0;

        ATextLayoutHelper getTextLayoutHelper() noexcept {
            AUI_ASSERTX(bool(mSymbols), "call enableCachingForTextLayoutHelper() before using getTextLayoutHelper");
            return ATextLayoutHelper(std::move(*mSymbols));
        }
    };
 
public:
    IRenderer(): mTexturePool([this] { return createNewTexture(); }) {}
    virtual ~IRenderer() = default;

    _<ITexture> getNewTexture() {
        return mTexturePool.get();
    }

    virtual _<IMultiStringCanvas> newMultiStringCanvas(const AFontStyle& style) = 0;

    virtual void rectangle(const ABrush& brush,
                           glm::vec2 position,
                           glm::vec2 size) = 0;
 

    virtual void roundedRectangle(const ABrush& brush,
                                  glm::vec2 position,
                                  glm::vec2 size,
                                  float radius) = 0;

    virtual void rectangleBorder(const ABrush& brush,
                                 glm::vec2 position,
                                 glm::vec2 size,
                                 float lineWidth = 1.f) = 0;
    virtual void roundedRectangleBorder(const ABrush& brush,
                                        glm::vec2 position,
                                        glm::vec2 size,
                                        float radius,
                                        int borderWidth) = 0;
 

    virtual void boxShadow(glm::vec2 position,
                           glm::vec2 size,
                           float blurRadius,
                           const AColor& color) = 0;

    virtual void boxShadowInner(glm::vec2 position,
                                glm::vec2 size,
                                float blurRadius,
                                float spreadRadius,
                                float borderRadius,
                                const AColor& color,
                                glm::vec2 offset) = 0;

    virtual void string(glm::vec2 position,
                        const AString& string,
                        const AFontStyle& fs = {}) = 0;

    virtual _<IPrerenderedString> prerenderString(glm::vec2 position, const AString& text, const AFontStyle& fs) = 0;

    void line(const ABrush& brush, glm::vec2 p1, glm::vec2 p2, const ABorderStyle& style = ABorderStyle::Solid{}, AMetric width = 1_dp) {
        glm::vec2 points[] = { p1, p2 };
        lines(brush, points, style, width);
    }

    virtual void lines(const ABrush& brush, AArrayView<glm::vec2> points, const ABorderStyle& style, AMetric width) = 0;

    void lines(const ABrush& brush, AArrayView<glm::vec2> points, const ABorderStyle& style = ABorderStyle::Solid{}) {
        lines(brush, points, style, 1_dp);
    }

    virtual void points(const ABrush& brush, AArrayView<glm::vec2> points, AMetric size) = 0;

    virtual void lines(const ABrush& brush, AArrayView<std::pair<glm::vec2, glm::vec2>> points, const ABorderStyle& style, AMetric width) = 0;

    void lines(const ABrush& brush, AArrayView<std::pair<glm::vec2, glm::vec2>> points, const ABorderStyle& style = ABorderStyle::Solid{}) {
        lines(brush, points, style, 1_dp);
    }

    virtual void squareSector(const ABrush& brush,
                              const glm::vec2& position,
                              const glm::vec2& size,
                              AAngleRadians begin,
                              AAngleRadians end) = 0;
 
    void setColorForced(const AColor& color)
    {
        mColor = color;
    }

    void setColor(const AColor& color)
    {
        setColorForced(mColor * color);
    }
 
    const AColor& getColor() const
    {
        return mColor;
    }

    void setTransform(const glm::mat4& transform)
    {
        mTransform *= transform;
    }

    void setTransformForced(const glm::mat4& transform)
    {
        mTransform = transform;
    }

    virtual void pushMaskBefore() = 0;

    virtual void pushMaskAfter() = 0;

    virtual void popMaskBefore() = 0;

    virtual void popMaskAfter() = 0;

    virtual void setBlending(Blending blending) = 0;
 

    [[nodiscard]]
    virtual _unique<IRenderViewToTexture> newRenderViewToTexture() noexcept = 0;

    virtual void setWindow(AWindowBase* window)
    {
        mWindow = window;
        setColorForced(1.f);
        setTransformForced(getProjectionMatrix());
        mStencilDepth = 0;
    }
 
    [[nodiscard]]
    AWindowBase* getWindow() const noexcept {
        return mWindow;
    }
 
    virtual glm::mat4 getProjectionMatrix() const = 0;
 
    const glm::mat4& getTransform()
    {
        return mTransform;
    }
 
    [[nodiscard]]
    std::uint8_t getStencilDepth() const noexcept {
        return mStencilDepth;
    }
 
    void setStencilDepth(uint8_t stencilDepth) {
        mStencilDepth = stencilDepth;
    }
 

    void translate(const glm::vec2& offset) {
        setTransformForced(glm::translate(getTransform(), glm::vec3(offset, 0.f)));
    }

    void rotate(const glm::vec3& axis, AAngleRadians angle) {
        setTransformForced(glm::rotate(getTransform(), angle.radians(), axis));
    }

    void rotate(AAngleRadians angle) {
        rotate({0.f, 0.f, 1.f}, angle);
    }
 
    void setAllowRenderToTexture(bool allowRenderToTexture) {
        mAllowRenderToTexture = allowRenderToTexture;
    }
 
    [[nodiscard]]
    bool allowRenderToTexture() const noexcept {
        return mAllowRenderToTexture;
    }

    void backdrops(glm::ivec2 position, glm::ivec2 size, std::span<ass::Backdrop::Any> backdrops);
 
protected:
    AColor mColor;
    glm::mat4 mTransform;
    AWindowBase* mWindow = nullptr;
    APool<ITexture> mTexturePool;
    uint8_t mStencilDepth = 0;
 
    virtual _unique<ITexture> createNewTexture() = 0;

    void stub(glm::vec2 position, glm::vec2 size);
 
    virtual void backdrops(glm::ivec2 position, glm::ivec2 size, std::span<ass::Backdrop::Preprocessed> backdrops);
 
private:
    bool mAllowRenderToTexture = false;
 
};