diff --git a/examples/VulkanTest/main.cpp b/examples/VulkanTest/main.cpp index 8a63435e3..fb42fa9aa 100644 --- a/examples/VulkanTest/main.cpp +++ b/examples/VulkanTest/main.cpp @@ -6,32 +6,8 @@ #include #include -VKAPI_ATTR VkBool32 VKAPI_CALL MyDebugReportCallback( - VkDebugUtilsMessageSeverityFlagBitsEXT messageSeverity, - VkDebugUtilsMessageTypeFlagsEXT messageTypes, - const VkDebugUtilsMessengerCallbackDataEXT* pCallbackData, - void* pUserData) -{ - if (pCallbackData->messageIdNumber != 0) - std::cerr << "#" << pCallbackData->messageIdNumber << " " << pCallbackData->messageIdNumber << ": "; - - std::cerr << pCallbackData->pMessage << std::endl; - return VK_FALSE; -} - int main() { - Nz::ParameterList params; - params.SetParameter("VkInstanceInfo_EnabledExtensionCount", 1LL); - params.SetParameter("VkInstanceInfo_EnabledExtension0", "VK_EXT_debug_report"); - - params.SetParameter("VkDeviceInfo_EnabledLayerCount", 1LL); - params.SetParameter("VkDeviceInfo_EnabledLayer0", "VK_LAYER_LUNARG_standard_validation"); - params.SetParameter("VkInstanceInfo_EnabledLayerCount", 1LL); - params.SetParameter("VkInstanceInfo_EnabledLayer0", "VK_LAYER_LUNARG_standard_validation"); - - Nz::Renderer::SetParameters(params); - Nz::Initializer loader; if (!loader) { @@ -39,31 +15,6 @@ int main() return __LINE__; } - Nz::Vk::Instance& instance = Nz::Vulkan::GetInstance(); - - VkDebugUtilsMessengerCreateInfoEXT callbackCreateInfo = { VK_STRUCTURE_TYPE_DEBUG_UTILS_MESSENGER_CREATE_INFO_EXT }; - callbackCreateInfo.messageSeverity = VK_DEBUG_UTILS_MESSAGE_SEVERITY_WARNING_BIT_EXT | VK_DEBUG_UTILS_MESSAGE_SEVERITY_ERROR_BIT_EXT | VK_DEBUG_UTILS_MESSAGE_SEVERITY_INFO_BIT_EXT | VK_DEBUG_UTILS_MESSAGE_SEVERITY_VERBOSE_BIT_EXT; - callbackCreateInfo.messageType = VK_DEBUG_UTILS_MESSAGE_TYPE_GENERAL_BIT_EXT | VK_DEBUG_UTILS_MESSAGE_TYPE_VALIDATION_BIT_EXT | VK_DEBUG_UTILS_MESSAGE_TYPE_PERFORMANCE_BIT_EXT; - callbackCreateInfo.pfnUserCallback = &MyDebugReportCallback; - - /* Register the callback */ - VkDebugUtilsMessengerEXT callback; - - instance.vkCreateDebugUtilsMessengerEXT(instance, &callbackCreateInfo, nullptr, &callback); - - - std::vector layerProperties; - if (!Nz::Vk::Loader::EnumerateInstanceLayerProperties(&layerProperties)) - { - NazaraError("Failed to enumerate instance layer properties"); - return __LINE__; - } - - for (const VkLayerProperties& properties : layerProperties) - { - std::cout << properties.layerName << ": \t" << properties.description << std::endl; - } - Nz::RenderWindow window; Nz::MeshParams meshParams; @@ -370,7 +321,5 @@ int main() } } - instance.vkDestroyDebugUtilsMessengerEXT(instance, callback, nullptr); - return EXIT_SUCCESS; } diff --git a/include/Nazara/VulkanRenderer/Wrapper/DebugUtilsMessengerEXT.hpp b/include/Nazara/VulkanRenderer/Wrapper/DebugUtilsMessengerEXT.hpp new file mode 100644 index 000000000..2a3f6fd97 --- /dev/null +++ b/include/Nazara/VulkanRenderer/Wrapper/DebugUtilsMessengerEXT.hpp @@ -0,0 +1,41 @@ +// Copyright (C) 2020 Jérôme Leclercq +// This file is part of the "Nazara Engine - Vulkan Renderer" +// For conditions of distribution and use, see copyright notice in Config.hpp + +#pragma once + +#ifndef NAZARA_VULKANRENDERER_VKDEBUGUTILSMESSENGEREXT_HPP +#define NAZARA_VULKANRENDERER_VKDEBUGUTILSMESSENGEREXT_HPP + +#include +#include + +namespace Nz +{ + namespace Vk + { + class DebugUtilsMessengerEXT : public InstanceObject + { + friend InstanceObject; + + public: + DebugUtilsMessengerEXT() = default; + DebugUtilsMessengerEXT(const DebugUtilsMessengerEXT&) = delete; + DebugUtilsMessengerEXT(DebugUtilsMessengerEXT&&) = default; + ~DebugUtilsMessengerEXT() = default; + + DebugUtilsMessengerEXT& operator=(const DebugUtilsMessengerEXT&) = delete; + DebugUtilsMessengerEXT& operator=(DebugUtilsMessengerEXT&&) = delete; + + static inline bool IsSupported(Instance& instance); + + private: + static inline VkResult CreateHelper(Instance& instance, const VkDebugUtilsMessengerCreateInfoEXT* createInfo, const VkAllocationCallbacks* allocator, VkDebugUtilsMessengerEXT* handle); + static inline void DestroyHelper(Instance& instance, VkDebugUtilsMessengerEXT handle, const VkAllocationCallbacks* allocator); + }; + } +} + +#include + +#endif // NAZARA_VULKANRENDERER_VKDEBUGUTILSMESSENGEREXT_HPP diff --git a/include/Nazara/VulkanRenderer/Wrapper/DebugUtilsMessengerEXT.inl b/include/Nazara/VulkanRenderer/Wrapper/DebugUtilsMessengerEXT.inl new file mode 100644 index 000000000..68d656676 --- /dev/null +++ b/include/Nazara/VulkanRenderer/Wrapper/DebugUtilsMessengerEXT.inl @@ -0,0 +1,29 @@ +// Copyright (C) 2020 Jérôme Leclercq +// This file is part of the "Nazara Engine - Vulkan Renderer" +// For conditions of distribution and use, see copyright notice in Config.hpp + +#include +#include + +namespace Nz +{ + namespace Vk + { + inline bool DebugUtilsMessengerEXT::IsSupported(Instance& instance) + { + return instance.vkCreateDebugUtilsMessengerEXT != nullptr; + } + + inline VkResult DebugUtilsMessengerEXT::CreateHelper(Instance& instance, const VkDebugUtilsMessengerCreateInfoEXT* createInfo, const VkAllocationCallbacks* allocator, VkDebugUtilsMessengerEXT* handle) + { + return instance.vkCreateDebugUtilsMessengerEXT(instance, createInfo, allocator, handle); + } + + inline void DebugUtilsMessengerEXT::DestroyHelper(Instance& instance, VkDebugUtilsMessengerEXT handle, const VkAllocationCallbacks* allocator) + { + return instance.vkDestroyDebugUtilsMessengerEXT(instance, handle, allocator); + } + } +} + +#include diff --git a/include/Nazara/VulkanRenderer/Wrapper/Device.hpp b/include/Nazara/VulkanRenderer/Wrapper/Device.hpp index 2f3ded74f..0dadcdfed 100644 --- a/include/Nazara/VulkanRenderer/Wrapper/Device.hpp +++ b/include/Nazara/VulkanRenderer/Wrapper/Device.hpp @@ -115,17 +115,17 @@ namespace Nz static constexpr std::size_t QueueCount = static_cast(QueueType::Max) + 1; std::unique_ptr m_internalData; + std::array m_defaultQueues; + std::unordered_set m_loadedExtensions; + std::unordered_set m_loadedLayers; + std::vector m_enabledQueuesInfos; + std::vector m_queuesByFamily; Instance& m_instance; const Vk::PhysicalDevice* m_physicalDevice; VkAllocationCallbacks m_allocator; VkDevice m_device; VkResult m_lastErrorCode; VmaAllocator m_memAllocator; - std::array m_defaultQueues; - std::unordered_set m_loadedExtensions; - std::unordered_set m_loadedLayers; - std::vector m_enabledQueuesInfos; - std::vector m_queuesByFamily; }; } } diff --git a/include/Nazara/VulkanRenderer/Wrapper/DeviceObject.inl b/include/Nazara/VulkanRenderer/Wrapper/DeviceObject.inl index 02e2de181..8f80a8e8f 100644 --- a/include/Nazara/VulkanRenderer/Wrapper/DeviceObject.inl +++ b/include/Nazara/VulkanRenderer/Wrapper/DeviceObject.inl @@ -5,8 +5,6 @@ #include #include #include -#include -#include #include namespace Nz diff --git a/include/Nazara/VulkanRenderer/Wrapper/Instance.hpp b/include/Nazara/VulkanRenderer/Wrapper/Instance.hpp index 64a70a7fd..2b17e0ffa 100644 --- a/include/Nazara/VulkanRenderer/Wrapper/Instance.hpp +++ b/include/Nazara/VulkanRenderer/Wrapper/Instance.hpp @@ -21,10 +21,10 @@ namespace Nz class NAZARA_VULKANRENDERER_API Instance { public: - inline Instance(); + Instance(); Instance(const Instance&) = delete; Instance(Instance&&) = delete; - inline ~Instance(); + ~Instance(); bool Create(const VkInstanceCreateInfo& createInfo, const VkAllocationCallbacks* allocator = nullptr); inline bool Create(const std::string& appName, UInt32 appVersion, const std::string& engineName, UInt32 engineVersion, const std::vector& layers, const std::vector& extensions, const VkAllocationCallbacks* allocator = nullptr); @@ -45,6 +45,8 @@ namespace Nz inline VkPhysicalDeviceProperties GetPhysicalDeviceProperties(VkPhysicalDevice device); bool GetPhysicalDeviceQueueFamilyProperties(VkPhysicalDevice device, std::vector* queueFamilyProperties); + void InstallDebugMessageCallback(); + inline bool IsExtensionLoaded(const std::string& extensionName) const; inline bool IsLayerLoaded(const std::string& layerName) const; inline bool IsValid() const; @@ -68,17 +70,20 @@ namespace Nz #undef NAZARA_VULKANRENDERER_INSTANCE_FUNCTION private: - inline void DestroyInstance(); + void DestroyInstance(); void ResetPointers(); inline PFN_vkVoidFunction GetProcAddr(const char* name); + struct InternalData; + + std::unique_ptr m_internalData; + std::unordered_set m_loadedExtensions; + std::unordered_set m_loadedLayers; VkAllocationCallbacks m_allocator; VkInstance m_instance; VkResult m_lastErrorCode; UInt32 m_apiVersion; - std::unordered_set m_loadedExtensions; - std::unordered_set m_loadedLayers; }; } } diff --git a/include/Nazara/VulkanRenderer/Wrapper/Instance.inl b/include/Nazara/VulkanRenderer/Wrapper/Instance.inl index a9a027d7f..0a2e6d0b5 100644 --- a/include/Nazara/VulkanRenderer/Wrapper/Instance.inl +++ b/include/Nazara/VulkanRenderer/Wrapper/Instance.inl @@ -12,17 +12,6 @@ namespace Nz { namespace Vk { - inline Instance::Instance() : - m_instance(nullptr) - { - } - - inline Instance::~Instance() - { - if (m_instance) - DestroyInstance(); - } - inline bool Instance::Create(const std::string& appName, UInt32 appVersion, const std::string& engineName, UInt32 engineVersion, const std::vector& layers, const std::vector& extensions, const VkAllocationCallbacks* allocator) { VkApplicationInfo appInfo = @@ -142,14 +131,6 @@ namespace Nz return properties; } - inline void Instance::DestroyInstance() - { - assert(m_instance != VK_NULL_HANDLE); - - if (vkDestroyInstance) - vkDestroyInstance(m_instance, (m_allocator.pfnAllocation) ? &m_allocator : nullptr); - } - inline PFN_vkVoidFunction Instance::GetProcAddr(const char* name) { PFN_vkVoidFunction func = Loader::GetInstanceProcAddr(m_instance, name); diff --git a/include/Nazara/VulkanRenderer/Wrapper/InstanceObject.hpp b/include/Nazara/VulkanRenderer/Wrapper/InstanceObject.hpp new file mode 100644 index 000000000..f1b9d431c --- /dev/null +++ b/include/Nazara/VulkanRenderer/Wrapper/InstanceObject.hpp @@ -0,0 +1,53 @@ +// Copyright (C) 2020 Jérôme Leclercq +// This file is part of the "Nazara Engine - Vulkan Renderer" +// For conditions of distribution and use, see copyright notice in Config.hpp + +#pragma once + +#ifndef NAZARA_VULKANRENDERER_VKINSTANCEOBJECT_HPP +#define NAZARA_VULKANRENDERER_VKINSTANCEOBJECT_HPP + +#include +#include +#include +#include +#include + +namespace Nz +{ + namespace Vk + { + template + class InstanceObject + { + public: + InstanceObject(); + InstanceObject(const InstanceObject&) = delete; + InstanceObject(InstanceObject&& object) noexcept; + ~InstanceObject(); + + bool Create(Instance& instance, const CreateInfo& createInfo, const VkAllocationCallbacks* allocator = nullptr); + void Destroy(); + + bool IsValid() const; + + Instance* GetInstance() const; + VkResult GetLastErrorCode() const; + + InstanceObject& operator=(const InstanceObject&) = delete; + InstanceObject& operator=(InstanceObject&& object) noexcept; + + operator VkType() const; + + protected: + MovablePtr m_instance; + VkAllocationCallbacks m_allocator; + VkType m_handle; + mutable VkResult m_lastErrorCode; + }; + } +} + +#include + +#endif // NAZARA_VULKANRENDERER_VKINSTANCEOBJECT_HPP diff --git a/include/Nazara/VulkanRenderer/Wrapper/InstanceObject.inl b/include/Nazara/VulkanRenderer/Wrapper/InstanceObject.inl new file mode 100644 index 000000000..586867564 --- /dev/null +++ b/include/Nazara/VulkanRenderer/Wrapper/InstanceObject.inl @@ -0,0 +1,103 @@ +// Copyright (C) 2020 Jérôme Leclercq +// This file is part of the "Nazara Engine - Vulkan Renderer" +// For conditions of distribution and use, see copyright notice in Config.hpp + +#include +#include +#include +#include + +namespace Nz +{ + namespace Vk + { + template + InstanceObject::InstanceObject() : + m_handle(VK_NULL_HANDLE) + { + } + + template + InstanceObject::InstanceObject(InstanceObject&& object) noexcept : + m_instance(std::move(object.m_instance)), + m_allocator(object.m_allocator), + m_handle(object.m_handle), + m_lastErrorCode(object.m_lastErrorCode) + { + object.m_handle = VK_NULL_HANDLE; + } + + template + InstanceObject::~InstanceObject() + { + Destroy(); + } + + template + bool InstanceObject::Create(Instance& instance, const CreateInfo& createInfo, const VkAllocationCallbacks* allocator) + { + m_instance = &instance; + m_lastErrorCode = C::CreateHelper(*m_instance, &createInfo, allocator, &m_handle); + if (m_lastErrorCode != VkResult::VK_SUCCESS) + { + NazaraError("Failed to create Vulkan object: " + TranslateVulkanError(m_lastErrorCode)); + return false; + } + + // Store the allocator to access them when needed + if (allocator) + m_allocator = *allocator; + else + m_allocator.pfnAllocation = nullptr; + + return true; + } + + template + void InstanceObject::Destroy() + { + if (IsValid()) + { + C::DestroyHelper(*m_instance, m_handle, (m_allocator.pfnAllocation) ? &m_allocator : nullptr); + m_handle = VK_NULL_HANDLE; + } + } + + template + bool InstanceObject::IsValid() const + { + return m_handle != VK_NULL_HANDLE; + } + + template + Instance* InstanceObject::GetInstance() const + { + return m_instance; + } + + template + VkResult InstanceObject::GetLastErrorCode() const + { + return m_lastErrorCode; + } + + template + auto InstanceObject::operator=(InstanceObject&& object) noexcept -> InstanceObject& + { + std::swap(m_allocator, object.m_allocator); + std::swap(m_instance, object.m_instance); + std::swap(m_handle, object.m_handle); + std::swap(m_lastErrorCode, object.m_lastErrorCode); + + return *this; + } + + template + InstanceObject::operator VkType() const + { + return m_handle; + } + } +} + +#include diff --git a/src/Nazara/VulkanRenderer/Vulkan.cpp b/src/Nazara/VulkanRenderer/Vulkan.cpp index fd1e8ca9e..4f55223e1 100644 --- a/src/Nazara/VulkanRenderer/Vulkan.cpp +++ b/src/Nazara/VulkanRenderer/Vulkan.cpp @@ -102,13 +102,28 @@ namespace Nz createFlags = static_cast(iParam); std::vector enabledLayers; - std::vector enabledExtensions; + + // Get supported layer list + std::unordered_set availableLayers; + std::vector layerList; + if (Vk::Loader::EnumerateInstanceLayerProperties(&layerList)) + { + for (VkLayerProperties& extProperty : layerList) + availableLayers.insert(extProperty.layerName); + } if (!parameters.GetBooleanParameter("VkInstanceInfo_OverrideEnabledLayers", &bParam) || !bParam) { //< Nazara default layers goes here + +#ifdef NAZARA_DEBUG + // Enable Vulkan validation if available in debug mode + if (availableLayers.count("VK_LAYER_LUNARG_standard_validation")) + enabledLayers.push_back("VK_LAYER_LUNARG_standard_validation"); +#endif } + std::vector enabledExtensions; std::vector additionalLayers; // Just to keep the String alive if (parameters.GetIntegerParameter("VkInstanceInfo_EnabledLayerCount", &iParam)) { @@ -127,7 +142,7 @@ namespace Nz } } - // Get extension list + // Get supported extension list std::unordered_set availableExtensions; std::vector extensionList; if (Vk::Loader::EnumerateInstanceExtensionProperties(&extensionList)) @@ -138,30 +153,26 @@ namespace Nz if (!parameters.GetBooleanParameter("VkInstanceInfo_OverrideEnabledExtensions", &bParam) || !bParam) { - enabledExtensions.push_back("VK_KHR_surface"); + enabledExtensions.push_back(VK_KHR_SURFACE_EXTENSION_NAME); #ifdef VK_USE_PLATFORM_ANDROID_KHR - enabledExtensions.push_back("VK_KHR_android_surface"); - #endif - - #ifdef VK_USE_PLATFORM_MIR_KHR - enabledExtensions.push_back("VK_KHR_mir_surface"); + enabledExtensions.push_back(VK_KHR_ANDROID_SURFACE_EXTENSION_NAME); #endif #ifdef VK_USE_PLATFORM_XCB_KHR - enabledExtensions.push_back("VK_KHR_xcb_surface"); + enabledExtensions.push_back(VK_KHR_XCB_SURFACE_EXTENSION_NAME); #endif #ifdef VK_USE_PLATFORM_XLIB_KHR - enabledExtensions.push_back("VK_KHR_xlib_surface"); + enabledExtensions.push_back(VK_KHR_XLIB_SURFACE_EXTENSION_NAME); #endif #ifdef VK_USE_PLATFORM_WAYLAND_KHR - enabledExtensions.push_back("VK_KHR_wayland_surface"); + enabledExtensions.push_back(VK_KHR_WAYLAND_SURFACE_EXTENSION_NAME); #endif #ifdef VK_USE_PLATFORM_WIN32_KHR - enabledExtensions.push_back("VK_KHR_win32_surface"); + enabledExtensions.push_back(VK_KHR_WIN32_SURFACE_EXTENSION_NAME); #endif if (availableExtensions.count(VK_KHR_GET_PHYSICAL_DEVICE_PROPERTIES_2_EXTENSION_NAME)) diff --git a/src/Nazara/VulkanRenderer/Wrapper/Instance.cpp b/src/Nazara/VulkanRenderer/Wrapper/Instance.cpp index 8d88817a4..f30416e34 100644 --- a/src/Nazara/VulkanRenderer/Wrapper/Instance.cpp +++ b/src/Nazara/VulkanRenderer/Wrapper/Instance.cpp @@ -5,19 +5,85 @@ #include #include #include +#include +#include #include +#include #include namespace Nz { namespace Vk { + namespace + { + VKAPI_ATTR VkBool32 VKAPI_CALL DebugCallback( + VkDebugUtilsMessageSeverityFlagBitsEXT messageSeverity, + VkDebugUtilsMessageTypeFlagsEXT messageTypes, + const VkDebugUtilsMessengerCallbackDataEXT* pCallbackData, + void* /*pUserData*/) + { + std::stringstream ss; + ss << "Vulkan log: "; + + if (messageSeverity & VK_DEBUG_UTILS_MESSAGE_SEVERITY_VERBOSE_BIT_EXT) + ss << "[Verbose]"; + + if (messageSeverity & VK_DEBUG_UTILS_MESSAGE_SEVERITY_INFO_BIT_EXT) + ss << "[Info]"; + + if (messageSeverity & VK_DEBUG_UTILS_MESSAGE_SEVERITY_WARNING_BIT_EXT) + ss << "[Warning]"; + + if (messageSeverity & VK_DEBUG_UTILS_MESSAGE_SEVERITY_ERROR_BIT_EXT) + ss << "[Error]"; + + + if (messageTypes & VK_DEBUG_UTILS_MESSAGE_TYPE_GENERAL_BIT_EXT) + ss << "[General]"; + + if (messageTypes & VK_DEBUG_UTILS_MESSAGE_TYPE_PERFORMANCE_BIT_EXT) + ss << "[Performance]"; + + if (messageTypes & VK_DEBUG_UTILS_MESSAGE_TYPE_VALIDATION_BIT_EXT) + ss << "[Validation]"; + + + ss << "[" << pCallbackData->messageIdNumber << ":" << pCallbackData->pMessageIdName << "]: " << pCallbackData->pMessage; + + if (messageSeverity & VK_DEBUG_UTILS_MESSAGE_SEVERITY_ERROR_BIT_EXT) + NazaraError(ss.str()); + else if (messageSeverity & VK_DEBUG_UTILS_MESSAGE_SEVERITY_WARNING_BIT_EXT) + NazaraWarning(ss.str()); + else + NazaraNotice(ss.str()); + + return VK_FALSE; //< Should the Vulkan call be aborted + } + } + + struct Instance::InternalData + { + DebugUtilsMessengerEXT debugMessenger; + }; + + Instance::Instance() : + m_instance(nullptr) + { + } + + Instance::~Instance() + { + if (m_instance) + DestroyInstance(); + } + bool Instance::Create(const VkInstanceCreateInfo& createInfo, const VkAllocationCallbacks* allocator) { m_lastErrorCode = Loader::vkCreateInstance(&createInfo, allocator, &m_instance); if (m_lastErrorCode != VkResult::VK_SUCCESS) { - NazaraError("Failed to create Vulkan instance"); + NazaraError("Failed to create Vulkan instance: " + TranslateVulkanError(m_lastErrorCode)); return false; } @@ -64,6 +130,9 @@ namespace Nz return false; } + m_internalData = std::make_unique(); + InstallDebugMessageCallback(); + return true; } @@ -140,6 +209,38 @@ namespace Nz return true; } + void Instance::InstallDebugMessageCallback() + { + NazaraAssert(m_internalData, "Instance must be created before callbacks are installed"); + + if (!Vk::DebugUtilsMessengerEXT::IsSupported(*this)) + { + NazaraWarning(VK_EXT_DEBUG_UTILS_EXTENSION_NAME " is not supported, cannot install debug message callback"); + return; + } + + VkDebugUtilsMessengerCreateInfoEXT callbackCreateInfo = { VK_STRUCTURE_TYPE_DEBUG_UTILS_MESSENGER_CREATE_INFO_EXT }; + callbackCreateInfo.messageSeverity = VK_DEBUG_UTILS_MESSAGE_SEVERITY_WARNING_BIT_EXT | VK_DEBUG_UTILS_MESSAGE_SEVERITY_ERROR_BIT_EXT | VK_DEBUG_UTILS_MESSAGE_SEVERITY_INFO_BIT_EXT | VK_DEBUG_UTILS_MESSAGE_SEVERITY_VERBOSE_BIT_EXT; + callbackCreateInfo.messageType = VK_DEBUG_UTILS_MESSAGE_TYPE_GENERAL_BIT_EXT | VK_DEBUG_UTILS_MESSAGE_TYPE_VALIDATION_BIT_EXT | VK_DEBUG_UTILS_MESSAGE_TYPE_PERFORMANCE_BIT_EXT; + callbackCreateInfo.pfnUserCallback = &DebugCallback; + + if (!m_internalData->debugMessenger.Create(*this, callbackCreateInfo)) + { + NazaraWarning("failed to install debug message callback"); + return; + } + } + + void Instance::DestroyInstance() + { + assert(m_instance != VK_NULL_HANDLE); + + m_internalData.reset(); + + if (vkDestroyInstance) + vkDestroyInstance(m_instance, (m_allocator.pfnAllocation) ? &m_allocator : nullptr); + } + void Instance::ResetPointers() { assert(m_instance != VK_NULL_HANDLE);