vk_device_context.h

Go to the documentation of this file.

#pragma once
 
#include <gui_core/gui_base_types.h>
#include <gui_core/graphics/gui_graphics_context.h>   // tachyon::DeviceScope
#include <gui_core/graphics/gui_image.h>
#include <gui_core/windows/gui_window_backend.h>      // tachyon::OSWindowHandle
 
#include <gui_core/graphics/vulkan/vk_image.h>
#include <gui_core/graphics/vulkan/vk_meshes.h>
#include <gui_core/graphics/vulkan/vk_rhi.h>
#include <gui_core/graphics/vulkan/vk_upload_worker.h>
#include <gui_core/graphics/vulkan/vk_descriptors.h>
#include <gui_core/memory/gui_allocation_hooks.h>
 
#include <vulkan/vulkan.h>
#include <vk_mem_alloc.h>
 
#include <algorithm>
#include <array>
#include <mutex>
#include <optional>
#include <unordered_map>
#include <unordered_set>
#include <string>
#include <vector>
#include <functional>
#include <source_location>
#include <span>
 
namespace tachyon
{
    class Buffer;
    class VisualColorStyle;
    struct VisualBoxStyle;
}
 
namespace tachyon::vulkan
{
 
    struct Style;
 

    struct DeletionQueue
    {
        ::std::deque<::std::function<void()>> deletors;

        void push_function(::std::function<void()>&& function)
        {
            deletors.push_back(function);
        }

        void flush()
        {
            // Reverse order: later resources may depend on earlier ones.
            for (auto it = deletors.rbegin(); it != deletors.rend(); it++)
            {
                (*it)();
            }
 
            deletors.clear();
        }
    };

    struct FrameWaits
    {
        void Add(VkSemaphore semaphore, uint64_t value, VkPipelineStageFlags2 stageMask)
        {
            if (semaphore == VK_NULL_HANDLE)
                return;
            for (size_t i = 0; i < waits.size(); ++i)
                if (waits[i].semaphore == semaphore)
                {
                    waits[i].value      = std::max(waits[i].value, value);
                    waits[i].stageMask |= stageMask;
                    // Submitted already: it's waited on again, by the next frame too.
                    if (i < submitted)
                        std::swap(waits[i], waits[--submitted]);
                    return;
                }
            waits.push_back({ .sType = VK_STRUCTURE_TYPE_SEMAPHORE_SUBMIT_INFO, .semaphore = semaphore,
                              .value = value, .stageMask = stageMask });
        }

        std::span<const VkSemaphoreSubmitInfo> Waits() const { return waits; }
        void Submitted() { submitted = waits.size(); }
        void NextFrame()
        {
            waits.erase(waits.begin(), waits.begin() + std::ptrdiff_t(submitted));
            submitted = 0;
        }

        void Clear() { waits.clear(); submitted = 0; }
 
    private:
        std::vector<VkSemaphoreSubmitInfo> waits;
        size_t submitted = 0;   
    };

    constexpr unsigned int FRAME_DELETION_SLOT_COUNT = 3;

    class VulkanDeviceContext
    {
    public:
        using SurfaceFactory = std::function<VkSurfaceKHR(VkInstance, const VkAllocationCallbacks*, tachyon::OSWindowHandle)>;
        void SetSurfaceFactory(SurfaceFactory factory) { m_surfaceFactory = std::move(factory); }

        void SetAllocationHooks(const tachyon::AllocationHooks& hooks);
        const VkAllocationCallbacks* AllocationCallbacks() const { return m_hooks.IsSet() ? &m_allocationCallbacks : nullptr; }

        struct InstanceDebugConfig
        {
            PFN_vkDebugUtilsMessengerCallbackEXT callback = nullptr;   
            void*                                userData = nullptr;   
            bool                                 enableSyncValidation = false;   
        };

        void SetInstanceDebugConfig(const InstanceDebugConfig& cfg) { m_instanceDebugConfig = cfg; }
 
