GraphicsCommandBuffer.hpp

Go to the documentation of this file.

//
//  CeresEngine - A game development framework
//
//  Created by Rogiel Sulzbach.
//  Copyright (c) 2018-2023 Rogiel Sulzbach. All rights reserved.
//
 
#pragma once
 
#include "CeresEngine/RenderAPI/Forward.hpp"
#include "CeresEngine/Resource/Forward.hpp"
#include "CeresEngine/Texture/Forward.hpp"
#include "CeresEngine/Text/Forward.hpp"
 
#include "Shape.hpp"
 
#include "CeresEngine/Macros.hpp"
 
#include "CeresEngine/Foundation/Container/Deque.hpp"
#include "CeresEngine/Foundation/Container/Map.hpp"
#include "CeresEngine/Foundation/Container/Variant.hpp"
 
#include "CeresEngine/Math/Rect.hpp"
#include "CeresEngine/Resource/ResourceHandle.hpp"
#include "CeresEngine/Text/TextLayout.hpp"
#include "CeresEngine/Texture/Texture.hpp"
 
namespace CeresEngine {
 
    struct GraphicsClipState final {
        Rect2 area;
 
        // Compares the `GraphicsClipState` for equality. Two states are
        [[nodiscard]] friend bool operator==(const GraphicsClipState& lhs, const GraphicsClipState& rhs) noexcept { return lhs.area == rhs.area; }
 
        [[nodiscard]] friend bool operator!=(const GraphicsClipState& lhs, const GraphicsClipState& rhs) noexcept { return !(lhs == rhs); }
    };
 
    struct GraphicsState final {
        AffineTransform transform;
 
        Optional<GraphicsClipState> clipState;
 
        [[nodiscard]] friend bool operator==(const GraphicsState& lhs, const GraphicsState& rhs) noexcept {
            return lhs.transform == rhs.transform && lhs.clipState == rhs.clipState;
        }
 
        [[nodiscard]] friend bool operator!=(const GraphicsState& lhs, const GraphicsState& rhs) noexcept { return !(lhs == rhs); }
    };
 
    struct TextureGraphicsCommand final {
        TexturePtr texture;
 
        Rect2 source = {0.0, 0.0, 1.0, 1.0};
 
        Rect2 target = {0.0, 0.0, 1.0, 1.0};
 
        Color tintColor = Color::white;
 
        TextureGraphicsCommand() = default;
 
        TextureGraphicsCommand(const TextureGraphicsCommand&) = default;
        TextureGraphicsCommand& operator=(const TextureGraphicsCommand&) = default;
        TextureGraphicsCommand(TextureGraphicsCommand&&) noexcept = default;
        TextureGraphicsCommand& operator=(TextureGraphicsCommand&&) noexcept = default;
 
        ~TextureGraphicsCommand() = default;
 
        template<typename Allocator>
        explicit TextureGraphicsCommand(std::allocator_arg_t, const Allocator& allocator) : TextureGraphicsCommand(allocator.get_allocator()) {}
        explicit TextureGraphicsCommand(AnyAllocatorReference allocator) : TextureGraphicsCommand() {}
 
        template<typename Allocator>
        explicit TextureGraphicsCommand(std::allocator_arg_t, const Allocator& allocator, const TextureGraphicsCommand& other)
                : TextureGraphicsCommand(other, allocator.get_allocator()) {}
        explicit TextureGraphicsCommand(const TextureGraphicsCommand& other, AnyAllocatorReference allocator) : TextureGraphicsCommand(other) {}
    };
 
    struct ShapeGraphicsCommand final {
        Shape shape;
 
        ShapeGraphicsCommand() = default;
 
        ShapeGraphicsCommand(const ShapeGraphicsCommand&) = default;
        ShapeGraphicsCommand& operator=(const ShapeGraphicsCommand&) = default;
        ShapeGraphicsCommand(ShapeGraphicsCommand&&) noexcept = default;
        ShapeGraphicsCommand& operator=(ShapeGraphicsCommand&&) noexcept = default;
 
        ~ShapeGraphicsCommand() = default;
 
        template<typename Allocator>
        explicit ShapeGraphicsCommand(std::allocator_arg_t, const Allocator& allocator) : ShapeGraphicsCommand(allocator.get_allocator()) {}
        explicit ShapeGraphicsCommand(AnyAllocatorReference allocator) : shape(allocator) {}
 
        template<typename Allocator>
        explicit ShapeGraphicsCommand(std::allocator_arg_t, const Allocator& allocator, const ShapeGraphicsCommand& other)
                : ShapeGraphicsCommand(other, allocator.get_allocator()) {}
        explicit ShapeGraphicsCommand(const ShapeGraphicsCommand& other, AnyAllocatorReference allocator) : shape(other.shape, allocator) {}
    };
 
    struct TextGraphicsCommand final {
        FontPtr font;
 
        TexturePtr texture;
 
        Vector<TextLayout, AnyAllocator> layout{gDefaultAllocator()};
 
        Vector2 offset;
 
