VKDevice.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 "VKCommon.hpp"
 
#include "VKComputePipeline.hpp"
#include "VKGraphicsPipeline.hpp"
#include "VKPipelineLayout.hpp"
#include "VKRenderPass.hpp"
#include "VKRenderTarget.hpp"
#include "VKSampler.hpp"
#include "VKShader.hpp"
 
#include "CeresEngine/DataTypes.hpp"
#include "CeresEngine/Macros.hpp"
 
#include "CeresEngine/Foundation/SmartPtr.hpp"
#include "CeresEngine/Foundation/Container/Map.hpp"
#include "CeresEngine/Foundation/Container/ObjectPool.hpp"
#include "CeresEngine/Foundation/Threading/ExecutionContext.hpp"
#include "CeresEngine/Foundation/Threading/ThreadPool.hpp"
 
#include "CeresEngine/RenderAPI/GPUDevice.hpp"
#include "CeresEngine/RenderAPI/RenderAPI.hpp"
 
namespace CeresEngine {
 
    class VKSwapchain;
    class VKMemoryAllocator;
 
    struct VKDeviceDescriptor final {
        UInt64 preferredLargeHeapBlockSize = 64 * 1024 * 1024;
 
        Vector<String> enabledExtensions = {};
 
        Vector<String> enabledLayers = {};
    };
 
    struct VKDeviceExtensionSet {
        Vector<VkExtensionProperties> properties;
        bool debugMarker = false;
 
        VKDeviceExtensionSet() = default;
        explicit VKDeviceExtensionSet(VkPhysicalDevice device);
        explicit VKDeviceExtensionSet(Vector<VkExtensionProperties> properties);
 
        [[nodiscard]] bool operator[](StringView name) const;
 
        [[nodiscard]] VKDeviceExtensionSet extract(const Vector<const char*>& extensions) const;
    };
 
    template<typename ObjectType> using VKDeviceObjectCache = VKObjectCache<ObjectType, VKDevice>;
 
    extern template class VKObjectCache<VKRenderPass, VKDevice>;
    extern template class VKObjectCache<VKPipelineLayout, VKDevice>;
    extern template class VKObjectCache<VKGraphicsPipeline, VKDevice>;
    extern template class VKObjectCache<VKComputePipeline, VKDevice>;
    extern template class VKObjectCache<VKShader, VKDevice>;
    extern template class VKObjectCache<VKShaderProgram, VKDevice>;
    extern template class VKObjectCache<VKRenderTarget, VKDevice>;
    extern template class VKObjectCache<VKSampler, VKDevice>;
 
    class VKDevice final : public GPUDevice, public VKObject<VKDevice, GPUDevice> {
        friend class VKCommandQueue;
 
    private:
        VKRenderAPI& mRenderer;
 
        VkPhysicalDevice mPhysicalDevice;
 
        VkDevice mDevice;
 
        GPUDeviceInfo mInfo;
 
        GPURenderingCapabilities mCapabilities;
 
        ThreadPool mTransferExecutor{1};
 
        LockedObject<Deque<VKCommandBufferPtr>> mPendingCommandBuffers;
 
        VkPipelineCache mPipelineCache;
 
    private:
        VkPhysicalDeviceProperties mPhysicalDeviceProperties;
        Vector<VkQueueFamilyProperties> mQueueFamilyProperties;
 
    private: // Command Queues
        VKCommandQueuePtr mGraphicsQueue;
 
        VKCommandQueuePtr mTransferQueue;
 
        VKCommandQueuePtr mComputeQueue;
 
    public: // Caches & shared objects
        VKDeviceObjectCache<VKRenderPass> renderPasses{*this};
        VKDeviceObjectCache<VKPipelineLayout> pipelineLayouts{*this};
        VKDeviceObjectCache<VKGraphicsPipeline> graphicsPipelines{*this};
        VKDeviceObjectCache<VKComputePipeline> computePipelines{*this};
        VKDeviceObjectCache<VKShader> shaders{*this};
        VKDeviceObjectCache<VKShaderProgram> shaderPrograms{*this};
        VKDeviceObjectCache<VKRenderTarget> renderTargets{*this};
        VKDeviceObjectCache<VKSampler> samplers{*this};
 
    private: // Default Objects
        VKBufferPtr mDummyBuffer;
        VKImagePtr mDummyImage;
        VKSamplerPtr mDummySampler;
 
        VKSwapchainPtr mSwapchain;
 
