GPUGraphicsPipeline.hpp

Go to the documentation of this file.

//
//  CeresEngine - A game development framework
//
//  Created by Rogiel Sulzbach.
//  Copyright (c) 2018-2022 Rogiel Sulzbach. All rights reserved.
//
 
#pragma once
 
#include "Common.hpp"
#include "Forward.hpp"
 
#include "GPUVertexFormat.hpp"
 
#include "CeresEngine/DataTypes.hpp"
#include "CeresEngine/Macros.hpp"
 
#include "CeresEngine/Foundation/Hash.hpp"
#include "CeresEngine/Foundation/SmartPtr.hpp"
#include "CeresEngine/Foundation/String.hpp"
#include "CeresEngine/Foundation/Container/SmallVector.hpp"
#include "CeresEngine/Foundation/Container/Vector.hpp"
 
#include "CeresEngine/Math/Extent.hpp"
#include "CeresEngine/Math/Math.hpp"
#include "CeresEngine/Math/Offset.hpp"
#include "CeresEngine/Mesh/PrimitiveTopology.hpp"
#include "CeresEngine/Mesh/VertexDeclaration.hpp"
 
#include <functional>
#include <iosfwd>
 
namespace CeresEngine {
    enum class CE_SCRIPT_EXPORT() GPUCompareOp {
        NeverPass,
        Less,
        Equal,
        LessEqual,
        Greater,
        NotEqual,
        GreaterEqual,
        AlwaysPass,
    };
 
    enum class CE_SCRIPT_EXPORT() GPUStencilOp {
        Keep,
        Zero,
        Replace,
        IncrementAndClamp,
        DecrementAndClamp,
        Invert,
        IncrementAndWrap,
        DecrementAndWrap,
    };
 
    enum class CE_SCRIPT_EXPORT() GPUBlendOp {
        Zero,
        One,
        SourceColor,
        InverseSourceColor,
        SourceAlpha,
        InverseSourceAlpha,
        DestinationColor,
        InverseDestinationColor,
        DestinationAlpha,
        InverseDestinationAlpha,
        SourceAlphaSaturate,
        BlendFactor,
        InverseBlendFactor,
        Source1Color,
        InverseSource1Color,
        Source1Alpha,
        InverseSource1Alpha,
    };
 
    enum class CE_SCRIPT_EXPORT() GPUBlendArithmetic {
        Add,
        Subtract,
        ReverseSubtract,
        Min,
        Max,
    };
 
    enum class CE_SCRIPT_EXPORT() GPUPolygonMode {
        Fill,
        Wireframe,
        Points,
    };
 
    enum class CE_SCRIPT_EXPORT() GPUCullMode {
        Disabled,
        Front,
        Back,
    };
 
    enum class CE_SCRIPT_EXPORT() GPULogicOp {
        Disabled,
        Clear,
        Set,
        Copy,
        CopyInverted,
        NoOp,
        Invert,
        AND,
        ANDReverse,
        ANDInverted,
        NAND,
        OR,
        ORReverse,
        ORInverted,
        NOR,
        XOR,
        Equivalent,
    };
 
    enum class GPUConservativeRasterizationMode {
        Overestimate,
 
        Underestimate
    };
 
    struct CE_SCRIPT_EXPORT() Viewport final {
        TOffset2<float> origin;
 
        TExtent2<float> extent;
 
        CE_SCRIPT_EXPORT()
        float minDepth = 0.0;
 
        CE_SCRIPT_EXPORT()
        float maxDepth = 1.0;
 
        CE_SCRIPT_EXPORT()
        Viewport() noexcept = default;
 
        CE_SCRIPT_EXPORT()
        Viewport(const Viewport&) noexcept = default;
        Viewport& operator=(const Viewport&) noexcept = default;
 
        CE_SCRIPT_EXPORT()
        CE_EXPLICIT(false) inline Viewport(const float x, const float y, const float width, const float height) noexcept : origin{x, y}, extent{width, height} {}
 
        CE_SCRIPT_EXPORT()
        CE_EXPLICIT(false) inline Viewport(const float x, const float y, const float width, const float height, const float minDepth, const float maxDepth) noexcept
                : origin{x, y}, extent{width, height}, minDepth{minDepth}, maxDepth{maxDepth} {}
 
        CE_EXPLICIT(false) inline Viewport(const TOffset2<float>& offset, const TExtent2<float>& extent) noexcept : origin{offset}, extent{extent} {}
 