        // ---- Host-provided device ----------------------------------------

        struct ExternalDevice
        {
            VkInstance       instance = VK_NULL_HANDLE;
            VkPhysicalDevice physicalDevice = VK_NULL_HANDLE;
            VkDevice         device = VK_NULL_HANDLE;
            VkQueue          graphicsQueue = VK_NULL_HANDLE;
            uint32_t         graphicsQueueFamily = 0;
            VmaAllocator     allocator = VK_NULL_HANDLE;
            std::mutex*      queueMutex = nullptr;
        };

        void SetExternalDevice(const ExternalDevice& external) { m_externalDevice = external; }
        [[nodiscard]] bool UsesExternalDevice() const noexcept { return m_externalDevice.has_value(); }

        struct DeviceRequirements
        {
            uint32_t                         apiVersion = VK_API_VERSION_1_3;   
            VkPhysicalDeviceFeatures         features{};     
            VkPhysicalDeviceVulkan11Features features11{};   
            VkPhysicalDeviceVulkan12Features features12{};   
            VkPhysicalDeviceVulkan13Features features13{};   
            std::vector<const char*>         deviceExtensions;   
        };

        [[nodiscard]] static DeviceRequirements GetDeviceRequirements();
        [[nodiscard]] static bool CheckPhysicalDeviceSupport(VkPhysicalDevice physicalDevice, std::string* problems);

        [[nodiscard]] std::unique_lock<std::mutex> LockQueue() const { return std::unique_lock<std::mutex>(*m_queueMutex); }

        void WaitIdle() const;
 
    public:
        tachyon::Image* CreateImage(tachyon::uint2 size, tachyon::ImageFormat format, tachyon::Sampler sampler, bool mipmapped = false) const;
        tachyon::Image* CreateImage(const void* data, tachyon::uint2 size, tachyon::ImageFormat format, tachyon::Sampler sampler, bool mipmapped = false);
        void RecordPendingUploads(VkCommandBuffer cmd);

        tachyon::RHI::ResidentBufferId CreateResidentBuffer(std::span<const tachyon::RHI::UploadRequest> requests,
                                                            std::span<tachyon::DeviceAddress> addresses);
        tachyon::RHI::ResidentState GetResidentBufferState(tachyon::RHI::ResidentBufferId id) const;
        void ReleaseResidentBuffer(tachyon::RHI::ResidentBufferId id);
        size_t ResidentBufferCount() const { return m_residentBuffers.size(); }

        UploadWorker& Uploads() const { return m_uploads; }
        void WaitForUploads() const { m_uploads.Wait(); }
        void DestroyImage(tachyon::Image* img);
        void ReleaseLiveImages();
        void RebuildLiveImages();
        void DestroyImageAtEnd(tachyon::Image* img, tachyon::DeviceScope scope,
                               const std::source_location& loc =
                               std::source_location::current());

        tachyon::Buffer* UploadVisualColorStyles(::std::span<const tachyon::VisualColorStyle> colorStyles) const;
        void DestroyVisualColorStyles(tachyon::Buffer* buffer);
        void DestroyVisualColorStylesAtEnd(tachyon::Buffer* buffer, tachyon::DeviceScope scope,
                                           const std::source_location& loc =
                                           std::source_location::current());

        tachyon::Buffer* UploadVisualBoxStyles(::std::span<const tachyon::VisualBoxStyle> styles) const;
        void DestroyVisualBoxStyles(tachyon::Buffer* buffer);
        void DestroyVisualBoxStylesAtEnd(tachyon::Buffer* buffer, tachyon::DeviceScope scope,
                                         const std::source_location& loc =
                                         std::source_location::current());

        FrameWaits frameWaits;

        DeletionQueue& GetDeletionQueue(tachyon::DeviceScope scope)
        {
            switch (scope)
            {
                case tachyon::DeviceScope::Frame:       return frameDeletionQueues[frameNumber % FRAME_DELETION_SLOT_COUNT];
                case tachyon::DeviceScope::Application: return mainDeletionQueue;
                default: throw;
            }
        }