        Color tintColor;
 
        TextGraphicsCommand() = default;
 
        TextGraphicsCommand(const TextGraphicsCommand&) = default;
        TextGraphicsCommand& operator=(const TextGraphicsCommand&) = default;
        TextGraphicsCommand(TextGraphicsCommand&&) noexcept = default;
        TextGraphicsCommand& operator=(TextGraphicsCommand&&) noexcept = default;
 
        ~TextGraphicsCommand() = default;
 
        template<typename Allocator> explicit TextGraphicsCommand(std::allocator_arg_t, const Allocator& allocator) : TextGraphicsCommand(allocator.get_allocator()) {}
        explicit TextGraphicsCommand(AnyAllocatorReference allocator) : layout(allocator) {}
 
        template<typename Allocator>
        explicit TextGraphicsCommand(std::allocator_arg_t, const Allocator& allocator, const TextGraphicsCommand& other)
                : TextGraphicsCommand(other, allocator.get_allocator()) {}
        explicit TextGraphicsCommand(const TextGraphicsCommand& other, AnyAllocatorReference allocator)
                : font(other.font), texture(other.texture), layout(other.layout, allocator), offset(other.offset), tintColor(other.tintColor) {}
    };
 
    struct ClearGraphicsCommand final {
        Rect2 target = {0.0, 0.0, 1.0, 1.0};
 
        Color color = Color::zero;
 
        ClearGraphicsCommand() = default;
 
        ClearGraphicsCommand(const ClearGraphicsCommand&) = default;
        ClearGraphicsCommand& operator=(const ClearGraphicsCommand&) = default;
        ClearGraphicsCommand(ClearGraphicsCommand&&) noexcept = default;
        ClearGraphicsCommand& operator=(ClearGraphicsCommand&&) noexcept = default;
 
        ~ClearGraphicsCommand() = default;
 
        template<typename Allocator> ClearGraphicsCommand(std::allocator_arg_t, const Allocator& allocator) : ClearGraphicsCommand(allocator.get_allocator()) {}
        explicit ClearGraphicsCommand(AnyAllocatorReference allocator) : ClearGraphicsCommand() {}
 
        template<typename Allocator>
        explicit ClearGraphicsCommand(std::allocator_arg_t, const Allocator& allocator, const ClearGraphicsCommand& other)
                : ClearGraphicsCommand(other, allocator.get_allocator()) {}
        explicit ClearGraphicsCommand(const ClearGraphicsCommand& other, AnyAllocatorReference allocator) : ClearGraphicsCommand(other) {}
    };
 
    struct RawGraphicsCommand final {
        using Command = std::function<void(GPUCommandBuffer&, const GraphicsState&)>;
 
        Command command;
 
        RawGraphicsCommand() = default;
 
        RawGraphicsCommand(const RawGraphicsCommand&) = default;
        RawGraphicsCommand& operator=(const RawGraphicsCommand&) = default;
        RawGraphicsCommand(RawGraphicsCommand&&) noexcept = default;
        RawGraphicsCommand& operator=(RawGraphicsCommand&&) noexcept = default;
 
        ~RawGraphicsCommand() = default;
 
        template<typename Allocator> explicit RawGraphicsCommand(std::allocator_arg_t, const Allocator& allocator) : RawGraphicsCommand(allocator.get_allocator()) {}
        explicit RawGraphicsCommand(AnyAllocatorReference allocator) : RawGraphicsCommand() {}
 
        template<typename Allocator>
        explicit RawGraphicsCommand(std::allocator_arg_t, const Allocator& allocator, const RawGraphicsCommand& other)
                : RawGraphicsCommand(other, allocator.get_allocator()) {}
        explicit RawGraphicsCommand(const RawGraphicsCommand& other, AnyAllocatorReference allocator) : RawGraphicsCommand(other) {}
    };
 
    struct GraphicsCommand final {
        friend class GraphicsCommandBuffer;
 
    public:
        GraphicsState graphicsState;
 
    private:
        using Variant = Variant<std::monostate, TextureGraphicsCommand, ShapeGraphicsCommand, TextGraphicsCommand, ClearGraphicsCommand, RawGraphicsCommand>;
        Variant mData;
 
    public:
        GraphicsCommand() = default;
        explicit GraphicsCommand(const GraphicsState& graphicsState, TextureGraphicsCommand&& command) : graphicsState(graphicsState), mData(std::move(command)) {}
        explicit GraphicsCommand(const GraphicsState& graphicsState, ShapeGraphicsCommand&& command) : graphicsState(graphicsState), mData(std::move(command)) {}
        explicit GraphicsCommand(const GraphicsState& graphicsState, TextGraphicsCommand&& command) : graphicsState(graphicsState), mData(std::move(command)) {}
        explicit GraphicsCommand(const GraphicsState& graphicsState, ClearGraphicsCommand&& command) : graphicsState(graphicsState), mData(std::move(command)) {}
        explicit GraphicsCommand(const GraphicsState& graphicsState, RawGraphicsCommand&& command) : graphicsState(graphicsState), mData(std::move(command)) {}
 
