GPUDevice.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 "GPUGraphicsPipeline.hpp"
#include "GPUSwapchain.hpp"
 
#include "CeresEngine/DataTypes.hpp"
#include "CeresEngine/Macros.hpp"
 
#include "CeresEngine/Foundation/Any.hpp"
#include "CeresEngine/Foundation/Async.hpp"
#include "CeresEngine/Foundation/Forward.hpp"
#include "CeresEngine/Foundation/Hash.hpp"
#include "CeresEngine/Foundation/SmartPtr.hpp"
#include "CeresEngine/Foundation/String.hpp"
 
#include <any>
#include <ostream>
 
namespace CeresEngine {
 
    enum class CE_SCRIPT_EXPORT() Origin {
        LowerLeft,
 
        UpperLeft,
    };
 
    enum class CE_SCRIPT_EXPORT() ClippingRange {
        MinusOneToOne,
 
        ZeroToOne,
    };
 
    struct CE_SCRIPT_EXPORT() GPURenderingFeatures final {
        CE_SCRIPT_EXPORT()
        bool hasRenderTargets = false;
 
        CE_SCRIPT_EXPORT()
        bool has3DImages = false;
 
        CE_SCRIPT_EXPORT()
        bool hasCubeImages = false;
 
        CE_SCRIPT_EXPORT()
        bool hasArrayImages = false;
 
        CE_SCRIPT_EXPORT()
        bool hasCubeArrayImages = false;
 
        CE_SCRIPT_EXPORT()
        bool hasMultiSampleImages = false;
 
        CE_SCRIPT_EXPORT()
        bool hasSamplers = false;
 
        CE_SCRIPT_EXPORT()
        bool hasConstantBuffers = false;
 
        CE_SCRIPT_EXPORT()
        bool hasStorageBuffers = false;
 
        CE_SCRIPT_EXPORT()
        bool hasGeometryShaders = false;
 
        CE_SCRIPT_EXPORT()
        bool hasTessellationShaders = false;
 
        CE_SCRIPT_EXPORT()
        bool hasComputeShaders = false;
 
        CE_SCRIPT_EXPORT()
        bool hasInstancing = false;
 
        CE_SCRIPT_EXPORT()
        bool hasOffsetInstancing = false;
 
        CE_SCRIPT_EXPORT()
        bool hasViewportArrays = false;
 
        CE_SCRIPT_EXPORT()
        bool hasConservativeRasterization = false;
 
        CE_SCRIPT_EXPORT()
        bool hasStreamOutputs = false;
 
        CE_SCRIPT_EXPORT()
        bool hasLogicOp = false;
 
        CE_SCRIPT_EXPORT()
        bool hasPipelineStatistics = false;
 
        CE_SCRIPT_EXPORT()
        bool hasRenderCondition = false;
 
        template<typename Processor> static constexpr void reflect(Processor&& RTTI) {
            CE_REFL_DATA(hasRenderTargets);
            CE_REFL_DATA(has3DImages);
            CE_REFL_DATA(hasCubeImages);
            CE_REFL_DATA(hasArrayImages);
            CE_REFL_DATA(hasCubeArrayImages);
            CE_REFL_DATA(hasMultiSampleImages);
            CE_REFL_DATA(hasSamplers);
            CE_REFL_DATA(hasConstantBuffers);
            CE_REFL_DATA(hasStorageBuffers);
            CE_REFL_DATA(hasGeometryShaders);
            CE_REFL_DATA(hasTessellationShaders);
            CE_REFL_DATA(hasComputeShaders);
            CE_REFL_DATA(hasInstancing);
            CE_REFL_DATA(hasOffsetInstancing);
            CE_REFL_DATA(hasViewportArrays);
            CE_REFL_DATA(hasConservativeRasterization);
            CE_REFL_DATA(hasStreamOutputs);
            CE_REFL_DATA(hasLogicOp);
            CE_REFL_DATA(hasPipelineStatistics);
            CE_REFL_DATA(hasRenderCondition);
        }
    };
 
    struct CE_SCRIPT_EXPORT() GPURenderingLimits final {
        float lineWidthRange[2] = {1.0f, 1.0f};
 
        CE_SCRIPT_EXPORT()
        float lineWidthGranularity;
 
        CE_SCRIPT_EXPORT()
        UInt32 maxImageArrayLayers = 0;
 
        CE_SCRIPT_EXPORT()
        UInt32 maxColorAttachments = 0;
 
        CE_SCRIPT_EXPORT()
        UInt32 maxPatchVertices = 0;
 
        CE_SCRIPT_EXPORT()
        UInt32 max1DImageSize = 0;
 
        CE_SCRIPT_EXPORT()
        UInt32 max2DImageSize = 0;
 
        CE_SCRIPT_EXPORT()
        UInt32 max3DImageSize = 0;
 
