ComputeShaderInterface.h

#pragma once
 
// Standard.
#include <string>
#include <memory>
#include <vector>
#include <variant>
#include <functional>
 
// Custom.
#include "misc/Error.h"
#include "render/general/pipeline/PipelineSharedPtr.h"
#include "render/general/resources/GpuResource.h"
 
namespace ne {
    class Renderer;
 
    enum class ComputeResourceUsage {
        READ_ONLY_ARRAY_BUFFER,  //< `StructuredBuffer` in HLSL, `readonly buffer` in GLSL.
        READ_WRITE_ARRAY_BUFFER, //< `RWStructuredBuffer` in HLSL, `buffer` in GLSL.
        CONSTANT_BUFFER,         //< `cbuffer` in HLSL, `uniform` in GLSL.
        READ_ONLY_TEXTURE,       //< `Texture2D` in HLSL, `uniform sampler2D` in GLSL.
        READ_WRITE_TEXTURE,      //< `RWTexture2D` in HLSL, `uniform image2D` in GLSL.
    };
 
    enum class ComputeExecutionStage : size_t {
        AFTER_DEPTH_PREPASS = 0, //< After depth texture is fully written but before color rendering (main
                                 // pass) is < started.
 
        SIZE //< Marks the size of this enum.
    };
 
    enum class ComputeExecutionGroup : size_t {
        FIRST = 0,
        SECOND,
        SIZE //< Marks the size of this enum.
    };
 
    class ComputeShaderInterface {
    public:
        ComputeShaderInterface() = delete;
        virtual ~ComputeShaderInterface();
 
        ComputeShaderInterface(const ComputeShaderInterface&) = delete;
        ComputeShaderInterface& operator=(const ComputeShaderInterface&) = delete;
 
        static std::variant<std::unique_ptr<ComputeShaderInterface>, Error> createUsingGraphicsQueue(
            Renderer* pRenderer,
            const std::string& sCompiledComputeShaderName,
            ComputeExecutionStage executionStage,
            ComputeExecutionGroup executionGroup = ComputeExecutionGroup::FIRST);
 
        [[nodiscard]] virtual std::optional<Error> bindResource(
            GpuResource* pResource,
            const std::string& sShaderResourceName,
            ComputeResourceUsage usage,
            bool bUpdateOnlyCurrentFrameResourceDescriptors = false) = 0;
 
        void submitForExecution(
            unsigned int iThreadGroupCountX,
            unsigned int iThreadGroupCountY,
            unsigned int iThreadGroupCountZ);
 
        ComputeExecutionGroup getExecutionGroup() const;
 
        ComputeExecutionStage getExecutionStage() const;
 
        std::string getComputeShaderName() const;
 
        Pipeline* getUsedPipeline() const;
 
    protected:
        static std::variant<std::unique_ptr<ComputeShaderInterface>, Error> createRenderSpecificInterface(
            Renderer* pRenderer,
            const std::string& sComputeShaderName,
            ComputeExecutionStage executionStage,
            ComputeExecutionGroup executionGroup);
 
        static std::unique_ptr<ComputeShaderInterface> createPartiallyInitializedRenderSpecificInterface(
            Renderer* pRenderer,
            const std::string& sComputeShaderName,
            ComputeExecutionStage executionStage,
            ComputeExecutionGroup executionGroup);
 
        ComputeShaderInterface(
            Renderer* pRenderer,
            const std::string& sComputeShaderName,
            ComputeExecutionStage executionStage,
            ComputeExecutionGroup executionGroup);
 
        Renderer* getRenderer();
 
        Pipeline* getPipeline() const;
 
        inline unsigned int getThreadGroupCountX() const { return iThreadGroupCountX; }
 
        inline unsigned int getThreadGroupCountY() const { return iThreadGroupCountY; }
 
        inline unsigned int getThreadGroupCountZ() const { return iThreadGroupCountZ; }
 
    private:
        Renderer* pRenderer = nullptr;
 
        PipelineSharedPtr pPipeline;
 
        unsigned int iThreadGroupCountX = 0;
 
        unsigned int iThreadGroupCountY = 0;
 
        unsigned int iThreadGroupCountZ = 0;
 
        const ComputeExecutionStage executionStage = ComputeExecutionStage::AFTER_DEPTH_PREPASS;
 
        const ComputeExecutionGroup executionGroup = ComputeExecutionGroup::FIRST;
 
        const std::string sComputeShaderName;
    };
}