        GraphicsCommand(const GraphicsCommand&) = default;
        GraphicsCommand& operator=(const GraphicsCommand&) = default;
 
        GraphicsCommand(GraphicsCommand&&) noexcept = default;
        GraphicsCommand& operator=(GraphicsCommand&&) noexcept = default;
 
        ~GraphicsCommand() = default;
 
        template<typename Allocator> explicit GraphicsCommand(std::allocator_arg_t, const Allocator& allocator) {}
 
        template<typename Allocator>
        explicit GraphicsCommand(std::allocator_arg_t, const Allocator& allocator, const GraphicsState& graphicsState, TextureGraphicsCommand&& command)
                : GraphicsCommand(graphicsState, TextureGraphicsCommand(command, allocator.get_allocator())) {}
 
        template<typename Allocator>
        explicit GraphicsCommand(std::allocator_arg_t, const Allocator& allocator, const GraphicsState& graphicsState, ShapeGraphicsCommand&& command)
                : GraphicsCommand(graphicsState, ShapeGraphicsCommand(command, allocator.get_allocator())) {}
 
        template<typename Allocator>
        explicit GraphicsCommand(std::allocator_arg_t, const Allocator& allocator, const GraphicsState& graphicsState, TextGraphicsCommand&& command)
                : GraphicsCommand(graphicsState, TextGraphicsCommand(command, allocator.get_allocator())) {}
 
        template<typename Allocator>
        explicit GraphicsCommand(std::allocator_arg_t, const Allocator& allocator, const GraphicsState& graphicsState, ClearGraphicsCommand&& command)
                : GraphicsCommand(graphicsState, ClearGraphicsCommand(command, allocator.get_allocator())) {}
 
        template<typename Allocator>
        explicit GraphicsCommand(std::allocator_arg_t, const Allocator& allocator, const GraphicsState& graphicsState, RawGraphicsCommand&& command)
                : GraphicsCommand(graphicsState, RawGraphicsCommand(command, allocator.get_allocator())) {}
 
        template<typename Allocator>
        GraphicsCommand(std::allocator_arg_t, const Allocator& allocator, const GraphicsCommand& other) : GraphicsCommand(other, allocator.get_allocator()) {}
 
        GraphicsCommand(const GraphicsCommand& other, AnyAllocatorReference allocator)
                //                : graphicsState(std::make_obj_using_allocator<GraphicsState>(allocator, other.graphicsState)),
                : graphicsState(other.graphicsState), mData(other.mData.visit([&allocator](const auto& command) -> Variant {
                      using T = std::decay_t<decltype(command)>;
                      if constexpr(std::is_same_v<T, std::monostate>) {
                          return {};
                      } else {
                          return T(command, allocator.get_allocator());
                      }
                  })) {}
 
    public:
        template<typename T> [[nodiscard]] bool is() const noexcept { return mData.is<T>(); }
        template<typename T> [[nodiscard]] T& as() { return mData.as<T>(); }
        template<typename T> [[nodiscard]] const T& as() const { return mData.as<T>(); }
 
        template<typename Visitor> decltype(auto) visit(Visitor&& visitor) const { return std::visit(std::forward<Visitor>(visitor), mData); }
    };
 
    class GraphicsCommandBuffer final {
    public:
        Deque<GraphicsCommand, AnyAllocatorReference> commands;
 
    public:
        template<typename Allocator>
        explicit GraphicsCommandBuffer(std::allocator_arg_t, const Allocator& allocator) : GraphicsCommandBuffer(allocator.get_allocator()) {}
        explicit GraphicsCommandBuffer(AnyAllocatorReference allocator) : commands(allocator) {}
 
        explicit GraphicsCommandBuffer() noexcept = default;
 
    public:
        template<typename T> T& pushCommand(const GraphicsState& graphicsState) {
            GraphicsCommand& command = commands.emplace_back(graphicsState, T());
            return command.as<T>();
        }
 
        template<typename T> T& tryReuseCommand(const GraphicsState& graphicsState) {
            if(commands.empty()) {
                return pushCommand<T>(graphicsState);
            }
 
            GraphicsCommand& command = commands.emplace_back(graphicsState, T());
            if(command.graphicsState == graphicsState || command.is<T>()) {
                return command.as<T>();
            }
 
            return pushCommand<T>(graphicsState);
        }
    };
 
} // namespace CeresEngine
 
CE_USES_ALLOCATOR(CeresEngine::TextureGraphicsCommand);
CE_USES_ALLOCATOR(CeresEngine::ShapeGraphicsCommand);
CE_USES_ALLOCATOR(CeresEngine::TextGraphicsCommand);
CE_USES_ALLOCATOR(CeresEngine::ClearGraphicsCommand);
CE_USES_ALLOCATOR(CeresEngine::RawGraphicsCommand);
CE_USES_ALLOCATOR(CeresEngine::GraphicsCommand);
CE_USES_ALLOCATOR(CeresEngine::GraphicsCommandBuffer);