        CE_SCRIPT_EXPORT()
        UInt32 maxCubeImageSize = 0;
 
        CE_SCRIPT_EXPORT()
        UInt32 maxAnisotropy = 0;
 
        TVector3<UInt32> maxComputeShaderWorkGroups = {0, 0, 0};
 
        TVector3<UInt32> maxComputeShaderWorkGroupSize = {0, 0, 0};
 
        CE_SCRIPT_EXPORT()
        UInt32 maxViewports = 0;
 
        TExtent2<UInt32> maxViewportSize = {0u, 0u};
 
        CE_SCRIPT_EXPORT()
        UInt64 maxBufferSize = 0;
 
        CE_SCRIPT_EXPORT()
        UInt64 maxConstantBufferSize = 0;
 
        template<typename Processor> static constexpr void reflect(Processor&& RTTI) {
            //            CE_REFL_DATA(lineWidthRange);
            CE_REFL_DATA(lineWidthGranularity);
            CE_REFL_DATA(maxImageArrayLayers);
            CE_REFL_DATA(maxColorAttachments);
            CE_REFL_DATA(maxPatchVertices);
            CE_REFL_DATA(max1DImageSize);
            CE_REFL_DATA(max2DImageSize);
            CE_REFL_DATA(max3DImageSize);
            CE_REFL_DATA(maxCubeImageSize);
            CE_REFL_DATA(maxAnisotropy);
            CE_REFL_DATA(maxComputeShaderWorkGroups);
            CE_REFL_DATA(maxComputeShaderWorkGroupSize);
            CE_REFL_DATA(maxViewports);
            CE_REFL_DATA(maxViewportSize);
            CE_REFL_DATA(maxBufferSize);
            CE_REFL_DATA(maxConstantBufferSize);
        }
    };
 
    struct CE_SCRIPT_EXPORT() GPURenderingCapabilities final {
        CE_SCRIPT_EXPORT()
        Origin screenSpaceOrigin = Origin::UpperLeft;
 
        CE_SCRIPT_EXPORT()
        Origin imageSpaceOrigin = Origin::UpperLeft;
 
        CE_SCRIPT_EXPORT()
        ClippingRange clippingRange = ClippingRange::ZeroToOne;
 
        Vector<Format> imageFormats;
 
        CE_SCRIPT_EXPORT()
        GPURenderingFeatures features;
 
        CE_SCRIPT_EXPORT()
        GPURenderingLimits limits;
 
        template<typename Processor> static constexpr void reflect(Processor&& RTTI) {
            CE_REFL_DATA(screenSpaceOrigin);
            CE_REFL_DATA(imageSpaceOrigin);
            CE_REFL_DATA(clippingRange);
            CE_REFL_DATA(imageFormats);
            CE_REFL_DATA(features);
            CE_REFL_DATA(limits);
        }
    };
 
    struct CE_SCRIPT_EXPORT() GPUDeviceDescriptor final {
        CE_SCRIPT_EXPORT()
        GPURenderingFeatures enabledFeatures;
 
        Any rendererDescriptor;
 
        template<typename Processor> static constexpr void reflect(Processor&& RTTI) {
            CE_REFL_DATA(enabledFeatures);
            //            CE_REFL_DATA(rendererDescriptor);
        }
    };
 
    struct CE_SCRIPT_EXPORT() GPUDeviceInfo final {
        CE_SCRIPT_EXPORT()
        String rendererName;
 
        CE_SCRIPT_EXPORT()
        String deviceName;
 
        CE_SCRIPT_EXPORT()
        String vendorName;
 
        CE_SCRIPT_EXPORT()
        String shadingLanguageName;
 
        template<typename Processor> static constexpr void reflect(Processor&& RTTI) {
            CE_REFL_DATA(rendererName);
            CE_REFL_DATA(deviceName);
            CE_REFL_DATA(vendorName);
            CE_REFL_DATA(shadingLanguageName);
        }
    };
 
    class CE_SCRIPT_EXPORT() GPUDevice : public GPUObject {
    public:
        CE_SCRIPT_EXPORT(pass = "ref", readonly = true)
        ExecutionContext& transferExecutionContext;
 
        const GPUDeviceInfo& information;
 
        const GPURenderingCapabilities& capabilities;
 
    public:
        explicit GPUDevice(ExecutionContext& transferExecutionContext, const GPUDeviceInfo& information, const GPURenderingCapabilities& capabilities);
 
        ~GPUDevice() override = default;
 
        GPUDevice(const GPUDevice&) = delete;
        GPUDevice& operator=(const GPUDevice&) = delete;
 
        GPUDevice(GPUDevice&&) = delete;
        GPUDevice& operator=(GPUDevice&&) = delete;
 