        CE_EXPLICIT(false) inline Viewport(const TExtent2<float>& extent) noexcept // NOLINT
                : origin(0.0, 0.0), extent{extent} {}
 
        CE_EXPLICIT(false) inline Viewport(const TExtent2<UInt32>& extent) noexcept // NOLINT
                : Viewport(TExtent2<float>(extent)) {}
 
        CE_EXPLICIT(false) inline Viewport(const TOffset2<float>& offset, const TExtent2<float>& extent, const float minDepth, const float maxDepth) noexcept
                : origin{offset}, extent{extent}, minDepth{minDepth}, maxDepth{maxDepth} {}
 
        template<typename Processor> static constexpr void reflect(Processor&& RTTI) {
            CE_REFL_DATA(origin);
            CE_REFL_DATA(extent);
            CE_REFL_DATA(minDepth);
            CE_REFL_DATA(maxDepth);
        }
    };
 
    struct CE_SCRIPT_EXPORT() Scissor final {
        CE_SCRIPT_EXPORT()
        Int32 x = 0;
 
        CE_SCRIPT_EXPORT()
        Int32 y = 0;
 
        CE_SCRIPT_EXPORT()
        Int32 width = 0;
 
        CE_SCRIPT_EXPORT()
        Int32 height = 0;
 
        CE_SCRIPT_EXPORT()
        Scissor() noexcept = default;
 
        CE_SCRIPT_EXPORT()
        Scissor(const Scissor&) noexcept = default;
        Scissor& operator=(const Scissor&) noexcept = default;
 
        CE_SCRIPT_EXPORT()
        inline Scissor(const Int32 x, const Int32 y, const Int32 width, const Int32 height) noexcept : x{x}, y{y}, width{width}, height{height} {}
 
        inline Scissor(const TOffset2<Int32>& offset, const TExtent2<Int32>& extent) noexcept
                : x{offset.x}, y{offset.y}, width{extent.width}, height{extent.height} {}
 
        template<typename Processor> static constexpr void reflect(Processor&& RTTI) {
            CE_REFL_DATA(x);
            CE_REFL_DATA(y);
            CE_REFL_DATA(width);
            CE_REFL_DATA(height);
        }
    };
 
    struct CE_SCRIPT_EXPORT() GPUVertexInputDescriptor final {
        SmallVector<GPUVertexFormat, 1> formats;
 
    public: // Reflection
        template<typename Processor> static constexpr void reflect(Processor&& RTTI) { CE_REFL_DATA(formats); }
    };
 
    struct CE_SCRIPT_EXPORT() GPUMultiSamplingDescriptor final {
        CE_SCRIPT_EXPORT()
        bool enabled = false;
 
        CE_SCRIPT_EXPORT()
        UInt32 samples = 1;
 
        CE_SCRIPT_EXPORT()
        UInt32 sampleMask = ~0u;
 
        [[nodiscard]] CE_SCRIPT_EXPORT()
        inline UInt32 getSampleCount() const noexcept { return (enabled && samples > 1 ? samples : 1); }
 
        template<typename Processor> static constexpr void reflect(Processor&& RTTI) {
            CE_REFL_DATA(enabled);
            CE_REFL_DATA(samples);
            CE_REFL_DATA(sampleMask);
        }
    };
 
    struct CE_SCRIPT_EXPORT() GPUDepthDescriptor final {
        CE_SCRIPT_EXPORT()
        bool testEnabled = false;
 
        CE_SCRIPT_EXPORT()
        bool writeEnabled = false;
 
        CE_SCRIPT_EXPORT()
        GPUCompareOp compareOp = GPUCompareOp::Less;
 
        template<typename Processor> static constexpr void reflect(Processor&& RTTI) {
            CE_REFL_DATA(testEnabled);
            CE_REFL_DATA(writeEnabled);
            CE_REFL_DATA(compareOp);
        }
    };
 
    struct CE_SCRIPT_EXPORT() GPUStencilFaceDescriptor final {
        CE_SCRIPT_EXPORT()
        GPUStencilOp stencilFailOp = GPUStencilOp::Keep;
 
        CE_SCRIPT_EXPORT()
        GPUStencilOp depthFailOp = GPUStencilOp::Keep;
 
        CE_SCRIPT_EXPORT()
        GPUStencilOp depthPassOp = GPUStencilOp::Keep;
 
        CE_SCRIPT_EXPORT()
        GPUCompareOp compareOp = GPUCompareOp::Less;
 
        CE_SCRIPT_EXPORT()
        UInt32 readMask = ~0u;
 
