VulkanDevice.h

#pragma once
#include "../../VulkanGraphics/Headers/VulkanInstance.h"
#include <NDEVR/GraphicsDevice.h>
struct VkDeviceCreateInfo;
namespace NDEVR
{
    class VulkanStagingRing;
    class VulkanDevice : public GraphicsDevice
    {
    public:
        VulkanDevice(VkPhysicalDevice physical_device, const DynamicPointer<VulkanInstance>& instance);
        VulkanDevice(const DynamicPointer<VulkanInstance>& instance);
        VulkanDevice(VulkanDevice&& instance) noexcept;
        virtual ~VulkanDevice(){};
        static DynamicPointer<VulkanDevice>& DefaultVulkanDevice();
        void setDeviceLost();
        UUID id() const override { return m_id; };
 
        void init() override;
        void cleanup();
        bool isInitialized() const override { return m_is_init; }
        bool isValid() const override;
        void destroyImageView(VkImageView image_view);
        VkCommandPool getCommandPool(uint04 id = Constant<uint04>::Invalid) const;
        void destroyCommandPool(uint04 id);
        VkQueue graphicsQueue(uint04 id = Constant<uint04>::Invalid) const;
        VkQueue presentQueue(void* window) const;
        VkCommandBuffer beginSingleTimeCommands(uint04 id = Constant<uint04>::Invalid) const;
        void endSingleTimeCommands(VkCommandBuffer commandBuffer, bool wait_for_completion, uint04 id = Constant<uint04>::Invalid) const;
        uint04 checkoutID() const;
        void checkoutID(uint04 id) const;
        void returnID(uint04 id = Constant<uint04>::Invalid) const;
        uint04 maxSupportedSamples() const override;
        virtual uint04 getThreadedID() const;
        bool isSoftwareRendered() const;
    #ifdef ANDROID
        virtual bool supportsMultiThreading() const override { return false; }
    #else
        virtual bool supportsMultiThreading() const override { return true; }
    #endif
        virtual void waitForGraphicsQueue(uint04 id = Constant<uint04>::Invalid) const;
        void logPhysicalDevice();
        const VkPhysicalDeviceProperties& physicalProperties() const;
        const VkPhysicalDeviceFeatures& physicalFeatures() const;
        const VkPhysicalDeviceFeatures& enabledFeatures() const;
        const void* initLockPtr() const override;//To initialize, must hold write lock, to use must hold read lock
        VkPresentModeKHR chooseSwapPresentMode(const Buffer<VkPresentModeKHR>& availablePresentModes);
        void addSurface(VkSurfaceKHR surface);
        void removeSurface(VkSurfaceKHR surface);
    
        VkFormat findDepthFormat() const;
        DynamicPointer<VulkanInstance> instance() const;
        VkInstance vkInstance() const { lib_assert(!m_instance.isNull(), "Instance not yet created, but access is attempted"); return m_instance->vkInstance(); }
        VkDevice device() const { return m_device; }
        const VkPhysicalDevice& physicalDevice() const { return m_physical_device; }
        VulkanStagingRing* stagingRing() const;
        void setLog(LogPtr log);
        uint04 graphicsFamilyIndex() const { return m_graphics_family_index; };
        LogPtr log() { return m_log; }
        bool supportsTriangleFan() const {return m_instance->supportsTriangleFan();}
        uint04 findMemoryType(uint04 typeFilter, uint04 properties) const;
    protected:
        void setQueueFamilies();
        void setupLogicalDevice();
        bool checkDeviceExtensionSupport(VkPhysicalDevice device);
        void createCommandPool(uint04 thread) const;
        virtual VkResult createLogicalDevice(const VkDeviceCreateInfo& create_info);
        virtual void autoChoosePhysicalDevice();
    protected:
        LogPtr m_log = nullptr;                             
        VulkanStagingRing* m_staging_ring = nullptr;        
        DynamicPointer<VulkanInstance> m_instance;          
        VkDevice m_device = vk_null;                        
        VkPhysicalDevice m_physical_device = vk_null;       
        Buffer<String> m_device_extensions;                 
        Buffer<String> m_device_layers;                     
        Buffer<VkSurfaceKHR> m_surfaces;                    
        UUID m_id;                                          
        Buffer<VkQueueFamilyProperties> m_queue_families;   
        mutable VkPhysicalDeviceProperties* m_physical_properties = nullptr;    
        mutable VkPhysicalDeviceFeatures* m_physical_features = nullptr;        
        mutable VkPhysicalDeviceFeatures* m_enabled_features = nullptr;         
        uint04 m_graphics_family_index = Constant<uint04>::Invalid; 
        uint04 m_present_family_index = Constant<uint04>::Invalid;  
        Time m_creation_time;                               
 
        mutable Dictionary<uint04, VkCommandPool> m_command_pools;  
 
        mutable Dictionary<void*, VkQueue> m_present_queue;         
        mutable Dictionary<uint04, VkQueue> m_graphics_queue;       
        mutable Dictionary<uint04, uint04> m_graphics_queue_index;  
        mutable Buffer<uint04> m_checkouts;                         
        mutable Dictionary<uint04, uint04> m_thread_checkouts;      
        bool m_is_software_rendered = false;                        
        bool m_is_init = false;                                     
    };
}