IRenderer.h

/*
 * AUI Framework - Declarative UI toolkit for modern C++20
 * Copyright (C) 2020-2025 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;
 
};
 
 

© 2025 AUI Framework Contributors. Documentation contributions included herein are the copyrights of their respective owners. The documentation provided herein is licensed under the terms of the GNU Free Documentation License version 1.3 as published by the Free Software Foundation. All trademarks are property of their respective owners.