VulkanDevice.h

Go to the documentation of this file.

 
#ifndef VULKAN_DEVICE_H
#define VULKAN_DEVICE_H
 
#include "global.h"
#include <vulkan/vulkan.h>
 
// Suppress nullability warnings from VMA header on macOS
#ifdef __clang__
#pragma clang diagnostic push
#pragma clang diagnostic ignored "-Wnullability-completeness"
#endif
#include <vk_mem_alloc.h>
#ifdef __clang__
#pragma clang diagnostic pop
#endif
 
#include <vector>
#include <string>
 
namespace helios {
 
    class VulkanDevice {
    public:
        VulkanDevice();
        ~VulkanDevice();
 
        // Delete copy/move constructors - this class manages Vulkan resources
        VulkanDevice(const VulkanDevice &) = delete;
        VulkanDevice &operator=(const VulkanDevice &) = delete;
        VulkanDevice(VulkanDevice &&) = delete;
        VulkanDevice &operator=(VulkanDevice &&) = delete;
 
        void initialize(bool enable_validation = false);
 
        void shutdown();
 
        bool supportsAtomicFloat() const {
            return has_atomic_float;
        }
 
        bool isMoltenVK() const {
            return is_moltenvk;
        }
 
        VkInstance getInstance() const {
            return instance;
        }
 
        VkPhysicalDevice getPhysicalDevice() const {
            return physical_device;
        }
 
        VkDevice getDevice() const {
            return device;
        }
 
        VkQueue getComputeQueue() const {
            return compute_queue;
        }
 
        uint32_t getComputeQueueFamily() const {
            return compute_queue_family;
        }
 
        VmaAllocator getAllocator() const {
            return allocator;
        }
 
        const VkPhysicalDeviceProperties &getDeviceProperties() const {
            return device_properties;
        }
 
        void printDeviceInfo() const;
 
        void probeComputeCapability();
 
    private:
        // Vulkan handles
        VkInstance instance = VK_NULL_HANDLE;
        VkPhysicalDevice physical_device = VK_NULL_HANDLE;
        VkDevice device = VK_NULL_HANDLE;
        VkQueue compute_queue = VK_NULL_HANDLE;
        uint32_t compute_queue_family = 0;
 
        // Memory allocator
        VmaAllocator allocator = VK_NULL_HANDLE;
 
        // Device properties and features
        VkPhysicalDeviceProperties device_properties{};
        bool has_atomic_float = false;
        bool is_moltenvk = false;
 
        // Optional: validation layers
        VkDebugUtilsMessengerEXT debug_messenger = VK_NULL_HANDLE;
 
        void createInstance(bool enable_validation);
 
        void selectPhysicalDevice();
 
        void createLogicalDevice();
 
        void createAllocator();
 
        void setupDebugMessenger();
 
        uint32_t findComputeQueueFamily(VkPhysicalDevice device_candidate) const;
 
        uint32_t scorePhysicalDevice(VkPhysicalDevice device_candidate) const;
 
        bool isDeviceSuitable(VkPhysicalDevice device_candidate) const;
 
        void detectMoltenVK();
 
        void detectAtomicFloat();
    };
 
} // namespace helios
 
#endif // VULKAN_DEVICE_H