GPUComputePipeline.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 "CeresEngine/Macros.hpp"
 
#include "CeresEngine/Foundation/Hash.hpp"
#include "CeresEngine/Foundation/SmartPtr.hpp"
#include "CeresEngine/Foundation/String.hpp"
 
#include <functional>
#include <utility>
 
namespace CeresEngine {
 
    struct CE_SCRIPT_EXPORT() GPUComputePipelineDescriptor final {
        CE_SCRIPT_EXPORT()
        GPUShaderProgramPtr shaderProgram = nullptr;
 
        CE_SCRIPT_EXPORT()
        GPUPipelineLayoutPtr pipelineLayout = nullptr;
 
        CE_SCRIPT_EXPORT()
        String name;
 
        CE_SCRIPT_EXPORT()
        GPUComputePipelineDescriptor() noexcept = default;
 
        CE_SCRIPT_EXPORT()
        inline explicit GPUComputePipelineDescriptor(GPUShaderProgramPtr shaderProgram, GPUPipelineLayoutPtr pipelineLayout = nullptr) noexcept
                : shaderProgram(std::move(shaderProgram)), pipelineLayout(std::move(pipelineLayout)) {}
 
        template<typename Processor> static constexpr void reflect(Processor&& RTTI) {
            CE_REFL_DATA(shaderProgram);
            CE_REFL_DATA(pipelineLayout);
            CE_REFL_DATA(name);
        }
    };
 
    using GPURenderingBlock = std::function<void()>;
 
    class CE_SCRIPT_EXPORT() GPUComputePipeline : public TDeviceObject<GPUComputePipelineDescriptor> {
    public:
        using TDeviceObject::TDeviceObject;
 
        GPUComputePipeline(const GPUComputePipeline&) = delete;
        GPUComputePipeline& operator=(const GPUComputePipeline&) = delete;
 
        GPUComputePipeline(GPUComputePipeline&&) = delete;
        GPUComputePipeline& operator=(GPUComputePipeline&&) = delete;
 
    public:
        [[nodiscard]] CE_SCRIPT_EXPORT()
        virtual GPUResourceSetPtr createResourceSet(const GPUResourceSetDescriptor& descriptor) = 0;
 
        virtual void begin(GPUCommandBuffer& commandBuffer) = 0;
 
        virtual void end(GPUCommandBuffer& commandBuffer) = 0;
 
        class Scope {
        private:
            GPUCommandBuffer* mCommandBuffer = nullptr;
 
            GPUComputePipeline* mComputePipeline = nullptr;
 
        public:
            explicit Scope(GPUCommandBuffer& commandBuffer, GPUComputePipeline& computePipeline)
                    : mCommandBuffer(&commandBuffer), mComputePipeline(&computePipeline) {
                mComputePipeline->begin(*mCommandBuffer);
            }
 
            explicit Scope(const GPUCommandBufferPtr& commandBuffer, GPUComputePipeline& computePipeline) : Scope(*commandBuffer, computePipeline) {}
 
            explicit Scope(GPUCommandBuffer& commandBuffer, const GPUComputePipelinePtr& computePipeline) : Scope(commandBuffer, *computePipeline) {}
 
            explicit Scope(const GPUCommandBufferPtr& commandBuffer, const GPUComputePipelinePtr& computePipeline) : Scope(*commandBuffer, *computePipeline) {}
 
            ~Scope() noexcept { reset(); }
 
        public:
            void reset() {
                if(mComputePipeline != nullptr) {
                    mComputePipeline->end(*mCommandBuffer);
                    mComputePipeline = nullptr;
                    mCommandBuffer = nullptr;
                }
            }
        };
 
        template<typename Func, typename... Args> decltype(auto) with(GPUCommandBuffer& commandBuffer, Func&& func, Args&&... args) {
            const Scope scope(commandBuffer, *this, std::forward<Args>(args)...);
            return func();
        }
    };
 
} // namespace CeresEngine
 
CE_REFLECT_HASH(CeresEngine::GPUComputePipelineDescriptor);