        void AdvanceFrameAndFlushDeletions()
        {
            const size_t flushSlot = (frameNumber + 1) % FRAME_DELETION_SLOT_COUNT;
            frameDeletionQueues[flushSlot].flush();
            ++frameNumber;
        }
 
    public:
        std::string      shaderDirectory;  
        GUIRenderContext renderContext;

        VkInstance       instance;
        VkDevice         device;
        VmaAllocator     allocator;
        VkPhysicalDevice chosenGPU;

        VkFence         immFence;
        VkCommandBuffer immCommandBuffer;
        VkCommandPool   immCommandPool;

        VkQueue         graphicsQueue;
        uint32_t        graphicsQueueFamily;

        VkDescriptorSetLayout singleImageDescriptorLayout;

        VkSampler defaultSamplerLinear;
        VkSampler defaultSamplerNearest;
        VkSampler defaultSamplerLinearClampToEdge;

        DeletionQueue mainDeletionQueue;
        std::array<DeletionQueue, FRAME_DELETION_SLOT_COUNT> frameDeletionQueues;
        uint64_t frameNumber{ 0 };
 
 

        VkDebugUtilsMessengerEXT debug_messenger;
        VkCommandPoolCreateInfo commandPoolInfo;
        VkFenceCreateInfo fenceCreateInfo;

        bool initialized{ false };
        tachyon::Error initError{};   

        bool Initialize();
        void Flush();  
        void Destroy(); 

        VkSurfaceKHR CreateSurface(tachyon::OSWindowHandle windowHandle);
 
    private:
        bool InitializeSharedResources();
        bool AdoptExternalDevice();
 
        SurfaceFactory m_surfaceFactory;
        tachyon::AllocationHooks  m_hooks;
        VkAllocationCallbacks m_allocationCallbacks{};
        InstanceDebugConfig m_instanceDebugConfig;
        std::optional<ExternalDevice> m_externalDevice;
        bool m_ownsInstance  = true;
        bool m_ownsDevice    = true;
        bool m_ownsAllocator = true;
 
        struct PendingUpload { Buffer staging; VkImage image; VkExtent3D extent; bool mipmapped; };
        std::vector<PendingUpload> m_pendingUploads;
 
        mutable UploadWorker m_uploads;

        struct ResidentBuffer { Buffer buffer; Buffer staging; size_t size = 0; bool ready = false; };
        std::unordered_map<tachyon::RHI::ResidentBufferId, ResidentBuffer> m_residentBuffers;
        tachyon::RHI::ResidentBufferId m_nextResidentBuffer = 1;
        mutable std::unordered_set<VulkanImage*> m_liveImages;   
 
        std::mutex  m_ownedQueueMutex;
        std::mutex* m_queueMutex = &m_ownedQueueMutex;
 
    public:

        Buffer CreateBuffer(size_t allocSize, VkBufferUsageFlags usage, VmaMemoryUsage memoryUsage) const;
        void DestroyBuffer(const Buffer& buffer) const;

        Buffer CreateMappedStorageBuffer(const void* data, size_t size, VkDeviceAddress& outAddress) const;

        VulkanImage CreateImage(VkExtent3D size, VkFormat format, VkImageUsageFlags usage, VkSampler sampler, bool mipmapped = false) const;
        void DestroyImage(const VulkanImage& img);

        VisualBoxStyleBuffers   UploadMesh(::std::span<const tachyon::VisualBoxStyle> visualBoxStyles) const;
        VisualColorStyleBuffers UploadMesh(::std::span<const tachyon::VisualColorStyle> colorStyles) const;
        void  DestroyMesh(const VisualBoxStyleBuffers& mesh) const;
        void  DestroyMesh(const VisualColorStyleBuffers& mesh) const;
 

        VkShaderModule CreateShader(::std::span<uint32_t> spirvBuffer) const;
        void DestroyShader(const VkShaderModule& shader) const;
    };

}