        CE_SCRIPT_EXPORT()
        UInt32 writeMask = ~0u;
 
        CE_SCRIPT_EXPORT()
        UInt32 reference = 0;
 
        template<typename Processor> static constexpr void reflect(Processor&& RTTI) {
            CE_REFL_DATA(stencilFailOp);
            CE_REFL_DATA(depthFailOp);
            CE_REFL_DATA(depthPassOp);
            CE_REFL_DATA(compareOp);
            CE_REFL_DATA(readMask);
            CE_REFL_DATA(writeMask);
            CE_REFL_DATA(reference);
        }
    };
 
    struct CE_SCRIPT_EXPORT() GPUStencilDescriptor final {
        CE_SCRIPT_EXPORT()
        bool testEnabled = false;
 
        CE_SCRIPT_EXPORT()
        GPUStencilFaceDescriptor front;
 
        CE_SCRIPT_EXPORT()
        GPUStencilFaceDescriptor back;
 
        template<typename Processor> static constexpr void reflect(Processor&& RTTI) {
            CE_REFL_DATA(testEnabled);
            CE_REFL_DATA(front);
            CE_REFL_DATA(back);
        }
    };
 
    struct CE_SCRIPT_EXPORT() GPUDepthBiasDescriptor final {
        CE_SCRIPT_EXPORT()
        float constantFactor = 0.0f;
 
        CE_SCRIPT_EXPORT()
        float slopeFactor = 0.0f;
 
        CE_SCRIPT_EXPORT()
        float clamp = 0.0f;
 
        template<typename Processor> static constexpr void reflect(Processor&& RTTI) {
            CE_REFL_DATA(constantFactor);
            CE_REFL_DATA(slopeFactor);
            CE_REFL_DATA(clamp);
        }
    };
 
    struct CE_SCRIPT_EXPORT() GPUConservativeRasterizationDescriptor final {
        CE_SCRIPT_EXPORT()
        bool enabled = false;
 
        GPUConservativeRasterizationMode mode = GPUConservativeRasterizationMode::Overestimate;
 
        float extraPrimitiveOverestimationSize = 0.0f;
 
        template<typename Processor> static constexpr void reflect(Processor&& RTTI) {
            CE_REFL_DATA(enabled);
            CE_REFL_DATA(mode);
            CE_REFL_DATA(extraPrimitiveOverestimationSize);
        }
    };
 
    struct CE_SCRIPT_EXPORT() GPURasterizerDescriptor final {
        CE_SCRIPT_EXPORT()
        GPUPolygonMode polygonMode = GPUPolygonMode::Fill;
 
        CE_SCRIPT_EXPORT()
        GPUCullMode cullMode = GPUCullMode::Disabled;
 
        CE_SCRIPT_EXPORT()
        GPUDepthBiasDescriptor depthBias;
 
        CE_SCRIPT_EXPORT()
        GPUMultiSamplingDescriptor multiSampling;
 
        CE_SCRIPT_EXPORT()
        GPUConservativeRasterizationDescriptor conservativeRasterization;
 
        CE_SCRIPT_EXPORT()
        bool frontCCW = false;
 
        CE_SCRIPT_EXPORT()
        bool depthClampEnabled = false;
 
        CE_SCRIPT_EXPORT()
        bool scissorTestEnabled = false;
 
        CE_SCRIPT_EXPORT()
        bool antiAliasedLineEnabled = false;
 
        CE_SCRIPT_EXPORT()
        float lineWidth = 1.0f;
 
        template<typename Processor> static constexpr void reflect(Processor&& RTTI) {
            CE_REFL_DATA(polygonMode);
            CE_REFL_DATA(cullMode);
            CE_REFL_DATA(depthBias);
            CE_REFL_DATA(multiSampling);
            CE_REFL_DATA(conservativeRasterization);
            CE_REFL_DATA(frontCCW);
            CE_REFL_DATA(depthClampEnabled);
            CE_REFL_DATA(scissorTestEnabled);
            CE_REFL_DATA(antiAliasedLineEnabled);
            CE_REFL_DATA(lineWidth);
        }
    };
 
    struct CE_SCRIPT_EXPORT() GPUBlendTargetDescriptor final {
        CE_SCRIPT_EXPORT()
        bool blendEnabled = false;
 
        CE_SCRIPT_EXPORT()
        GPUBlendOp srcColor = GPUBlendOp::SourceAlpha;
 
        CE_SCRIPT_EXPORT()
        GPUBlendOp dstColor = GPUBlendOp::InverseSourceAlpha;
 