    public: // Factory methods
        [[nodiscard]] CE_SCRIPT_EXPORT()
        virtual GPUCommandBufferPtr createCommandBuffer(const GPUCommandBufferDescriptor& descriptor) = 0;
 
        [[nodiscard]] CE_SCRIPT_EXPORT()
        virtual GPURenderPassPtr createRenderPass(const GPURenderPassDescriptor& descriptor) = 0;
 
        [[nodiscard]] CE_SCRIPT_EXPORT()
        virtual GPUPipelineLayoutPtr createPipelineLayout(const GPUPipelineLayoutDescriptor& descriptor) = 0;
 
        [[nodiscard]] CE_SCRIPT_EXPORT()
        virtual GPUGraphicsPipelinePtr createGraphicsPipeline(const GPUGraphicsPipelineDescriptor& descriptor) = 0;
 
        [[nodiscard]] CE_SCRIPT_EXPORT()
        virtual GPUComputePipelinePtr createComputePipeline(const GPUComputePipelineDescriptor& descriptor) = 0;
 
        [[nodiscard]] CE_SCRIPT_EXPORT()
        virtual GPUShaderPtr createShader(const GPUShaderDescriptor& descriptor) = 0;
 
        [[nodiscard]] CE_SCRIPT_EXPORT()
        virtual GPUShaderProgramPtr createShaderProgram(const GPUShaderProgramDescriptor& descriptor) = 0;
 
        [[nodiscard]] CE_SCRIPT_EXPORT()
        virtual GPURenderTargetPtr createRenderTarget(const GPURenderTargetDescriptor& descriptor) = 0;
 
        [[nodiscard]] CE_SCRIPT_EXPORT()
        virtual GPUBufferPtr createBuffer(const GPUBufferDescriptor& descriptor) = 0;
 
        [[nodiscard]] virtual Async<GPUBufferPtr> createBufferAsync(const GPUBufferDescriptor& descriptor);
 
        [[nodiscard]] CE_SCRIPT_EXPORT()
        virtual GPUImagePtr createImage(const GPUImageDescriptor& descriptor) = 0;
 
        [[nodiscard]] virtual Async<GPUImagePtr> createImageAsync(const GPUImageDescriptor& descriptor);
 
        [[nodiscard]] CE_SCRIPT_EXPORT()
        virtual GPUSamplerPtr createSampler(const GPUSamplerDescriptor& descriptor) = 0;
 
        [[nodiscard]] CE_SCRIPT_EXPORT()
        virtual GPUFencePtr createFence(const GPUFenceDescriptor& descriptor) = 0;
 
        [[nodiscard]] virtual GPUTimerQueryPtr createTimerQuery(const GPUTimerQueryDescriptor& descriptor) = 0;
 
        [[nodiscard]] virtual GPUOcclusionQueryPtr createOcclusionQuery(const GPUOcclusionQueryDescriptor& descriptor) = 0;
 
        [[nodiscard]] virtual GPUSwapchainPtr createSwapchain(const GPUSwapchainDescriptor& descriptor) = 0;
 
    public:
        [[nodiscard]] CE_SCRIPT_EXPORT()
        virtual GPUCommandQueuePtr getGraphicsQueue() = 0;
 
        [[nodiscard]] CE_SCRIPT_EXPORT()
        virtual GPUCommandQueuePtr getTransferQueue() = 0;
 
        [[nodiscard]] CE_SCRIPT_EXPORT()
        virtual GPUCommandQueuePtr getComputeQueue() = 0;
    };
 
    using ValidateRenderingCapabilitiesFunc = std::function<bool(const String& info, const String& attrib)>;
 
    [[nodiscard]] bool validateRenderingCapabilities(const GPURenderingCapabilities& presentCaps, const GPURenderingCapabilities& requiredCaps,
        const ValidateRenderingCapabilitiesFunc& callback = nullptr) noexcept;
 
    std::ostream& operator<<(std::ostream& os, const GPUDeviceInfo& info);
 
    std::ostream& operator<<(std::ostream& os, Origin origin);
 
    std::ostream& operator<<(std::ostream& os, ClippingRange clippingRange);
 
    std::ostream& operator<<(std::ostream& os, const GPURenderingFeatures& features);
 
    std::ostream& operator<<(std::ostream& os, const GPURenderingLimits& limits);
 
    std::ostream& operator<<(std::ostream& os, const GPURenderingCapabilities& capabilities);
 
} // namespace CeresEngine
 
CE_REFLECT_HASH(CeresEngine::GPURenderingFeatures);
 
CE_REFLECT_HASH(CeresEngine::GPURenderingLimits);
 
CE_REFLECT_HASH(CeresEngine::GPURenderingCapabilities);
 
CE_REFLECT_HASH(CeresEngine::GPUDeviceDescriptor);
 
CE_REFLECT_HASH(CeresEngine::GPUDeviceInfo);