VulkanInstance.h

Go to the documentation of this file.

/*--------------------------------------------------------------------------------------------
Copyright (c) 2019, NDEVR LLC
tyler.parke@ndevr.org
  __    __   ____     _____ __     __  _______
 |  \  |  | |  __ \  |  ___|\ \   / / |   __  \
 |   \ |  | | |  \ \ | |___  \ \ / /  |  |__)  |
 |  . \|  | | |__/ / | |___   \ V /   |   _   /
 |  |\    |_|_____/__|_____|___\_/____|  | \  \
 |__| \__________________________________|  \__\
 
Subject to the terms of the Enterprise+ Agreement, NDEVR hereby grants 
Licensee a limited, non-exclusive, non-transferable, royalty-free license 
(without the right to sublicense) to use the API solely for the purpose of 
Licensee's internal development efforts to develop applications for which 
the API was provided.
 
The above copyright notice and this permission notice shall be included in all 
copies or substantial portions of the Software.
 
THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED,
INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR
PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE
FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR
OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
DEALINGS IN THE SOFTWARE.
 
Library: Graphics
File: VulkanInstance
Included in API: True
Author(s): Tyler Parke
 *-----------------------------------------------------------------------------------------**/
#pragma once
#include "VulkanDefines.h"
#include "VulkanDefines.h"
#include "Base/Headers/RWLock.h"
#include "Base/Headers/String.h"
#include "Base/Headers/Pointer.hpp"
#include "Base/Headers/Buffer.hpp"
#include "Base/Headers/Time.h"
#include "Base/Headers/UUID.h"
#include "Base/Headers/ApplicationOptions.h"
#include <vulkan/vulkan.h>
 
#define VK_DEFINE_HANDLE(object) typedef struct object##_T* object;
#if !defined(DEFINE_NON_DISPATCHABLE_HANDLE)
    #if defined(__LP64__) || defined(_WIN64) || (defined(__x86_64__) && !defined(__ILP32__) ) || defined(_M_X64) || defined(__ia64) || defined (_M_IA64) || defined(__aarch64__) || defined(__powerpc64__)
    #define DEFINE_NON_DISPATCHABLE_HANDLE(object) typedef struct object##_T *object;
    #else
    #define DEFINE_NON_DISPATCHABLE_HANDLE(object) typedef uint64_t object;
    #endif
#endif
 
 
VK_DEFINE_HANDLE(VkInstance)
VK_DEFINE_HANDLE(VkPhysicalDevice)
VK_DEFINE_HANDLE(VkDevice)
VK_DEFINE_HANDLE(VkQueue)
VK_DEFINE_HANDLE(VkCommandBuffer)
 
DEFINE_NON_DISPATCHABLE_HANDLE(VkDebugReportCallbackEXT);
 
DEFINE_NON_DISPATCHABLE_HANDLE(VkSurfaceKHR);
DEFINE_NON_DISPATCHABLE_HANDLE(VkCommandPool);
DEFINE_NON_DISPATCHABLE_HANDLE(VkImageView);
struct VkApplicationInfo;
namespace NDEVR
{
    struct SwapChainSupportDetails;
    class File;
    class Log;
    class WindowInstance;
    struct Module;
    //Executes a Vulkan command and handles the results, throwing an exception if necessary.
    extern VkResult vkExecute(VkResult result, const char* error_message);
 
    /**--------------------------------------------------------------------------------------------------
    \brief The connection between the NDEVR API and the Vulkan library. See: 
        https://vulkan-tutorial.com/Drawing_a_triangle/Setup/Instance
    Creating this connection involves specifying some details about NDEVR library to the driver.
    **/
    class VulkanInstance 
    {
    public:
        VulkanInstance();
        VulkanInstance(VulkanInstance&& instance) noexcept;
        static void setupModule(Module& module);
        static Module VulkanBackupModule();
        void setDeviceLost();
        virtual ~VulkanInstance();
        bool isValid() const;
        virtual void init();
        void setLog(ProgressInfo* log);
        ProgressInfo* log() { return m_log; }
        
        void cleanup();
        const String& surfaceType() const;
        
        VkInstance vkInstance() const { lib_assert(m_vk_instance, "Instance not yet created, but access is attempted"); return m_vk_instance; }
        
        static DynamicPointer<VulkanInstance>& DefaultVulkanInstance();
        bool supportsKHRSwapchain() const;
        bool supportsTriangleFan() const;
        bool supportsValidation() const { return m_supports_validation; };
        const Buffer<String>& validationLayers() const { return m_validation_layers; };
        const Buffer<VkPhysicalDevice>& physicalDevices() const { return m_available_physical_devices; };
        virtual uint04 deviceSuitableScore(VkPhysicalDevice device);//0 = not suitable
        bool isSoftwareRendered() const;
    protected:
        virtual VkResult createVkInstance(const VkInstanceCreateInfo& create_info);
        virtual VkInstanceCreateInfo createInfo();
        virtual VkApplicationInfo applicationInfo(const String& app_name);
        virtual uint04 setupExtensions(const char**& extensions);
        virtual uint04 setupLayers(const char**& layers);
        void initializeAll();
    public:
        static String HardwareRenderedVulkanLib();
        static String SoftwareRenderedVulkanLib();
        String vulkanLibUsed() const;
    protected:
        bool checkLayerSupport(const String& layer);
        bool checkExtensionSupport(const String& layer);
        bool checkValidationSupport();
        virtual void setAvailablePhysicalDevices();
        virtual void setupInstance();
        virtual void setAvailableExtensionInfo();
        virtual void setAvailableLayerInfo();
        virtual void setupDebug();
        
        
        virtual VkSurfaceFormatKHR chooseSwapSurfaceFormat(const Buffer<VkSurfaceFormatKHR, uint04, ObjectAllocator<true>>& availableFormats);
        Time creationTime() const { return m_creation_time; }
    public:
        static Buffer<VulkanInstance*> s_instances;
    protected:
        VkInstance m_vk_instance;
        ProgressInfo* m_log;
        VkDebugReportCallbackEXT m_debug_callback;
 
        Buffer<VkExtensionProperties, uint04, ObjectAllocator<true>> m_available_extension_info;
        Buffer<VkLayerProperties, uint04, ObjectAllocator<true>> m_available_layer_info;
        Buffer<VkPhysicalDevice> m_available_physical_devices;//All devices found at init
 
        Buffer<String> m_extensions;
        Buffer<String> m_validation_layers;
        bool m_supports_validation;
        bool m_is_init = false;
        bool m_is_software_rendered = false;
        bool m_supports_tri_fan;
        String m_surface_type;
        Time m_creation_time;
    };
 
    
}