        CE_SCRIPT_EXPORT()
        GPUBlendArithmetic colorArithmetic = GPUBlendArithmetic::Add;
 
        CE_SCRIPT_EXPORT()
        GPUBlendOp srcAlpha = GPUBlendOp::SourceAlpha;
 
        CE_SCRIPT_EXPORT()
        GPUBlendOp dstAlpha = GPUBlendOp::InverseSourceAlpha;
 
        CE_SCRIPT_EXPORT()
        GPUBlendArithmetic alphaArithmetic = GPUBlendArithmetic::Add;
 
        CE_SCRIPT_EXPORT()
        Vector4b colorMask = {true, true, true, true};
 
        template<typename Processor> static constexpr void reflect(Processor&& RTTI) {
            CE_REFL_DATA(blendEnabled);
            CE_REFL_DATA(srcColor);
            CE_REFL_DATA(dstColor);
            CE_REFL_DATA(colorArithmetic);
            CE_REFL_DATA(srcAlpha);
            CE_REFL_DATA(dstAlpha);
            CE_REFL_DATA(alphaArithmetic);
            CE_REFL_DATA(colorMask);
        }
    };
 
    struct CE_SCRIPT_EXPORT() GPUBlendDescriptor final {
        CE_SCRIPT_EXPORT()
        bool alphaToCoverageEnabled = false;
 
        CE_SCRIPT_EXPORT()
        bool independentBlendEnabled = false;
 
        CE_SCRIPT_EXPORT()
        GPULogicOp logicOp = GPULogicOp::Disabled;
 
        CE_SCRIPT_EXPORT()
        Vector4f blendFactor = {0.0f, 0.0f, 0.0f, 0.0f};
 
        Array<GPUBlendTargetDescriptor, 8> targets;
 
        template<typename Processor> static constexpr void reflect(Processor&& RTTI) {
            CE_REFL_DATA(alphaToCoverageEnabled);
            CE_REFL_DATA(independentBlendEnabled);
            CE_REFL_DATA(logicOp);
            CE_REFL_DATA(blendFactor);
            CE_REFL_DATA(targets);
        }
    };
 
    struct GPUGraphicsPipelineState final {
        CE_SCRIPT_EXPORT()
        GPUDepthDescriptor depth;
 
        CE_SCRIPT_EXPORT()
        GPUStencilDescriptor stencil;
 
        CE_SCRIPT_EXPORT()
        GPURasterizerDescriptor rasterizer;
 
        CE_SCRIPT_EXPORT()
        GPUBlendDescriptor blend;
 
        template<typename Processor> static constexpr void reflect(Processor&& RTTI) {
            CE_REFL_DATA(depth);
            CE_REFL_DATA(stencil);
            CE_REFL_DATA(rasterizer);
            CE_REFL_DATA(blend);
        }
    };
 
    struct CE_SCRIPT_EXPORT() GPUGraphicsPipelineDescriptor final {
        CE_SCRIPT_EXPORT()
        GPUShaderProgramPtr shaderProgram = nullptr;
 
        CE_SCRIPT_EXPORT()
        GPURenderPassPtr renderPass = nullptr;
 
        CE_SCRIPT_EXPORT()
        GPUPipelineLayoutPtr pipelineLayout = nullptr;
 
        CE_SCRIPT_EXPORT()
        PrimitiveTopology primitiveTopology = PrimitiveTopology::Triangles;
 
        CE_SCRIPT_EXPORT()
        UInt32 patchControlPoints = 0;
 
        Vector<Viewport> viewports;
 
        Vector<Scissor> scissors;
 
        CE_SCRIPT_EXPORT()
        GPUVertexInputDescriptor vertexInput;
 
        CE_SCRIPT_EXPORT()
        GPUGraphicsPipelineState state;
 
        CE_SCRIPT_EXPORT()
        String name;
 
        template<typename Processor> static constexpr void reflect(Processor&& RTTI) {
            CE_REFL_DATA(shaderProgram);
            CE_REFL_DATA(renderPass);
            CE_REFL_DATA(pipelineLayout);
            CE_REFL_DATA(primitiveTopology);
            CE_REFL_DATA(patchControlPoints);
            CE_REFL_DATA(viewports);
            CE_REFL_DATA(scissors);
            CE_REFL_DATA(vertexInput);
            CE_REFL_DATA(state);
            CE_REFL_DATA(name);
        }
    };
 
    using GPURenderingBlock = std::function<void()>;
 
