GPURenderPass.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 "GPUFormat.hpp"
#include "GPUImage.hpp"
 
#include "CeresEngine/DataTypes.hpp"
#include "CeresEngine/Macros.hpp"
 
#include "CeresEngine/Foundation/Hash.hpp"
#include "CeresEngine/Foundation/ScopeExit.hpp"
#include "CeresEngine/Foundation/SmartPtr.hpp"
#include "CeresEngine/Foundation/Container/Vector.hpp"
 
#include "CeresEngine/Math/Color.hpp"
 
#include <functional>
 
namespace CeresEngine {
 
    enum class CE_SCRIPT_EXPORT() GPUAttachmentLoadOp {
        Undefined,
 
        Load,
 
        Clear,
    };
 
    enum class CE_SCRIPT_EXPORT() GPUAttachmentStoreOp {
        Undefined,
 
        Store,
    };
 
    struct CE_SCRIPT_EXPORT() GPUAttachmentFormatDescriptor final {
        Format format = Format::Undefined;
 
        CE_SCRIPT_EXPORT()
        UInt32 samples = 1;
 
        CE_SCRIPT_EXPORT()
        GPUAttachmentLoadOp loadOp = GPUAttachmentLoadOp::Load;
 
        CE_SCRIPT_EXPORT()
        GPUAttachmentStoreOp storeOp = GPUAttachmentStoreOp::Store;
 
        CE_SCRIPT_EXPORT()
        GPUImageLayout initialLayout = GPUImageLayout::DontCare;
 
        CE_SCRIPT_EXPORT()
        GPUImageLayout finalLayout = GPUImageLayout::ShaderAccess;
 
    public: // Reflection
        template<typename Processor> static constexpr void reflect(Processor&& RTTI) {
            CE_REFL_DATA(format);
            CE_REFL_DATA(samples);
            CE_REFL_DATA(loadOp);
            CE_REFL_DATA(storeOp);
            CE_REFL_DATA(initialLayout);
            CE_REFL_DATA(finalLayout);
        }
    };
 
    struct CE_SCRIPT_EXPORT() GPURenderPassDescriptor final {
        Vector<GPUAttachmentFormatDescriptor> colorAttachments;
 
        CE_SCRIPT_EXPORT()
        GPUAttachmentFormatDescriptor depthAttachment;
 
        CE_SCRIPT_EXPORT()
        GPUAttachmentFormatDescriptor stencilAttachment;
 
        CE_SCRIPT_EXPORT()
        String name;
 
        template<typename Processor> static constexpr void reflect(Processor&& RTTI) {
            CE_REFL_DATA(colorAttachments);
            CE_REFL_DATA(depthAttachment);
            CE_REFL_DATA(stencilAttachment);
            CE_REFL_DATA(name);
        }
    };
 
    class CE_SCRIPT_EXPORT() GPURenderPass : public TDeviceObject<GPURenderPassDescriptor> {
    public:
        using TDeviceObject::TDeviceObject;
 
        GPURenderPass(const GPURenderPass&) = delete;
        GPURenderPass& operator=(const GPURenderPass&) = delete;
 
        GPURenderPass(GPURenderPass&&) = delete;
        GPURenderPass& operator=(GPURenderPass&&) = delete;
 
    public:
        virtual void begin(GPUCommandBuffer& commandBuffer, GPURenderTarget& renderTarget, const Color& clearColor = Color(0.0, 0.0, 0.0, 0.0)) = 0;
 
        virtual void end(GPUCommandBuffer& commandBuffer, GPURenderTarget& renderTarget) = 0;
 
        class Scope {
        private:
            GPUCommandBuffer* mCommandBuffer = nullptr;
 
            GPURenderPass* mRenderPass = nullptr;
 
            GPURenderTarget* mRenderTarget = nullptr;
 
        public:
            template<typename... Args>
            explicit Scope(GPUCommandBuffer& commandBuffer, GPURenderPass& renderPass, GPURenderTarget& renderTarget, Args&&... args)
                    : mCommandBuffer(&commandBuffer), mRenderPass(&renderPass), mRenderTarget(&renderTarget) {
                mRenderPass->begin(*mCommandBuffer, renderTarget, std::forward<Args>(args)...);
            }
 
            template<typename... Args>
            explicit Scope(const GPUCommandBufferPtr& commandBuffer, GPURenderPass& renderPass, GPURenderTarget& renderTarget, Args&&... args)
                    : Scope(*commandBuffer, renderPass, renderTarget, std::forward<Args>(args)...) {}
 
            template<typename... Args>
            explicit Scope(const GPUCommandBufferPtr& commandBuffer, const GPURenderPassPtr& renderPass, GPURenderTarget& renderTarget, Args&&... args)
                    : Scope(*commandBuffer, *renderPass, renderTarget, std::forward<Args>(args)...) {}
 
            template<typename... Args>
            explicit Scope(const GPUCommandBufferPtr& commandBuffer, GPURenderPass& renderPass, const GPURenderTargetPtr& renderTarget, Args&&... args)
                    : Scope(*commandBuffer, renderPass, *renderTarget, std::forward<Args>(args)...) {}
 
            template<typename... Args>
            explicit Scope(GPUCommandBuffer& commandBuffer, const GPURenderPassPtr& renderPass, GPURenderTarget& renderTarget, Args&&... args)
                    : Scope(commandBuffer, *renderPass, renderTarget, std::forward<Args>(args)...) {}
 
            template<typename... Args>
            explicit Scope(GPUCommandBuffer& commandBuffer, const GPURenderPassPtr& renderPass, const GPURenderTargetPtr& renderTarget, Args&&... args)
                    : Scope(commandBuffer, *renderPass, *renderTarget, std::forward<Args>(args)...) {}
 
            template<typename... Args>
            explicit Scope(GPUCommandBuffer& commandBuffer, GPURenderPass& renderPass, const GPURenderTargetPtr& renderTarget, Args&&... args)
                    : Scope(commandBuffer, renderPass, *renderTarget, std::forward<Args>(args)...) {}
 
            template<typename... Args>
            explicit Scope(const GPUCommandBufferPtr& commandBuffer, const GPURenderPassPtr& renderPass, const GPURenderTargetPtr& renderTarget, Args&&... args)
                    : Scope(*commandBuffer, *renderPass, *renderTarget, std::forward<Args>(args)...) {}
 
            ~Scope() noexcept { reset(); }
 
        public:
            void reset() {
                if(mRenderPass != nullptr) {
                    mRenderPass->end(*mCommandBuffer, *mRenderTarget);
                    mRenderPass = nullptr;
                    mRenderTarget = nullptr;
                    mCommandBuffer = nullptr;
                }
            }
        };
 
        template<typename Func, typename... Args>
        decltype(auto) with(GPUCommandBuffer& commandBuffer, GPURenderTarget& renderTarget, Func&& block, Args&&... args) {
            const Scope scope(commandBuffer, *this, renderTarget, std::forward<Args>(args)...);
            return block();
        }
    };
 
} // namespace CeresEngine
 
CE_REFLECT_HASH(CeresEngine::GPUAttachmentFormatDescriptor);
 
CE_REFLECT_HASH(CeresEngine::GPURenderPassDescriptor);