    private: // Memory Manager
        UPtr<VKMemoryAllocator> mMemoryAllocator;
 
    public:
        const VKDeviceExtensionSet supportedExtensions;
        VKDeviceExtensionSet enabledExtensions;
 
    public:
        VKDevice(VKRenderAPI& renderer, const GPUDeviceDescriptor& descriptor, VkPhysicalDevice physicalDevice);
        ~VKDevice() final;
 
        [[nodiscard]] CE_EXPLICIT_FALSE operator VkDevice() const noexcept { return mDevice; }
 
    public:
        [[nodiscard]] GPUCommandBufferPtr createCommandBuffer(const GPUCommandBufferDescriptor& descriptor) final;
 
        [[nodiscard]] GPURenderPassPtr createRenderPass(const GPURenderPassDescriptor& descriptor) final;
 
        [[nodiscard]] GPUPipelineLayoutPtr createPipelineLayout(const GPUPipelineLayoutDescriptor& descriptor) final;
 
        [[nodiscard]] GPUGraphicsPipelinePtr createGraphicsPipeline(const GPUGraphicsPipelineDescriptor& descriptor) final;
 
        [[nodiscard]] GPUComputePipelinePtr createComputePipeline(const GPUComputePipelineDescriptor& descriptor) final;
 
        [[nodiscard]] GPUShaderPtr createShader(const GPUShaderDescriptor& descriptor) final;
 
        [[nodiscard]] GPUShaderProgramPtr createShaderProgram(const GPUShaderProgramDescriptor& descriptor) final;
 
        [[nodiscard]] GPURenderTargetPtr createRenderTarget(const GPURenderTargetDescriptor& descriptor) final;
 
        [[nodiscard]] GPUBufferPtr createBuffer(const GPUBufferDescriptor& descriptor) final;
 
        [[nodiscard]] GPUImagePtr createImage(const GPUImageDescriptor& descriptor) final;
 
        [[nodiscard]] GPUSamplerPtr createSampler(const GPUSamplerDescriptor& descriptor) final;
 
        [[nodiscard]] GPUFencePtr createFence(const GPUFenceDescriptor& descriptor) final;
 
        [[nodiscard]] GPUTimerQueryPtr createTimerQuery(const GPUTimerQueryDescriptor& descriptor) final;
 
        [[nodiscard]] GPUOcclusionQueryPtr createOcclusionQuery(const GPUOcclusionQueryDescriptor& descriptor) final;
 
        [[nodiscard]] GPUSwapchainPtr createSwapchain(const GPUSwapchainDescriptor& descriptor) final;
 
    public: // Default Queues
        [[nodiscard]] GPUCommandQueuePtr getGraphicsQueue() final;
 
        [[nodiscard]] GPUCommandQueuePtr getTransferQueue() final;
 
        [[nodiscard]] GPUCommandQueuePtr getComputeQueue() final;
 
    public:
        void update();
        void wait();
 
        void didSubmitCommandBuffer(VKCommandBuffer& commandBuffer);
 
    public:
        [[nodiscard]] GPUBufferPtr getDummyBuffer() const;
 
        [[nodiscard]] GPUImagePtr getDummyImage() const;
 
        [[nodiscard]] GPUSamplerPtr getDummySampler() const;
 
    public:
        [[nodiscard]] VKMemoryAllocator& getMemoryAllocator() const { return *mMemoryAllocator; }
 
        [[nodiscard]] VKRenderAPI& getRenderer() { return mRenderer; }
 
        [[nodiscard]] VkPhysicalDevice getPhysicalDevice() { return mPhysicalDevice; }
 
        [[nodiscard]] VkPipelineCache getPipelineCache() const { return mPipelineCache; }
        [[nodiscard]] const VkPhysicalDeviceProperties& getPhysicalDeviceProperties() const { return mPhysicalDeviceProperties; }
        [[nodiscard]] const Vector<VkQueueFamilyProperties>& getQueueFamilyProperties() const { return mQueueFamilyProperties; }
 
    public:
        [[nodiscard]] UInt32 findMemoryType(UInt32 typeFilter, VkMemoryPropertyFlags properties);
 
        [[nodiscard]] static VkPhysicalDevice pickPhysicalDevice(VkInstance instance, const DevicePickerFunc& picker);
 
    public:
        VkAllocationCallbacks* allocationCallbacks = nullptr;
    };
 
} // namespace CeresEngine