    class CE_SCRIPT_EXPORT() GPUGraphicsPipeline : public TDeviceObject<GPUGraphicsPipelineDescriptor> {
    public:
        using TDeviceObject::TDeviceObject;
 
        GPUGraphicsPipeline(const GPUGraphicsPipeline&) = delete;
        GPUGraphicsPipeline& operator=(const GPUGraphicsPipeline&) = delete;
 
        GPUGraphicsPipeline(GPUGraphicsPipeline&&) = delete;
        GPUGraphicsPipeline& operator=(GPUGraphicsPipeline&&) = delete;
 
    public:
        [[nodiscard]] CE_SCRIPT_EXPORT()
        virtual GPUResourceSetPtr createResourceSet(const GPUResourceSetDescriptor& descriptor, UInt32 setIndex = 0) = 0;
 
        virtual void begin(GPUCommandBuffer& commandBuffer) = 0;
 
        virtual void end(GPUCommandBuffer& commandBuffer) = 0;
 
        class Scope {
        private:
            GPUCommandBuffer* mCommandBuffer = nullptr;
 
            GPUGraphicsPipeline* mGraphicsPipeline = nullptr;
 
        public:
            explicit Scope(GPUCommandBuffer& commandBuffer, GPUGraphicsPipeline& graphicsPipeline)
                    : mCommandBuffer(&commandBuffer), mGraphicsPipeline(&graphicsPipeline) {
                mGraphicsPipeline->begin(*mCommandBuffer);
            }
 
            explicit Scope(const GPUCommandBufferPtr& commandBuffer, GPUGraphicsPipeline& graphicsPipeline) : Scope(*commandBuffer, graphicsPipeline) {}
 
            explicit Scope(GPUCommandBuffer& commandBuffer, const GPUGraphicsPipelinePtr& graphicsPipeline) : Scope(commandBuffer, *graphicsPipeline) {}
 
            explicit Scope(const GPUCommandBufferPtr& commandBuffer, const GPUGraphicsPipelinePtr& graphicsPipeline)
                    : Scope(*commandBuffer, *graphicsPipeline) {}
 
            ~Scope() noexcept { reset(); }
 
        public:
            void reset() {
                if(mGraphicsPipeline != nullptr) {
                    mGraphicsPipeline->end(*mCommandBuffer);
                    mGraphicsPipeline = nullptr;
                    mCommandBuffer = nullptr;
                }
            }
        };
 
        template<typename Func, typename... Args> decltype(auto) with(GPUCommandBuffer& commandBuffer, Func&& func) {
            const Scope scope(commandBuffer, *this);
            return func();
        }
    };
 
    std::ostream& operator<<(std::ostream& os, const GPUCompareOp& value);
 
    std::ostream& operator<<(std::ostream& os, const GPUStencilOp& value);
 
    std::ostream& operator<<(std::ostream& os, const GPUBlendOp& value);
 
    std::ostream& operator<<(std::ostream& os, const GPUBlendArithmetic& value);
 
    std::ostream& operator<<(std::ostream& os, const GPUPolygonMode& value);
 
    std::ostream& operator<<(std::ostream& os, const GPUCullMode& value);
 
    std::ostream& operator<<(std::ostream& os, const GPULogicOp& value);
 
} // namespace CeresEngine
 
CE_REFLECT_HASH(CeresEngine::Viewport);
 
CE_REFLECT_HASH(CeresEngine::Scissor);
 
CE_REFLECT_HASH(CeresEngine::GPUMultiSamplingDescriptor);
 
CE_REFLECT_HASH(CeresEngine::GPUVertexInputDescriptor);
 
CE_REFLECT_HASH(CeresEngine::GPUDepthDescriptor);
 
CE_REFLECT_HASH(CeresEngine::GPUStencilFaceDescriptor);
 
CE_REFLECT_HASH(CeresEngine::GPUStencilDescriptor);
 
CE_REFLECT_HASH(CeresEngine::GPUDepthBiasDescriptor);
 
CE_REFLECT_HASH(CeresEngine::GPUConservativeRasterizationDescriptor);
 
CE_REFLECT_HASH(CeresEngine::GPURasterizerDescriptor);
 
CE_REFLECT_HASH(CeresEngine::GPUBlendTargetDescriptor);
 
CE_REFLECT_HASH(CeresEngine::GPUBlendDescriptor);
 
CE_REFLECT_HASH(CeresEngine::GPUGraphicsPipelineState);
 
CE_REFLECT_HASH(CeresEngine::GPUGraphicsPipelineDescriptor);