| // Copyright 2015-2022 The Khronos Group Inc. |
| // |
| // SPDX-License-Identifier: Apache-2.0 OR MIT |
| // |
| |
| // This header is generated from the Khronos Vulkan XML API Registry. |
| |
| #ifndef VULKAN_RAII_HPP |
| #define VULKAN_RAII_HPP |
| |
| #include <vulkan/vulkan.hpp> |
| |
| #if !defined(VULKAN_HPP_RAII_NAMESPACE) |
| # define VULKAN_HPP_RAII_NAMESPACE raii |
| #endif |
| |
| namespace VULKAN_HPP_NAMESPACE { |
| namespace VULKAN_HPP_RAII_NAMESPACE { |
| #if !defined(VULKAN_HPP_DISABLE_ENHANCED_MODE) && !defined(VULKAN_HPP_NO_EXCEPTIONS) |
| |
| template<class T, class U = T> |
| VULKAN_HPP_CONSTEXPR_14 VULKAN_HPP_INLINE T exchange(T &obj, U &&newValue) |
| { |
| # if(14 <= VULKAN_HPP_CPP_VERSION) |
| return std::exchange<T>(obj, std::forward<U>(newValue)); |
| # else |
| T oldValue = std::move(obj); |
| obj = std::forward<U>(newValue); |
| return oldValue; |
| # endif |
| } |
| |
| class ContextDispatcher : public DispatchLoaderBase |
| { |
| public: |
| ContextDispatcher(PFN_vkGetInstanceProcAddr getProcAddr) |
| : vkGetInstanceProcAddr(getProcAddr) |
| //=== VK_VERSION_1_0 === |
| , vkCreateInstance(PFN_vkCreateInstance(getProcAddr(NULL, "vkCreateInstance"))) |
| , vkEnumerateInstanceExtensionProperties(PFN_vkEnumerateInstanceExtensionProperties(getProcAddr(NULL, "vkEnumerateInstanceExtensionProperties"))) |
| , vkEnumerateInstanceLayerProperties(PFN_vkEnumerateInstanceLayerProperties(getProcAddr(NULL, "vkEnumerateInstanceLayerProperties"))) |
| //=== VK_VERSION_1_1 === |
| , vkEnumerateInstanceVersion(PFN_vkEnumerateInstanceVersion(getProcAddr(NULL, "vkEnumerateInstanceVersion"))) |
| { |
| } |
| |
| public: |
| PFN_vkGetInstanceProcAddr vkGetInstanceProcAddr = 0; |
| |
| //=== VK_VERSION_1_0 === |
| PFN_vkCreateInstance vkCreateInstance = 0; |
| PFN_vkEnumerateInstanceExtensionProperties vkEnumerateInstanceExtensionProperties = 0; |
| PFN_vkEnumerateInstanceLayerProperties vkEnumerateInstanceLayerProperties = 0; |
| |
| //=== VK_VERSION_1_1 === |
| PFN_vkEnumerateInstanceVersion vkEnumerateInstanceVersion = 0; |
| }; |
| |
| class InstanceDispatcher : public DispatchLoaderBase |
| { |
| public: |
| InstanceDispatcher(PFN_vkGetInstanceProcAddr getProcAddr, VkInstance instance) |
| : vkGetInstanceProcAddr(getProcAddr) |
| { |
| //=== VK_VERSION_1_0 === |
| vkDestroyInstance = PFN_vkDestroyInstance(vkGetInstanceProcAddr(instance, "vkDestroyInstance")); |
| vkEnumeratePhysicalDevices = PFN_vkEnumeratePhysicalDevices(vkGetInstanceProcAddr(instance, "vkEnumeratePhysicalDevices")); |
| vkGetPhysicalDeviceFeatures = PFN_vkGetPhysicalDeviceFeatures(vkGetInstanceProcAddr(instance, "vkGetPhysicalDeviceFeatures")); |
| vkGetPhysicalDeviceFormatProperties = |
| PFN_vkGetPhysicalDeviceFormatProperties(vkGetInstanceProcAddr(instance, "vkGetPhysicalDeviceFormatProperties")); |
| vkGetPhysicalDeviceImageFormatProperties = |
| PFN_vkGetPhysicalDeviceImageFormatProperties(vkGetInstanceProcAddr(instance, "vkGetPhysicalDeviceImageFormatProperties")); |
| vkGetPhysicalDeviceProperties = PFN_vkGetPhysicalDeviceProperties(vkGetInstanceProcAddr(instance, "vkGetPhysicalDeviceProperties")); |
| vkGetPhysicalDeviceQueueFamilyProperties = |
| PFN_vkGetPhysicalDeviceQueueFamilyProperties(vkGetInstanceProcAddr(instance, "vkGetPhysicalDeviceQueueFamilyProperties")); |
| vkGetPhysicalDeviceMemoryProperties = |
| PFN_vkGetPhysicalDeviceMemoryProperties(vkGetInstanceProcAddr(instance, "vkGetPhysicalDeviceMemoryProperties")); |
| vkCreateDevice = PFN_vkCreateDevice(vkGetInstanceProcAddr(instance, "vkCreateDevice")); |
| vkEnumerateDeviceExtensionProperties = |
| PFN_vkEnumerateDeviceExtensionProperties(vkGetInstanceProcAddr(instance, "vkEnumerateDeviceExtensionProperties")); |
| vkEnumerateDeviceLayerProperties = PFN_vkEnumerateDeviceLayerProperties(vkGetInstanceProcAddr(instance, "vkEnumerateDeviceLayerProperties")); |
| vkGetPhysicalDeviceSparseImageFormatProperties = |
| PFN_vkGetPhysicalDeviceSparseImageFormatProperties(vkGetInstanceProcAddr(instance, "vkGetPhysicalDeviceSparseImageFormatProperties")); |
| |
| //=== VK_VERSION_1_1 === |
| vkEnumeratePhysicalDeviceGroups = PFN_vkEnumeratePhysicalDeviceGroups(vkGetInstanceProcAddr(instance, "vkEnumeratePhysicalDeviceGroups")); |
| vkGetPhysicalDeviceFeatures2 = PFN_vkGetPhysicalDeviceFeatures2(vkGetInstanceProcAddr(instance, "vkGetPhysicalDeviceFeatures2")); |
| vkGetPhysicalDeviceProperties2 = PFN_vkGetPhysicalDeviceProperties2(vkGetInstanceProcAddr(instance, "vkGetPhysicalDeviceProperties2")); |
| vkGetPhysicalDeviceFormatProperties2 = |
| PFN_vkGetPhysicalDeviceFormatProperties2(vkGetInstanceProcAddr(instance, "vkGetPhysicalDeviceFormatProperties2")); |
| vkGetPhysicalDeviceImageFormatProperties2 = |
| PFN_vkGetPhysicalDeviceImageFormatProperties2(vkGetInstanceProcAddr(instance, "vkGetPhysicalDeviceImageFormatProperties2")); |
| vkGetPhysicalDeviceQueueFamilyProperties2 = |
| PFN_vkGetPhysicalDeviceQueueFamilyProperties2(vkGetInstanceProcAddr(instance, "vkGetPhysicalDeviceQueueFamilyProperties2")); |
| vkGetPhysicalDeviceMemoryProperties2 = |
| PFN_vkGetPhysicalDeviceMemoryProperties2(vkGetInstanceProcAddr(instance, "vkGetPhysicalDeviceMemoryProperties2")); |
| vkGetPhysicalDeviceSparseImageFormatProperties2 = |
| PFN_vkGetPhysicalDeviceSparseImageFormatProperties2(vkGetInstanceProcAddr(instance, "vkGetPhysicalDeviceSparseImageFormatProperties2")); |
| vkGetPhysicalDeviceExternalBufferProperties = |
| PFN_vkGetPhysicalDeviceExternalBufferProperties(vkGetInstanceProcAddr(instance, "vkGetPhysicalDeviceExternalBufferProperties")); |
| vkGetPhysicalDeviceExternalFenceProperties = |
| PFN_vkGetPhysicalDeviceExternalFenceProperties(vkGetInstanceProcAddr(instance, "vkGetPhysicalDeviceExternalFenceProperties")); |
| vkGetPhysicalDeviceExternalSemaphoreProperties = |
| PFN_vkGetPhysicalDeviceExternalSemaphoreProperties(vkGetInstanceProcAddr(instance, "vkGetPhysicalDeviceExternalSemaphoreProperties")); |
| |
| //=== VK_VERSION_1_3 === |
| vkGetPhysicalDeviceToolProperties = PFN_vkGetPhysicalDeviceToolProperties(vkGetInstanceProcAddr(instance, "vkGetPhysicalDeviceToolProperties")); |
| |
| //=== VK_EXT_acquire_drm_display === |
| vkAcquireDrmDisplayEXT = PFN_vkAcquireDrmDisplayEXT(vkGetInstanceProcAddr(instance, "vkAcquireDrmDisplayEXT")); |
| vkGetDrmDisplayEXT = PFN_vkGetDrmDisplayEXT(vkGetInstanceProcAddr(instance, "vkGetDrmDisplayEXT")); |
| |
| # if defined(VK_USE_PLATFORM_XLIB_XRANDR_EXT) |
| //=== VK_EXT_acquire_xlib_display === |
| vkAcquireXlibDisplayEXT = PFN_vkAcquireXlibDisplayEXT(vkGetInstanceProcAddr(instance, "vkAcquireXlibDisplayEXT")); |
| vkGetRandROutputDisplayEXT = PFN_vkGetRandROutputDisplayEXT(vkGetInstanceProcAddr(instance, "vkGetRandROutputDisplayEXT")); |
| # endif /*VK_USE_PLATFORM_XLIB_XRANDR_EXT*/ |
| |
| //=== VK_EXT_calibrated_timestamps === |
| vkGetPhysicalDeviceCalibrateableTimeDomainsEXT = |
| PFN_vkGetPhysicalDeviceCalibrateableTimeDomainsEXT(vkGetInstanceProcAddr(instance, "vkGetPhysicalDeviceCalibrateableTimeDomainsEXT")); |
| |
| //=== VK_EXT_debug_report === |
| vkCreateDebugReportCallbackEXT = PFN_vkCreateDebugReportCallbackEXT(vkGetInstanceProcAddr(instance, "vkCreateDebugReportCallbackEXT")); |
| vkDestroyDebugReportCallbackEXT = PFN_vkDestroyDebugReportCallbackEXT(vkGetInstanceProcAddr(instance, "vkDestroyDebugReportCallbackEXT")); |
| vkDebugReportMessageEXT = PFN_vkDebugReportMessageEXT(vkGetInstanceProcAddr(instance, "vkDebugReportMessageEXT")); |
| |
| //=== VK_EXT_debug_utils === |
| vkCreateDebugUtilsMessengerEXT = PFN_vkCreateDebugUtilsMessengerEXT(vkGetInstanceProcAddr(instance, "vkCreateDebugUtilsMessengerEXT")); |
| vkDestroyDebugUtilsMessengerEXT = PFN_vkDestroyDebugUtilsMessengerEXT(vkGetInstanceProcAddr(instance, "vkDestroyDebugUtilsMessengerEXT")); |
| vkSubmitDebugUtilsMessageEXT = PFN_vkSubmitDebugUtilsMessageEXT(vkGetInstanceProcAddr(instance, "vkSubmitDebugUtilsMessageEXT")); |
| |
| //=== VK_EXT_direct_mode_display === |
| vkReleaseDisplayEXT = PFN_vkReleaseDisplayEXT(vkGetInstanceProcAddr(instance, "vkReleaseDisplayEXT")); |
| |
| # if defined(VK_USE_PLATFORM_DIRECTFB_EXT) |
| //=== VK_EXT_directfb_surface === |
| vkCreateDirectFBSurfaceEXT = PFN_vkCreateDirectFBSurfaceEXT(vkGetInstanceProcAddr(instance, "vkCreateDirectFBSurfaceEXT")); |
| vkGetPhysicalDeviceDirectFBPresentationSupportEXT = |
| PFN_vkGetPhysicalDeviceDirectFBPresentationSupportEXT(vkGetInstanceProcAddr(instance, "vkGetPhysicalDeviceDirectFBPresentationSupportEXT")); |
| # endif /*VK_USE_PLATFORM_DIRECTFB_EXT*/ |
| |
| //=== VK_EXT_display_surface_counter === |
| vkGetPhysicalDeviceSurfaceCapabilities2EXT = |
| PFN_vkGetPhysicalDeviceSurfaceCapabilities2EXT(vkGetInstanceProcAddr(instance, "vkGetPhysicalDeviceSurfaceCapabilities2EXT")); |
| |
| # if defined(VK_USE_PLATFORM_WIN32_KHR) |
| //=== VK_EXT_full_screen_exclusive === |
| vkGetPhysicalDeviceSurfacePresentModes2EXT = |
| PFN_vkGetPhysicalDeviceSurfacePresentModes2EXT(vkGetInstanceProcAddr(instance, "vkGetPhysicalDeviceSurfacePresentModes2EXT")); |
| # endif /*VK_USE_PLATFORM_WIN32_KHR*/ |
| |
| //=== VK_EXT_headless_surface === |
| vkCreateHeadlessSurfaceEXT = PFN_vkCreateHeadlessSurfaceEXT(vkGetInstanceProcAddr(instance, "vkCreateHeadlessSurfaceEXT")); |
| |
| # if defined(VK_USE_PLATFORM_METAL_EXT) |
| //=== VK_EXT_metal_surface === |
| vkCreateMetalSurfaceEXT = PFN_vkCreateMetalSurfaceEXT(vkGetInstanceProcAddr(instance, "vkCreateMetalSurfaceEXT")); |
| # endif /*VK_USE_PLATFORM_METAL_EXT*/ |
| |
| //=== VK_EXT_sample_locations === |
| vkGetPhysicalDeviceMultisamplePropertiesEXT = |
| PFN_vkGetPhysicalDeviceMultisamplePropertiesEXT(vkGetInstanceProcAddr(instance, "vkGetPhysicalDeviceMultisamplePropertiesEXT")); |
| |
| //=== VK_EXT_tooling_info === |
| vkGetPhysicalDeviceToolPropertiesEXT = |
| PFN_vkGetPhysicalDeviceToolPropertiesEXT(vkGetInstanceProcAddr(instance, "vkGetPhysicalDeviceToolPropertiesEXT")); |
| if(!vkGetPhysicalDeviceToolProperties) |
| vkGetPhysicalDeviceToolProperties = vkGetPhysicalDeviceToolPropertiesEXT; |
| |
| # if defined(VK_USE_PLATFORM_FUCHSIA) |
| //=== VK_FUCHSIA_imagepipe_surface === |
| vkCreateImagePipeSurfaceFUCHSIA = PFN_vkCreateImagePipeSurfaceFUCHSIA(vkGetInstanceProcAddr(instance, "vkCreateImagePipeSurfaceFUCHSIA")); |
| # endif /*VK_USE_PLATFORM_FUCHSIA*/ |
| |
| # if defined(VK_USE_PLATFORM_GGP) |
| //=== VK_GGP_stream_descriptor_surface === |
| vkCreateStreamDescriptorSurfaceGGP = PFN_vkCreateStreamDescriptorSurfaceGGP(vkGetInstanceProcAddr(instance, "vkCreateStreamDescriptorSurfaceGGP")); |
| # endif /*VK_USE_PLATFORM_GGP*/ |
| |
| # if defined(VK_USE_PLATFORM_ANDROID_KHR) |
| //=== VK_KHR_android_surface === |
| vkCreateAndroidSurfaceKHR = PFN_vkCreateAndroidSurfaceKHR(vkGetInstanceProcAddr(instance, "vkCreateAndroidSurfaceKHR")); |
| # endif /*VK_USE_PLATFORM_ANDROID_KHR*/ |
| |
| //=== VK_KHR_device_group === |
| vkGetPhysicalDevicePresentRectanglesKHR = |
| PFN_vkGetPhysicalDevicePresentRectanglesKHR(vkGetInstanceProcAddr(instance, "vkGetPhysicalDevicePresentRectanglesKHR")); |
| |
| //=== VK_KHR_device_group_creation === |
| vkEnumeratePhysicalDeviceGroupsKHR = PFN_vkEnumeratePhysicalDeviceGroupsKHR(vkGetInstanceProcAddr(instance, "vkEnumeratePhysicalDeviceGroupsKHR")); |
| if(!vkEnumeratePhysicalDeviceGroups) |
| vkEnumeratePhysicalDeviceGroups = vkEnumeratePhysicalDeviceGroupsKHR; |
| |
| //=== VK_KHR_display === |
| vkGetPhysicalDeviceDisplayPropertiesKHR = |
| PFN_vkGetPhysicalDeviceDisplayPropertiesKHR(vkGetInstanceProcAddr(instance, "vkGetPhysicalDeviceDisplayPropertiesKHR")); |
| vkGetPhysicalDeviceDisplayPlanePropertiesKHR = |
| PFN_vkGetPhysicalDeviceDisplayPlanePropertiesKHR(vkGetInstanceProcAddr(instance, "vkGetPhysicalDeviceDisplayPlanePropertiesKHR")); |
| vkGetDisplayPlaneSupportedDisplaysKHR = |
| PFN_vkGetDisplayPlaneSupportedDisplaysKHR(vkGetInstanceProcAddr(instance, "vkGetDisplayPlaneSupportedDisplaysKHR")); |
| vkGetDisplayModePropertiesKHR = PFN_vkGetDisplayModePropertiesKHR(vkGetInstanceProcAddr(instance, "vkGetDisplayModePropertiesKHR")); |
| vkCreateDisplayModeKHR = PFN_vkCreateDisplayModeKHR(vkGetInstanceProcAddr(instance, "vkCreateDisplayModeKHR")); |
| vkGetDisplayPlaneCapabilitiesKHR = PFN_vkGetDisplayPlaneCapabilitiesKHR(vkGetInstanceProcAddr(instance, "vkGetDisplayPlaneCapabilitiesKHR")); |
| vkCreateDisplayPlaneSurfaceKHR = PFN_vkCreateDisplayPlaneSurfaceKHR(vkGetInstanceProcAddr(instance, "vkCreateDisplayPlaneSurfaceKHR")); |
| |
| //=== VK_KHR_external_fence_capabilities === |
| vkGetPhysicalDeviceExternalFencePropertiesKHR = |
| PFN_vkGetPhysicalDeviceExternalFencePropertiesKHR(vkGetInstanceProcAddr(instance, "vkGetPhysicalDeviceExternalFencePropertiesKHR")); |
| if(!vkGetPhysicalDeviceExternalFenceProperties) |
| vkGetPhysicalDeviceExternalFenceProperties = vkGetPhysicalDeviceExternalFencePropertiesKHR; |
| |
| //=== VK_KHR_external_memory_capabilities === |
| vkGetPhysicalDeviceExternalBufferPropertiesKHR = |
| PFN_vkGetPhysicalDeviceExternalBufferPropertiesKHR(vkGetInstanceProcAddr(instance, "vkGetPhysicalDeviceExternalBufferPropertiesKHR")); |
| if(!vkGetPhysicalDeviceExternalBufferProperties) |
| vkGetPhysicalDeviceExternalBufferProperties = vkGetPhysicalDeviceExternalBufferPropertiesKHR; |
| |
| //=== VK_KHR_external_semaphore_capabilities === |
| vkGetPhysicalDeviceExternalSemaphorePropertiesKHR = |
| PFN_vkGetPhysicalDeviceExternalSemaphorePropertiesKHR(vkGetInstanceProcAddr(instance, "vkGetPhysicalDeviceExternalSemaphorePropertiesKHR")); |
| if(!vkGetPhysicalDeviceExternalSemaphoreProperties) |
| vkGetPhysicalDeviceExternalSemaphoreProperties = vkGetPhysicalDeviceExternalSemaphorePropertiesKHR; |
| |
| //=== VK_KHR_fragment_shading_rate === |
| vkGetPhysicalDeviceFragmentShadingRatesKHR = |
| PFN_vkGetPhysicalDeviceFragmentShadingRatesKHR(vkGetInstanceProcAddr(instance, "vkGetPhysicalDeviceFragmentShadingRatesKHR")); |
| |
| //=== VK_KHR_get_display_properties2 === |
| vkGetPhysicalDeviceDisplayProperties2KHR = |
| PFN_vkGetPhysicalDeviceDisplayProperties2KHR(vkGetInstanceProcAddr(instance, "vkGetPhysicalDeviceDisplayProperties2KHR")); |
| vkGetPhysicalDeviceDisplayPlaneProperties2KHR = |
| PFN_vkGetPhysicalDeviceDisplayPlaneProperties2KHR(vkGetInstanceProcAddr(instance, "vkGetPhysicalDeviceDisplayPlaneProperties2KHR")); |
| vkGetDisplayModeProperties2KHR = PFN_vkGetDisplayModeProperties2KHR(vkGetInstanceProcAddr(instance, "vkGetDisplayModeProperties2KHR")); |
| vkGetDisplayPlaneCapabilities2KHR = PFN_vkGetDisplayPlaneCapabilities2KHR(vkGetInstanceProcAddr(instance, "vkGetDisplayPlaneCapabilities2KHR")); |
| |
| //=== VK_KHR_get_physical_device_properties2 === |
| vkGetPhysicalDeviceFeatures2KHR = PFN_vkGetPhysicalDeviceFeatures2KHR(vkGetInstanceProcAddr(instance, "vkGetPhysicalDeviceFeatures2KHR")); |
| if(!vkGetPhysicalDeviceFeatures2) |
| vkGetPhysicalDeviceFeatures2 = vkGetPhysicalDeviceFeatures2KHR; |
| vkGetPhysicalDeviceProperties2KHR = PFN_vkGetPhysicalDeviceProperties2KHR(vkGetInstanceProcAddr(instance, "vkGetPhysicalDeviceProperties2KHR")); |
| if(!vkGetPhysicalDeviceProperties2) |
| vkGetPhysicalDeviceProperties2 = vkGetPhysicalDeviceProperties2KHR; |
| vkGetPhysicalDeviceFormatProperties2KHR = |
| PFN_vkGetPhysicalDeviceFormatProperties2KHR(vkGetInstanceProcAddr(instance, "vkGetPhysicalDeviceFormatProperties2KHR")); |
| if(!vkGetPhysicalDeviceFormatProperties2) |
| vkGetPhysicalDeviceFormatProperties2 = vkGetPhysicalDeviceFormatProperties2KHR; |
| vkGetPhysicalDeviceImageFormatProperties2KHR = |
| PFN_vkGetPhysicalDeviceImageFormatProperties2KHR(vkGetInstanceProcAddr(instance, "vkGetPhysicalDeviceImageFormatProperties2KHR")); |
| if(!vkGetPhysicalDeviceImageFormatProperties2) |
| vkGetPhysicalDeviceImageFormatProperties2 = vkGetPhysicalDeviceImageFormatProperties2KHR; |
| vkGetPhysicalDeviceQueueFamilyProperties2KHR = |
| PFN_vkGetPhysicalDeviceQueueFamilyProperties2KHR(vkGetInstanceProcAddr(instance, "vkGetPhysicalDeviceQueueFamilyProperties2KHR")); |
| if(!vkGetPhysicalDeviceQueueFamilyProperties2) |
| vkGetPhysicalDeviceQueueFamilyProperties2 = vkGetPhysicalDeviceQueueFamilyProperties2KHR; |
| vkGetPhysicalDeviceMemoryProperties2KHR = |
| PFN_vkGetPhysicalDeviceMemoryProperties2KHR(vkGetInstanceProcAddr(instance, "vkGetPhysicalDeviceMemoryProperties2KHR")); |
| if(!vkGetPhysicalDeviceMemoryProperties2) |
| vkGetPhysicalDeviceMemoryProperties2 = vkGetPhysicalDeviceMemoryProperties2KHR; |
| vkGetPhysicalDeviceSparseImageFormatProperties2KHR = |
| PFN_vkGetPhysicalDeviceSparseImageFormatProperties2KHR(vkGetInstanceProcAddr(instance, "vkGetPhysicalDeviceSparseImageFormatProperties2KHR")); |
| if(!vkGetPhysicalDeviceSparseImageFormatProperties2) |
| vkGetPhysicalDeviceSparseImageFormatProperties2 = vkGetPhysicalDeviceSparseImageFormatProperties2KHR; |
| |
| //=== VK_KHR_get_surface_capabilities2 === |
| vkGetPhysicalDeviceSurfaceCapabilities2KHR = |
| PFN_vkGetPhysicalDeviceSurfaceCapabilities2KHR(vkGetInstanceProcAddr(instance, "vkGetPhysicalDeviceSurfaceCapabilities2KHR")); |
| vkGetPhysicalDeviceSurfaceFormats2KHR = |
| PFN_vkGetPhysicalDeviceSurfaceFormats2KHR(vkGetInstanceProcAddr(instance, "vkGetPhysicalDeviceSurfaceFormats2KHR")); |
| |
| //=== VK_KHR_performance_query === |
| vkEnumeratePhysicalDeviceQueueFamilyPerformanceQueryCountersKHR = PFN_vkEnumeratePhysicalDeviceQueueFamilyPerformanceQueryCountersKHR( |
| vkGetInstanceProcAddr(instance, "vkEnumeratePhysicalDeviceQueueFamilyPerformanceQueryCountersKHR")); |
| vkGetPhysicalDeviceQueueFamilyPerformanceQueryPassesKHR = PFN_vkGetPhysicalDeviceQueueFamilyPerformanceQueryPassesKHR( |
| vkGetInstanceProcAddr(instance, "vkGetPhysicalDeviceQueueFamilyPerformanceQueryPassesKHR")); |
| |
| //=== VK_KHR_surface === |
| vkDestroySurfaceKHR = PFN_vkDestroySurfaceKHR(vkGetInstanceProcAddr(instance, "vkDestroySurfaceKHR")); |
| vkGetPhysicalDeviceSurfaceSupportKHR = |
| PFN_vkGetPhysicalDeviceSurfaceSupportKHR(vkGetInstanceProcAddr(instance, "vkGetPhysicalDeviceSurfaceSupportKHR")); |
| vkGetPhysicalDeviceSurfaceCapabilitiesKHR = |
| PFN_vkGetPhysicalDeviceSurfaceCapabilitiesKHR(vkGetInstanceProcAddr(instance, "vkGetPhysicalDeviceSurfaceCapabilitiesKHR")); |
| vkGetPhysicalDeviceSurfaceFormatsKHR = |
| PFN_vkGetPhysicalDeviceSurfaceFormatsKHR(vkGetInstanceProcAddr(instance, "vkGetPhysicalDeviceSurfaceFormatsKHR")); |
| vkGetPhysicalDeviceSurfacePresentModesKHR = |
| PFN_vkGetPhysicalDeviceSurfacePresentModesKHR(vkGetInstanceProcAddr(instance, "vkGetPhysicalDeviceSurfacePresentModesKHR")); |
| |
| # if defined(VK_ENABLE_BETA_EXTENSIONS) |
| //=== VK_KHR_video_queue === |
| vkGetPhysicalDeviceVideoCapabilitiesKHR = |
| PFN_vkGetPhysicalDeviceVideoCapabilitiesKHR(vkGetInstanceProcAddr(instance, "vkGetPhysicalDeviceVideoCapabilitiesKHR")); |
| vkGetPhysicalDeviceVideoFormatPropertiesKHR = |
| PFN_vkGetPhysicalDeviceVideoFormatPropertiesKHR(vkGetInstanceProcAddr(instance, "vkGetPhysicalDeviceVideoFormatPropertiesKHR")); |
| # endif /*VK_ENABLE_BETA_EXTENSIONS*/ |
| |
| # if defined(VK_USE_PLATFORM_WAYLAND_KHR) |
| //=== VK_KHR_wayland_surface === |
| vkCreateWaylandSurfaceKHR = PFN_vkCreateWaylandSurfaceKHR(vkGetInstanceProcAddr(instance, "vkCreateWaylandSurfaceKHR")); |
| vkGetPhysicalDeviceWaylandPresentationSupportKHR = |
| PFN_vkGetPhysicalDeviceWaylandPresentationSupportKHR(vkGetInstanceProcAddr(instance, "vkGetPhysicalDeviceWaylandPresentationSupportKHR")); |
| # endif /*VK_USE_PLATFORM_WAYLAND_KHR*/ |
| |
| # if defined(VK_USE_PLATFORM_WIN32_KHR) |
| //=== VK_KHR_win32_surface === |
| vkCreateWin32SurfaceKHR = PFN_vkCreateWin32SurfaceKHR(vkGetInstanceProcAddr(instance, "vkCreateWin32SurfaceKHR")); |
| vkGetPhysicalDeviceWin32PresentationSupportKHR = |
| PFN_vkGetPhysicalDeviceWin32PresentationSupportKHR(vkGetInstanceProcAddr(instance, "vkGetPhysicalDeviceWin32PresentationSupportKHR")); |
| # endif /*VK_USE_PLATFORM_WIN32_KHR*/ |
| |
| # if defined(VK_USE_PLATFORM_XCB_KHR) |
| //=== VK_KHR_xcb_surface === |
| vkCreateXcbSurfaceKHR = PFN_vkCreateXcbSurfaceKHR(vkGetInstanceProcAddr(instance, "vkCreateXcbSurfaceKHR")); |
| vkGetPhysicalDeviceXcbPresentationSupportKHR = |
| PFN_vkGetPhysicalDeviceXcbPresentationSupportKHR(vkGetInstanceProcAddr(instance, "vkGetPhysicalDeviceXcbPresentationSupportKHR")); |
| # endif /*VK_USE_PLATFORM_XCB_KHR*/ |
| |
| # if defined(VK_USE_PLATFORM_XLIB_KHR) |
| //=== VK_KHR_xlib_surface === |
| vkCreateXlibSurfaceKHR = PFN_vkCreateXlibSurfaceKHR(vkGetInstanceProcAddr(instance, "vkCreateXlibSurfaceKHR")); |
| vkGetPhysicalDeviceXlibPresentationSupportKHR = |
| PFN_vkGetPhysicalDeviceXlibPresentationSupportKHR(vkGetInstanceProcAddr(instance, "vkGetPhysicalDeviceXlibPresentationSupportKHR")); |
| # endif /*VK_USE_PLATFORM_XLIB_KHR*/ |
| |
| # if defined(VK_USE_PLATFORM_IOS_MVK) |
| //=== VK_MVK_ios_surface === |
| vkCreateIOSSurfaceMVK = PFN_vkCreateIOSSurfaceMVK(vkGetInstanceProcAddr(instance, "vkCreateIOSSurfaceMVK")); |
| # endif /*VK_USE_PLATFORM_IOS_MVK*/ |
| |
| # if defined(VK_USE_PLATFORM_MACOS_MVK) |
| //=== VK_MVK_macos_surface === |
| vkCreateMacOSSurfaceMVK = PFN_vkCreateMacOSSurfaceMVK(vkGetInstanceProcAddr(instance, "vkCreateMacOSSurfaceMVK")); |
| # endif /*VK_USE_PLATFORM_MACOS_MVK*/ |
| |
| # if defined(VK_USE_PLATFORM_VI_NN) |
| //=== VK_NN_vi_surface === |
| vkCreateViSurfaceNN = PFN_vkCreateViSurfaceNN(vkGetInstanceProcAddr(instance, "vkCreateViSurfaceNN")); |
| # endif /*VK_USE_PLATFORM_VI_NN*/ |
| |
| # if defined(VK_USE_PLATFORM_WIN32_KHR) |
| //=== VK_NV_acquire_winrt_display === |
| vkAcquireWinrtDisplayNV = PFN_vkAcquireWinrtDisplayNV(vkGetInstanceProcAddr(instance, "vkAcquireWinrtDisplayNV")); |
| vkGetWinrtDisplayNV = PFN_vkGetWinrtDisplayNV(vkGetInstanceProcAddr(instance, "vkGetWinrtDisplayNV")); |
| # endif /*VK_USE_PLATFORM_WIN32_KHR*/ |
| |
| //=== VK_NV_cooperative_matrix === |
| vkGetPhysicalDeviceCooperativeMatrixPropertiesNV = |
| PFN_vkGetPhysicalDeviceCooperativeMatrixPropertiesNV(vkGetInstanceProcAddr(instance, "vkGetPhysicalDeviceCooperativeMatrixPropertiesNV")); |
| |
| //=== VK_NV_coverage_reduction_mode === |
| vkGetPhysicalDeviceSupportedFramebufferMixedSamplesCombinationsNV = PFN_vkGetPhysicalDeviceSupportedFramebufferMixedSamplesCombinationsNV( |
| vkGetInstanceProcAddr(instance, "vkGetPhysicalDeviceSupportedFramebufferMixedSamplesCombinationsNV")); |
| |
| //=== VK_NV_external_memory_capabilities === |
| vkGetPhysicalDeviceExternalImageFormatPropertiesNV = |
| PFN_vkGetPhysicalDeviceExternalImageFormatPropertiesNV(vkGetInstanceProcAddr(instance, "vkGetPhysicalDeviceExternalImageFormatPropertiesNV")); |
| |
| # if defined(VK_USE_PLATFORM_SCREEN_QNX) |
| //=== VK_QNX_screen_surface === |
| vkCreateScreenSurfaceQNX = PFN_vkCreateScreenSurfaceQNX(vkGetInstanceProcAddr(instance, "vkCreateScreenSurfaceQNX")); |
| vkGetPhysicalDeviceScreenPresentationSupportQNX = |
| PFN_vkGetPhysicalDeviceScreenPresentationSupportQNX(vkGetInstanceProcAddr(instance, "vkGetPhysicalDeviceScreenPresentationSupportQNX")); |
| # endif /*VK_USE_PLATFORM_SCREEN_QNX*/ |
| |
| vkGetDeviceProcAddr = PFN_vkGetDeviceProcAddr(vkGetInstanceProcAddr(instance, "vkGetDeviceProcAddr")); |
| } |
| |
| public: |
| //=== VK_VERSION_1_0 === |
| PFN_vkDestroyInstance vkDestroyInstance = 0; |
| PFN_vkEnumeratePhysicalDevices vkEnumeratePhysicalDevices = 0; |
| PFN_vkGetPhysicalDeviceFeatures vkGetPhysicalDeviceFeatures = 0; |
| PFN_vkGetPhysicalDeviceFormatProperties vkGetPhysicalDeviceFormatProperties = 0; |
| PFN_vkGetPhysicalDeviceImageFormatProperties vkGetPhysicalDeviceImageFormatProperties = 0; |
| PFN_vkGetPhysicalDeviceProperties vkGetPhysicalDeviceProperties = 0; |
| PFN_vkGetPhysicalDeviceQueueFamilyProperties vkGetPhysicalDeviceQueueFamilyProperties = 0; |
| PFN_vkGetPhysicalDeviceMemoryProperties vkGetPhysicalDeviceMemoryProperties = 0; |
| PFN_vkGetInstanceProcAddr vkGetInstanceProcAddr = 0; |
| PFN_vkCreateDevice vkCreateDevice = 0; |
| PFN_vkEnumerateDeviceExtensionProperties vkEnumerateDeviceExtensionProperties = 0; |
| PFN_vkEnumerateDeviceLayerProperties vkEnumerateDeviceLayerProperties = 0; |
| PFN_vkGetPhysicalDeviceSparseImageFormatProperties vkGetPhysicalDeviceSparseImageFormatProperties = 0; |
| |
| //=== VK_VERSION_1_1 === |
| PFN_vkEnumeratePhysicalDeviceGroups vkEnumeratePhysicalDeviceGroups = 0; |
| PFN_vkGetPhysicalDeviceFeatures2 vkGetPhysicalDeviceFeatures2 = 0; |
| PFN_vkGetPhysicalDeviceProperties2 vkGetPhysicalDeviceProperties2 = 0; |
| PFN_vkGetPhysicalDeviceFormatProperties2 vkGetPhysicalDeviceFormatProperties2 = 0; |
| PFN_vkGetPhysicalDeviceImageFormatProperties2 vkGetPhysicalDeviceImageFormatProperties2 = 0; |
| PFN_vkGetPhysicalDeviceQueueFamilyProperties2 vkGetPhysicalDeviceQueueFamilyProperties2 = 0; |
| PFN_vkGetPhysicalDeviceMemoryProperties2 vkGetPhysicalDeviceMemoryProperties2 = 0; |
| PFN_vkGetPhysicalDeviceSparseImageFormatProperties2 vkGetPhysicalDeviceSparseImageFormatProperties2 = 0; |
| PFN_vkGetPhysicalDeviceExternalBufferProperties vkGetPhysicalDeviceExternalBufferProperties = 0; |
| PFN_vkGetPhysicalDeviceExternalFenceProperties vkGetPhysicalDeviceExternalFenceProperties = 0; |
| PFN_vkGetPhysicalDeviceExternalSemaphoreProperties vkGetPhysicalDeviceExternalSemaphoreProperties = 0; |
| |
| //=== VK_VERSION_1_3 === |
| PFN_vkGetPhysicalDeviceToolProperties vkGetPhysicalDeviceToolProperties = 0; |
| |
| //=== VK_EXT_acquire_drm_display === |
| PFN_vkAcquireDrmDisplayEXT vkAcquireDrmDisplayEXT = 0; |
| PFN_vkGetDrmDisplayEXT vkGetDrmDisplayEXT = 0; |
| |
| # if defined(VK_USE_PLATFORM_XLIB_XRANDR_EXT) |
| //=== VK_EXT_acquire_xlib_display === |
| PFN_vkAcquireXlibDisplayEXT vkAcquireXlibDisplayEXT = 0; |
| PFN_vkGetRandROutputDisplayEXT vkGetRandROutputDisplayEXT = 0; |
| # else |
| PFN_dummy vkAcquireXlibDisplayEXT_placeholder = 0; |
| PFN_dummy vkGetRandROutputDisplayEXT_placeholder = 0; |
| # endif /*VK_USE_PLATFORM_XLIB_XRANDR_EXT*/ |
| |
| //=== VK_EXT_calibrated_timestamps === |
| PFN_vkGetPhysicalDeviceCalibrateableTimeDomainsEXT vkGetPhysicalDeviceCalibrateableTimeDomainsEXT = 0; |
| |
| //=== VK_EXT_debug_report === |
| PFN_vkCreateDebugReportCallbackEXT vkCreateDebugReportCallbackEXT = 0; |
| PFN_vkDestroyDebugReportCallbackEXT vkDestroyDebugReportCallbackEXT = 0; |
| PFN_vkDebugReportMessageEXT vkDebugReportMessageEXT = 0; |
| |
| //=== VK_EXT_debug_utils === |
| PFN_vkCreateDebugUtilsMessengerEXT vkCreateDebugUtilsMessengerEXT = 0; |
| PFN_vkDestroyDebugUtilsMessengerEXT vkDestroyDebugUtilsMessengerEXT = 0; |
| PFN_vkSubmitDebugUtilsMessageEXT vkSubmitDebugUtilsMessageEXT = 0; |
| |
| //=== VK_EXT_direct_mode_display === |
| PFN_vkReleaseDisplayEXT vkReleaseDisplayEXT = 0; |
| |
| # if defined(VK_USE_PLATFORM_DIRECTFB_EXT) |
| //=== VK_EXT_directfb_surface === |
| PFN_vkCreateDirectFBSurfaceEXT vkCreateDirectFBSurfaceEXT = 0; |
| PFN_vkGetPhysicalDeviceDirectFBPresentationSupportEXT vkGetPhysicalDeviceDirectFBPresentationSupportEXT = 0; |
| # else |
| PFN_dummy vkCreateDirectFBSurfaceEXT_placeholder = 0; |
| PFN_dummy vkGetPhysicalDeviceDirectFBPresentationSupportEXT_placeholder = 0; |
| # endif /*VK_USE_PLATFORM_DIRECTFB_EXT*/ |
| |
| //=== VK_EXT_display_surface_counter === |
| PFN_vkGetPhysicalDeviceSurfaceCapabilities2EXT vkGetPhysicalDeviceSurfaceCapabilities2EXT = 0; |
| |
| # if defined(VK_USE_PLATFORM_WIN32_KHR) |
| //=== VK_EXT_full_screen_exclusive === |
| PFN_vkGetPhysicalDeviceSurfacePresentModes2EXT vkGetPhysicalDeviceSurfacePresentModes2EXT = 0; |
| # else |
| PFN_dummy vkGetPhysicalDeviceSurfacePresentModes2EXT_placeholder = 0; |
| # endif /*VK_USE_PLATFORM_WIN32_KHR*/ |
| |
| //=== VK_EXT_headless_surface === |
| PFN_vkCreateHeadlessSurfaceEXT vkCreateHeadlessSurfaceEXT = 0; |
| |
| # if defined(VK_USE_PLATFORM_METAL_EXT) |
| //=== VK_EXT_metal_surface === |
| PFN_vkCreateMetalSurfaceEXT vkCreateMetalSurfaceEXT = 0; |
| # else |
| PFN_dummy vkCreateMetalSurfaceEXT_placeholder = 0; |
| # endif /*VK_USE_PLATFORM_METAL_EXT*/ |
| |
| //=== VK_EXT_sample_locations === |
| PFN_vkGetPhysicalDeviceMultisamplePropertiesEXT vkGetPhysicalDeviceMultisamplePropertiesEXT = 0; |
| |
| //=== VK_EXT_tooling_info === |
| PFN_vkGetPhysicalDeviceToolPropertiesEXT vkGetPhysicalDeviceToolPropertiesEXT = 0; |
| |
| # if defined(VK_USE_PLATFORM_FUCHSIA) |
| //=== VK_FUCHSIA_imagepipe_surface === |
| PFN_vkCreateImagePipeSurfaceFUCHSIA vkCreateImagePipeSurfaceFUCHSIA = 0; |
| # else |
| PFN_dummy vkCreateImagePipeSurfaceFUCHSIA_placeholder = 0; |
| # endif /*VK_USE_PLATFORM_FUCHSIA*/ |
| |
| # if defined(VK_USE_PLATFORM_GGP) |
| //=== VK_GGP_stream_descriptor_surface === |
| PFN_vkCreateStreamDescriptorSurfaceGGP vkCreateStreamDescriptorSurfaceGGP = 0; |
| # else |
| PFN_dummy vkCreateStreamDescriptorSurfaceGGP_placeholder = 0; |
| # endif /*VK_USE_PLATFORM_GGP*/ |
| |
| # if defined(VK_USE_PLATFORM_ANDROID_KHR) |
| //=== VK_KHR_android_surface === |
| PFN_vkCreateAndroidSurfaceKHR vkCreateAndroidSurfaceKHR = 0; |
| # else |
| PFN_dummy vkCreateAndroidSurfaceKHR_placeholder = 0; |
| # endif /*VK_USE_PLATFORM_ANDROID_KHR*/ |
| |
| //=== VK_KHR_device_group === |
| PFN_vkGetPhysicalDevicePresentRectanglesKHR vkGetPhysicalDevicePresentRectanglesKHR = 0; |
| |
| //=== VK_KHR_device_group_creation === |
| PFN_vkEnumeratePhysicalDeviceGroupsKHR vkEnumeratePhysicalDeviceGroupsKHR = 0; |
| |
| //=== VK_KHR_display === |
| PFN_vkGetPhysicalDeviceDisplayPropertiesKHR vkGetPhysicalDeviceDisplayPropertiesKHR = 0; |
| PFN_vkGetPhysicalDeviceDisplayPlanePropertiesKHR vkGetPhysicalDeviceDisplayPlanePropertiesKHR = 0; |
| PFN_vkGetDisplayPlaneSupportedDisplaysKHR vkGetDisplayPlaneSupportedDisplaysKHR = 0; |
| PFN_vkGetDisplayModePropertiesKHR vkGetDisplayModePropertiesKHR = 0; |
| PFN_vkCreateDisplayModeKHR vkCreateDisplayModeKHR = 0; |
| PFN_vkGetDisplayPlaneCapabilitiesKHR vkGetDisplayPlaneCapabilitiesKHR = 0; |
| PFN_vkCreateDisplayPlaneSurfaceKHR vkCreateDisplayPlaneSurfaceKHR = 0; |
| |
| //=== VK_KHR_external_fence_capabilities === |
| PFN_vkGetPhysicalDeviceExternalFencePropertiesKHR vkGetPhysicalDeviceExternalFencePropertiesKHR = 0; |
| |
| //=== VK_KHR_external_memory_capabilities === |
| PFN_vkGetPhysicalDeviceExternalBufferPropertiesKHR vkGetPhysicalDeviceExternalBufferPropertiesKHR = 0; |
| |
| //=== VK_KHR_external_semaphore_capabilities === |
| PFN_vkGetPhysicalDeviceExternalSemaphorePropertiesKHR vkGetPhysicalDeviceExternalSemaphorePropertiesKHR = 0; |
| |
| //=== VK_KHR_fragment_shading_rate === |
| PFN_vkGetPhysicalDeviceFragmentShadingRatesKHR vkGetPhysicalDeviceFragmentShadingRatesKHR = 0; |
| |
| //=== VK_KHR_get_display_properties2 === |
| PFN_vkGetPhysicalDeviceDisplayProperties2KHR vkGetPhysicalDeviceDisplayProperties2KHR = 0; |
| PFN_vkGetPhysicalDeviceDisplayPlaneProperties2KHR vkGetPhysicalDeviceDisplayPlaneProperties2KHR = 0; |
| PFN_vkGetDisplayModeProperties2KHR vkGetDisplayModeProperties2KHR = 0; |
| PFN_vkGetDisplayPlaneCapabilities2KHR vkGetDisplayPlaneCapabilities2KHR = 0; |
| |
| //=== VK_KHR_get_physical_device_properties2 === |
| PFN_vkGetPhysicalDeviceFeatures2KHR vkGetPhysicalDeviceFeatures2KHR = 0; |
| PFN_vkGetPhysicalDeviceProperties2KHR vkGetPhysicalDeviceProperties2KHR = 0; |
| PFN_vkGetPhysicalDeviceFormatProperties2KHR vkGetPhysicalDeviceFormatProperties2KHR = 0; |
| PFN_vkGetPhysicalDeviceImageFormatProperties2KHR vkGetPhysicalDeviceImageFormatProperties2KHR = 0; |
| PFN_vkGetPhysicalDeviceQueueFamilyProperties2KHR vkGetPhysicalDeviceQueueFamilyProperties2KHR = 0; |
| PFN_vkGetPhysicalDeviceMemoryProperties2KHR vkGetPhysicalDeviceMemoryProperties2KHR = 0; |
| PFN_vkGetPhysicalDeviceSparseImageFormatProperties2KHR vkGetPhysicalDeviceSparseImageFormatProperties2KHR = 0; |
| |
| //=== VK_KHR_get_surface_capabilities2 === |
| PFN_vkGetPhysicalDeviceSurfaceCapabilities2KHR vkGetPhysicalDeviceSurfaceCapabilities2KHR = 0; |
| PFN_vkGetPhysicalDeviceSurfaceFormats2KHR vkGetPhysicalDeviceSurfaceFormats2KHR = 0; |
| |
| //=== VK_KHR_performance_query === |
| PFN_vkEnumeratePhysicalDeviceQueueFamilyPerformanceQueryCountersKHR vkEnumeratePhysicalDeviceQueueFamilyPerformanceQueryCountersKHR = 0; |
| PFN_vkGetPhysicalDeviceQueueFamilyPerformanceQueryPassesKHR vkGetPhysicalDeviceQueueFamilyPerformanceQueryPassesKHR = 0; |
| |
| //=== VK_KHR_surface === |
| PFN_vkDestroySurfaceKHR vkDestroySurfaceKHR = 0; |
| PFN_vkGetPhysicalDeviceSurfaceSupportKHR vkGetPhysicalDeviceSurfaceSupportKHR = 0; |
| PFN_vkGetPhysicalDeviceSurfaceCapabilitiesKHR vkGetPhysicalDeviceSurfaceCapabilitiesKHR = 0; |
| PFN_vkGetPhysicalDeviceSurfaceFormatsKHR vkGetPhysicalDeviceSurfaceFormatsKHR = 0; |
| PFN_vkGetPhysicalDeviceSurfacePresentModesKHR vkGetPhysicalDeviceSurfacePresentModesKHR = 0; |
| |
| # if defined(VK_ENABLE_BETA_EXTENSIONS) |
| //=== VK_KHR_video_queue === |
| PFN_vkGetPhysicalDeviceVideoCapabilitiesKHR vkGetPhysicalDeviceVideoCapabilitiesKHR = 0; |
| PFN_vkGetPhysicalDeviceVideoFormatPropertiesKHR vkGetPhysicalDeviceVideoFormatPropertiesKHR = 0; |
| # else |
| PFN_dummy vkGetPhysicalDeviceVideoCapabilitiesKHR_placeholder = 0; |
| PFN_dummy vkGetPhysicalDeviceVideoFormatPropertiesKHR_placeholder = 0; |
| # endif /*VK_ENABLE_BETA_EXTENSIONS*/ |
| |
| # if defined(VK_USE_PLATFORM_WAYLAND_KHR) |
| //=== VK_KHR_wayland_surface === |
| PFN_vkCreateWaylandSurfaceKHR vkCreateWaylandSurfaceKHR = 0; |
| PFN_vkGetPhysicalDeviceWaylandPresentationSupportKHR vkGetPhysicalDeviceWaylandPresentationSupportKHR = 0; |
| # else |
| PFN_dummy vkCreateWaylandSurfaceKHR_placeholder = 0; |
| PFN_dummy vkGetPhysicalDeviceWaylandPresentationSupportKHR_placeholder = 0; |
| # endif /*VK_USE_PLATFORM_WAYLAND_KHR*/ |
| |
| # if defined(VK_USE_PLATFORM_WIN32_KHR) |
| //=== VK_KHR_win32_surface === |
| PFN_vkCreateWin32SurfaceKHR vkCreateWin32SurfaceKHR = 0; |
| PFN_vkGetPhysicalDeviceWin32PresentationSupportKHR vkGetPhysicalDeviceWin32PresentationSupportKHR = 0; |
| # else |
| PFN_dummy vkCreateWin32SurfaceKHR_placeholder = 0; |
| PFN_dummy vkGetPhysicalDeviceWin32PresentationSupportKHR_placeholder = 0; |
| # endif /*VK_USE_PLATFORM_WIN32_KHR*/ |
| |
| # if defined(VK_USE_PLATFORM_XCB_KHR) |
| //=== VK_KHR_xcb_surface === |
| PFN_vkCreateXcbSurfaceKHR vkCreateXcbSurfaceKHR = 0; |
| PFN_vkGetPhysicalDeviceXcbPresentationSupportKHR vkGetPhysicalDeviceXcbPresentationSupportKHR = 0; |
| # else |
| PFN_dummy vkCreateXcbSurfaceKHR_placeholder = 0; |
| PFN_dummy vkGetPhysicalDeviceXcbPresentationSupportKHR_placeholder = 0; |
| # endif /*VK_USE_PLATFORM_XCB_KHR*/ |
| |
| # if defined(VK_USE_PLATFORM_XLIB_KHR) |
| //=== VK_KHR_xlib_surface === |
| PFN_vkCreateXlibSurfaceKHR vkCreateXlibSurfaceKHR = 0; |
| PFN_vkGetPhysicalDeviceXlibPresentationSupportKHR vkGetPhysicalDeviceXlibPresentationSupportKHR = 0; |
| # else |
| PFN_dummy vkCreateXlibSurfaceKHR_placeholder = 0; |
| PFN_dummy vkGetPhysicalDeviceXlibPresentationSupportKHR_placeholder = 0; |
| # endif /*VK_USE_PLATFORM_XLIB_KHR*/ |
| |
| # if defined(VK_USE_PLATFORM_IOS_MVK) |
| //=== VK_MVK_ios_surface === |
| PFN_vkCreateIOSSurfaceMVK vkCreateIOSSurfaceMVK = 0; |
| # else |
| PFN_dummy vkCreateIOSSurfaceMVK_placeholder = 0; |
| # endif /*VK_USE_PLATFORM_IOS_MVK*/ |
| |
| # if defined(VK_USE_PLATFORM_MACOS_MVK) |
| //=== VK_MVK_macos_surface === |
| PFN_vkCreateMacOSSurfaceMVK vkCreateMacOSSurfaceMVK = 0; |
| # else |
| PFN_dummy vkCreateMacOSSurfaceMVK_placeholder = 0; |
| # endif /*VK_USE_PLATFORM_MACOS_MVK*/ |
| |
| # if defined(VK_USE_PLATFORM_VI_NN) |
| //=== VK_NN_vi_surface === |
| PFN_vkCreateViSurfaceNN vkCreateViSurfaceNN = 0; |
| # else |
| PFN_dummy vkCreateViSurfaceNN_placeholder = 0; |
| # endif /*VK_USE_PLATFORM_VI_NN*/ |
| |
| # if defined(VK_USE_PLATFORM_WIN32_KHR) |
| //=== VK_NV_acquire_winrt_display === |
| PFN_vkAcquireWinrtDisplayNV vkAcquireWinrtDisplayNV = 0; |
| PFN_vkGetWinrtDisplayNV vkGetWinrtDisplayNV = 0; |
| # else |
| PFN_dummy vkAcquireWinrtDisplayNV_placeholder = 0; |
| PFN_dummy vkGetWinrtDisplayNV_placeholder = 0; |
| # endif /*VK_USE_PLATFORM_WIN32_KHR*/ |
| |
| //=== VK_NV_cooperative_matrix === |
| PFN_vkGetPhysicalDeviceCooperativeMatrixPropertiesNV vkGetPhysicalDeviceCooperativeMatrixPropertiesNV = 0; |
| |
| //=== VK_NV_coverage_reduction_mode === |
| PFN_vkGetPhysicalDeviceSupportedFramebufferMixedSamplesCombinationsNV vkGetPhysicalDeviceSupportedFramebufferMixedSamplesCombinationsNV = 0; |
| |
| //=== VK_NV_external_memory_capabilities === |
| PFN_vkGetPhysicalDeviceExternalImageFormatPropertiesNV vkGetPhysicalDeviceExternalImageFormatPropertiesNV = 0; |
| |
| # if defined(VK_USE_PLATFORM_SCREEN_QNX) |
| //=== VK_QNX_screen_surface === |
| PFN_vkCreateScreenSurfaceQNX vkCreateScreenSurfaceQNX = 0; |
| PFN_vkGetPhysicalDeviceScreenPresentationSupportQNX vkGetPhysicalDeviceScreenPresentationSupportQNX = 0; |
| # else |
| PFN_dummy vkCreateScreenSurfaceQNX_placeholder = 0; |
| PFN_dummy vkGetPhysicalDeviceScreenPresentationSupportQNX_placeholder = 0; |
| # endif /*VK_USE_PLATFORM_SCREEN_QNX*/ |
| |
| PFN_vkGetDeviceProcAddr vkGetDeviceProcAddr = 0; |
| }; |
| |
| class DeviceDispatcher : public DispatchLoaderBase |
| { |
| public: |
| DeviceDispatcher(PFN_vkGetDeviceProcAddr getProcAddr, VkDevice device) |
| : vkGetDeviceProcAddr(getProcAddr) |
| { |
| //=== VK_VERSION_1_0 === |
| vkGetDeviceProcAddr = PFN_vkGetDeviceProcAddr(vkGetDeviceProcAddr(device, "vkGetDeviceProcAddr")); |
| vkDestroyDevice = PFN_vkDestroyDevice(vkGetDeviceProcAddr(device, "vkDestroyDevice")); |
| vkGetDeviceQueue = PFN_vkGetDeviceQueue(vkGetDeviceProcAddr(device, "vkGetDeviceQueue")); |
| vkQueueSubmit = PFN_vkQueueSubmit(vkGetDeviceProcAddr(device, "vkQueueSubmit")); |
| vkQueueWaitIdle = PFN_vkQueueWaitIdle(vkGetDeviceProcAddr(device, "vkQueueWaitIdle")); |
| vkDeviceWaitIdle = PFN_vkDeviceWaitIdle(vkGetDeviceProcAddr(device, "vkDeviceWaitIdle")); |
| vkAllocateMemory = PFN_vkAllocateMemory(vkGetDeviceProcAddr(device, "vkAllocateMemory")); |
| vkFreeMemory = PFN_vkFreeMemory(vkGetDeviceProcAddr(device, "vkFreeMemory")); |
| vkMapMemory = PFN_vkMapMemory(vkGetDeviceProcAddr(device, "vkMapMemory")); |
| vkUnmapMemory = PFN_vkUnmapMemory(vkGetDeviceProcAddr(device, "vkUnmapMemory")); |
| vkFlushMappedMemoryRanges = PFN_vkFlushMappedMemoryRanges(vkGetDeviceProcAddr(device, "vkFlushMappedMemoryRanges")); |
| vkInvalidateMappedMemoryRanges = PFN_vkInvalidateMappedMemoryRanges(vkGetDeviceProcAddr(device, "vkInvalidateMappedMemoryRanges")); |
| vkGetDeviceMemoryCommitment = PFN_vkGetDeviceMemoryCommitment(vkGetDeviceProcAddr(device, "vkGetDeviceMemoryCommitment")); |
| vkBindBufferMemory = PFN_vkBindBufferMemory(vkGetDeviceProcAddr(device, "vkBindBufferMemory")); |
| vkBindImageMemory = PFN_vkBindImageMemory(vkGetDeviceProcAddr(device, "vkBindImageMemory")); |
| vkGetBufferMemoryRequirements = PFN_vkGetBufferMemoryRequirements(vkGetDeviceProcAddr(device, "vkGetBufferMemoryRequirements")); |
| vkGetImageMemoryRequirements = PFN_vkGetImageMemoryRequirements(vkGetDeviceProcAddr(device, "vkGetImageMemoryRequirements")); |
| vkGetImageSparseMemoryRequirements = PFN_vkGetImageSparseMemoryRequirements(vkGetDeviceProcAddr(device, "vkGetImageSparseMemoryRequirements")); |
| vkQueueBindSparse = PFN_vkQueueBindSparse(vkGetDeviceProcAddr(device, "vkQueueBindSparse")); |
| vkCreateFence = PFN_vkCreateFence(vkGetDeviceProcAddr(device, "vkCreateFence")); |
| vkDestroyFence = PFN_vkDestroyFence(vkGetDeviceProcAddr(device, "vkDestroyFence")); |
| vkResetFences = PFN_vkResetFences(vkGetDeviceProcAddr(device, "vkResetFences")); |
| vkGetFenceStatus = PFN_vkGetFenceStatus(vkGetDeviceProcAddr(device, "vkGetFenceStatus")); |
| vkWaitForFences = PFN_vkWaitForFences(vkGetDeviceProcAddr(device, "vkWaitForFences")); |
| vkCreateSemaphore = PFN_vkCreateSemaphore(vkGetDeviceProcAddr(device, "vkCreateSemaphore")); |
| vkDestroySemaphore = PFN_vkDestroySemaphore(vkGetDeviceProcAddr(device, "vkDestroySemaphore")); |
| vkCreateEvent = PFN_vkCreateEvent(vkGetDeviceProcAddr(device, "vkCreateEvent")); |
| vkDestroyEvent = PFN_vkDestroyEvent(vkGetDeviceProcAddr(device, "vkDestroyEvent")); |
| vkGetEventStatus = PFN_vkGetEventStatus(vkGetDeviceProcAddr(device, "vkGetEventStatus")); |
| vkSetEvent = PFN_vkSetEvent(vkGetDeviceProcAddr(device, "vkSetEvent")); |
| vkResetEvent = PFN_vkResetEvent(vkGetDeviceProcAddr(device, "vkResetEvent")); |
| vkCreateQueryPool = PFN_vkCreateQueryPool(vkGetDeviceProcAddr(device, "vkCreateQueryPool")); |
| vkDestroyQueryPool = PFN_vkDestroyQueryPool(vkGetDeviceProcAddr(device, "vkDestroyQueryPool")); |
| vkGetQueryPoolResults = PFN_vkGetQueryPoolResults(vkGetDeviceProcAddr(device, "vkGetQueryPoolResults")); |
| vkCreateBuffer = PFN_vkCreateBuffer(vkGetDeviceProcAddr(device, "vkCreateBuffer")); |
| vkDestroyBuffer = PFN_vkDestroyBuffer(vkGetDeviceProcAddr(device, "vkDestroyBuffer")); |
| vkCreateBufferView = PFN_vkCreateBufferView(vkGetDeviceProcAddr(device, "vkCreateBufferView")); |
| vkDestroyBufferView = PFN_vkDestroyBufferView(vkGetDeviceProcAddr(device, "vkDestroyBufferView")); |
| vkCreateImage = PFN_vkCreateImage(vkGetDeviceProcAddr(device, "vkCreateImage")); |
| vkDestroyImage = PFN_vkDestroyImage(vkGetDeviceProcAddr(device, "vkDestroyImage")); |
| vkGetImageSubresourceLayout = PFN_vkGetImageSubresourceLayout(vkGetDeviceProcAddr(device, "vkGetImageSubresourceLayout")); |
| vkCreateImageView = PFN_vkCreateImageView(vkGetDeviceProcAddr(device, "vkCreateImageView")); |
| vkDestroyImageView = PFN_vkDestroyImageView(vkGetDeviceProcAddr(device, "vkDestroyImageView")); |
| vkCreateShaderModule = PFN_vkCreateShaderModule(vkGetDeviceProcAddr(device, "vkCreateShaderModule")); |
| vkDestroyShaderModule = PFN_vkDestroyShaderModule(vkGetDeviceProcAddr(device, "vkDestroyShaderModule")); |
| vkCreatePipelineCache = PFN_vkCreatePipelineCache(vkGetDeviceProcAddr(device, "vkCreatePipelineCache")); |
| vkDestroyPipelineCache = PFN_vkDestroyPipelineCache(vkGetDeviceProcAddr(device, "vkDestroyPipelineCache")); |
| vkGetPipelineCacheData = PFN_vkGetPipelineCacheData(vkGetDeviceProcAddr(device, "vkGetPipelineCacheData")); |
| vkMergePipelineCaches = PFN_vkMergePipelineCaches(vkGetDeviceProcAddr(device, "vkMergePipelineCaches")); |
| vkCreateGraphicsPipelines = PFN_vkCreateGraphicsPipelines(vkGetDeviceProcAddr(device, "vkCreateGraphicsPipelines")); |
| vkCreateComputePipelines = PFN_vkCreateComputePipelines(vkGetDeviceProcAddr(device, "vkCreateComputePipelines")); |
| vkDestroyPipeline = PFN_vkDestroyPipeline(vkGetDeviceProcAddr(device, "vkDestroyPipeline")); |
| vkCreatePipelineLayout = PFN_vkCreatePipelineLayout(vkGetDeviceProcAddr(device, "vkCreatePipelineLayout")); |
| vkDestroyPipelineLayout = PFN_vkDestroyPipelineLayout(vkGetDeviceProcAddr(device, "vkDestroyPipelineLayout")); |
| vkCreateSampler = PFN_vkCreateSampler(vkGetDeviceProcAddr(device, "vkCreateSampler")); |
| vkDestroySampler = PFN_vkDestroySampler(vkGetDeviceProcAddr(device, "vkDestroySampler")); |
| vkCreateDescriptorSetLayout = PFN_vkCreateDescriptorSetLayout(vkGetDeviceProcAddr(device, "vkCreateDescriptorSetLayout")); |
| vkDestroyDescriptorSetLayout = PFN_vkDestroyDescriptorSetLayout(vkGetDeviceProcAddr(device, "vkDestroyDescriptorSetLayout")); |
| vkCreateDescriptorPool = PFN_vkCreateDescriptorPool(vkGetDeviceProcAddr(device, "vkCreateDescriptorPool")); |
| vkDestroyDescriptorPool = PFN_vkDestroyDescriptorPool(vkGetDeviceProcAddr(device, "vkDestroyDescriptorPool")); |
| vkResetDescriptorPool = PFN_vkResetDescriptorPool(vkGetDeviceProcAddr(device, "vkResetDescriptorPool")); |
| vkAllocateDescriptorSets = PFN_vkAllocateDescriptorSets(vkGetDeviceProcAddr(device, "vkAllocateDescriptorSets")); |
| vkFreeDescriptorSets = PFN_vkFreeDescriptorSets(vkGetDeviceProcAddr(device, "vkFreeDescriptorSets")); |
| vkUpdateDescriptorSets = PFN_vkUpdateDescriptorSets(vkGetDeviceProcAddr(device, "vkUpdateDescriptorSets")); |
| vkCreateFramebuffer = PFN_vkCreateFramebuffer(vkGetDeviceProcAddr(device, "vkCreateFramebuffer")); |
| vkDestroyFramebuffer = PFN_vkDestroyFramebuffer(vkGetDeviceProcAddr(device, "vkDestroyFramebuffer")); |
| vkCreateRenderPass = PFN_vkCreateRenderPass(vkGetDeviceProcAddr(device, "vkCreateRenderPass")); |
| vkDestroyRenderPass = PFN_vkDestroyRenderPass(vkGetDeviceProcAddr(device, "vkDestroyRenderPass")); |
| vkGetRenderAreaGranularity = PFN_vkGetRenderAreaGranularity(vkGetDeviceProcAddr(device, "vkGetRenderAreaGranularity")); |
| vkCreateCommandPool = PFN_vkCreateCommandPool(vkGetDeviceProcAddr(device, "vkCreateCommandPool")); |
| vkDestroyCommandPool = PFN_vkDestroyCommandPool(vkGetDeviceProcAddr(device, "vkDestroyCommandPool")); |
| vkResetCommandPool = PFN_vkResetCommandPool(vkGetDeviceProcAddr(device, "vkResetCommandPool")); |
| vkAllocateCommandBuffers = PFN_vkAllocateCommandBuffers(vkGetDeviceProcAddr(device, "vkAllocateCommandBuffers")); |
| vkFreeCommandBuffers = PFN_vkFreeCommandBuffers(vkGetDeviceProcAddr(device, "vkFreeCommandBuffers")); |
| vkBeginCommandBuffer = PFN_vkBeginCommandBuffer(vkGetDeviceProcAddr(device, "vkBeginCommandBuffer")); |
| vkEndCommandBuffer = PFN_vkEndCommandBuffer(vkGetDeviceProcAddr(device, "vkEndCommandBuffer")); |
| vkResetCommandBuffer = PFN_vkResetCommandBuffer(vkGetDeviceProcAddr(device, "vkResetCommandBuffer")); |
| vkCmdBindPipeline = PFN_vkCmdBindPipeline(vkGetDeviceProcAddr(device, "vkCmdBindPipeline")); |
| vkCmdSetViewport = PFN_vkCmdSetViewport(vkGetDeviceProcAddr(device, "vkCmdSetViewport")); |
| vkCmdSetScissor = PFN_vkCmdSetScissor(vkGetDeviceProcAddr(device, "vkCmdSetScissor")); |
| vkCmdSetLineWidth = PFN_vkCmdSetLineWidth(vkGetDeviceProcAddr(device, "vkCmdSetLineWidth")); |
| vkCmdSetDepthBias = PFN_vkCmdSetDepthBias(vkGetDeviceProcAddr(device, "vkCmdSetDepthBias")); |
| vkCmdSetBlendConstants = PFN_vkCmdSetBlendConstants(vkGetDeviceProcAddr(device, "vkCmdSetBlendConstants")); |
| vkCmdSetDepthBounds = PFN_vkCmdSetDepthBounds(vkGetDeviceProcAddr(device, "vkCmdSetDepthBounds")); |
| vkCmdSetStencilCompareMask = PFN_vkCmdSetStencilCompareMask(vkGetDeviceProcAddr(device, "vkCmdSetStencilCompareMask")); |
| vkCmdSetStencilWriteMask = PFN_vkCmdSetStencilWriteMask(vkGetDeviceProcAddr(device, "vkCmdSetStencilWriteMask")); |
| vkCmdSetStencilReference = PFN_vkCmdSetStencilReference(vkGetDeviceProcAddr(device, "vkCmdSetStencilReference")); |
| vkCmdBindDescriptorSets = PFN_vkCmdBindDescriptorSets(vkGetDeviceProcAddr(device, "vkCmdBindDescriptorSets")); |
| vkCmdBindIndexBuffer = PFN_vkCmdBindIndexBuffer(vkGetDeviceProcAddr(device, "vkCmdBindIndexBuffer")); |
| vkCmdBindVertexBuffers = PFN_vkCmdBindVertexBuffers(vkGetDeviceProcAddr(device, "vkCmdBindVertexBuffers")); |
| vkCmdDraw = PFN_vkCmdDraw(vkGetDeviceProcAddr(device, "vkCmdDraw")); |
| vkCmdDrawIndexed = PFN_vkCmdDrawIndexed(vkGetDeviceProcAddr(device, "vkCmdDrawIndexed")); |
| vkCmdDrawIndirect = PFN_vkCmdDrawIndirect(vkGetDeviceProcAddr(device, "vkCmdDrawIndirect")); |
| vkCmdDrawIndexedIndirect = PFN_vkCmdDrawIndexedIndirect(vkGetDeviceProcAddr(device, "vkCmdDrawIndexedIndirect")); |
| vkCmdDispatch = PFN_vkCmdDispatch(vkGetDeviceProcAddr(device, "vkCmdDispatch")); |
| vkCmdDispatchIndirect = PFN_vkCmdDispatchIndirect(vkGetDeviceProcAddr(device, "vkCmdDispatchIndirect")); |
| vkCmdCopyBuffer = PFN_vkCmdCopyBuffer(vkGetDeviceProcAddr(device, "vkCmdCopyBuffer")); |
| vkCmdCopyImage = PFN_vkCmdCopyImage(vkGetDeviceProcAddr(device, "vkCmdCopyImage")); |
| vkCmdBlitImage = PFN_vkCmdBlitImage(vkGetDeviceProcAddr(device, "vkCmdBlitImage")); |
| vkCmdCopyBufferToImage = PFN_vkCmdCopyBufferToImage(vkGetDeviceProcAddr(device, "vkCmdCopyBufferToImage")); |
| vkCmdCopyImageToBuffer = PFN_vkCmdCopyImageToBuffer(vkGetDeviceProcAddr(device, "vkCmdCopyImageToBuffer")); |
| vkCmdUpdateBuffer = PFN_vkCmdUpdateBuffer(vkGetDeviceProcAddr(device, "vkCmdUpdateBuffer")); |
| vkCmdFillBuffer = PFN_vkCmdFillBuffer(vkGetDeviceProcAddr(device, "vkCmdFillBuffer")); |
| vkCmdClearColorImage = PFN_vkCmdClearColorImage(vkGetDeviceProcAddr(device, "vkCmdClearColorImage")); |
| vkCmdClearDepthStencilImage = PFN_vkCmdClearDepthStencilImage(vkGetDeviceProcAddr(device, "vkCmdClearDepthStencilImage")); |
| vkCmdClearAttachments = PFN_vkCmdClearAttachments(vkGetDeviceProcAddr(device, "vkCmdClearAttachments")); |
| vkCmdResolveImage = PFN_vkCmdResolveImage(vkGetDeviceProcAddr(device, "vkCmdResolveImage")); |
| vkCmdSetEvent = PFN_vkCmdSetEvent(vkGetDeviceProcAddr(device, "vkCmdSetEvent")); |
| vkCmdResetEvent = PFN_vkCmdResetEvent(vkGetDeviceProcAddr(device, "vkCmdResetEvent")); |
| vkCmdWaitEvents = PFN_vkCmdWaitEvents(vkGetDeviceProcAddr(device, "vkCmdWaitEvents")); |
| vkCmdPipelineBarrier = PFN_vkCmdPipelineBarrier(vkGetDeviceProcAddr(device, "vkCmdPipelineBarrier")); |
| vkCmdBeginQuery = PFN_vkCmdBeginQuery(vkGetDeviceProcAddr(device, "vkCmdBeginQuery")); |
| vkCmdEndQuery = PFN_vkCmdEndQuery(vkGetDeviceProcAddr(device, "vkCmdEndQuery")); |
| vkCmdResetQueryPool = PFN_vkCmdResetQueryPool(vkGetDeviceProcAddr(device, "vkCmdResetQueryPool")); |
| vkCmdWriteTimestamp = PFN_vkCmdWriteTimestamp(vkGetDeviceProcAddr(device, "vkCmdWriteTimestamp")); |
| vkCmdCopyQueryPoolResults = PFN_vkCmdCopyQueryPoolResults(vkGetDeviceProcAddr(device, "vkCmdCopyQueryPoolResults")); |
| vkCmdPushConstants = PFN_vkCmdPushConstants(vkGetDeviceProcAddr(device, "vkCmdPushConstants")); |
| vkCmdBeginRenderPass = PFN_vkCmdBeginRenderPass(vkGetDeviceProcAddr(device, "vkCmdBeginRenderPass")); |
| vkCmdNextSubpass = PFN_vkCmdNextSubpass(vkGetDeviceProcAddr(device, "vkCmdNextSubpass")); |
| vkCmdEndRenderPass = PFN_vkCmdEndRenderPass(vkGetDeviceProcAddr(device, "vkCmdEndRenderPass")); |
| vkCmdExecuteCommands = PFN_vkCmdExecuteCommands(vkGetDeviceProcAddr(device, "vkCmdExecuteCommands")); |
| |
| //=== VK_VERSION_1_1 === |
| vkBindBufferMemory2 = PFN_vkBindBufferMemory2(vkGetDeviceProcAddr(device, "vkBindBufferMemory2")); |
| vkBindImageMemory2 = PFN_vkBindImageMemory2(vkGetDeviceProcAddr(device, "vkBindImageMemory2")); |
| vkGetDeviceGroupPeerMemoryFeatures = PFN_vkGetDeviceGroupPeerMemoryFeatures(vkGetDeviceProcAddr(device, "vkGetDeviceGroupPeerMemoryFeatures")); |
| vkCmdSetDeviceMask = PFN_vkCmdSetDeviceMask(vkGetDeviceProcAddr(device, "vkCmdSetDeviceMask")); |
| vkCmdDispatchBase = PFN_vkCmdDispatchBase(vkGetDeviceProcAddr(device, "vkCmdDispatchBase")); |
| vkGetImageMemoryRequirements2 = PFN_vkGetImageMemoryRequirements2(vkGetDeviceProcAddr(device, "vkGetImageMemoryRequirements2")); |
| vkGetBufferMemoryRequirements2 = PFN_vkGetBufferMemoryRequirements2(vkGetDeviceProcAddr(device, "vkGetBufferMemoryRequirements2")); |
| vkGetImageSparseMemoryRequirements2 = PFN_vkGetImageSparseMemoryRequirements2(vkGetDeviceProcAddr(device, "vkGetImageSparseMemoryRequirements2")); |
| vkTrimCommandPool = PFN_vkTrimCommandPool(vkGetDeviceProcAddr(device, "vkTrimCommandPool")); |
| vkGetDeviceQueue2 = PFN_vkGetDeviceQueue2(vkGetDeviceProcAddr(device, "vkGetDeviceQueue2")); |
| vkCreateSamplerYcbcrConversion = PFN_vkCreateSamplerYcbcrConversion(vkGetDeviceProcAddr(device, "vkCreateSamplerYcbcrConversion")); |
| vkDestroySamplerYcbcrConversion = PFN_vkDestroySamplerYcbcrConversion(vkGetDeviceProcAddr(device, "vkDestroySamplerYcbcrConversion")); |
| vkCreateDescriptorUpdateTemplate = PFN_vkCreateDescriptorUpdateTemplate(vkGetDeviceProcAddr(device, "vkCreateDescriptorUpdateTemplate")); |
| vkDestroyDescriptorUpdateTemplate = PFN_vkDestroyDescriptorUpdateTemplate(vkGetDeviceProcAddr(device, "vkDestroyDescriptorUpdateTemplate")); |
| vkUpdateDescriptorSetWithTemplate = PFN_vkUpdateDescriptorSetWithTemplate(vkGetDeviceProcAddr(device, "vkUpdateDescriptorSetWithTemplate")); |
| vkGetDescriptorSetLayoutSupport = PFN_vkGetDescriptorSetLayoutSupport(vkGetDeviceProcAddr(device, "vkGetDescriptorSetLayoutSupport")); |
| |
| //=== VK_VERSION_1_2 === |
| vkCmdDrawIndirectCount = PFN_vkCmdDrawIndirectCount(vkGetDeviceProcAddr(device, "vkCmdDrawIndirectCount")); |
| vkCmdDrawIndexedIndirectCount = PFN_vkCmdDrawIndexedIndirectCount(vkGetDeviceProcAddr(device, "vkCmdDrawIndexedIndirectCount")); |
| vkCreateRenderPass2 = PFN_vkCreateRenderPass2(vkGetDeviceProcAddr(device, "vkCreateRenderPass2")); |
| vkCmdBeginRenderPass2 = PFN_vkCmdBeginRenderPass2(vkGetDeviceProcAddr(device, "vkCmdBeginRenderPass2")); |
| vkCmdNextSubpass2 = PFN_vkCmdNextSubpass2(vkGetDeviceProcAddr(device, "vkCmdNextSubpass2")); |
| vkCmdEndRenderPass2 = PFN_vkCmdEndRenderPass2(vkGetDeviceProcAddr(device, "vkCmdEndRenderPass2")); |
| vkResetQueryPool = PFN_vkResetQueryPool(vkGetDeviceProcAddr(device, "vkResetQueryPool")); |
| vkGetSemaphoreCounterValue = PFN_vkGetSemaphoreCounterValue(vkGetDeviceProcAddr(device, "vkGetSemaphoreCounterValue")); |
| vkWaitSemaphores = PFN_vkWaitSemaphores(vkGetDeviceProcAddr(device, "vkWaitSemaphores")); |
| vkSignalSemaphore = PFN_vkSignalSemaphore(vkGetDeviceProcAddr(device, "vkSignalSemaphore")); |
| vkGetBufferDeviceAddress = PFN_vkGetBufferDeviceAddress(vkGetDeviceProcAddr(device, "vkGetBufferDeviceAddress")); |
| vkGetBufferOpaqueCaptureAddress = PFN_vkGetBufferOpaqueCaptureAddress(vkGetDeviceProcAddr(device, "vkGetBufferOpaqueCaptureAddress")); |
| vkGetDeviceMemoryOpaqueCaptureAddress = |
| PFN_vkGetDeviceMemoryOpaqueCaptureAddress(vkGetDeviceProcAddr(device, "vkGetDeviceMemoryOpaqueCaptureAddress")); |
| |
| //=== VK_VERSION_1_3 === |
| vkCreatePrivateDataSlot = PFN_vkCreatePrivateDataSlot(vkGetDeviceProcAddr(device, "vkCreatePrivateDataSlot")); |
| vkDestroyPrivateDataSlot = PFN_vkDestroyPrivateDataSlot(vkGetDeviceProcAddr(device, "vkDestroyPrivateDataSlot")); |
| vkSetPrivateData = PFN_vkSetPrivateData(vkGetDeviceProcAddr(device, "vkSetPrivateData")); |
| vkGetPrivateData = PFN_vkGetPrivateData(vkGetDeviceProcAddr(device, "vkGetPrivateData")); |
| vkCmdSetEvent2 = PFN_vkCmdSetEvent2(vkGetDeviceProcAddr(device, "vkCmdSetEvent2")); |
| vkCmdResetEvent2 = PFN_vkCmdResetEvent2(vkGetDeviceProcAddr(device, "vkCmdResetEvent2")); |
| vkCmdWaitEvents2 = PFN_vkCmdWaitEvents2(vkGetDeviceProcAddr(device, "vkCmdWaitEvents2")); |
| vkCmdPipelineBarrier2 = PFN_vkCmdPipelineBarrier2(vkGetDeviceProcAddr(device, "vkCmdPipelineBarrier2")); |
| vkCmdWriteTimestamp2 = PFN_vkCmdWriteTimestamp2(vkGetDeviceProcAddr(device, "vkCmdWriteTimestamp2")); |
| vkQueueSubmit2 = PFN_vkQueueSubmit2(vkGetDeviceProcAddr(device, "vkQueueSubmit2")); |
| vkCmdCopyBuffer2 = PFN_vkCmdCopyBuffer2(vkGetDeviceProcAddr(device, "vkCmdCopyBuffer2")); |
| vkCmdCopyImage2 = PFN_vkCmdCopyImage2(vkGetDeviceProcAddr(device, "vkCmdCopyImage2")); |
| vkCmdCopyBufferToImage2 = PFN_vkCmdCopyBufferToImage2(vkGetDeviceProcAddr(device, "vkCmdCopyBufferToImage2")); |
| vkCmdCopyImageToBuffer2 = PFN_vkCmdCopyImageToBuffer2(vkGetDeviceProcAddr(device, "vkCmdCopyImageToBuffer2")); |
| vkCmdBlitImage2 = PFN_vkCmdBlitImage2(vkGetDeviceProcAddr(device, "vkCmdBlitImage2")); |
| vkCmdResolveImage2 = PFN_vkCmdResolveImage2(vkGetDeviceProcAddr(device, "vkCmdResolveImage2")); |
| vkCmdBeginRendering = PFN_vkCmdBeginRendering(vkGetDeviceProcAddr(device, "vkCmdBeginRendering")); |
| vkCmdEndRendering = PFN_vkCmdEndRendering(vkGetDeviceProcAddr(device, "vkCmdEndRendering")); |
| vkCmdSetCullMode = PFN_vkCmdSetCullMode(vkGetDeviceProcAddr(device, "vkCmdSetCullMode")); |
| vkCmdSetFrontFace = PFN_vkCmdSetFrontFace(vkGetDeviceProcAddr(device, "vkCmdSetFrontFace")); |
| vkCmdSetPrimitiveTopology = PFN_vkCmdSetPrimitiveTopology(vkGetDeviceProcAddr(device, "vkCmdSetPrimitiveTopology")); |
| vkCmdSetViewportWithCount = PFN_vkCmdSetViewportWithCount(vkGetDeviceProcAddr(device, "vkCmdSetViewportWithCount")); |
| vkCmdSetScissorWithCount = PFN_vkCmdSetScissorWithCount(vkGetDeviceProcAddr(device, "vkCmdSetScissorWithCount")); |
| vkCmdBindVertexBuffers2 = PFN_vkCmdBindVertexBuffers2(vkGetDeviceProcAddr(device, "vkCmdBindVertexBuffers2")); |
| vkCmdSetDepthTestEnable = PFN_vkCmdSetDepthTestEnable(vkGetDeviceProcAddr(device, "vkCmdSetDepthTestEnable")); |
| vkCmdSetDepthWriteEnable = PFN_vkCmdSetDepthWriteEnable(vkGetDeviceProcAddr(device, "vkCmdSetDepthWriteEnable")); |
| vkCmdSetDepthCompareOp = PFN_vkCmdSetDepthCompareOp(vkGetDeviceProcAddr(device, "vkCmdSetDepthCompareOp")); |
| vkCmdSetDepthBoundsTestEnable = PFN_vkCmdSetDepthBoundsTestEnable(vkGetDeviceProcAddr(device, "vkCmdSetDepthBoundsTestEnable")); |
| vkCmdSetStencilTestEnable = PFN_vkCmdSetStencilTestEnable(vkGetDeviceProcAddr(device, "vkCmdSetStencilTestEnable")); |
| vkCmdSetStencilOp = PFN_vkCmdSetStencilOp(vkGetDeviceProcAddr(device, "vkCmdSetStencilOp")); |
| vkCmdSetRasterizerDiscardEnable = PFN_vkCmdSetRasterizerDiscardEnable(vkGetDeviceProcAddr(device, "vkCmdSetRasterizerDiscardEnable")); |
| vkCmdSetDepthBiasEnable = PFN_vkCmdSetDepthBiasEnable(vkGetDeviceProcAddr(device, "vkCmdSetDepthBiasEnable")); |
| vkCmdSetPrimitiveRestartEnable = PFN_vkCmdSetPrimitiveRestartEnable(vkGetDeviceProcAddr(device, "vkCmdSetPrimitiveRestartEnable")); |
| vkGetDeviceBufferMemoryRequirements = PFN_vkGetDeviceBufferMemoryRequirements(vkGetDeviceProcAddr(device, "vkGetDeviceBufferMemoryRequirements")); |
| vkGetDeviceImageMemoryRequirements = PFN_vkGetDeviceImageMemoryRequirements(vkGetDeviceProcAddr(device, "vkGetDeviceImageMemoryRequirements")); |
| vkGetDeviceImageSparseMemoryRequirements = |
| PFN_vkGetDeviceImageSparseMemoryRequirements(vkGetDeviceProcAddr(device, "vkGetDeviceImageSparseMemoryRequirements")); |
| |
| //=== VK_AMD_buffer_marker === |
| vkCmdWriteBufferMarkerAMD = PFN_vkCmdWriteBufferMarkerAMD(vkGetDeviceProcAddr(device, "vkCmdWriteBufferMarkerAMD")); |
| |
| //=== VK_AMD_display_native_hdr === |
| vkSetLocalDimmingAMD = PFN_vkSetLocalDimmingAMD(vkGetDeviceProcAddr(device, "vkSetLocalDimmingAMD")); |
| |
| //=== VK_AMD_draw_indirect_count === |
| vkCmdDrawIndirectCountAMD = PFN_vkCmdDrawIndirectCountAMD(vkGetDeviceProcAddr(device, "vkCmdDrawIndirectCountAMD")); |
| if(!vkCmdDrawIndirectCount) |
| vkCmdDrawIndirectCount = vkCmdDrawIndirectCountAMD; |
| vkCmdDrawIndexedIndirectCountAMD = PFN_vkCmdDrawIndexedIndirectCountAMD(vkGetDeviceProcAddr(device, "vkCmdDrawIndexedIndirectCountAMD")); |
| if(!vkCmdDrawIndexedIndirectCount) |
| vkCmdDrawIndexedIndirectCount = vkCmdDrawIndexedIndirectCountAMD; |
| |
| //=== VK_AMD_shader_info === |
| vkGetShaderInfoAMD = PFN_vkGetShaderInfoAMD(vkGetDeviceProcAddr(device, "vkGetShaderInfoAMD")); |
| |
| # if defined(VK_USE_PLATFORM_ANDROID_KHR) |
| //=== VK_ANDROID_external_memory_android_hardware_buffer === |
| vkGetAndroidHardwareBufferPropertiesANDROID = |
| PFN_vkGetAndroidHardwareBufferPropertiesANDROID(vkGetDeviceProcAddr(device, "vkGetAndroidHardwareBufferPropertiesANDROID")); |
| vkGetMemoryAndroidHardwareBufferANDROID = |
| PFN_vkGetMemoryAndroidHardwareBufferANDROID(vkGetDeviceProcAddr(device, "vkGetMemoryAndroidHardwareBufferANDROID")); |
| # endif /*VK_USE_PLATFORM_ANDROID_KHR*/ |
| |
| //=== VK_EXT_buffer_device_address === |
| vkGetBufferDeviceAddressEXT = PFN_vkGetBufferDeviceAddressEXT(vkGetDeviceProcAddr(device, "vkGetBufferDeviceAddressEXT")); |
| if(!vkGetBufferDeviceAddress) |
| vkGetBufferDeviceAddress = vkGetBufferDeviceAddressEXT; |
| |
| //=== VK_EXT_calibrated_timestamps === |
| vkGetCalibratedTimestampsEXT = PFN_vkGetCalibratedTimestampsEXT(vkGetDeviceProcAddr(device, "vkGetCalibratedTimestampsEXT")); |
| |
| //=== VK_EXT_color_write_enable === |
| vkCmdSetColorWriteEnableEXT = PFN_vkCmdSetColorWriteEnableEXT(vkGetDeviceProcAddr(device, "vkCmdSetColorWriteEnableEXT")); |
| |
| //=== VK_EXT_conditional_rendering === |
| vkCmdBeginConditionalRenderingEXT = PFN_vkCmdBeginConditionalRenderingEXT(vkGetDeviceProcAddr(device, "vkCmdBeginConditionalRenderingEXT")); |
| vkCmdEndConditionalRenderingEXT = PFN_vkCmdEndConditionalRenderingEXT(vkGetDeviceProcAddr(device, "vkCmdEndConditionalRenderingEXT")); |
| |
| //=== VK_EXT_debug_marker === |
| vkDebugMarkerSetObjectTagEXT = PFN_vkDebugMarkerSetObjectTagEXT(vkGetDeviceProcAddr(device, "vkDebugMarkerSetObjectTagEXT")); |
| vkDebugMarkerSetObjectNameEXT = PFN_vkDebugMarkerSetObjectNameEXT(vkGetDeviceProcAddr(device, "vkDebugMarkerSetObjectNameEXT")); |
| vkCmdDebugMarkerBeginEXT = PFN_vkCmdDebugMarkerBeginEXT(vkGetDeviceProcAddr(device, "vkCmdDebugMarkerBeginEXT")); |
| vkCmdDebugMarkerEndEXT = PFN_vkCmdDebugMarkerEndEXT(vkGetDeviceProcAddr(device, "vkCmdDebugMarkerEndEXT")); |
| vkCmdDebugMarkerInsertEXT = PFN_vkCmdDebugMarkerInsertEXT(vkGetDeviceProcAddr(device, "vkCmdDebugMarkerInsertEXT")); |
| |
| //=== VK_EXT_debug_utils === |
| vkSetDebugUtilsObjectNameEXT = PFN_vkSetDebugUtilsObjectNameEXT(vkGetDeviceProcAddr(device, "vkSetDebugUtilsObjectNameEXT")); |
| vkSetDebugUtilsObjectTagEXT = PFN_vkSetDebugUtilsObjectTagEXT(vkGetDeviceProcAddr(device, "vkSetDebugUtilsObjectTagEXT")); |
| vkQueueBeginDebugUtilsLabelEXT = PFN_vkQueueBeginDebugUtilsLabelEXT(vkGetDeviceProcAddr(device, "vkQueueBeginDebugUtilsLabelEXT")); |
| vkQueueEndDebugUtilsLabelEXT = PFN_vkQueueEndDebugUtilsLabelEXT(vkGetDeviceProcAddr(device, "vkQueueEndDebugUtilsLabelEXT")); |
| vkQueueInsertDebugUtilsLabelEXT = PFN_vkQueueInsertDebugUtilsLabelEXT(vkGetDeviceProcAddr(device, "vkQueueInsertDebugUtilsLabelEXT")); |
| vkCmdBeginDebugUtilsLabelEXT = PFN_vkCmdBeginDebugUtilsLabelEXT(vkGetDeviceProcAddr(device, "vkCmdBeginDebugUtilsLabelEXT")); |
| vkCmdEndDebugUtilsLabelEXT = PFN_vkCmdEndDebugUtilsLabelEXT(vkGetDeviceProcAddr(device, "vkCmdEndDebugUtilsLabelEXT")); |
| vkCmdInsertDebugUtilsLabelEXT = PFN_vkCmdInsertDebugUtilsLabelEXT(vkGetDeviceProcAddr(device, "vkCmdInsertDebugUtilsLabelEXT")); |
| |
| //=== VK_EXT_discard_rectangles === |
| vkCmdSetDiscardRectangleEXT = PFN_vkCmdSetDiscardRectangleEXT(vkGetDeviceProcAddr(device, "vkCmdSetDiscardRectangleEXT")); |
| |
| //=== VK_EXT_display_control === |
| vkDisplayPowerControlEXT = PFN_vkDisplayPowerControlEXT(vkGetDeviceProcAddr(device, "vkDisplayPowerControlEXT")); |
| vkRegisterDeviceEventEXT = PFN_vkRegisterDeviceEventEXT(vkGetDeviceProcAddr(device, "vkRegisterDeviceEventEXT")); |
| vkRegisterDisplayEventEXT = PFN_vkRegisterDisplayEventEXT(vkGetDeviceProcAddr(device, "vkRegisterDisplayEventEXT")); |
| vkGetSwapchainCounterEXT = PFN_vkGetSwapchainCounterEXT(vkGetDeviceProcAddr(device, "vkGetSwapchainCounterEXT")); |
| |
| //=== VK_EXT_extended_dynamic_state === |
| vkCmdSetCullModeEXT = PFN_vkCmdSetCullModeEXT(vkGetDeviceProcAddr(device, "vkCmdSetCullModeEXT")); |
| if(!vkCmdSetCullMode) |
| vkCmdSetCullMode = vkCmdSetCullModeEXT; |
| vkCmdSetFrontFaceEXT = PFN_vkCmdSetFrontFaceEXT(vkGetDeviceProcAddr(device, "vkCmdSetFrontFaceEXT")); |
| if(!vkCmdSetFrontFace) |
| vkCmdSetFrontFace = vkCmdSetFrontFaceEXT; |
| vkCmdSetPrimitiveTopologyEXT = PFN_vkCmdSetPrimitiveTopologyEXT(vkGetDeviceProcAddr(device, "vkCmdSetPrimitiveTopologyEXT")); |
| if(!vkCmdSetPrimitiveTopology) |
| vkCmdSetPrimitiveTopology = vkCmdSetPrimitiveTopologyEXT; |
| vkCmdSetViewportWithCountEXT = PFN_vkCmdSetViewportWithCountEXT(vkGetDeviceProcAddr(device, "vkCmdSetViewportWithCountEXT")); |
| if(!vkCmdSetViewportWithCount) |
| vkCmdSetViewportWithCount = vkCmdSetViewportWithCountEXT; |
| vkCmdSetScissorWithCountEXT = PFN_vkCmdSetScissorWithCountEXT(vkGetDeviceProcAddr(device, "vkCmdSetScissorWithCountEXT")); |
| if(!vkCmdSetScissorWithCount) |
| vkCmdSetScissorWithCount = vkCmdSetScissorWithCountEXT; |
| vkCmdBindVertexBuffers2EXT = PFN_vkCmdBindVertexBuffers2EXT(vkGetDeviceProcAddr(device, "vkCmdBindVertexBuffers2EXT")); |
| if(!vkCmdBindVertexBuffers2) |
| vkCmdBindVertexBuffers2 = vkCmdBindVertexBuffers2EXT; |
| vkCmdSetDepthTestEnableEXT = PFN_vkCmdSetDepthTestEnableEXT(vkGetDeviceProcAddr(device, "vkCmdSetDepthTestEnableEXT")); |
| if(!vkCmdSetDepthTestEnable) |
| vkCmdSetDepthTestEnable = vkCmdSetDepthTestEnableEXT; |
| vkCmdSetDepthWriteEnableEXT = PFN_vkCmdSetDepthWriteEnableEXT(vkGetDeviceProcAddr(device, "vkCmdSetDepthWriteEnableEXT")); |
| if(!vkCmdSetDepthWriteEnable) |
| vkCmdSetDepthWriteEnable = vkCmdSetDepthWriteEnableEXT; |
| vkCmdSetDepthCompareOpEXT = PFN_vkCmdSetDepthCompareOpEXT(vkGetDeviceProcAddr(device, "vkCmdSetDepthCompareOpEXT")); |
| if(!vkCmdSetDepthCompareOp) |
| vkCmdSetDepthCompareOp = vkCmdSetDepthCompareOpEXT; |
| vkCmdSetDepthBoundsTestEnableEXT = PFN_vkCmdSetDepthBoundsTestEnableEXT(vkGetDeviceProcAddr(device, "vkCmdSetDepthBoundsTestEnableEXT")); |
| if(!vkCmdSetDepthBoundsTestEnable) |
| vkCmdSetDepthBoundsTestEnable = vkCmdSetDepthBoundsTestEnableEXT; |
| vkCmdSetStencilTestEnableEXT = PFN_vkCmdSetStencilTestEnableEXT(vkGetDeviceProcAddr(device, "vkCmdSetStencilTestEnableEXT")); |
| if(!vkCmdSetStencilTestEnable) |
| vkCmdSetStencilTestEnable = vkCmdSetStencilTestEnableEXT; |
| vkCmdSetStencilOpEXT = PFN_vkCmdSetStencilOpEXT(vkGetDeviceProcAddr(device, "vkCmdSetStencilOpEXT")); |
| if(!vkCmdSetStencilOp) |
| vkCmdSetStencilOp = vkCmdSetStencilOpEXT; |
| |
| //=== VK_EXT_extended_dynamic_state2 === |
| vkCmdSetPatchControlPointsEXT = PFN_vkCmdSetPatchControlPointsEXT(vkGetDeviceProcAddr(device, "vkCmdSetPatchControlPointsEXT")); |
| vkCmdSetRasterizerDiscardEnableEXT = PFN_vkCmdSetRasterizerDiscardEnableEXT(vkGetDeviceProcAddr(device, "vkCmdSetRasterizerDiscardEnableEXT")); |
| if(!vkCmdSetRasterizerDiscardEnable) |
| vkCmdSetRasterizerDiscardEnable = vkCmdSetRasterizerDiscardEnableEXT; |
| vkCmdSetDepthBiasEnableEXT = PFN_vkCmdSetDepthBiasEnableEXT(vkGetDeviceProcAddr(device, "vkCmdSetDepthBiasEnableEXT")); |
| if(!vkCmdSetDepthBiasEnable) |
| vkCmdSetDepthBiasEnable = vkCmdSetDepthBiasEnableEXT; |
| vkCmdSetLogicOpEXT = PFN_vkCmdSetLogicOpEXT(vkGetDeviceProcAddr(device, "vkCmdSetLogicOpEXT")); |
| vkCmdSetPrimitiveRestartEnableEXT = PFN_vkCmdSetPrimitiveRestartEnableEXT(vkGetDeviceProcAddr(device, "vkCmdSetPrimitiveRestartEnableEXT")); |
| if(!vkCmdSetPrimitiveRestartEnable) |
| vkCmdSetPrimitiveRestartEnable = vkCmdSetPrimitiveRestartEnableEXT; |
| |
| //=== VK_EXT_external_memory_host === |
| vkGetMemoryHostPointerPropertiesEXT = PFN_vkGetMemoryHostPointerPropertiesEXT(vkGetDeviceProcAddr(device, "vkGetMemoryHostPointerPropertiesEXT")); |
| |
| # if defined(VK_USE_PLATFORM_WIN32_KHR) |
| //=== VK_EXT_full_screen_exclusive === |
| vkAcquireFullScreenExclusiveModeEXT = PFN_vkAcquireFullScreenExclusiveModeEXT(vkGetDeviceProcAddr(device, "vkAcquireFullScreenExclusiveModeEXT")); |
| vkReleaseFullScreenExclusiveModeEXT = PFN_vkReleaseFullScreenExclusiveModeEXT(vkGetDeviceProcAddr(device, "vkReleaseFullScreenExclusiveModeEXT")); |
| vkGetDeviceGroupSurfacePresentModes2EXT = |
| PFN_vkGetDeviceGroupSurfacePresentModes2EXT(vkGetDeviceProcAddr(device, "vkGetDeviceGroupSurfacePresentModes2EXT")); |
| # endif /*VK_USE_PLATFORM_WIN32_KHR*/ |
| |
| //=== VK_EXT_hdr_metadata === |
| vkSetHdrMetadataEXT = PFN_vkSetHdrMetadataEXT(vkGetDeviceProcAddr(device, "vkSetHdrMetadataEXT")); |
| |
| //=== VK_EXT_host_query_reset === |
| vkResetQueryPoolEXT = PFN_vkResetQueryPoolEXT(vkGetDeviceProcAddr(device, "vkResetQueryPoolEXT")); |
| if(!vkResetQueryPool) |
| vkResetQueryPool = vkResetQueryPoolEXT; |
| |
| //=== VK_EXT_image_drm_format_modifier === |
| vkGetImageDrmFormatModifierPropertiesEXT = |
| PFN_vkGetImageDrmFormatModifierPropertiesEXT(vkGetDeviceProcAddr(device, "vkGetImageDrmFormatModifierPropertiesEXT")); |
| |
| //=== VK_EXT_line_rasterization === |
| vkCmdSetLineStippleEXT = PFN_vkCmdSetLineStippleEXT(vkGetDeviceProcAddr(device, "vkCmdSetLineStippleEXT")); |
| |
| //=== VK_EXT_multi_draw === |
| vkCmdDrawMultiEXT = PFN_vkCmdDrawMultiEXT(vkGetDeviceProcAddr(device, "vkCmdDrawMultiEXT")); |
| vkCmdDrawMultiIndexedEXT = PFN_vkCmdDrawMultiIndexedEXT(vkGetDeviceProcAddr(device, "vkCmdDrawMultiIndexedEXT")); |
| |
| //=== VK_EXT_pageable_device_local_memory === |
| vkSetDeviceMemoryPriorityEXT = PFN_vkSetDeviceMemoryPriorityEXT(vkGetDeviceProcAddr(device, "vkSetDeviceMemoryPriorityEXT")); |
| |
| //=== VK_EXT_private_data === |
| vkCreatePrivateDataSlotEXT = PFN_vkCreatePrivateDataSlotEXT(vkGetDeviceProcAddr(device, "vkCreatePrivateDataSlotEXT")); |
| if(!vkCreatePrivateDataSlot) |
| vkCreatePrivateDataSlot = vkCreatePrivateDataSlotEXT; |
| vkDestroyPrivateDataSlotEXT = PFN_vkDestroyPrivateDataSlotEXT(vkGetDeviceProcAddr(device, "vkDestroyPrivateDataSlotEXT")); |
| if(!vkDestroyPrivateDataSlot) |
| vkDestroyPrivateDataSlot = vkDestroyPrivateDataSlotEXT; |
| vkSetPrivateDataEXT = PFN_vkSetPrivateDataEXT(vkGetDeviceProcAddr(device, "vkSetPrivateDataEXT")); |
| if(!vkSetPrivateData) |
| vkSetPrivateData = vkSetPrivateDataEXT; |
| vkGetPrivateDataEXT = PFN_vkGetPrivateDataEXT(vkGetDeviceProcAddr(device, "vkGetPrivateDataEXT")); |
| if(!vkGetPrivateData) |
| vkGetPrivateData = vkGetPrivateDataEXT; |
| |
| //=== VK_EXT_sample_locations === |
| vkCmdSetSampleLocationsEXT = PFN_vkCmdSetSampleLocationsEXT(vkGetDeviceProcAddr(device, "vkCmdSetSampleLocationsEXT")); |
| |
| //=== VK_EXT_transform_feedback === |
| vkCmdBindTransformFeedbackBuffersEXT = |
| PFN_vkCmdBindTransformFeedbackBuffersEXT(vkGetDeviceProcAddr(device, "vkCmdBindTransformFeedbackBuffersEXT")); |
| vkCmdBeginTransformFeedbackEXT = PFN_vkCmdBeginTransformFeedbackEXT(vkGetDeviceProcAddr(device, "vkCmdBeginTransformFeedbackEXT")); |
| vkCmdEndTransformFeedbackEXT = PFN_vkCmdEndTransformFeedbackEXT(vkGetDeviceProcAddr(device, "vkCmdEndTransformFeedbackEXT")); |
| vkCmdBeginQueryIndexedEXT = PFN_vkCmdBeginQueryIndexedEXT(vkGetDeviceProcAddr(device, "vkCmdBeginQueryIndexedEXT")); |
| vkCmdEndQueryIndexedEXT = PFN_vkCmdEndQueryIndexedEXT(vkGetDeviceProcAddr(device, "vkCmdEndQueryIndexedEXT")); |
| vkCmdDrawIndirectByteCountEXT = PFN_vkCmdDrawIndirectByteCountEXT(vkGetDeviceProcAddr(device, "vkCmdDrawIndirectByteCountEXT")); |
| |
| //=== VK_EXT_validation_cache === |
| vkCreateValidationCacheEXT = PFN_vkCreateValidationCacheEXT(vkGetDeviceProcAddr(device, "vkCreateValidationCacheEXT")); |
| vkDestroyValidationCacheEXT = PFN_vkDestroyValidationCacheEXT(vkGetDeviceProcAddr(device, "vkDestroyValidationCacheEXT")); |
| vkMergeValidationCachesEXT = PFN_vkMergeValidationCachesEXT(vkGetDeviceProcAddr(device, "vkMergeValidationCachesEXT")); |
| vkGetValidationCacheDataEXT = PFN_vkGetValidationCacheDataEXT(vkGetDeviceProcAddr(device, "vkGetValidationCacheDataEXT")); |
| |
| //=== VK_EXT_vertex_input_dynamic_state === |
| vkCmdSetVertexInputEXT = PFN_vkCmdSetVertexInputEXT(vkGetDeviceProcAddr(device, "vkCmdSetVertexInputEXT")); |
| |
| # if defined(VK_USE_PLATFORM_FUCHSIA) |
| //=== VK_FUCHSIA_buffer_collection === |
| vkCreateBufferCollectionFUCHSIA = PFN_vkCreateBufferCollectionFUCHSIA(vkGetDeviceProcAddr(device, "vkCreateBufferCollectionFUCHSIA")); |
| vkSetBufferCollectionImageConstraintsFUCHSIA = |
| PFN_vkSetBufferCollectionImageConstraintsFUCHSIA(vkGetDeviceProcAddr(device, "vkSetBufferCollectionImageConstraintsFUCHSIA")); |
| vkSetBufferCollectionBufferConstraintsFUCHSIA = |
| PFN_vkSetBufferCollectionBufferConstraintsFUCHSIA(vkGetDeviceProcAddr(device, "vkSetBufferCollectionBufferConstraintsFUCHSIA")); |
| vkDestroyBufferCollectionFUCHSIA = PFN_vkDestroyBufferCollectionFUCHSIA(vkGetDeviceProcAddr(device, "vkDestroyBufferCollectionFUCHSIA")); |
| vkGetBufferCollectionPropertiesFUCHSIA = |
| PFN_vkGetBufferCollectionPropertiesFUCHSIA(vkGetDeviceProcAddr(device, "vkGetBufferCollectionPropertiesFUCHSIA")); |
| # endif /*VK_USE_PLATFORM_FUCHSIA*/ |
| |
| # if defined(VK_USE_PLATFORM_FUCHSIA) |
| //=== VK_FUCHSIA_external_memory === |
| vkGetMemoryZirconHandleFUCHSIA = PFN_vkGetMemoryZirconHandleFUCHSIA(vkGetDeviceProcAddr(device, "vkGetMemoryZirconHandleFUCHSIA")); |
| vkGetMemoryZirconHandlePropertiesFUCHSIA = |
| PFN_vkGetMemoryZirconHandlePropertiesFUCHSIA(vkGetDeviceProcAddr(device, "vkGetMemoryZirconHandlePropertiesFUCHSIA")); |
| # endif /*VK_USE_PLATFORM_FUCHSIA*/ |
| |
| # if defined(VK_USE_PLATFORM_FUCHSIA) |
| //=== VK_FUCHSIA_external_semaphore === |
| vkImportSemaphoreZirconHandleFUCHSIA = |
| PFN_vkImportSemaphoreZirconHandleFUCHSIA(vkGetDeviceProcAddr(device, "vkImportSemaphoreZirconHandleFUCHSIA")); |
| vkGetSemaphoreZirconHandleFUCHSIA = PFN_vkGetSemaphoreZirconHandleFUCHSIA(vkGetDeviceProcAddr(device, "vkGetSemaphoreZirconHandleFUCHSIA")); |
| # endif /*VK_USE_PLATFORM_FUCHSIA*/ |
| |
| //=== VK_GOOGLE_display_timing === |
| vkGetRefreshCycleDurationGOOGLE = PFN_vkGetRefreshCycleDurationGOOGLE(vkGetDeviceProcAddr(device, "vkGetRefreshCycleDurationGOOGLE")); |
| vkGetPastPresentationTimingGOOGLE = PFN_vkGetPastPresentationTimingGOOGLE(vkGetDeviceProcAddr(device, "vkGetPastPresentationTimingGOOGLE")); |
| |
| //=== VK_HUAWEI_invocation_mask === |
| vkCmdBindInvocationMaskHUAWEI = PFN_vkCmdBindInvocationMaskHUAWEI(vkGetDeviceProcAddr(device, "vkCmdBindInvocationMaskHUAWEI")); |
| |
| //=== VK_HUAWEI_subpass_shading === |
| vkGetDeviceSubpassShadingMaxWorkgroupSizeHUAWEI = |
| PFN_vkGetDeviceSubpassShadingMaxWorkgroupSizeHUAWEI(vkGetDeviceProcAddr(device, "vkGetDeviceSubpassShadingMaxWorkgroupSizeHUAWEI")); |
| vkCmdSubpassShadingHUAWEI = PFN_vkCmdSubpassShadingHUAWEI(vkGetDeviceProcAddr(device, "vkCmdSubpassShadingHUAWEI")); |
| |
| //=== VK_INTEL_performance_query === |
| vkInitializePerformanceApiINTEL = PFN_vkInitializePerformanceApiINTEL(vkGetDeviceProcAddr(device, "vkInitializePerformanceApiINTEL")); |
| vkUninitializePerformanceApiINTEL = PFN_vkUninitializePerformanceApiINTEL(vkGetDeviceProcAddr(device, "vkUninitializePerformanceApiINTEL")); |
| vkCmdSetPerformanceMarkerINTEL = PFN_vkCmdSetPerformanceMarkerINTEL(vkGetDeviceProcAddr(device, "vkCmdSetPerformanceMarkerINTEL")); |
| vkCmdSetPerformanceStreamMarkerINTEL = |
| PFN_vkCmdSetPerformanceStreamMarkerINTEL(vkGetDeviceProcAddr(device, "vkCmdSetPerformanceStreamMarkerINTEL")); |
| vkCmdSetPerformanceOverrideINTEL = PFN_vkCmdSetPerformanceOverrideINTEL(vkGetDeviceProcAddr(device, "vkCmdSetPerformanceOverrideINTEL")); |
| vkAcquirePerformanceConfigurationINTEL = |
| PFN_vkAcquirePerformanceConfigurationINTEL(vkGetDeviceProcAddr(device, "vkAcquirePerformanceConfigurationINTEL")); |
| vkReleasePerformanceConfigurationINTEL = |
| PFN_vkReleasePerformanceConfigurationINTEL(vkGetDeviceProcAddr(device, "vkReleasePerformanceConfigurationINTEL")); |
| vkQueueSetPerformanceConfigurationINTEL = |
| PFN_vkQueueSetPerformanceConfigurationINTEL(vkGetDeviceProcAddr(device, "vkQueueSetPerformanceConfigurationINTEL")); |
| vkGetPerformanceParameterINTEL = PFN_vkGetPerformanceParameterINTEL(vkGetDeviceProcAddr(device, "vkGetPerformanceParameterINTEL")); |
| |
| //=== VK_KHR_acceleration_structure === |
| vkCreateAccelerationStructureKHR = PFN_vkCreateAccelerationStructureKHR(vkGetDeviceProcAddr(device, "vkCreateAccelerationStructureKHR")); |
| vkDestroyAccelerationStructureKHR = PFN_vkDestroyAccelerationStructureKHR(vkGetDeviceProcAddr(device, "vkDestroyAccelerationStructureKHR")); |
| vkCmdBuildAccelerationStructuresKHR = PFN_vkCmdBuildAccelerationStructuresKHR(vkGetDeviceProcAddr(device, "vkCmdBuildAccelerationStructuresKHR")); |
| vkCmdBuildAccelerationStructuresIndirectKHR = |
| PFN_vkCmdBuildAccelerationStructuresIndirectKHR(vkGetDeviceProcAddr(device, "vkCmdBuildAccelerationStructuresIndirectKHR")); |
| vkBuildAccelerationStructuresKHR = PFN_vkBuildAccelerationStructuresKHR(vkGetDeviceProcAddr(device, "vkBuildAccelerationStructuresKHR")); |
| vkCopyAccelerationStructureKHR = PFN_vkCopyAccelerationStructureKHR(vkGetDeviceProcAddr(device, "vkCopyAccelerationStructureKHR")); |
| vkCopyAccelerationStructureToMemoryKHR = |
| PFN_vkCopyAccelerationStructureToMemoryKHR(vkGetDeviceProcAddr(device, "vkCopyAccelerationStructureToMemoryKHR")); |
| vkCopyMemoryToAccelerationStructureKHR = |
| PFN_vkCopyMemoryToAccelerationStructureKHR(vkGetDeviceProcAddr(device, "vkCopyMemoryToAccelerationStructureKHR")); |
| vkWriteAccelerationStructuresPropertiesKHR = |
| PFN_vkWriteAccelerationStructuresPropertiesKHR(vkGetDeviceProcAddr(device, "vkWriteAccelerationStructuresPropertiesKHR")); |
| vkCmdCopyAccelerationStructureKHR = PFN_vkCmdCopyAccelerationStructureKHR(vkGetDeviceProcAddr(device, "vkCmdCopyAccelerationStructureKHR")); |
| vkCmdCopyAccelerationStructureToMemoryKHR = |
| PFN_vkCmdCopyAccelerationStructureToMemoryKHR(vkGetDeviceProcAddr(device, "vkCmdCopyAccelerationStructureToMemoryKHR")); |
| vkCmdCopyMemoryToAccelerationStructureKHR = |
| PFN_vkCmdCopyMemoryToAccelerationStructureKHR(vkGetDeviceProcAddr(device, "vkCmdCopyMemoryToAccelerationStructureKHR")); |
| vkGetAccelerationStructureDeviceAddressKHR = |
| PFN_vkGetAccelerationStructureDeviceAddressKHR(vkGetDeviceProcAddr(device, "vkGetAccelerationStructureDeviceAddressKHR")); |
| vkCmdWriteAccelerationStructuresPropertiesKHR = |
| PFN_vkCmdWriteAccelerationStructuresPropertiesKHR(vkGetDeviceProcAddr(device, "vkCmdWriteAccelerationStructuresPropertiesKHR")); |
| vkGetDeviceAccelerationStructureCompatibilityKHR = |
| PFN_vkGetDeviceAccelerationStructureCompatibilityKHR(vkGetDeviceProcAddr(device, "vkGetDeviceAccelerationStructureCompatibilityKHR")); |
| vkGetAccelerationStructureBuildSizesKHR = |
| PFN_vkGetAccelerationStructureBuildSizesKHR(vkGetDeviceProcAddr(device, "vkGetAccelerationStructureBuildSizesKHR")); |
| |
| //=== VK_KHR_bind_memory2 === |
| vkBindBufferMemory2KHR = PFN_vkBindBufferMemory2KHR(vkGetDeviceProcAddr(device, "vkBindBufferMemory2KHR")); |
| if(!vkBindBufferMemory2) |
| vkBindBufferMemory2 = vkBindBufferMemory2KHR; |
| vkBindImageMemory2KHR = PFN_vkBindImageMemory2KHR(vkGetDeviceProcAddr(device, "vkBindImageMemory2KHR")); |
| if(!vkBindImageMemory2) |
| vkBindImageMemory2 = vkBindImageMemory2KHR; |
| |
| //=== VK_KHR_buffer_device_address === |
| vkGetBufferDeviceAddressKHR = PFN_vkGetBufferDeviceAddressKHR(vkGetDeviceProcAddr(device, "vkGetBufferDeviceAddressKHR")); |
| if(!vkGetBufferDeviceAddress) |
| vkGetBufferDeviceAddress = vkGetBufferDeviceAddressKHR; |
| vkGetBufferOpaqueCaptureAddressKHR = PFN_vkGetBufferOpaqueCaptureAddressKHR(vkGetDeviceProcAddr(device, "vkGetBufferOpaqueCaptureAddressKHR")); |
| if(!vkGetBufferOpaqueCaptureAddress) |
| vkGetBufferOpaqueCaptureAddress = vkGetBufferOpaqueCaptureAddressKHR; |
| vkGetDeviceMemoryOpaqueCaptureAddressKHR = |
| PFN_vkGetDeviceMemoryOpaqueCaptureAddressKHR(vkGetDeviceProcAddr(device, "vkGetDeviceMemoryOpaqueCaptureAddressKHR")); |
| if(!vkGetDeviceMemoryOpaqueCaptureAddress) |
| vkGetDeviceMemoryOpaqueCaptureAddress = vkGetDeviceMemoryOpaqueCaptureAddressKHR; |
| |
| //=== VK_KHR_copy_commands2 === |
| vkCmdCopyBuffer2KHR = PFN_vkCmdCopyBuffer2KHR(vkGetDeviceProcAddr(device, "vkCmdCopyBuffer2KHR")); |
| if(!vkCmdCopyBuffer2) |
| vkCmdCopyBuffer2 = vkCmdCopyBuffer2KHR; |
| vkCmdCopyImage2KHR = PFN_vkCmdCopyImage2KHR(vkGetDeviceProcAddr(device, "vkCmdCopyImage2KHR")); |
| if(!vkCmdCopyImage2) |
| vkCmdCopyImage2 = vkCmdCopyImage2KHR; |
| vkCmdCopyBufferToImage2KHR = PFN_vkCmdCopyBufferToImage2KHR(vkGetDeviceProcAddr(device, "vkCmdCopyBufferToImage2KHR")); |
| if(!vkCmdCopyBufferToImage2) |
| vkCmdCopyBufferToImage2 = vkCmdCopyBufferToImage2KHR; |
| vkCmdCopyImageToBuffer2KHR = PFN_vkCmdCopyImageToBuffer2KHR(vkGetDeviceProcAddr(device, "vkCmdCopyImageToBuffer2KHR")); |
| if(!vkCmdCopyImageToBuffer2) |
| vkCmdCopyImageToBuffer2 = vkCmdCopyImageToBuffer2KHR; |
| vkCmdBlitImage2KHR = PFN_vkCmdBlitImage2KHR(vkGetDeviceProcAddr(device, "vkCmdBlitImage2KHR")); |
| if(!vkCmdBlitImage2) |
| vkCmdBlitImage2 = vkCmdBlitImage2KHR; |
| vkCmdResolveImage2KHR = PFN_vkCmdResolveImage2KHR(vkGetDeviceProcAddr(device, "vkCmdResolveImage2KHR")); |
| if(!vkCmdResolveImage2) |
| vkCmdResolveImage2 = vkCmdResolveImage2KHR; |
| |
| //=== VK_KHR_create_renderpass2 === |
| vkCreateRenderPass2KHR = PFN_vkCreateRenderPass2KHR(vkGetDeviceProcAddr(device, "vkCreateRenderPass2KHR")); |
| if(!vkCreateRenderPass2) |
| vkCreateRenderPass2 = vkCreateRenderPass2KHR; |
| vkCmdBeginRenderPass2KHR = PFN_vkCmdBeginRenderPass2KHR(vkGetDeviceProcAddr(device, "vkCmdBeginRenderPass2KHR")); |
| if(!vkCmdBeginRenderPass2) |
| vkCmdBeginRenderPass2 = vkCmdBeginRenderPass2KHR; |
| vkCmdNextSubpass2KHR = PFN_vkCmdNextSubpass2KHR(vkGetDeviceProcAddr(device, "vkCmdNextSubpass2KHR")); |
| if(!vkCmdNextSubpass2) |
| vkCmdNextSubpass2 = vkCmdNextSubpass2KHR; |
| vkCmdEndRenderPass2KHR = PFN_vkCmdEndRenderPass2KHR(vkGetDeviceProcAddr(device, "vkCmdEndRenderPass2KHR")); |
| if(!vkCmdEndRenderPass2) |
| vkCmdEndRenderPass2 = vkCmdEndRenderPass2KHR; |
| |
| //=== VK_KHR_deferred_host_operations === |
| vkCreateDeferredOperationKHR = PFN_vkCreateDeferredOperationKHR(vkGetDeviceProcAddr(device, "vkCreateDeferredOperationKHR")); |
| vkDestroyDeferredOperationKHR = PFN_vkDestroyDeferredOperationKHR(vkGetDeviceProcAddr(device, "vkDestroyDeferredOperationKHR")); |
| vkGetDeferredOperationMaxConcurrencyKHR = |
| PFN_vkGetDeferredOperationMaxConcurrencyKHR(vkGetDeviceProcAddr(device, "vkGetDeferredOperationMaxConcurrencyKHR")); |
| vkGetDeferredOperationResultKHR = PFN_vkGetDeferredOperationResultKHR(vkGetDeviceProcAddr(device, "vkGetDeferredOperationResultKHR")); |
| vkDeferredOperationJoinKHR = PFN_vkDeferredOperationJoinKHR(vkGetDeviceProcAddr(device, "vkDeferredOperationJoinKHR")); |
| |
| //=== VK_KHR_descriptor_update_template === |
| vkCreateDescriptorUpdateTemplateKHR = PFN_vkCreateDescriptorUpdateTemplateKHR(vkGetDeviceProcAddr(device, "vkCreateDescriptorUpdateTemplateKHR")); |
| if(!vkCreateDescriptorUpdateTemplate) |
| vkCreateDescriptorUpdateTemplate = vkCreateDescriptorUpdateTemplateKHR; |
| vkDestroyDescriptorUpdateTemplateKHR = |
| PFN_vkDestroyDescriptorUpdateTemplateKHR(vkGetDeviceProcAddr(device, "vkDestroyDescriptorUpdateTemplateKHR")); |
| if(!vkDestroyDescriptorUpdateTemplate) |
| vkDestroyDescriptorUpdateTemplate = vkDestroyDescriptorUpdateTemplateKHR; |
| vkUpdateDescriptorSetWithTemplateKHR = |
| PFN_vkUpdateDescriptorSetWithTemplateKHR(vkGetDeviceProcAddr(device, "vkUpdateDescriptorSetWithTemplateKHR")); |
| if(!vkUpdateDescriptorSetWithTemplate) |
| vkUpdateDescriptorSetWithTemplate = vkUpdateDescriptorSetWithTemplateKHR; |
| vkCmdPushDescriptorSetWithTemplateKHR = |
| PFN_vkCmdPushDescriptorSetWithTemplateKHR(vkGetDeviceProcAddr(device, "vkCmdPushDescriptorSetWithTemplateKHR")); |
| |
| //=== VK_KHR_device_group === |
| vkGetDeviceGroupPeerMemoryFeaturesKHR = |
| PFN_vkGetDeviceGroupPeerMemoryFeaturesKHR(vkGetDeviceProcAddr(device, "vkGetDeviceGroupPeerMemoryFeaturesKHR")); |
| if(!vkGetDeviceGroupPeerMemoryFeatures) |
| vkGetDeviceGroupPeerMemoryFeatures = vkGetDeviceGroupPeerMemoryFeaturesKHR; |
| vkCmdSetDeviceMaskKHR = PFN_vkCmdSetDeviceMaskKHR(vkGetDeviceProcAddr(device, "vkCmdSetDeviceMaskKHR")); |
| if(!vkCmdSetDeviceMask) |
| vkCmdSetDeviceMask = vkCmdSetDeviceMaskKHR; |
| vkCmdDispatchBaseKHR = PFN_vkCmdDispatchBaseKHR(vkGetDeviceProcAddr(device, "vkCmdDispatchBaseKHR")); |
| if(!vkCmdDispatchBase) |
| vkCmdDispatchBase = vkCmdDispatchBaseKHR; |
| vkGetDeviceGroupPresentCapabilitiesKHR = |
| PFN_vkGetDeviceGroupPresentCapabilitiesKHR(vkGetDeviceProcAddr(device, "vkGetDeviceGroupPresentCapabilitiesKHR")); |
| vkGetDeviceGroupSurfacePresentModesKHR = |
| PFN_vkGetDeviceGroupSurfacePresentModesKHR(vkGetDeviceProcAddr(device, "vkGetDeviceGroupSurfacePresentModesKHR")); |
| vkAcquireNextImage2KHR = PFN_vkAcquireNextImage2KHR(vkGetDeviceProcAddr(device, "vkAcquireNextImage2KHR")); |
| |
| //=== VK_KHR_display_swapchain === |
| vkCreateSharedSwapchainsKHR = PFN_vkCreateSharedSwapchainsKHR(vkGetDeviceProcAddr(device, "vkCreateSharedSwapchainsKHR")); |
| |
| //=== VK_KHR_draw_indirect_count === |
| vkCmdDrawIndirectCountKHR = PFN_vkCmdDrawIndirectCountKHR(vkGetDeviceProcAddr(device, "vkCmdDrawIndirectCountKHR")); |
| if(!vkCmdDrawIndirectCount) |
| vkCmdDrawIndirectCount = vkCmdDrawIndirectCountKHR; |
| vkCmdDrawIndexedIndirectCountKHR = PFN_vkCmdDrawIndexedIndirectCountKHR(vkGetDeviceProcAddr(device, "vkCmdDrawIndexedIndirectCountKHR")); |
| if(!vkCmdDrawIndexedIndirectCount) |
| vkCmdDrawIndexedIndirectCount = vkCmdDrawIndexedIndirectCountKHR; |
| |
| //=== VK_KHR_dynamic_rendering === |
| vkCmdBeginRenderingKHR = PFN_vkCmdBeginRenderingKHR(vkGetDeviceProcAddr(device, "vkCmdBeginRenderingKHR")); |
| if(!vkCmdBeginRendering) |
| vkCmdBeginRendering = vkCmdBeginRenderingKHR; |
| vkCmdEndRenderingKHR = PFN_vkCmdEndRenderingKHR(vkGetDeviceProcAddr(device, "vkCmdEndRenderingKHR")); |
| if(!vkCmdEndRendering) |
| vkCmdEndRendering = vkCmdEndRenderingKHR; |
| |
| //=== VK_KHR_external_fence_fd === |
| vkImportFenceFdKHR = PFN_vkImportFenceFdKHR(vkGetDeviceProcAddr(device, "vkImportFenceFdKHR")); |
| vkGetFenceFdKHR = PFN_vkGetFenceFdKHR(vkGetDeviceProcAddr(device, "vkGetFenceFdKHR")); |
| |
| # if defined(VK_USE_PLATFORM_WIN32_KHR) |
| //=== VK_KHR_external_fence_win32 === |
| vkImportFenceWin32HandleKHR = PFN_vkImportFenceWin32HandleKHR(vkGetDeviceProcAddr(device, "vkImportFenceWin32HandleKHR")); |
| vkGetFenceWin32HandleKHR = PFN_vkGetFenceWin32HandleKHR(vkGetDeviceProcAddr(device, "vkGetFenceWin32HandleKHR")); |
| # endif /*VK_USE_PLATFORM_WIN32_KHR*/ |
| |
| //=== VK_KHR_external_memory_fd === |
| vkGetMemoryFdKHR = PFN_vkGetMemoryFdKHR(vkGetDeviceProcAddr(device, "vkGetMemoryFdKHR")); |
| vkGetMemoryFdPropertiesKHR = PFN_vkGetMemoryFdPropertiesKHR(vkGetDeviceProcAddr(device, "vkGetMemoryFdPropertiesKHR")); |
| |
| # if defined(VK_USE_PLATFORM_WIN32_KHR) |
| //=== VK_KHR_external_memory_win32 === |
| vkGetMemoryWin32HandleKHR = PFN_vkGetMemoryWin32HandleKHR(vkGetDeviceProcAddr(device, "vkGetMemoryWin32HandleKHR")); |
| vkGetMemoryWin32HandlePropertiesKHR = PFN_vkGetMemoryWin32HandlePropertiesKHR(vkGetDeviceProcAddr(device, "vkGetMemoryWin32HandlePropertiesKHR")); |
| # endif /*VK_USE_PLATFORM_WIN32_KHR*/ |
| |
| //=== VK_KHR_external_semaphore_fd === |
| vkImportSemaphoreFdKHR = PFN_vkImportSemaphoreFdKHR(vkGetDeviceProcAddr(device, "vkImportSemaphoreFdKHR")); |
| vkGetSemaphoreFdKHR = PFN_vkGetSemaphoreFdKHR(vkGetDeviceProcAddr(device, "vkGetSemaphoreFdKHR")); |
| |
| # if defined(VK_USE_PLATFORM_WIN32_KHR) |
| //=== VK_KHR_external_semaphore_win32 === |
| vkImportSemaphoreWin32HandleKHR = PFN_vkImportSemaphoreWin32HandleKHR(vkGetDeviceProcAddr(device, "vkImportSemaphoreWin32HandleKHR")); |
| vkGetSemaphoreWin32HandleKHR = PFN_vkGetSemaphoreWin32HandleKHR(vkGetDeviceProcAddr(device, "vkGetSemaphoreWin32HandleKHR")); |
| # endif /*VK_USE_PLATFORM_WIN32_KHR*/ |
| |
| //=== VK_KHR_fragment_shading_rate === |
| vkCmdSetFragmentShadingRateKHR = PFN_vkCmdSetFragmentShadingRateKHR(vkGetDeviceProcAddr(device, "vkCmdSetFragmentShadingRateKHR")); |
| |
| //=== VK_KHR_get_memory_requirements2 === |
| vkGetImageMemoryRequirements2KHR = PFN_vkGetImageMemoryRequirements2KHR(vkGetDeviceProcAddr(device, "vkGetImageMemoryRequirements2KHR")); |
| if(!vkGetImageMemoryRequirements2) |
| vkGetImageMemoryRequirements2 = vkGetImageMemoryRequirements2KHR; |
| vkGetBufferMemoryRequirements2KHR = PFN_vkGetBufferMemoryRequirements2KHR(vkGetDeviceProcAddr(device, "vkGetBufferMemoryRequirements2KHR")); |
| if(!vkGetBufferMemoryRequirements2) |
| vkGetBufferMemoryRequirements2 = vkGetBufferMemoryRequirements2KHR; |
| vkGetImageSparseMemoryRequirements2KHR = |
| PFN_vkGetImageSparseMemoryRequirements2KHR(vkGetDeviceProcAddr(device, "vkGetImageSparseMemoryRequirements2KHR")); |
| if(!vkGetImageSparseMemoryRequirements2) |
| vkGetImageSparseMemoryRequirements2 = vkGetImageSparseMemoryRequirements2KHR; |
| |
| //=== VK_KHR_maintenance1 === |
| vkTrimCommandPoolKHR = PFN_vkTrimCommandPoolKHR(vkGetDeviceProcAddr(device, "vkTrimCommandPoolKHR")); |
| if(!vkTrimCommandPool) |
| vkTrimCommandPool = vkTrimCommandPoolKHR; |
| |
| //=== VK_KHR_maintenance3 === |
| vkGetDescriptorSetLayoutSupportKHR = PFN_vkGetDescriptorSetLayoutSupportKHR(vkGetDeviceProcAddr(device, "vkGetDescriptorSetLayoutSupportKHR")); |
| if(!vkGetDescriptorSetLayoutSupport) |
| vkGetDescriptorSetLayoutSupport = vkGetDescriptorSetLayoutSupportKHR; |
| |
| //=== VK_KHR_maintenance4 === |
| vkGetDeviceBufferMemoryRequirementsKHR = |
| PFN_vkGetDeviceBufferMemoryRequirementsKHR(vkGetDeviceProcAddr(device, "vkGetDeviceBufferMemoryRequirementsKHR")); |
| if(!vkGetDeviceBufferMemoryRequirements) |
| vkGetDeviceBufferMemoryRequirements = vkGetDeviceBufferMemoryRequirementsKHR; |
| vkGetDeviceImageMemoryRequirementsKHR = |
| PFN_vkGetDeviceImageMemoryRequirementsKHR(vkGetDeviceProcAddr(device, "vkGetDeviceImageMemoryRequirementsKHR")); |
| if(!vkGetDeviceImageMemoryRequirements) |
| vkGetDeviceImageMemoryRequirements = vkGetDeviceImageMemoryRequirementsKHR; |
| vkGetDeviceImageSparseMemoryRequirementsKHR = |
| PFN_vkGetDeviceImageSparseMemoryRequirementsKHR(vkGetDeviceProcAddr(device, "vkGetDeviceImageSparseMemoryRequirementsKHR")); |
| if(!vkGetDeviceImageSparseMemoryRequirements) |
| vkGetDeviceImageSparseMemoryRequirements = vkGetDeviceImageSparseMemoryRequirementsKHR; |
| |
| //=== VK_KHR_performance_query === |
| vkAcquireProfilingLockKHR = PFN_vkAcquireProfilingLockKHR(vkGetDeviceProcAddr(device, "vkAcquireProfilingLockKHR")); |
| vkReleaseProfilingLockKHR = PFN_vkReleaseProfilingLockKHR(vkGetDeviceProcAddr(device, "vkReleaseProfilingLockKHR")); |
| |
| //=== VK_KHR_pipeline_executable_properties === |
| vkGetPipelineExecutablePropertiesKHR = |
| PFN_vkGetPipelineExecutablePropertiesKHR(vkGetDeviceProcAddr(device, "vkGetPipelineExecutablePropertiesKHR")); |
| vkGetPipelineExecutableStatisticsKHR = |
| PFN_vkGetPipelineExecutableStatisticsKHR(vkGetDeviceProcAddr(device, "vkGetPipelineExecutableStatisticsKHR")); |
| vkGetPipelineExecutableInternalRepresentationsKHR = |
| PFN_vkGetPipelineExecutableInternalRepresentationsKHR(vkGetDeviceProcAddr(device, "vkGetPipelineExecutableInternalRepresentationsKHR")); |
| |
| //=== VK_KHR_present_wait === |
| vkWaitForPresentKHR = PFN_vkWaitForPresentKHR(vkGetDeviceProcAddr(device, "vkWaitForPresentKHR")); |
| |
| //=== VK_KHR_push_descriptor === |
| vkCmdPushDescriptorSetKHR = PFN_vkCmdPushDescriptorSetKHR(vkGetDeviceProcAddr(device, "vkCmdPushDescriptorSetKHR")); |
| |
| //=== VK_KHR_ray_tracing_pipeline === |
| vkCmdTraceRaysKHR = PFN_vkCmdTraceRaysKHR(vkGetDeviceProcAddr(device, "vkCmdTraceRaysKHR")); |
| vkCreateRayTracingPipelinesKHR = PFN_vkCreateRayTracingPipelinesKHR(vkGetDeviceProcAddr(device, "vkCreateRayTracingPipelinesKHR")); |
| vkGetRayTracingShaderGroupHandlesKHR = |
| PFN_vkGetRayTracingShaderGroupHandlesKHR(vkGetDeviceProcAddr(device, "vkGetRayTracingShaderGroupHandlesKHR")); |
| vkGetRayTracingCaptureReplayShaderGroupHandlesKHR = |
| PFN_vkGetRayTracingCaptureReplayShaderGroupHandlesKHR(vkGetDeviceProcAddr(device, "vkGetRayTracingCaptureReplayShaderGroupHandlesKHR")); |
| vkCmdTraceRaysIndirectKHR = PFN_vkCmdTraceRaysIndirectKHR(vkGetDeviceProcAddr(device, "vkCmdTraceRaysIndirectKHR")); |
| vkGetRayTracingShaderGroupStackSizeKHR = |
| PFN_vkGetRayTracingShaderGroupStackSizeKHR(vkGetDeviceProcAddr(device, "vkGetRayTracingShaderGroupStackSizeKHR")); |
| vkCmdSetRayTracingPipelineStackSizeKHR = |
| PFN_vkCmdSetRayTracingPipelineStackSizeKHR(vkGetDeviceProcAddr(device, "vkCmdSetRayTracingPipelineStackSizeKHR")); |
| |
| //=== VK_KHR_sampler_ycbcr_conversion === |
| vkCreateSamplerYcbcrConversionKHR = PFN_vkCreateSamplerYcbcrConversionKHR(vkGetDeviceProcAddr(device, "vkCreateSamplerYcbcrConversionKHR")); |
| if(!vkCreateSamplerYcbcrConversion) |
| vkCreateSamplerYcbcrConversion = vkCreateSamplerYcbcrConversionKHR; |
| vkDestroySamplerYcbcrConversionKHR = PFN_vkDestroySamplerYcbcrConversionKHR(vkGetDeviceProcAddr(device, "vkDestroySamplerYcbcrConversionKHR")); |
| if(!vkDestroySamplerYcbcrConversion) |
| vkDestroySamplerYcbcrConversion = vkDestroySamplerYcbcrConversionKHR; |
| |
| //=== VK_KHR_shared_presentable_image === |
| vkGetSwapchainStatusKHR = PFN_vkGetSwapchainStatusKHR(vkGetDeviceProcAddr(device, "vkGetSwapchainStatusKHR")); |
| |
| //=== VK_KHR_swapchain === |
| vkCreateSwapchainKHR = PFN_vkCreateSwapchainKHR(vkGetDeviceProcAddr(device, "vkCreateSwapchainKHR")); |
| vkDestroySwapchainKHR = PFN_vkDestroySwapchainKHR(vkGetDeviceProcAddr(device, "vkDestroySwapchainKHR")); |
| vkGetSwapchainImagesKHR = PFN_vkGetSwapchainImagesKHR(vkGetDeviceProcAddr(device, "vkGetSwapchainImagesKHR")); |
| vkAcquireNextImageKHR = PFN_vkAcquireNextImageKHR(vkGetDeviceProcAddr(device, "vkAcquireNextImageKHR")); |
| vkQueuePresentKHR = PFN_vkQueuePresentKHR(vkGetDeviceProcAddr(device, "vkQueuePresentKHR")); |
| |
| //=== VK_KHR_synchronization2 === |
| vkCmdSetEvent2KHR = PFN_vkCmdSetEvent2KHR(vkGetDeviceProcAddr(device, "vkCmdSetEvent2KHR")); |
| if(!vkCmdSetEvent2) |
| vkCmdSetEvent2 = vkCmdSetEvent2KHR; |
| vkCmdResetEvent2KHR = PFN_vkCmdResetEvent2KHR(vkGetDeviceProcAddr(device, "vkCmdResetEvent2KHR")); |
| if(!vkCmdResetEvent2) |
| vkCmdResetEvent2 = vkCmdResetEvent2KHR; |
| vkCmdWaitEvents2KHR = PFN_vkCmdWaitEvents2KHR(vkGetDeviceProcAddr(device, "vkCmdWaitEvents2KHR")); |
| if(!vkCmdWaitEvents2) |
| vkCmdWaitEvents2 = vkCmdWaitEvents2KHR; |
| vkCmdPipelineBarrier2KHR = PFN_vkCmdPipelineBarrier2KHR(vkGetDeviceProcAddr(device, "vkCmdPipelineBarrier2KHR")); |
| if(!vkCmdPipelineBarrier2) |
| vkCmdPipelineBarrier2 = vkCmdPipelineBarrier2KHR; |
| vkCmdWriteTimestamp2KHR = PFN_vkCmdWriteTimestamp2KHR(vkGetDeviceProcAddr(device, "vkCmdWriteTimestamp2KHR")); |
| if(!vkCmdWriteTimestamp2) |
| vkCmdWriteTimestamp2 = vkCmdWriteTimestamp2KHR; |
| vkQueueSubmit2KHR = PFN_vkQueueSubmit2KHR(vkGetDeviceProcAddr(device, "vkQueueSubmit2KHR")); |
| if(!vkQueueSubmit2) |
| vkQueueSubmit2 = vkQueueSubmit2KHR; |
| vkCmdWriteBufferMarker2AMD = PFN_vkCmdWriteBufferMarker2AMD(vkGetDeviceProcAddr(device, "vkCmdWriteBufferMarker2AMD")); |
| vkGetQueueCheckpointData2NV = PFN_vkGetQueueCheckpointData2NV(vkGetDeviceProcAddr(device, "vkGetQueueCheckpointData2NV")); |
| |
| //=== VK_KHR_timeline_semaphore === |
| vkGetSemaphoreCounterValueKHR = PFN_vkGetSemaphoreCounterValueKHR(vkGetDeviceProcAddr(device, "vkGetSemaphoreCounterValueKHR")); |
| if(!vkGetSemaphoreCounterValue) |
| vkGetSemaphoreCounterValue = vkGetSemaphoreCounterValueKHR; |
| vkWaitSemaphoresKHR = PFN_vkWaitSemaphoresKHR(vkGetDeviceProcAddr(device, "vkWaitSemaphoresKHR")); |
| if(!vkWaitSemaphores) |
| vkWaitSemaphores = vkWaitSemaphoresKHR; |
| vkSignalSemaphoreKHR = PFN_vkSignalSemaphoreKHR(vkGetDeviceProcAddr(device, "vkSignalSemaphoreKHR")); |
| if(!vkSignalSemaphore) |
| vkSignalSemaphore = vkSignalSemaphoreKHR; |
| |
| # if defined(VK_ENABLE_BETA_EXTENSIONS) |
| //=== VK_KHR_video_decode_queue === |
| vkCmdDecodeVideoKHR = PFN_vkCmdDecodeVideoKHR(vkGetDeviceProcAddr(device, "vkCmdDecodeVideoKHR")); |
| # endif /*VK_ENABLE_BETA_EXTENSIONS*/ |
| |
| # if defined(VK_ENABLE_BETA_EXTENSIONS) |
| //=== VK_KHR_video_encode_queue === |
| vkCmdEncodeVideoKHR = PFN_vkCmdEncodeVideoKHR(vkGetDeviceProcAddr(device, "vkCmdEncodeVideoKHR")); |
| # endif /*VK_ENABLE_BETA_EXTENSIONS*/ |
| |
| # if defined(VK_ENABLE_BETA_EXTENSIONS) |
| //=== VK_KHR_video_queue === |
| vkCreateVideoSessionKHR = PFN_vkCreateVideoSessionKHR(vkGetDeviceProcAddr(device, "vkCreateVideoSessionKHR")); |
| vkDestroyVideoSessionKHR = PFN_vkDestroyVideoSessionKHR(vkGetDeviceProcAddr(device, "vkDestroyVideoSessionKHR")); |
| vkGetVideoSessionMemoryRequirementsKHR = |
| PFN_vkGetVideoSessionMemoryRequirementsKHR(vkGetDeviceProcAddr(device, "vkGetVideoSessionMemoryRequirementsKHR")); |
| vkBindVideoSessionMemoryKHR = PFN_vkBindVideoSessionMemoryKHR(vkGetDeviceProcAddr(device, "vkBindVideoSessionMemoryKHR")); |
| vkCreateVideoSessionParametersKHR = PFN_vkCreateVideoSessionParametersKHR(vkGetDeviceProcAddr(device, "vkCreateVideoSessionParametersKHR")); |
| vkUpdateVideoSessionParametersKHR = PFN_vkUpdateVideoSessionParametersKHR(vkGetDeviceProcAddr(device, "vkUpdateVideoSessionParametersKHR")); |
| vkDestroyVideoSessionParametersKHR = PFN_vkDestroyVideoSessionParametersKHR(vkGetDeviceProcAddr(device, "vkDestroyVideoSessionParametersKHR")); |
| vkCmdBeginVideoCodingKHR = PFN_vkCmdBeginVideoCodingKHR(vkGetDeviceProcAddr(device, "vkCmdBeginVideoCodingKHR")); |
| vkCmdEndVideoCodingKHR = PFN_vkCmdEndVideoCodingKHR(vkGetDeviceProcAddr(device, "vkCmdEndVideoCodingKHR")); |
| vkCmdControlVideoCodingKHR = PFN_vkCmdControlVideoCodingKHR(vkGetDeviceProcAddr(device, "vkCmdControlVideoCodingKHR")); |
| # endif /*VK_ENABLE_BETA_EXTENSIONS*/ |
| |
| //=== VK_NVX_binary_import === |
| vkCreateCuModuleNVX = PFN_vkCreateCuModuleNVX(vkGetDeviceProcAddr(device, "vkCreateCuModuleNVX")); |
| vkCreateCuFunctionNVX = PFN_vkCreateCuFunctionNVX(vkGetDeviceProcAddr(device, "vkCreateCuFunctionNVX")); |
| vkDestroyCuModuleNVX = PFN_vkDestroyCuModuleNVX(vkGetDeviceProcAddr(device, "vkDestroyCuModuleNVX")); |
| vkDestroyCuFunctionNVX = PFN_vkDestroyCuFunctionNVX(vkGetDeviceProcAddr(device, "vkDestroyCuFunctionNVX")); |
| vkCmdCuLaunchKernelNVX = PFN_vkCmdCuLaunchKernelNVX(vkGetDeviceProcAddr(device, "vkCmdCuLaunchKernelNVX")); |
| |
| //=== VK_NVX_image_view_handle === |
| vkGetImageViewHandleNVX = PFN_vkGetImageViewHandleNVX(vkGetDeviceProcAddr(device, "vkGetImageViewHandleNVX")); |
| vkGetImageViewAddressNVX = PFN_vkGetImageViewAddressNVX(vkGetDeviceProcAddr(device, "vkGetImageViewAddressNVX")); |
| |
| //=== VK_NV_clip_space_w_scaling === |
| vkCmdSetViewportWScalingNV = PFN_vkCmdSetViewportWScalingNV(vkGetDeviceProcAddr(device, "vkCmdSetViewportWScalingNV")); |
| |
| //=== VK_NV_device_diagnostic_checkpoints === |
| vkCmdSetCheckpointNV = PFN_vkCmdSetCheckpointNV(vkGetDeviceProcAddr(device, "vkCmdSetCheckpointNV")); |
| vkGetQueueCheckpointDataNV = PFN_vkGetQueueCheckpointDataNV(vkGetDeviceProcAddr(device, "vkGetQueueCheckpointDataNV")); |
| |
| //=== VK_NV_device_generated_commands === |
| vkGetGeneratedCommandsMemoryRequirementsNV = |
| PFN_vkGetGeneratedCommandsMemoryRequirementsNV(vkGetDeviceProcAddr(device, "vkGetGeneratedCommandsMemoryRequirementsNV")); |
| vkCmdPreprocessGeneratedCommandsNV = PFN_vkCmdPreprocessGeneratedCommandsNV(vkGetDeviceProcAddr(device, "vkCmdPreprocessGeneratedCommandsNV")); |
| vkCmdExecuteGeneratedCommandsNV = PFN_vkCmdExecuteGeneratedCommandsNV(vkGetDeviceProcAddr(device, "vkCmdExecuteGeneratedCommandsNV")); |
| vkCmdBindPipelineShaderGroupNV = PFN_vkCmdBindPipelineShaderGroupNV(vkGetDeviceProcAddr(device, "vkCmdBindPipelineShaderGroupNV")); |
| vkCreateIndirectCommandsLayoutNV = PFN_vkCreateIndirectCommandsLayoutNV(vkGetDeviceProcAddr(device, "vkCreateIndirectCommandsLayoutNV")); |
| vkDestroyIndirectCommandsLayoutNV = PFN_vkDestroyIndirectCommandsLayoutNV(vkGetDeviceProcAddr(device, "vkDestroyIndirectCommandsLayoutNV")); |
| |
| //=== VK_NV_external_memory_rdma === |
| vkGetMemoryRemoteAddressNV = PFN_vkGetMemoryRemoteAddressNV(vkGetDeviceProcAddr(device, "vkGetMemoryRemoteAddressNV")); |
| |
| # if defined(VK_USE_PLATFORM_WIN32_KHR) |
| //=== VK_NV_external_memory_win32 === |
| vkGetMemoryWin32HandleNV = PFN_vkGetMemoryWin32HandleNV(vkGetDeviceProcAddr(device, "vkGetMemoryWin32HandleNV")); |
| # endif /*VK_USE_PLATFORM_WIN32_KHR*/ |
| |
| //=== VK_NV_fragment_shading_rate_enums === |
| vkCmdSetFragmentShadingRateEnumNV = PFN_vkCmdSetFragmentShadingRateEnumNV(vkGetDeviceProcAddr(device, "vkCmdSetFragmentShadingRateEnumNV")); |
| |
| //=== VK_NV_mesh_shader === |
| vkCmdDrawMeshTasksNV = PFN_vkCmdDrawMeshTasksNV(vkGetDeviceProcAddr(device, "vkCmdDrawMeshTasksNV")); |
| vkCmdDrawMeshTasksIndirectNV = PFN_vkCmdDrawMeshTasksIndirectNV(vkGetDeviceProcAddr(device, "vkCmdDrawMeshTasksIndirectNV")); |
| vkCmdDrawMeshTasksIndirectCountNV = PFN_vkCmdDrawMeshTasksIndirectCountNV(vkGetDeviceProcAddr(device, "vkCmdDrawMeshTasksIndirectCountNV")); |
| |
| //=== VK_NV_ray_tracing === |
| vkCreateAccelerationStructureNV = PFN_vkCreateAccelerationStructureNV(vkGetDeviceProcAddr(device, "vkCreateAccelerationStructureNV")); |
| vkDestroyAccelerationStructureNV = PFN_vkDestroyAccelerationStructureNV(vkGetDeviceProcAddr(device, "vkDestroyAccelerationStructureNV")); |
| vkGetAccelerationStructureMemoryRequirementsNV = |
| PFN_vkGetAccelerationStructureMemoryRequirementsNV(vkGetDeviceProcAddr(device, "vkGetAccelerationStructureMemoryRequirementsNV")); |
| vkBindAccelerationStructureMemoryNV = PFN_vkBindAccelerationStructureMemoryNV(vkGetDeviceProcAddr(device, "vkBindAccelerationStructureMemoryNV")); |
| vkCmdBuildAccelerationStructureNV = PFN_vkCmdBuildAccelerationStructureNV(vkGetDeviceProcAddr(device, "vkCmdBuildAccelerationStructureNV")); |
| vkCmdCopyAccelerationStructureNV = PFN_vkCmdCopyAccelerationStructureNV(vkGetDeviceProcAddr(device, "vkCmdCopyAccelerationStructureNV")); |
| vkCmdTraceRaysNV = PFN_vkCmdTraceRaysNV(vkGetDeviceProcAddr(device, "vkCmdTraceRaysNV")); |
| vkCreateRayTracingPipelinesNV = PFN_vkCreateRayTracingPipelinesNV(vkGetDeviceProcAddr(device, "vkCreateRayTracingPipelinesNV")); |
| vkGetRayTracingShaderGroupHandlesNV = PFN_vkGetRayTracingShaderGroupHandlesNV(vkGetDeviceProcAddr(device, "vkGetRayTracingShaderGroupHandlesNV")); |
| if(!vkGetRayTracingShaderGroupHandlesKHR) |
| vkGetRayTracingShaderGroupHandlesKHR = vkGetRayTracingShaderGroupHandlesNV; |
| vkGetAccelerationStructureHandleNV = PFN_vkGetAccelerationStructureHandleNV(vkGetDeviceProcAddr(device, "vkGetAccelerationStructureHandleNV")); |
| vkCmdWriteAccelerationStructuresPropertiesNV = |
| PFN_vkCmdWriteAccelerationStructuresPropertiesNV(vkGetDeviceProcAddr(device, "vkCmdWriteAccelerationStructuresPropertiesNV")); |
| vkCompileDeferredNV = PFN_vkCompileDeferredNV(vkGetDeviceProcAddr(device, "vkCompileDeferredNV")); |
| |
| //=== VK_NV_scissor_exclusive === |
| vkCmdSetExclusiveScissorNV = PFN_vkCmdSetExclusiveScissorNV(vkGetDeviceProcAddr(device, "vkCmdSetExclusiveScissorNV")); |
| |
| //=== VK_NV_shading_rate_image === |
| vkCmdBindShadingRateImageNV = PFN_vkCmdBindShadingRateImageNV(vkGetDeviceProcAddr(device, "vkCmdBindShadingRateImageNV")); |
| vkCmdSetViewportShadingRatePaletteNV = |
| PFN_vkCmdSetViewportShadingRatePaletteNV(vkGetDeviceProcAddr(device, "vkCmdSetViewportShadingRatePaletteNV")); |
| vkCmdSetCoarseSampleOrderNV = PFN_vkCmdSetCoarseSampleOrderNV(vkGetDeviceProcAddr(device, "vkCmdSetCoarseSampleOrderNV")); |
| |
| //=== VK_VALVE_descriptor_set_host_mapping === |
| vkGetDescriptorSetLayoutHostMappingInfoVALVE = |
| PFN_vkGetDescriptorSetLayoutHostMappingInfoVALVE(vkGetDeviceProcAddr(device, "vkGetDescriptorSetLayoutHostMappingInfoVALVE")); |
| vkGetDescriptorSetHostMappingVALVE = PFN_vkGetDescriptorSetHostMappingVALVE(vkGetDeviceProcAddr(device, "vkGetDescriptorSetHostMappingVALVE")); |
| } |
| |
| public: |
| //=== VK_VERSION_1_0 === |
| PFN_vkGetDeviceProcAddr vkGetDeviceProcAddr = 0; |
| PFN_vkDestroyDevice vkDestroyDevice = 0; |
| PFN_vkGetDeviceQueue vkGetDeviceQueue = 0; |
| PFN_vkQueueSubmit vkQueueSubmit = 0; |
| PFN_vkQueueWaitIdle vkQueueWaitIdle = 0; |
| PFN_vkDeviceWaitIdle vkDeviceWaitIdle = 0; |
| PFN_vkAllocateMemory vkAllocateMemory = 0; |
| PFN_vkFreeMemory vkFreeMemory = 0; |
| PFN_vkMapMemory vkMapMemory = 0; |
| PFN_vkUnmapMemory vkUnmapMemory = 0; |
| PFN_vkFlushMappedMemoryRanges vkFlushMappedMemoryRanges = 0; |
| PFN_vkInvalidateMappedMemoryRanges vkInvalidateMappedMemoryRanges = 0; |
| PFN_vkGetDeviceMemoryCommitment vkGetDeviceMemoryCommitment = 0; |
| PFN_vkBindBufferMemory vkBindBufferMemory = 0; |
| PFN_vkBindImageMemory vkBindImageMemory = 0; |
| PFN_vkGetBufferMemoryRequirements vkGetBufferMemoryRequirements = 0; |
| PFN_vkGetImageMemoryRequirements vkGetImageMemoryRequirements = 0; |
| PFN_vkGetImageSparseMemoryRequirements vkGetImageSparseMemoryRequirements = 0; |
| PFN_vkQueueBindSparse vkQueueBindSparse = 0; |
| PFN_vkCreateFence vkCreateFence = 0; |
| PFN_vkDestroyFence vkDestroyFence = 0; |
| PFN_vkResetFences vkResetFences = 0; |
| PFN_vkGetFenceStatus vkGetFenceStatus = 0; |
| PFN_vkWaitForFences vkWaitForFences = 0; |
| PFN_vkCreateSemaphore vkCreateSemaphore = 0; |
| PFN_vkDestroySemaphore vkDestroySemaphore = 0; |
| PFN_vkCreateEvent vkCreateEvent = 0; |
| PFN_vkDestroyEvent vkDestroyEvent = 0; |
| PFN_vkGetEventStatus vkGetEventStatus = 0; |
| PFN_vkSetEvent vkSetEvent = 0; |
| PFN_vkResetEvent vkResetEvent = 0; |
| PFN_vkCreateQueryPool vkCreateQueryPool = 0; |
| PFN_vkDestroyQueryPool vkDestroyQueryPool = 0; |
| PFN_vkGetQueryPoolResults vkGetQueryPoolResults = 0; |
| PFN_vkCreateBuffer vkCreateBuffer = 0; |
| PFN_vkDestroyBuffer vkDestroyBuffer = 0; |
| PFN_vkCreateBufferView vkCreateBufferView = 0; |
| PFN_vkDestroyBufferView vkDestroyBufferView = 0; |
| PFN_vkCreateImage vkCreateImage = 0; |
| PFN_vkDestroyImage vkDestroyImage = 0; |
| PFN_vkGetImageSubresourceLayout vkGetImageSubresourceLayout = 0; |
| PFN_vkCreateImageView vkCreateImageView = 0; |
| PFN_vkDestroyImageView vkDestroyImageView = 0; |
| PFN_vkCreateShaderModule vkCreateShaderModule = 0; |
| PFN_vkDestroyShaderModule vkDestroyShaderModule = 0; |
| PFN_vkCreatePipelineCache vkCreatePipelineCache = 0; |
| PFN_vkDestroyPipelineCache vkDestroyPipelineCache = 0; |
| PFN_vkGetPipelineCacheData vkGetPipelineCacheData = 0; |
| PFN_vkMergePipelineCaches vkMergePipelineCaches = 0; |
| PFN_vkCreateGraphicsPipelines vkCreateGraphicsPipelines = 0; |
| PFN_vkCreateComputePipelines vkCreateComputePipelines = 0; |
| PFN_vkDestroyPipeline vkDestroyPipeline = 0; |
| PFN_vkCreatePipelineLayout vkCreatePipelineLayout = 0; |
| PFN_vkDestroyPipelineLayout vkDestroyPipelineLayout = 0; |
| PFN_vkCreateSampler vkCreateSampler = 0; |
| PFN_vkDestroySampler vkDestroySampler = 0; |
| PFN_vkCreateDescriptorSetLayout vkCreateDescriptorSetLayout = 0; |
| PFN_vkDestroyDescriptorSetLayout vkDestroyDescriptorSetLayout = 0; |
| PFN_vkCreateDescriptorPool vkCreateDescriptorPool = 0; |
| PFN_vkDestroyDescriptorPool vkDestroyDescriptorPool = 0; |
| PFN_vkResetDescriptorPool vkResetDescriptorPool = 0; |
| PFN_vkAllocateDescriptorSets vkAllocateDescriptorSets = 0; |
| PFN_vkFreeDescriptorSets vkFreeDescriptorSets = 0; |
| PFN_vkUpdateDescriptorSets vkUpdateDescriptorSets = 0; |
| PFN_vkCreateFramebuffer vkCreateFramebuffer = 0; |
| PFN_vkDestroyFramebuffer vkDestroyFramebuffer = 0; |
| PFN_vkCreateRenderPass vkCreateRenderPass = 0; |
| PFN_vkDestroyRenderPass vkDestroyRenderPass = 0; |
| PFN_vkGetRenderAreaGranularity vkGetRenderAreaGranularity = 0; |
| PFN_vkCreateCommandPool vkCreateCommandPool = 0; |
| PFN_vkDestroyCommandPool vkDestroyCommandPool = 0; |
| PFN_vkResetCommandPool vkResetCommandPool = 0; |
| PFN_vkAllocateCommandBuffers vkAllocateCommandBuffers = 0; |
| PFN_vkFreeCommandBuffers vkFreeCommandBuffers = 0; |
| PFN_vkBeginCommandBuffer vkBeginCommandBuffer = 0; |
| PFN_vkEndCommandBuffer vkEndCommandBuffer = 0; |
| PFN_vkResetCommandBuffer vkResetCommandBuffer = 0; |
| PFN_vkCmdBindPipeline vkCmdBindPipeline = 0; |
| PFN_vkCmdSetViewport vkCmdSetViewport = 0; |
| PFN_vkCmdSetScissor vkCmdSetScissor = 0; |
| PFN_vkCmdSetLineWidth vkCmdSetLineWidth = 0; |
| PFN_vkCmdSetDepthBias vkCmdSetDepthBias = 0; |
| PFN_vkCmdSetBlendConstants vkCmdSetBlendConstants = 0; |
| PFN_vkCmdSetDepthBounds vkCmdSetDepthBounds = 0; |
| PFN_vkCmdSetStencilCompareMask vkCmdSetStencilCompareMask = 0; |
| PFN_vkCmdSetStencilWriteMask vkCmdSetStencilWriteMask = 0; |
| PFN_vkCmdSetStencilReference vkCmdSetStencilReference = 0; |
| PFN_vkCmdBindDescriptorSets vkCmdBindDescriptorSets = 0; |
| PFN_vkCmdBindIndexBuffer vkCmdBindIndexBuffer = 0; |
| PFN_vkCmdBindVertexBuffers vkCmdBindVertexBuffers = 0; |
| PFN_vkCmdDraw vkCmdDraw = 0; |
| PFN_vkCmdDrawIndexed vkCmdDrawIndexed = 0; |
| PFN_vkCmdDrawIndirect vkCmdDrawIndirect = 0; |
| PFN_vkCmdDrawIndexedIndirect vkCmdDrawIndexedIndirect = 0; |
| PFN_vkCmdDispatch vkCmdDispatch = 0; |
| PFN_vkCmdDispatchIndirect vkCmdDispatchIndirect = 0; |
| PFN_vkCmdCopyBuffer vkCmdCopyBuffer = 0; |
| PFN_vkCmdCopyImage vkCmdCopyImage = 0; |
| PFN_vkCmdBlitImage vkCmdBlitImage = 0; |
| PFN_vkCmdCopyBufferToImage vkCmdCopyBufferToImage = 0; |
| PFN_vkCmdCopyImageToBuffer vkCmdCopyImageToBuffer = 0; |
| PFN_vkCmdUpdateBuffer vkCmdUpdateBuffer = 0; |
| PFN_vkCmdFillBuffer vkCmdFillBuffer = 0; |
| PFN_vkCmdClearColorImage vkCmdClearColorImage = 0; |
| PFN_vkCmdClearDepthStencilImage vkCmdClearDepthStencilImage = 0; |
| PFN_vkCmdClearAttachments vkCmdClearAttachments = 0; |
| PFN_vkCmdResolveImage vkCmdResolveImage = 0; |
| PFN_vkCmdSetEvent vkCmdSetEvent = 0; |
| PFN_vkCmdResetEvent vkCmdResetEvent = 0; |
| PFN_vkCmdWaitEvents vkCmdWaitEvents = 0; |
| PFN_vkCmdPipelineBarrier vkCmdPipelineBarrier = 0; |
| PFN_vkCmdBeginQuery vkCmdBeginQuery = 0; |
| PFN_vkCmdEndQuery vkCmdEndQuery = 0; |
| PFN_vkCmdResetQueryPool vkCmdResetQueryPool = 0; |
| PFN_vkCmdWriteTimestamp vkCmdWriteTimestamp = 0; |
| PFN_vkCmdCopyQueryPoolResults vkCmdCopyQueryPoolResults = 0; |
| PFN_vkCmdPushConstants vkCmdPushConstants = 0; |
| PFN_vkCmdBeginRenderPass vkCmdBeginRenderPass = 0; |
| PFN_vkCmdNextSubpass vkCmdNextSubpass = 0; |
| PFN_vkCmdEndRenderPass vkCmdEndRenderPass = 0; |
| PFN_vkCmdExecuteCommands vkCmdExecuteCommands = 0; |
| |
| //=== VK_VERSION_1_1 === |
| PFN_vkBindBufferMemory2 vkBindBufferMemory2 = 0; |
| PFN_vkBindImageMemory2 vkBindImageMemory2 = 0; |
| PFN_vkGetDeviceGroupPeerMemoryFeatures vkGetDeviceGroupPeerMemoryFeatures = 0; |
| PFN_vkCmdSetDeviceMask vkCmdSetDeviceMask = 0; |
| PFN_vkCmdDispatchBase vkCmdDispatchBase = 0; |
| PFN_vkGetImageMemoryRequirements2 vkGetImageMemoryRequirements2 = 0; |
| PFN_vkGetBufferMemoryRequirements2 vkGetBufferMemoryRequirements2 = 0; |
| PFN_vkGetImageSparseMemoryRequirements2 vkGetImageSparseMemoryRequirements2 = 0; |
| PFN_vkTrimCommandPool vkTrimCommandPool = 0; |
| PFN_vkGetDeviceQueue2 vkGetDeviceQueue2 = 0; |
| PFN_vkCreateSamplerYcbcrConversion vkCreateSamplerYcbcrConversion = 0; |
| PFN_vkDestroySamplerYcbcrConversion vkDestroySamplerYcbcrConversion = 0; |
| PFN_vkCreateDescriptorUpdateTemplate vkCreateDescriptorUpdateTemplate = 0; |
| PFN_vkDestroyDescriptorUpdateTemplate vkDestroyDescriptorUpdateTemplate = 0; |
| PFN_vkUpdateDescriptorSetWithTemplate vkUpdateDescriptorSetWithTemplate = 0; |
| PFN_vkGetDescriptorSetLayoutSupport vkGetDescriptorSetLayoutSupport = 0; |
| |
| //=== VK_VERSION_1_2 === |
| PFN_vkCmdDrawIndirectCount vkCmdDrawIndirectCount = 0; |
| PFN_vkCmdDrawIndexedIndirectCount vkCmdDrawIndexedIndirectCount = 0; |
| PFN_vkCreateRenderPass2 vkCreateRenderPass2 = 0; |
| PFN_vkCmdBeginRenderPass2 vkCmdBeginRenderPass2 = 0; |
| PFN_vkCmdNextSubpass2 vkCmdNextSubpass2 = 0; |
| PFN_vkCmdEndRenderPass2 vkCmdEndRenderPass2 = 0; |
| PFN_vkResetQueryPool vkResetQueryPool = 0; |
| PFN_vkGetSemaphoreCounterValue vkGetSemaphoreCounterValue = 0; |
| PFN_vkWaitSemaphores vkWaitSemaphores = 0; |
| PFN_vkSignalSemaphore vkSignalSemaphore = 0; |
| PFN_vkGetBufferDeviceAddress vkGetBufferDeviceAddress = 0; |
| PFN_vkGetBufferOpaqueCaptureAddress vkGetBufferOpaqueCaptureAddress = 0; |
| PFN_vkGetDeviceMemoryOpaqueCaptureAddress vkGetDeviceMemoryOpaqueCaptureAddress = 0; |
| |
| //=== VK_VERSION_1_3 === |
| PFN_vkCreatePrivateDataSlot vkCreatePrivateDataSlot = 0; |
| PFN_vkDestroyPrivateDataSlot vkDestroyPrivateDataSlot = 0; |
| PFN_vkSetPrivateData vkSetPrivateData = 0; |
| PFN_vkGetPrivateData vkGetPrivateData = 0; |
| PFN_vkCmdSetEvent2 vkCmdSetEvent2 = 0; |
| PFN_vkCmdResetEvent2 vkCmdResetEvent2 = 0; |
| PFN_vkCmdWaitEvents2 vkCmdWaitEvents2 = 0; |
| PFN_vkCmdPipelineBarrier2 vkCmdPipelineBarrier2 = 0; |
| PFN_vkCmdWriteTimestamp2 vkCmdWriteTimestamp2 = 0; |
| PFN_vkQueueSubmit2 vkQueueSubmit2 = 0; |
| PFN_vkCmdCopyBuffer2 vkCmdCopyBuffer2 = 0; |
| PFN_vkCmdCopyImage2 vkCmdCopyImage2 = 0; |
| PFN_vkCmdCopyBufferToImage2 vkCmdCopyBufferToImage2 = 0; |
| PFN_vkCmdCopyImageToBuffer2 vkCmdCopyImageToBuffer2 = 0; |
| PFN_vkCmdBlitImage2 vkCmdBlitImage2 = 0; |
| PFN_vkCmdResolveImage2 vkCmdResolveImage2 = 0; |
| PFN_vkCmdBeginRendering vkCmdBeginRendering = 0; |
| PFN_vkCmdEndRendering vkCmdEndRendering = 0; |
| PFN_vkCmdSetCullMode vkCmdSetCullMode = 0; |
| PFN_vkCmdSetFrontFace vkCmdSetFrontFace = 0; |
| PFN_vkCmdSetPrimitiveTopology vkCmdSetPrimitiveTopology = 0; |
| PFN_vkCmdSetViewportWithCount vkCmdSetViewportWithCount = 0; |
| PFN_vkCmdSetScissorWithCount vkCmdSetScissorWithCount = 0; |
| PFN_vkCmdBindVertexBuffers2 vkCmdBindVertexBuffers2 = 0; |
| PFN_vkCmdSetDepthTestEnable vkCmdSetDepthTestEnable = 0; |
| PFN_vkCmdSetDepthWriteEnable vkCmdSetDepthWriteEnable = 0; |
| PFN_vkCmdSetDepthCompareOp vkCmdSetDepthCompareOp = 0; |
| PFN_vkCmdSetDepthBoundsTestEnable vkCmdSetDepthBoundsTestEnable = 0; |
| PFN_vkCmdSetStencilTestEnable vkCmdSetStencilTestEnable = 0; |
| PFN_vkCmdSetStencilOp vkCmdSetStencilOp = 0; |
| PFN_vkCmdSetRasterizerDiscardEnable vkCmdSetRasterizerDiscardEnable = 0; |
| PFN_vkCmdSetDepthBiasEnable vkCmdSetDepthBiasEnable = 0; |
| PFN_vkCmdSetPrimitiveRestartEnable vkCmdSetPrimitiveRestartEnable = 0; |
| PFN_vkGetDeviceBufferMemoryRequirements vkGetDeviceBufferMemoryRequirements = 0; |
| PFN_vkGetDeviceImageMemoryRequirements vkGetDeviceImageMemoryRequirements = 0; |
| PFN_vkGetDeviceImageSparseMemoryRequirements vkGetDeviceImageSparseMemoryRequirements = 0; |
| |
| //=== VK_AMD_buffer_marker === |
| PFN_vkCmdWriteBufferMarkerAMD vkCmdWriteBufferMarkerAMD = 0; |
| |
| //=== VK_AMD_display_native_hdr === |
| PFN_vkSetLocalDimmingAMD vkSetLocalDimmingAMD = 0; |
| |
| //=== VK_AMD_draw_indirect_count === |
| PFN_vkCmdDrawIndirectCountAMD vkCmdDrawIndirectCountAMD = 0; |
| PFN_vkCmdDrawIndexedIndirectCountAMD vkCmdDrawIndexedIndirectCountAMD = 0; |
| |
| //=== VK_AMD_shader_info === |
| PFN_vkGetShaderInfoAMD vkGetShaderInfoAMD = 0; |
| |
| # if defined(VK_USE_PLATFORM_ANDROID_KHR) |
| //=== VK_ANDROID_external_memory_android_hardware_buffer === |
| PFN_vkGetAndroidHardwareBufferPropertiesANDROID vkGetAndroidHardwareBufferPropertiesANDROID = 0; |
| PFN_vkGetMemoryAndroidHardwareBufferANDROID vkGetMemoryAndroidHardwareBufferANDROID = 0; |
| # else |
| PFN_dummy vkGetAndroidHardwareBufferPropertiesANDROID_placeholder = 0; |
| PFN_dummy vkGetMemoryAndroidHardwareBufferANDROID_placeholder = 0; |
| # endif /*VK_USE_PLATFORM_ANDROID_KHR*/ |
| |
| //=== VK_EXT_buffer_device_address === |
| PFN_vkGetBufferDeviceAddressEXT vkGetBufferDeviceAddressEXT = 0; |
| |
| //=== VK_EXT_calibrated_timestamps === |
| PFN_vkGetCalibratedTimestampsEXT vkGetCalibratedTimestampsEXT = 0; |
| |
| //=== VK_EXT_color_write_enable === |
| PFN_vkCmdSetColorWriteEnableEXT vkCmdSetColorWriteEnableEXT = 0; |
| |
| //=== VK_EXT_conditional_rendering === |
| PFN_vkCmdBeginConditionalRenderingEXT vkCmdBeginConditionalRenderingEXT = 0; |
| PFN_vkCmdEndConditionalRenderingEXT vkCmdEndConditionalRenderingEXT = 0; |
| |
| //=== VK_EXT_debug_marker === |
| PFN_vkDebugMarkerSetObjectTagEXT vkDebugMarkerSetObjectTagEXT = 0; |
| PFN_vkDebugMarkerSetObjectNameEXT vkDebugMarkerSetObjectNameEXT = 0; |
| PFN_vkCmdDebugMarkerBeginEXT vkCmdDebugMarkerBeginEXT = 0; |
| PFN_vkCmdDebugMarkerEndEXT vkCmdDebugMarkerEndEXT = 0; |
| PFN_vkCmdDebugMarkerInsertEXT vkCmdDebugMarkerInsertEXT = 0; |
| |
| //=== VK_EXT_debug_utils === |
| PFN_vkSetDebugUtilsObjectNameEXT vkSetDebugUtilsObjectNameEXT = 0; |
| PFN_vkSetDebugUtilsObjectTagEXT vkSetDebugUtilsObjectTagEXT = 0; |
| PFN_vkQueueBeginDebugUtilsLabelEXT vkQueueBeginDebugUtilsLabelEXT = 0; |
| PFN_vkQueueEndDebugUtilsLabelEXT vkQueueEndDebugUtilsLabelEXT = 0; |
| PFN_vkQueueInsertDebugUtilsLabelEXT vkQueueInsertDebugUtilsLabelEXT = 0; |
| PFN_vkCmdBeginDebugUtilsLabelEXT vkCmdBeginDebugUtilsLabelEXT = 0; |
| PFN_vkCmdEndDebugUtilsLabelEXT vkCmdEndDebugUtilsLabelEXT = 0; |
| PFN_vkCmdInsertDebugUtilsLabelEXT vkCmdInsertDebugUtilsLabelEXT = 0; |
| |
| //=== VK_EXT_discard_rectangles === |
| PFN_vkCmdSetDiscardRectangleEXT vkCmdSetDiscardRectangleEXT = 0; |
| |
| //=== VK_EXT_display_control === |
| PFN_vkDisplayPowerControlEXT vkDisplayPowerControlEXT = 0; |
| PFN_vkRegisterDeviceEventEXT vkRegisterDeviceEventEXT = 0; |
| PFN_vkRegisterDisplayEventEXT vkRegisterDisplayEventEXT = 0; |
| PFN_vkGetSwapchainCounterEXT vkGetSwapchainCounterEXT = 0; |
| |
| //=== VK_EXT_extended_dynamic_state === |
| PFN_vkCmdSetCullModeEXT vkCmdSetCullModeEXT = 0; |
| PFN_vkCmdSetFrontFaceEXT vkCmdSetFrontFaceEXT = 0; |
| PFN_vkCmdSetPrimitiveTopologyEXT vkCmdSetPrimitiveTopologyEXT = 0; |
| PFN_vkCmdSetViewportWithCountEXT vkCmdSetViewportWithCountEXT = 0; |
| PFN_vkCmdSetScissorWithCountEXT vkCmdSetScissorWithCountEXT = 0; |
| PFN_vkCmdBindVertexBuffers2EXT vkCmdBindVertexBuffers2EXT = 0; |
| PFN_vkCmdSetDepthTestEnableEXT vkCmdSetDepthTestEnableEXT = 0; |
| PFN_vkCmdSetDepthWriteEnableEXT vkCmdSetDepthWriteEnableEXT = 0; |
| PFN_vkCmdSetDepthCompareOpEXT vkCmdSetDepthCompareOpEXT = 0; |
| PFN_vkCmdSetDepthBoundsTestEnableEXT vkCmdSetDepthBoundsTestEnableEXT = 0; |
| PFN_vkCmdSetStencilTestEnableEXT vkCmdSetStencilTestEnableEXT = 0; |
| PFN_vkCmdSetStencilOpEXT vkCmdSetStencilOpEXT = 0; |
| |
| //=== VK_EXT_extended_dynamic_state2 === |
| PFN_vkCmdSetPatchControlPointsEXT vkCmdSetPatchControlPointsEXT = 0; |
| PFN_vkCmdSetRasterizerDiscardEnableEXT vkCmdSetRasterizerDiscardEnableEXT = 0; |
| PFN_vkCmdSetDepthBiasEnableEXT vkCmdSetDepthBiasEnableEXT = 0; |
| PFN_vkCmdSetLogicOpEXT vkCmdSetLogicOpEXT = 0; |
| PFN_vkCmdSetPrimitiveRestartEnableEXT vkCmdSetPrimitiveRestartEnableEXT = 0; |
| |
| //=== VK_EXT_external_memory_host === |
| PFN_vkGetMemoryHostPointerPropertiesEXT vkGetMemoryHostPointerPropertiesEXT = 0; |
| |
| # if defined(VK_USE_PLATFORM_WIN32_KHR) |
| //=== VK_EXT_full_screen_exclusive === |
| PFN_vkAcquireFullScreenExclusiveModeEXT vkAcquireFullScreenExclusiveModeEXT = 0; |
| PFN_vkReleaseFullScreenExclusiveModeEXT vkReleaseFullScreenExclusiveModeEXT = 0; |
| PFN_vkGetDeviceGroupSurfacePresentModes2EXT vkGetDeviceGroupSurfacePresentModes2EXT = 0; |
| # else |
| PFN_dummy vkAcquireFullScreenExclusiveModeEXT_placeholder = 0; |
| PFN_dummy vkReleaseFullScreenExclusiveModeEXT_placeholder = 0; |
| PFN_dummy vkGetDeviceGroupSurfacePresentModes2EXT_placeholder = 0; |
| # endif /*VK_USE_PLATFORM_WIN32_KHR*/ |
| |
| //=== VK_EXT_hdr_metadata === |
| PFN_vkSetHdrMetadataEXT vkSetHdrMetadataEXT = 0; |
| |
| //=== VK_EXT_host_query_reset === |
| PFN_vkResetQueryPoolEXT vkResetQueryPoolEXT = 0; |
| |
| //=== VK_EXT_image_drm_format_modifier === |
| PFN_vkGetImageDrmFormatModifierPropertiesEXT vkGetImageDrmFormatModifierPropertiesEXT = 0; |
| |
| //=== VK_EXT_line_rasterization === |
| PFN_vkCmdSetLineStippleEXT vkCmdSetLineStippleEXT = 0; |
| |
| //=== VK_EXT_multi_draw === |
| PFN_vkCmdDrawMultiEXT vkCmdDrawMultiEXT = 0; |
| PFN_vkCmdDrawMultiIndexedEXT vkCmdDrawMultiIndexedEXT = 0; |
| |
| //=== VK_EXT_pageable_device_local_memory === |
| PFN_vkSetDeviceMemoryPriorityEXT vkSetDeviceMemoryPriorityEXT = 0; |
| |
| //=== VK_EXT_private_data === |
| PFN_vkCreatePrivateDataSlotEXT vkCreatePrivateDataSlotEXT = 0; |
| PFN_vkDestroyPrivateDataSlotEXT vkDestroyPrivateDataSlotEXT = 0; |
| PFN_vkSetPrivateDataEXT vkSetPrivateDataEXT = 0; |
| PFN_vkGetPrivateDataEXT vkGetPrivateDataEXT = 0; |
| |
| //=== VK_EXT_sample_locations === |
| PFN_vkCmdSetSampleLocationsEXT vkCmdSetSampleLocationsEXT = 0; |
| |
| //=== VK_EXT_transform_feedback === |
| PFN_vkCmdBindTransformFeedbackBuffersEXT vkCmdBindTransformFeedbackBuffersEXT = 0; |
| PFN_vkCmdBeginTransformFeedbackEXT vkCmdBeginTransformFeedbackEXT = 0; |
| PFN_vkCmdEndTransformFeedbackEXT vkCmdEndTransformFeedbackEXT = 0; |
| PFN_vkCmdBeginQueryIndexedEXT vkCmdBeginQueryIndexedEXT = 0; |
| PFN_vkCmdEndQueryIndexedEXT vkCmdEndQueryIndexedEXT = 0; |
| PFN_vkCmdDrawIndirectByteCountEXT vkCmdDrawIndirectByteCountEXT = 0; |
| |
| //=== VK_EXT_validation_cache === |
| PFN_vkCreateValidationCacheEXT vkCreateValidationCacheEXT = 0; |
| PFN_vkDestroyValidationCacheEXT vkDestroyValidationCacheEXT = 0; |
| PFN_vkMergeValidationCachesEXT vkMergeValidationCachesEXT = 0; |
| PFN_vkGetValidationCacheDataEXT vkGetValidationCacheDataEXT = 0; |
| |
| //=== VK_EXT_vertex_input_dynamic_state === |
| PFN_vkCmdSetVertexInputEXT vkCmdSetVertexInputEXT = 0; |
| |
| # if defined(VK_USE_PLATFORM_FUCHSIA) |
| //=== VK_FUCHSIA_buffer_collection === |
| PFN_vkCreateBufferCollectionFUCHSIA vkCreateBufferCollectionFUCHSIA = 0; |
| PFN_vkSetBufferCollectionImageConstraintsFUCHSIA vkSetBufferCollectionImageConstraintsFUCHSIA = 0; |
| PFN_vkSetBufferCollectionBufferConstraintsFUCHSIA vkSetBufferCollectionBufferConstraintsFUCHSIA = 0; |
| PFN_vkDestroyBufferCollectionFUCHSIA vkDestroyBufferCollectionFUCHSIA = 0; |
| PFN_vkGetBufferCollectionPropertiesFUCHSIA vkGetBufferCollectionPropertiesFUCHSIA = 0; |
| # else |
| PFN_dummy vkCreateBufferCollectionFUCHSIA_placeholder = 0; |
| PFN_dummy vkSetBufferCollectionImageConstraintsFUCHSIA_placeholder = 0; |
| PFN_dummy vkSetBufferCollectionBufferConstraintsFUCHSIA_placeholder = 0; |
| PFN_dummy vkDestroyBufferCollectionFUCHSIA_placeholder = 0; |
| PFN_dummy vkGetBufferCollectionPropertiesFUCHSIA_placeholder = 0; |
| # endif /*VK_USE_PLATFORM_FUCHSIA*/ |
| |
| # if defined(VK_USE_PLATFORM_FUCHSIA) |
| //=== VK_FUCHSIA_external_memory === |
| PFN_vkGetMemoryZirconHandleFUCHSIA vkGetMemoryZirconHandleFUCHSIA = 0; |
| PFN_vkGetMemoryZirconHandlePropertiesFUCHSIA vkGetMemoryZirconHandlePropertiesFUCHSIA = 0; |
| # else |
| PFN_dummy vkGetMemoryZirconHandleFUCHSIA_placeholder = 0; |
| PFN_dummy vkGetMemoryZirconHandlePropertiesFUCHSIA_placeholder = 0; |
| # endif /*VK_USE_PLATFORM_FUCHSIA*/ |
| |
| # if defined(VK_USE_PLATFORM_FUCHSIA) |
| //=== VK_FUCHSIA_external_semaphore === |
| PFN_vkImportSemaphoreZirconHandleFUCHSIA vkImportSemaphoreZirconHandleFUCHSIA = 0; |
| PFN_vkGetSemaphoreZirconHandleFUCHSIA vkGetSemaphoreZirconHandleFUCHSIA = 0; |
| # else |
| PFN_dummy vkImportSemaphoreZirconHandleFUCHSIA_placeholder = 0; |
| PFN_dummy vkGetSemaphoreZirconHandleFUCHSIA_placeholder = 0; |
| # endif /*VK_USE_PLATFORM_FUCHSIA*/ |
| |
| //=== VK_GOOGLE_display_timing === |
| PFN_vkGetRefreshCycleDurationGOOGLE vkGetRefreshCycleDurationGOOGLE = 0; |
| PFN_vkGetPastPresentationTimingGOOGLE vkGetPastPresentationTimingGOOGLE = 0; |
| |
| //=== VK_HUAWEI_invocation_mask === |
| PFN_vkCmdBindInvocationMaskHUAWEI vkCmdBindInvocationMaskHUAWEI = 0; |
| |
| //=== VK_HUAWEI_subpass_shading === |
| PFN_vkGetDeviceSubpassShadingMaxWorkgroupSizeHUAWEI vkGetDeviceSubpassShadingMaxWorkgroupSizeHUAWEI = 0; |
| PFN_vkCmdSubpassShadingHUAWEI vkCmdSubpassShadingHUAWEI = 0; |
| |
| //=== VK_INTEL_performance_query === |
| PFN_vkInitializePerformanceApiINTEL vkInitializePerformanceApiINTEL = 0; |
| PFN_vkUninitializePerformanceApiINTEL vkUninitializePerformanceApiINTEL = 0; |
| PFN_vkCmdSetPerformanceMarkerINTEL vkCmdSetPerformanceMarkerINTEL = 0; |
| PFN_vkCmdSetPerformanceStreamMarkerINTEL vkCmdSetPerformanceStreamMarkerINTEL = 0; |
| PFN_vkCmdSetPerformanceOverrideINTEL vkCmdSetPerformanceOverrideINTEL = 0; |
| PFN_vkAcquirePerformanceConfigurationINTEL vkAcquirePerformanceConfigurationINTEL = 0; |
| PFN_vkReleasePerformanceConfigurationINTEL vkReleasePerformanceConfigurationINTEL = 0; |
| PFN_vkQueueSetPerformanceConfigurationINTEL vkQueueSetPerformanceConfigurationINTEL = 0; |
| PFN_vkGetPerformanceParameterINTEL vkGetPerformanceParameterINTEL = 0; |
| |
| //=== VK_KHR_acceleration_structure === |
| PFN_vkCreateAccelerationStructureKHR vkCreateAccelerationStructureKHR = 0; |
| PFN_vkDestroyAccelerationStructureKHR vkDestroyAccelerationStructureKHR = 0; |
| PFN_vkCmdBuildAccelerationStructuresKHR vkCmdBuildAccelerationStructuresKHR = 0; |
| PFN_vkCmdBuildAccelerationStructuresIndirectKHR vkCmdBuildAccelerationStructuresIndirectKHR = 0; |
| PFN_vkBuildAccelerationStructuresKHR vkBuildAccelerationStructuresKHR = 0; |
| PFN_vkCopyAccelerationStructureKHR vkCopyAccelerationStructureKHR = 0; |
| PFN_vkCopyAccelerationStructureToMemoryKHR vkCopyAccelerationStructureToMemoryKHR = 0; |
| PFN_vkCopyMemoryToAccelerationStructureKHR vkCopyMemoryToAccelerationStructureKHR = 0; |
| PFN_vkWriteAccelerationStructuresPropertiesKHR vkWriteAccelerationStructuresPropertiesKHR = 0; |
| PFN_vkCmdCopyAccelerationStructureKHR vkCmdCopyAccelerationStructureKHR = 0; |
| PFN_vkCmdCopyAccelerationStructureToMemoryKHR vkCmdCopyAccelerationStructureToMemoryKHR = 0; |
| PFN_vkCmdCopyMemoryToAccelerationStructureKHR vkCmdCopyMemoryToAccelerationStructureKHR = 0; |
| PFN_vkGetAccelerationStructureDeviceAddressKHR vkGetAccelerationStructureDeviceAddressKHR = 0; |
| PFN_vkCmdWriteAccelerationStructuresPropertiesKHR vkCmdWriteAccelerationStructuresPropertiesKHR = 0; |
| PFN_vkGetDeviceAccelerationStructureCompatibilityKHR vkGetDeviceAccelerationStructureCompatibilityKHR = 0; |
| PFN_vkGetAccelerationStructureBuildSizesKHR vkGetAccelerationStructureBuildSizesKHR = 0; |
| |
| //=== VK_KHR_bind_memory2 === |
| PFN_vkBindBufferMemory2KHR vkBindBufferMemory2KHR = 0; |
| PFN_vkBindImageMemory2KHR vkBindImageMemory2KHR = 0; |
| |
| //=== VK_KHR_buffer_device_address === |
| PFN_vkGetBufferDeviceAddressKHR vkGetBufferDeviceAddressKHR = 0; |
| PFN_vkGetBufferOpaqueCaptureAddressKHR vkGetBufferOpaqueCaptureAddressKHR = 0; |
| PFN_vkGetDeviceMemoryOpaqueCaptureAddressKHR vkGetDeviceMemoryOpaqueCaptureAddressKHR = 0; |
| |
| //=== VK_KHR_copy_commands2 === |
| PFN_vkCmdCopyBuffer2KHR vkCmdCopyBuffer2KHR = 0; |
| PFN_vkCmdCopyImage2KHR vkCmdCopyImage2KHR = 0; |
| PFN_vkCmdCopyBufferToImage2KHR vkCmdCopyBufferToImage2KHR = 0; |
| PFN_vkCmdCopyImageToBuffer2KHR vkCmdCopyImageToBuffer2KHR = 0; |
| PFN_vkCmdBlitImage2KHR vkCmdBlitImage2KHR = 0; |
| PFN_vkCmdResolveImage2KHR vkCmdResolveImage2KHR = 0; |
| |
| //=== VK_KHR_create_renderpass2 === |
| PFN_vkCreateRenderPass2KHR vkCreateRenderPass2KHR = 0; |
| PFN_vkCmdBeginRenderPass2KHR vkCmdBeginRenderPass2KHR = 0; |
| PFN_vkCmdNextSubpass2KHR vkCmdNextSubpass2KHR = 0; |
| PFN_vkCmdEndRenderPass2KHR vkCmdEndRenderPass2KHR = 0; |
| |
| //=== VK_KHR_deferred_host_operations === |
| PFN_vkCreateDeferredOperationKHR vkCreateDeferredOperationKHR = 0; |
| PFN_vkDestroyDeferredOperationKHR vkDestroyDeferredOperationKHR = 0; |
| PFN_vkGetDeferredOperationMaxConcurrencyKHR vkGetDeferredOperationMaxConcurrencyKHR = 0; |
| PFN_vkGetDeferredOperationResultKHR vkGetDeferredOperationResultKHR = 0; |
| PFN_vkDeferredOperationJoinKHR vkDeferredOperationJoinKHR = 0; |
| |
| //=== VK_KHR_descriptor_update_template === |
| PFN_vkCreateDescriptorUpdateTemplateKHR vkCreateDescriptorUpdateTemplateKHR = 0; |
| PFN_vkDestroyDescriptorUpdateTemplateKHR vkDestroyDescriptorUpdateTemplateKHR = 0; |
| PFN_vkUpdateDescriptorSetWithTemplateKHR vkUpdateDescriptorSetWithTemplateKHR = 0; |
| PFN_vkCmdPushDescriptorSetWithTemplateKHR vkCmdPushDescriptorSetWithTemplateKHR = 0; |
| |
| //=== VK_KHR_device_group === |
| PFN_vkGetDeviceGroupPeerMemoryFeaturesKHR vkGetDeviceGroupPeerMemoryFeaturesKHR = 0; |
| PFN_vkCmdSetDeviceMaskKHR vkCmdSetDeviceMaskKHR = 0; |
| PFN_vkCmdDispatchBaseKHR vkCmdDispatchBaseKHR = 0; |
| PFN_vkGetDeviceGroupPresentCapabilitiesKHR vkGetDeviceGroupPresentCapabilitiesKHR = 0; |
| PFN_vkGetDeviceGroupSurfacePresentModesKHR vkGetDeviceGroupSurfacePresentModesKHR = 0; |
| PFN_vkAcquireNextImage2KHR vkAcquireNextImage2KHR = 0; |
| |
| //=== VK_KHR_display_swapchain === |
| PFN_vkCreateSharedSwapchainsKHR vkCreateSharedSwapchainsKHR = 0; |
| |
| //=== VK_KHR_draw_indirect_count === |
| PFN_vkCmdDrawIndirectCountKHR vkCmdDrawIndirectCountKHR = 0; |
| PFN_vkCmdDrawIndexedIndirectCountKHR vkCmdDrawIndexedIndirectCountKHR = 0; |
| |
| //=== VK_KHR_dynamic_rendering === |
| PFN_vkCmdBeginRenderingKHR vkCmdBeginRenderingKHR = 0; |
| PFN_vkCmdEndRenderingKHR vkCmdEndRenderingKHR = 0; |
| |
| //=== VK_KHR_external_fence_fd === |
| PFN_vkImportFenceFdKHR vkImportFenceFdKHR = 0; |
| PFN_vkGetFenceFdKHR vkGetFenceFdKHR = 0; |
| |
| # if defined(VK_USE_PLATFORM_WIN32_KHR) |
| //=== VK_KHR_external_fence_win32 === |
| PFN_vkImportFenceWin32HandleKHR vkImportFenceWin32HandleKHR = 0; |
| PFN_vkGetFenceWin32HandleKHR vkGetFenceWin32HandleKHR = 0; |
| # else |
| PFN_dummy vkImportFenceWin32HandleKHR_placeholder = 0; |
| PFN_dummy vkGetFenceWin32HandleKHR_placeholder = 0; |
| # endif /*VK_USE_PLATFORM_WIN32_KHR*/ |
| |
| //=== VK_KHR_external_memory_fd === |
| PFN_vkGetMemoryFdKHR vkGetMemoryFdKHR = 0; |
| PFN_vkGetMemoryFdPropertiesKHR vkGetMemoryFdPropertiesKHR = 0; |
| |
| # if defined(VK_USE_PLATFORM_WIN32_KHR) |
| //=== VK_KHR_external_memory_win32 === |
| PFN_vkGetMemoryWin32HandleKHR vkGetMemoryWin32HandleKHR = 0; |
| PFN_vkGetMemoryWin32HandlePropertiesKHR vkGetMemoryWin32HandlePropertiesKHR = 0; |
| # else |
| PFN_dummy vkGetMemoryWin32HandleKHR_placeholder = 0; |
| PFN_dummy vkGetMemoryWin32HandlePropertiesKHR_placeholder = 0; |
| # endif /*VK_USE_PLATFORM_WIN32_KHR*/ |
| |
| //=== VK_KHR_external_semaphore_fd === |
| PFN_vkImportSemaphoreFdKHR vkImportSemaphoreFdKHR = 0; |
| PFN_vkGetSemaphoreFdKHR vkGetSemaphoreFdKHR = 0; |
| |
| # if defined(VK_USE_PLATFORM_WIN32_KHR) |
| //=== VK_KHR_external_semaphore_win32 === |
| PFN_vkImportSemaphoreWin32HandleKHR vkImportSemaphoreWin32HandleKHR = 0; |
| PFN_vkGetSemaphoreWin32HandleKHR vkGetSemaphoreWin32HandleKHR = 0; |
| # else |
| PFN_dummy vkImportSemaphoreWin32HandleKHR_placeholder = 0; |
| PFN_dummy vkGetSemaphoreWin32HandleKHR_placeholder = 0; |
| # endif /*VK_USE_PLATFORM_WIN32_KHR*/ |
| |
| //=== VK_KHR_fragment_shading_rate === |
| PFN_vkCmdSetFragmentShadingRateKHR vkCmdSetFragmentShadingRateKHR = 0; |
| |
| //=== VK_KHR_get_memory_requirements2 === |
| PFN_vkGetImageMemoryRequirements2KHR vkGetImageMemoryRequirements2KHR = 0; |
| PFN_vkGetBufferMemoryRequirements2KHR vkGetBufferMemoryRequirements2KHR = 0; |
| PFN_vkGetImageSparseMemoryRequirements2KHR vkGetImageSparseMemoryRequirements2KHR = 0; |
| |
| //=== VK_KHR_maintenance1 === |
| PFN_vkTrimCommandPoolKHR vkTrimCommandPoolKHR = 0; |
| |
| //=== VK_KHR_maintenance3 === |
| PFN_vkGetDescriptorSetLayoutSupportKHR vkGetDescriptorSetLayoutSupportKHR = 0; |
| |
| //=== VK_KHR_maintenance4 === |
| PFN_vkGetDeviceBufferMemoryRequirementsKHR vkGetDeviceBufferMemoryRequirementsKHR = 0; |
| PFN_vkGetDeviceImageMemoryRequirementsKHR vkGetDeviceImageMemoryRequirementsKHR = 0; |
| PFN_vkGetDeviceImageSparseMemoryRequirementsKHR vkGetDeviceImageSparseMemoryRequirementsKHR = 0; |
| |
| //=== VK_KHR_performance_query === |
| PFN_vkAcquireProfilingLockKHR vkAcquireProfilingLockKHR = 0; |
| PFN_vkReleaseProfilingLockKHR vkReleaseProfilingLockKHR = 0; |
| |
| //=== VK_KHR_pipeline_executable_properties === |
| PFN_vkGetPipelineExecutablePropertiesKHR vkGetPipelineExecutablePropertiesKHR = 0; |
| PFN_vkGetPipelineExecutableStatisticsKHR vkGetPipelineExecutableStatisticsKHR = 0; |
| PFN_vkGetPipelineExecutableInternalRepresentationsKHR vkGetPipelineExecutableInternalRepresentationsKHR = 0; |
| |
| //=== VK_KHR_present_wait === |
| PFN_vkWaitForPresentKHR vkWaitForPresentKHR = 0; |
| |
| //=== VK_KHR_push_descriptor === |
| PFN_vkCmdPushDescriptorSetKHR vkCmdPushDescriptorSetKHR = 0; |
| |
| //=== VK_KHR_ray_tracing_pipeline === |
| PFN_vkCmdTraceRaysKHR vkCmdTraceRaysKHR = 0; |
| PFN_vkCreateRayTracingPipelinesKHR vkCreateRayTracingPipelinesKHR = 0; |
| PFN_vkGetRayTracingShaderGroupHandlesKHR vkGetRayTracingShaderGroupHandlesKHR = 0; |
| PFN_vkGetRayTracingCaptureReplayShaderGroupHandlesKHR vkGetRayTracingCaptureReplayShaderGroupHandlesKHR = 0; |
| PFN_vkCmdTraceRaysIndirectKHR vkCmdTraceRaysIndirectKHR = 0; |
| PFN_vkGetRayTracingShaderGroupStackSizeKHR vkGetRayTracingShaderGroupStackSizeKHR = 0; |
| PFN_vkCmdSetRayTracingPipelineStackSizeKHR vkCmdSetRayTracingPipelineStackSizeKHR = 0; |
| |
| //=== VK_KHR_sampler_ycbcr_conversion === |
| PFN_vkCreateSamplerYcbcrConversionKHR vkCreateSamplerYcbcrConversionKHR = 0; |
| PFN_vkDestroySamplerYcbcrConversionKHR vkDestroySamplerYcbcrConversionKHR = 0; |
| |
| //=== VK_KHR_shared_presentable_image === |
| PFN_vkGetSwapchainStatusKHR vkGetSwapchainStatusKHR = 0; |
| |
| //=== VK_KHR_swapchain === |
| PFN_vkCreateSwapchainKHR vkCreateSwapchainKHR = 0; |
| PFN_vkDestroySwapchainKHR vkDestroySwapchainKHR = 0; |
| PFN_vkGetSwapchainImagesKHR vkGetSwapchainImagesKHR = 0; |
| PFN_vkAcquireNextImageKHR vkAcquireNextImageKHR = 0; |
| PFN_vkQueuePresentKHR vkQueuePresentKHR = 0; |
| |
| //=== VK_KHR_synchronization2 === |
| PFN_vkCmdSetEvent2KHR vkCmdSetEvent2KHR = 0; |
| PFN_vkCmdResetEvent2KHR vkCmdResetEvent2KHR = 0; |
| PFN_vkCmdWaitEvents2KHR vkCmdWaitEvents2KHR = 0; |
| PFN_vkCmdPipelineBarrier2KHR vkCmdPipelineBarrier2KHR = 0; |
| PFN_vkCmdWriteTimestamp2KHR vkCmdWriteTimestamp2KHR = 0; |
| PFN_vkQueueSubmit2KHR vkQueueSubmit2KHR = 0; |
| PFN_vkCmdWriteBufferMarker2AMD vkCmdWriteBufferMarker2AMD = 0; |
| PFN_vkGetQueueCheckpointData2NV vkGetQueueCheckpointData2NV = 0; |
| |
| //=== VK_KHR_timeline_semaphore === |
| PFN_vkGetSemaphoreCounterValueKHR vkGetSemaphoreCounterValueKHR = 0; |
| PFN_vkWaitSemaphoresKHR vkWaitSemaphoresKHR = 0; |
| PFN_vkSignalSemaphoreKHR vkSignalSemaphoreKHR = 0; |
| |
| # if defined(VK_ENABLE_BETA_EXTENSIONS) |
| //=== VK_KHR_video_decode_queue === |
| PFN_vkCmdDecodeVideoKHR vkCmdDecodeVideoKHR = 0; |
| # else |
| PFN_dummy vkCmdDecodeVideoKHR_placeholder = 0; |
| # endif /*VK_ENABLE_BETA_EXTENSIONS*/ |
| |
| # if defined(VK_ENABLE_BETA_EXTENSIONS) |
| //=== VK_KHR_video_encode_queue === |
| PFN_vkCmdEncodeVideoKHR vkCmdEncodeVideoKHR = 0; |
| # else |
| PFN_dummy vkCmdEncodeVideoKHR_placeholder = 0; |
| # endif /*VK_ENABLE_BETA_EXTENSIONS*/ |
| |
| # if defined(VK_ENABLE_BETA_EXTENSIONS) |
| //=== VK_KHR_video_queue === |
| PFN_vkCreateVideoSessionKHR vkCreateVideoSessionKHR = 0; |
| PFN_vkDestroyVideoSessionKHR vkDestroyVideoSessionKHR = 0; |
| PFN_vkGetVideoSessionMemoryRequirementsKHR vkGetVideoSessionMemoryRequirementsKHR = 0; |
| PFN_vkBindVideoSessionMemoryKHR vkBindVideoSessionMemoryKHR = 0; |
| PFN_vkCreateVideoSessionParametersKHR vkCreateVideoSessionParametersKHR = 0; |
| PFN_vkUpdateVideoSessionParametersKHR vkUpdateVideoSessionParametersKHR = 0; |
| PFN_vkDestroyVideoSessionParametersKHR vkDestroyVideoSessionParametersKHR = 0; |
| PFN_vkCmdBeginVideoCodingKHR vkCmdBeginVideoCodingKHR = 0; |
| PFN_vkCmdEndVideoCodingKHR vkCmdEndVideoCodingKHR = 0; |
| PFN_vkCmdControlVideoCodingKHR vkCmdControlVideoCodingKHR = 0; |
| # else |
| PFN_dummy vkCreateVideoSessionKHR_placeholder = 0; |
| PFN_dummy vkDestroyVideoSessionKHR_placeholder = 0; |
| PFN_dummy vkGetVideoSessionMemoryRequirementsKHR_placeholder = 0; |
| PFN_dummy vkBindVideoSessionMemoryKHR_placeholder = 0; |
| PFN_dummy vkCreateVideoSessionParametersKHR_placeholder = 0; |
| PFN_dummy vkUpdateVideoSessionParametersKHR_placeholder = 0; |
| PFN_dummy vkDestroyVideoSessionParametersKHR_placeholder = 0; |
| PFN_dummy vkCmdBeginVideoCodingKHR_placeholder = 0; |
| PFN_dummy vkCmdEndVideoCodingKHR_placeholder = 0; |
| PFN_dummy vkCmdControlVideoCodingKHR_placeholder = 0; |
| # endif /*VK_ENABLE_BETA_EXTENSIONS*/ |
| |
| //=== VK_NVX_binary_import === |
| PFN_vkCreateCuModuleNVX vkCreateCuModuleNVX = 0; |
| PFN_vkCreateCuFunctionNVX vkCreateCuFunctionNVX = 0; |
| PFN_vkDestroyCuModuleNVX vkDestroyCuModuleNVX = 0; |
| PFN_vkDestroyCuFunctionNVX vkDestroyCuFunctionNVX = 0; |
| PFN_vkCmdCuLaunchKernelNVX vkCmdCuLaunchKernelNVX = 0; |
| |
| //=== VK_NVX_image_view_handle === |
| PFN_vkGetImageViewHandleNVX vkGetImageViewHandleNVX = 0; |
| PFN_vkGetImageViewAddressNVX vkGetImageViewAddressNVX = 0; |
| |
| //=== VK_NV_clip_space_w_scaling === |
| PFN_vkCmdSetViewportWScalingNV vkCmdSetViewportWScalingNV = 0; |
| |
| //=== VK_NV_device_diagnostic_checkpoints === |
| PFN_vkCmdSetCheckpointNV vkCmdSetCheckpointNV = 0; |
| PFN_vkGetQueueCheckpointDataNV vkGetQueueCheckpointDataNV = 0; |
| |
| //=== VK_NV_device_generated_commands === |
| PFN_vkGetGeneratedCommandsMemoryRequirementsNV vkGetGeneratedCommandsMemoryRequirementsNV = 0; |
| PFN_vkCmdPreprocessGeneratedCommandsNV vkCmdPreprocessGeneratedCommandsNV = 0; |
| PFN_vkCmdExecuteGeneratedCommandsNV vkCmdExecuteGeneratedCommandsNV = 0; |
| PFN_vkCmdBindPipelineShaderGroupNV vkCmdBindPipelineShaderGroupNV = 0; |
| PFN_vkCreateIndirectCommandsLayoutNV vkCreateIndirectCommandsLayoutNV = 0; |
| PFN_vkDestroyIndirectCommandsLayoutNV vkDestroyIndirectCommandsLayoutNV = 0; |
| |
| //=== VK_NV_external_memory_rdma === |
| PFN_vkGetMemoryRemoteAddressNV vkGetMemoryRemoteAddressNV = 0; |
| |
| # if defined(VK_USE_PLATFORM_WIN32_KHR) |
| //=== VK_NV_external_memory_win32 === |
| PFN_vkGetMemoryWin32HandleNV vkGetMemoryWin32HandleNV = 0; |
| # else |
| PFN_dummy vkGetMemoryWin32HandleNV_placeholder = 0; |
| # endif /*VK_USE_PLATFORM_WIN32_KHR*/ |
| |
| //=== VK_NV_fragment_shading_rate_enums === |
| PFN_vkCmdSetFragmentShadingRateEnumNV vkCmdSetFragmentShadingRateEnumNV = 0; |
| |
| //=== VK_NV_mesh_shader === |
| PFN_vkCmdDrawMeshTasksNV vkCmdDrawMeshTasksNV = 0; |
| PFN_vkCmdDrawMeshTasksIndirectNV vkCmdDrawMeshTasksIndirectNV = 0; |
| PFN_vkCmdDrawMeshTasksIndirectCountNV vkCmdDrawMeshTasksIndirectCountNV = 0; |
| |
| //=== VK_NV_ray_tracing === |
| PFN_vkCreateAccelerationStructureNV vkCreateAccelerationStructureNV = 0; |
| PFN_vkDestroyAccelerationStructureNV vkDestroyAccelerationStructureNV = 0; |
| PFN_vkGetAccelerationStructureMemoryRequirementsNV vkGetAccelerationStructureMemoryRequirementsNV = 0; |
| PFN_vkBindAccelerationStructureMemoryNV vkBindAccelerationStructureMemoryNV = 0; |
| PFN_vkCmdBuildAccelerationStructureNV vkCmdBuildAccelerationStructureNV = 0; |
| PFN_vkCmdCopyAccelerationStructureNV vkCmdCopyAccelerationStructureNV = 0; |
| PFN_vkCmdTraceRaysNV vkCmdTraceRaysNV = 0; |
| PFN_vkCreateRayTracingPipelinesNV vkCreateRayTracingPipelinesNV = 0; |
| PFN_vkGetRayTracingShaderGroupHandlesNV vkGetRayTracingShaderGroupHandlesNV = 0; |
| PFN_vkGetAccelerationStructureHandleNV vkGetAccelerationStructureHandleNV = 0; |
| PFN_vkCmdWriteAccelerationStructuresPropertiesNV vkCmdWriteAccelerationStructuresPropertiesNV = 0; |
| PFN_vkCompileDeferredNV vkCompileDeferredNV = 0; |
| |
| //=== VK_NV_scissor_exclusive === |
| PFN_vkCmdSetExclusiveScissorNV vkCmdSetExclusiveScissorNV = 0; |
| |
| //=== VK_NV_shading_rate_image === |
| PFN_vkCmdBindShadingRateImageNV vkCmdBindShadingRateImageNV = 0; |
| PFN_vkCmdSetViewportShadingRatePaletteNV vkCmdSetViewportShadingRatePaletteNV = 0; |
| PFN_vkCmdSetCoarseSampleOrderNV vkCmdSetCoarseSampleOrderNV = 0; |
| |
| //=== VK_VALVE_descriptor_set_host_mapping === |
| PFN_vkGetDescriptorSetLayoutHostMappingInfoVALVE vkGetDescriptorSetLayoutHostMappingInfoVALVE = 0; |
| PFN_vkGetDescriptorSetHostMappingVALVE vkGetDescriptorSetHostMappingVALVE = 0; |
| }; |
| |
| //======================================== |
| //=== RAII HANDLE forward declarations === |
| //======================================== |
| |
| //=== VK_VERSION_1_0 === |
| class Instance; |
| class PhysicalDevice; |
| class Device; |
| class Queue; |
| class DeviceMemory; |
| class Fence; |
| class Semaphore; |
| class Event; |
| class QueryPool; |
| class Buffer; |
| class BufferView; |
| class Image; |
| class ImageView; |
| class ShaderModule; |
| class PipelineCache; |
| class Pipeline; |
| class PipelineLayout; |
| class Sampler; |
| class DescriptorPool; |
| class DescriptorSet; |
| class DescriptorSetLayout; |
| class Framebuffer; |
| class RenderPass; |
| class CommandPool; |
| class CommandBuffer; |
| |
| //=== VK_VERSION_1_1 === |
| class SamplerYcbcrConversion; |
| class DescriptorUpdateTemplate; |
| |
| //=== VK_VERSION_1_3 === |
| class PrivateDataSlot; |
| |
| //=== VK_KHR_surface === |
| class SurfaceKHR; |
| |
| //=== VK_KHR_swapchain === |
| class SwapchainKHR; |
| |
| //=== VK_KHR_display === |
| class DisplayKHR; |
| class DisplayModeKHR; |
| |
| //=== VK_EXT_debug_report === |
| class DebugReportCallbackEXT; |
| |
| # if defined(VK_ENABLE_BETA_EXTENSIONS) |
| //=== VK_KHR_video_queue === |
| class VideoSessionKHR; |
| class VideoSessionParametersKHR; |
| # endif /*VK_ENABLE_BETA_EXTENSIONS*/ |
| |
| //=== VK_NVX_binary_import === |
| class CuModuleNVX; |
| class CuFunctionNVX; |
| |
| //=== VK_EXT_debug_utils === |
| class DebugUtilsMessengerEXT; |
| |
| //=== VK_KHR_acceleration_structure === |
| class AccelerationStructureKHR; |
| |
| //=== VK_EXT_validation_cache === |
| class ValidationCacheEXT; |
| |
| //=== VK_NV_ray_tracing === |
| class AccelerationStructureNV; |
| |
| //=== VK_INTEL_performance_query === |
| class PerformanceConfigurationINTEL; |
| |
| //=== VK_KHR_deferred_host_operations === |
| class DeferredOperationKHR; |
| |
| //=== VK_NV_device_generated_commands === |
| class IndirectCommandsLayoutNV; |
| |
| # if defined(VK_USE_PLATFORM_FUCHSIA) |
| //=== VK_FUCHSIA_buffer_collection === |
| class BufferCollectionFUCHSIA; |
| # endif /*VK_USE_PLATFORM_FUCHSIA*/ |
| |
| //==================== |
| //=== RAII HANDLES === |
| //==================== |
| |
| class Context |
| { |
| public: |
| # if VULKAN_HPP_ENABLE_DYNAMIC_LOADER_TOOL |
| Context() |
| : m_dispatcher(new VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::ContextDispatcher( |
| m_dynamicLoader.getProcAddress<PFN_vkGetInstanceProcAddr>("vkGetInstanceProcAddr"))) |
| # else |
| Context(PFN_vkGetInstanceProcAddr getInstanceProcAddr) |
| : m_dispatcher(new VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::ContextDispatcher(getInstanceProcAddr)) |
| # endif |
| { |
| } |
| |
| ~Context() = default; |
| |
| Context(Context const &) = delete; |
| Context(Context &&rhs) VULKAN_HPP_NOEXCEPT |
| # if VULKAN_HPP_ENABLE_DYNAMIC_LOADER_TOOL |
| : m_dynamicLoader(std::move(rhs.m_dynamicLoader)), |
| m_dispatcher(rhs.m_dispatcher.release()) |
| # else |
| : m_dispatcher(rhs.m_dispatcher.release()) |
| # endif |
| { |
| } |
| Context &operator=(Context const &) = delete; |
| Context &operator=(Context &&rhs) VULKAN_HPP_NOEXCEPT |
| { |
| if(this != &rhs) |
| { |
| # if VULKAN_HPP_ENABLE_DYNAMIC_LOADER_TOOL |
| m_dynamicLoader = std::move(rhs.m_dynamicLoader); |
| # endif |
| m_dispatcher.reset(rhs.m_dispatcher.release()); |
| } |
| return *this; |
| } |
| |
| VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::ContextDispatcher const *getDispatcher() const |
| { |
| VULKAN_HPP_ASSERT(m_dispatcher->getVkHeaderVersion() == VK_HEADER_VERSION); |
| return &*m_dispatcher; |
| } |
| |
| void swap(VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::Context &rhs) |
| { |
| # if VULKAN_HPP_ENABLE_DYNAMIC_LOADER_TOOL |
| std::swap(m_dynamicLoader, rhs.m_dynamicLoader); |
| # endif |
| m_dispatcher.swap(rhs.m_dispatcher); |
| } |
| |
| //=== VK_VERSION_1_0 === |
| |
| VULKAN_HPP_NODISCARD VULKAN_HPP_RAII_NAMESPACE::Instance |
| createInstance(VULKAN_HPP_NAMESPACE::InstanceCreateInfo const &createInfo, |
| VULKAN_HPP_NAMESPACE::Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator = nullptr) const; |
| |
| VULKAN_HPP_NODISCARD std::vector<VULKAN_HPP_NAMESPACE::ExtensionProperties> |
| enumerateInstanceExtensionProperties(Optional<const std::string> layerName VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT) const; |
| |
| VULKAN_HPP_NODISCARD std::vector<VULKAN_HPP_NAMESPACE::LayerProperties> enumerateInstanceLayerProperties() const; |
| |
| //=== VK_VERSION_1_1 === |
| |
| VULKAN_HPP_NODISCARD uint32_t enumerateInstanceVersion() const; |
| |
| private: |
| # if VULKAN_HPP_ENABLE_DYNAMIC_LOADER_TOOL |
| VULKAN_HPP_NAMESPACE::DynamicLoader m_dynamicLoader; |
| # endif |
| std::unique_ptr<VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::ContextDispatcher> m_dispatcher; |
| }; |
| |
| class Instance |
| { |
| public: |
| using CType = VkInstance; |
| |
| static VULKAN_HPP_CONST_OR_CONSTEXPR VULKAN_HPP_NAMESPACE::ObjectType objectType = VULKAN_HPP_NAMESPACE::ObjectType::eInstance; |
| static VULKAN_HPP_CONST_OR_CONSTEXPR VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT debugReportObjectType = |
| VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT::eInstance; |
| |
| public: |
| Instance(VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::Context const &context, |
| VULKAN_HPP_NAMESPACE::InstanceCreateInfo const &createInfo, |
| VULKAN_HPP_NAMESPACE::Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator = nullptr) |
| : m_allocator(static_cast<const VULKAN_HPP_NAMESPACE::AllocationCallbacks *>(allocator)) |
| { |
| VULKAN_HPP_NAMESPACE::Result result = |
| static_cast<VULKAN_HPP_NAMESPACE::Result>(context.getDispatcher()->vkCreateInstance(reinterpret_cast<const VkInstanceCreateInfo *>(&createInfo), |
| reinterpret_cast<const VkAllocationCallbacks *>(m_allocator), |
| reinterpret_cast<VkInstance *>(&m_instance))); |
| if(result != VULKAN_HPP_NAMESPACE::Result::eSuccess) |
| { |
| throwResultException(result, "vkCreateInstance"); |
| } |
| m_dispatcher.reset(new VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::InstanceDispatcher(context.getDispatcher()->vkGetInstanceProcAddr, |
| static_cast<VkInstance>(m_instance))); |
| } |
| |
| Instance(VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::Context const &context, |
| VkInstance instance, |
| VULKAN_HPP_NAMESPACE::Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator = nullptr) |
| : m_instance(instance) |
| , m_allocator(static_cast<const VULKAN_HPP_NAMESPACE::AllocationCallbacks *>(allocator)) |
| { |
| m_dispatcher.reset(new VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::InstanceDispatcher(context.getDispatcher()->vkGetInstanceProcAddr, |
| static_cast<VkInstance>(m_instance))); |
| } |
| |
| Instance(std::nullptr_t) {} |
| |
| ~Instance() |
| { |
| clear(); |
| } |
| |
| Instance() = delete; |
| Instance(Instance const &) = delete; |
| Instance(Instance &&rhs) VULKAN_HPP_NOEXCEPT |
| : m_instance(VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange(rhs.m_instance, {})), |
| m_allocator(VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange(rhs.m_allocator, {})), |
| m_dispatcher(rhs.m_dispatcher.release()) |
| { |
| } |
| Instance &operator=(Instance const &) = delete; |
| Instance &operator=(Instance &&rhs) VULKAN_HPP_NOEXCEPT |
| { |
| if(this != &rhs) |
| { |
| clear(); |
| m_instance = VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange(rhs.m_instance, {}); |
| m_allocator = VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange(rhs.m_allocator, {}); |
| m_dispatcher.reset(rhs.m_dispatcher.release()); |
| } |
| return *this; |
| } |
| |
| VULKAN_HPP_NAMESPACE::Instance const &operator*() const VULKAN_HPP_NOEXCEPT |
| { |
| return m_instance; |
| } |
| |
| void clear() VULKAN_HPP_NOEXCEPT |
| { |
| if(m_instance) |
| { |
| getDispatcher()->vkDestroyInstance(static_cast<VkInstance>(m_instance), reinterpret_cast<const VkAllocationCallbacks *>(m_allocator)); |
| } |
| m_instance = nullptr; |
| m_allocator = nullptr; |
| m_dispatcher = nullptr; |
| } |
| |
| VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::InstanceDispatcher const *getDispatcher() const |
| { |
| VULKAN_HPP_ASSERT(m_dispatcher->getVkHeaderVersion() == VK_HEADER_VERSION); |
| return &*m_dispatcher; |
| } |
| |
| void swap(VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::Instance &rhs) VULKAN_HPP_NOEXCEPT |
| { |
| std::swap(m_instance, rhs.m_instance); |
| std::swap(m_allocator, rhs.m_allocator); |
| std::swap(m_dispatcher, rhs.m_dispatcher); |
| } |
| |
| //=== VK_VERSION_1_0 === |
| |
| VULKAN_HPP_NODISCARD std::vector<VULKAN_HPP_RAII_NAMESPACE::PhysicalDevice> enumeratePhysicalDevices() const; |
| |
| VULKAN_HPP_NODISCARD PFN_vkVoidFunction getProcAddr(const std::string &name) const VULKAN_HPP_NOEXCEPT; |
| |
| //=== VK_VERSION_1_1 === |
| |
| VULKAN_HPP_NODISCARD std::vector<VULKAN_HPP_NAMESPACE::PhysicalDeviceGroupProperties> enumeratePhysicalDeviceGroups() const; |
| |
| //=== VK_KHR_display === |
| |
| VULKAN_HPP_NODISCARD VULKAN_HPP_RAII_NAMESPACE::SurfaceKHR |
| createDisplayPlaneSurfaceKHR(VULKAN_HPP_NAMESPACE::DisplaySurfaceCreateInfoKHR const &createInfo, |
| VULKAN_HPP_NAMESPACE::Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator = nullptr) const; |
| |
| # if defined(VK_USE_PLATFORM_XLIB_KHR) |
| //=== VK_KHR_xlib_surface === |
| |
| VULKAN_HPP_NODISCARD VULKAN_HPP_RAII_NAMESPACE::SurfaceKHR |
| createXlibSurfaceKHR(VULKAN_HPP_NAMESPACE::XlibSurfaceCreateInfoKHR const &createInfo, |
| VULKAN_HPP_NAMESPACE::Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator = nullptr) const; |
| # endif /*VK_USE_PLATFORM_XLIB_KHR*/ |
| |
| # if defined(VK_USE_PLATFORM_XCB_KHR) |
| //=== VK_KHR_xcb_surface === |
| |
| VULKAN_HPP_NODISCARD VULKAN_HPP_RAII_NAMESPACE::SurfaceKHR |
| createXcbSurfaceKHR(VULKAN_HPP_NAMESPACE::XcbSurfaceCreateInfoKHR const &createInfo, |
| VULKAN_HPP_NAMESPACE::Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator = nullptr) const; |
| # endif /*VK_USE_PLATFORM_XCB_KHR*/ |
| |
| # if defined(VK_USE_PLATFORM_WAYLAND_KHR) |
| //=== VK_KHR_wayland_surface === |
| |
| VULKAN_HPP_NODISCARD VULKAN_HPP_RAII_NAMESPACE::SurfaceKHR |
| createWaylandSurfaceKHR(VULKAN_HPP_NAMESPACE::WaylandSurfaceCreateInfoKHR const &createInfo, |
| VULKAN_HPP_NAMESPACE::Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator = nullptr) const; |
| # endif /*VK_USE_PLATFORM_WAYLAND_KHR*/ |
| |
| # if defined(VK_USE_PLATFORM_ANDROID_KHR) |
| //=== VK_KHR_android_surface === |
| |
| VULKAN_HPP_NODISCARD VULKAN_HPP_RAII_NAMESPACE::SurfaceKHR |
| createAndroidSurfaceKHR(VULKAN_HPP_NAMESPACE::AndroidSurfaceCreateInfoKHR const &createInfo, |
| VULKAN_HPP_NAMESPACE::Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator = nullptr) const; |
| # endif /*VK_USE_PLATFORM_ANDROID_KHR*/ |
| |
| # if defined(VK_USE_PLATFORM_WIN32_KHR) |
| //=== VK_KHR_win32_surface === |
| |
| VULKAN_HPP_NODISCARD VULKAN_HPP_RAII_NAMESPACE::SurfaceKHR |
| createWin32SurfaceKHR(VULKAN_HPP_NAMESPACE::Win32SurfaceCreateInfoKHR const &createInfo, |
| VULKAN_HPP_NAMESPACE::Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator = nullptr) const; |
| # endif /*VK_USE_PLATFORM_WIN32_KHR*/ |
| |
| //=== VK_EXT_debug_report === |
| |
| VULKAN_HPP_NODISCARD VULKAN_HPP_RAII_NAMESPACE::DebugReportCallbackEXT |
| createDebugReportCallbackEXT(VULKAN_HPP_NAMESPACE::DebugReportCallbackCreateInfoEXT const &createInfo, |
| VULKAN_HPP_NAMESPACE::Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator = nullptr) const; |
| |
| void debugReportMessageEXT(VULKAN_HPP_NAMESPACE::DebugReportFlagsEXT flags, |
| VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT objectType_, |
| uint64_t object, |
| size_t location, |
| int32_t messageCode, |
| const std::string &layerPrefix, |
| const std::string &message) const VULKAN_HPP_NOEXCEPT; |
| |
| # if defined(VK_USE_PLATFORM_GGP) |
| //=== VK_GGP_stream_descriptor_surface === |
| |
| VULKAN_HPP_NODISCARD VULKAN_HPP_RAII_NAMESPACE::SurfaceKHR |
| createStreamDescriptorSurfaceGGP(VULKAN_HPP_NAMESPACE::StreamDescriptorSurfaceCreateInfoGGP const &createInfo, |
| VULKAN_HPP_NAMESPACE::Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator = nullptr) const; |
| # endif /*VK_USE_PLATFORM_GGP*/ |
| |
| # if defined(VK_USE_PLATFORM_VI_NN) |
| //=== VK_NN_vi_surface === |
| |
| VULKAN_HPP_NODISCARD VULKAN_HPP_RAII_NAMESPACE::SurfaceKHR |
| createViSurfaceNN(VULKAN_HPP_NAMESPACE::ViSurfaceCreateInfoNN const &createInfo, |
| VULKAN_HPP_NAMESPACE::Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator = nullptr) const; |
| # endif /*VK_USE_PLATFORM_VI_NN*/ |
| |
| //=== VK_KHR_device_group_creation === |
| |
| VULKAN_HPP_NODISCARD std::vector<VULKAN_HPP_NAMESPACE::PhysicalDeviceGroupProperties> enumeratePhysicalDeviceGroupsKHR() const; |
| |
| # if defined(VK_USE_PLATFORM_IOS_MVK) |
| //=== VK_MVK_ios_surface === |
| |
| VULKAN_HPP_NODISCARD VULKAN_HPP_RAII_NAMESPACE::SurfaceKHR |
| createIOSSurfaceMVK(VULKAN_HPP_NAMESPACE::IOSSurfaceCreateInfoMVK const &createInfo, |
| VULKAN_HPP_NAMESPACE::Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator = nullptr) const; |
| # endif /*VK_USE_PLATFORM_IOS_MVK*/ |
| |
| # if defined(VK_USE_PLATFORM_MACOS_MVK) |
| //=== VK_MVK_macos_surface === |
| |
| VULKAN_HPP_NODISCARD VULKAN_HPP_RAII_NAMESPACE::SurfaceKHR |
| createMacOSSurfaceMVK(VULKAN_HPP_NAMESPACE::MacOSSurfaceCreateInfoMVK const &createInfo, |
| VULKAN_HPP_NAMESPACE::Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator = nullptr) const; |
| # endif /*VK_USE_PLATFORM_MACOS_MVK*/ |
| |
| //=== VK_EXT_debug_utils === |
| |
| VULKAN_HPP_NODISCARD VULKAN_HPP_RAII_NAMESPACE::DebugUtilsMessengerEXT |
| createDebugUtilsMessengerEXT(VULKAN_HPP_NAMESPACE::DebugUtilsMessengerCreateInfoEXT const &createInfo, |
| VULKAN_HPP_NAMESPACE::Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator = nullptr) const; |
| |
| void submitDebugUtilsMessageEXT(VULKAN_HPP_NAMESPACE::DebugUtilsMessageSeverityFlagBitsEXT messageSeverity, |
| VULKAN_HPP_NAMESPACE::DebugUtilsMessageTypeFlagsEXT messageTypes, |
| const VULKAN_HPP_NAMESPACE::DebugUtilsMessengerCallbackDataEXT &callbackData) const VULKAN_HPP_NOEXCEPT; |
| |
| # if defined(VK_USE_PLATFORM_FUCHSIA) |
| //=== VK_FUCHSIA_imagepipe_surface === |
| |
| VULKAN_HPP_NODISCARD VULKAN_HPP_RAII_NAMESPACE::SurfaceKHR |
| createImagePipeSurfaceFUCHSIA(VULKAN_HPP_NAMESPACE::ImagePipeSurfaceCreateInfoFUCHSIA const &createInfo, |
| VULKAN_HPP_NAMESPACE::Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator = nullptr) const; |
| # endif /*VK_USE_PLATFORM_FUCHSIA*/ |
| |
| # if defined(VK_USE_PLATFORM_METAL_EXT) |
| //=== VK_EXT_metal_surface === |
| |
| VULKAN_HPP_NODISCARD VULKAN_HPP_RAII_NAMESPACE::SurfaceKHR |
| createMetalSurfaceEXT(VULKAN_HPP_NAMESPACE::MetalSurfaceCreateInfoEXT const &createInfo, |
| VULKAN_HPP_NAMESPACE::Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator = nullptr) const; |
| # endif /*VK_USE_PLATFORM_METAL_EXT*/ |
| |
| //=== VK_EXT_headless_surface === |
| |
| VULKAN_HPP_NODISCARD VULKAN_HPP_RAII_NAMESPACE::SurfaceKHR |
| createHeadlessSurfaceEXT(VULKAN_HPP_NAMESPACE::HeadlessSurfaceCreateInfoEXT const &createInfo, |
| VULKAN_HPP_NAMESPACE::Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator = nullptr) const; |
| |
| # if defined(VK_USE_PLATFORM_DIRECTFB_EXT) |
| //=== VK_EXT_directfb_surface === |
| |
| VULKAN_HPP_NODISCARD VULKAN_HPP_RAII_NAMESPACE::SurfaceKHR |
| createDirectFBSurfaceEXT(VULKAN_HPP_NAMESPACE::DirectFBSurfaceCreateInfoEXT const &createInfo, |
| VULKAN_HPP_NAMESPACE::Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator = nullptr) const; |
| # endif /*VK_USE_PLATFORM_DIRECTFB_EXT*/ |
| |
| # if defined(VK_USE_PLATFORM_SCREEN_QNX) |
| //=== VK_QNX_screen_surface === |
| |
| VULKAN_HPP_NODISCARD VULKAN_HPP_RAII_NAMESPACE::SurfaceKHR |
| createScreenSurfaceQNX(VULKAN_HPP_NAMESPACE::ScreenSurfaceCreateInfoQNX const &createInfo, |
| VULKAN_HPP_NAMESPACE::Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator = nullptr) const; |
| # endif /*VK_USE_PLATFORM_SCREEN_QNX*/ |
| |
| private: |
| VULKAN_HPP_NAMESPACE::Instance m_instance = {}; |
| const VULKAN_HPP_NAMESPACE::AllocationCallbacks *m_allocator = {}; |
| std::unique_ptr<VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::InstanceDispatcher> m_dispatcher; |
| }; |
| |
| class PhysicalDevice |
| { |
| public: |
| using CType = VkPhysicalDevice; |
| |
| static VULKAN_HPP_CONST_OR_CONSTEXPR VULKAN_HPP_NAMESPACE::ObjectType objectType = VULKAN_HPP_NAMESPACE::ObjectType::ePhysicalDevice; |
| static VULKAN_HPP_CONST_OR_CONSTEXPR VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT debugReportObjectType = |
| VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT::ePhysicalDevice; |
| |
| public: |
| PhysicalDevice(VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::Instance const &instance, VkPhysicalDevice physicalDevice) |
| : m_physicalDevice(physicalDevice) |
| , m_dispatcher(instance.getDispatcher()) |
| { |
| } |
| |
| PhysicalDevice(std::nullptr_t) {} |
| |
| ~PhysicalDevice() |
| { |
| clear(); |
| } |
| |
| PhysicalDevice() = delete; |
| PhysicalDevice(PhysicalDevice const &rhs) |
| : m_physicalDevice(rhs.m_physicalDevice) |
| , m_dispatcher(rhs.m_dispatcher) |
| {} |
| PhysicalDevice(PhysicalDevice &&rhs) VULKAN_HPP_NOEXCEPT |
| : m_physicalDevice(VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange(rhs.m_physicalDevice, {})), |
| m_dispatcher(VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange(rhs.m_dispatcher, nullptr)) |
| { |
| } |
| PhysicalDevice &operator=(PhysicalDevice const &rhs) |
| { |
| m_physicalDevice = rhs.m_physicalDevice; |
| m_dispatcher = rhs.m_dispatcher; |
| return *this; |
| } |
| PhysicalDevice &operator=(PhysicalDevice &&rhs) VULKAN_HPP_NOEXCEPT |
| { |
| if(this != &rhs) |
| { |
| m_physicalDevice = VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange(rhs.m_physicalDevice, {}); |
| m_dispatcher = VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange(rhs.m_dispatcher, nullptr); |
| } |
| return *this; |
| } |
| |
| VULKAN_HPP_NAMESPACE::PhysicalDevice const &operator*() const VULKAN_HPP_NOEXCEPT |
| { |
| return m_physicalDevice; |
| } |
| |
| void clear() VULKAN_HPP_NOEXCEPT |
| { |
| m_physicalDevice = nullptr; |
| m_dispatcher = nullptr; |
| } |
| |
| VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::InstanceDispatcher const *getDispatcher() const |
| { |
| VULKAN_HPP_ASSERT(m_dispatcher->getVkHeaderVersion() == VK_HEADER_VERSION); |
| return m_dispatcher; |
| } |
| |
| void swap(VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::PhysicalDevice &rhs) VULKAN_HPP_NOEXCEPT |
| { |
| std::swap(m_physicalDevice, rhs.m_physicalDevice); |
| std::swap(m_dispatcher, rhs.m_dispatcher); |
| } |
| |
| //=== VK_VERSION_1_0 === |
| |
| VULKAN_HPP_NODISCARD VULKAN_HPP_NAMESPACE::PhysicalDeviceFeatures getFeatures() const VULKAN_HPP_NOEXCEPT; |
| |
| VULKAN_HPP_NODISCARD VULKAN_HPP_NAMESPACE::FormatProperties getFormatProperties(VULKAN_HPP_NAMESPACE::Format format) const VULKAN_HPP_NOEXCEPT; |
| |
| VULKAN_HPP_NODISCARD VULKAN_HPP_NAMESPACE::ImageFormatProperties |
| getImageFormatProperties(VULKAN_HPP_NAMESPACE::Format format, |
| VULKAN_HPP_NAMESPACE::ImageType type, |
| VULKAN_HPP_NAMESPACE::ImageTiling tiling, |
| VULKAN_HPP_NAMESPACE::ImageUsageFlags usage, |
| VULKAN_HPP_NAMESPACE::ImageCreateFlags flags VULKAN_HPP_DEFAULT_ARGUMENT_ASSIGNMENT) const; |
| |
| VULKAN_HPP_NODISCARD VULKAN_HPP_NAMESPACE::PhysicalDeviceProperties getProperties() const VULKAN_HPP_NOEXCEPT; |
| |
| VULKAN_HPP_NODISCARD std::vector<VULKAN_HPP_NAMESPACE::QueueFamilyProperties> getQueueFamilyProperties() const VULKAN_HPP_NOEXCEPT; |
| |
| VULKAN_HPP_NODISCARD VULKAN_HPP_NAMESPACE::PhysicalDeviceMemoryProperties getMemoryProperties() const VULKAN_HPP_NOEXCEPT; |
| |
| VULKAN_HPP_NODISCARD VULKAN_HPP_RAII_NAMESPACE::Device |
| createDevice(VULKAN_HPP_NAMESPACE::DeviceCreateInfo const &createInfo, |
| VULKAN_HPP_NAMESPACE::Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator = nullptr) const; |
| |
| VULKAN_HPP_NODISCARD std::vector<VULKAN_HPP_NAMESPACE::ExtensionProperties> |
| enumerateDeviceExtensionProperties(Optional<const std::string> layerName VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT) const; |
| |
| VULKAN_HPP_NODISCARD std::vector<VULKAN_HPP_NAMESPACE::LayerProperties> enumerateDeviceLayerProperties() const; |
| |
| VULKAN_HPP_NODISCARD std::vector<VULKAN_HPP_NAMESPACE::SparseImageFormatProperties> |
| getSparseImageFormatProperties(VULKAN_HPP_NAMESPACE::Format format, |
| VULKAN_HPP_NAMESPACE::ImageType type, |
| VULKAN_HPP_NAMESPACE::SampleCountFlagBits samples, |
| VULKAN_HPP_NAMESPACE::ImageUsageFlags usage, |
| VULKAN_HPP_NAMESPACE::ImageTiling tiling) const VULKAN_HPP_NOEXCEPT; |
| |
| //=== VK_VERSION_1_1 === |
| |
| VULKAN_HPP_NODISCARD VULKAN_HPP_NAMESPACE::PhysicalDeviceFeatures2 getFeatures2() const VULKAN_HPP_NOEXCEPT; |
| |
| template<typename X, typename Y, typename... Z> |
| VULKAN_HPP_NODISCARD StructureChain<X, Y, Z...> getFeatures2() const VULKAN_HPP_NOEXCEPT; |
| |
| VULKAN_HPP_NODISCARD VULKAN_HPP_NAMESPACE::PhysicalDeviceProperties2 getProperties2() const VULKAN_HPP_NOEXCEPT; |
| |
| template<typename X, typename Y, typename... Z> |
| VULKAN_HPP_NODISCARD StructureChain<X, Y, Z...> getProperties2() const VULKAN_HPP_NOEXCEPT; |
| |
| VULKAN_HPP_NODISCARD VULKAN_HPP_NAMESPACE::FormatProperties2 getFormatProperties2(VULKAN_HPP_NAMESPACE::Format format) const VULKAN_HPP_NOEXCEPT; |
| |
| template<typename X, typename Y, typename... Z> |
| VULKAN_HPP_NODISCARD StructureChain<X, Y, Z...> getFormatProperties2(VULKAN_HPP_NAMESPACE::Format format) const VULKAN_HPP_NOEXCEPT; |
| |
| VULKAN_HPP_NODISCARD VULKAN_HPP_NAMESPACE::ImageFormatProperties2 |
| getImageFormatProperties2(const VULKAN_HPP_NAMESPACE::PhysicalDeviceImageFormatInfo2 &imageFormatInfo) const; |
| |
| template<typename X, typename Y, typename... Z> |
| VULKAN_HPP_NODISCARD StructureChain<X, Y, Z...> |
| getImageFormatProperties2(const VULKAN_HPP_NAMESPACE::PhysicalDeviceImageFormatInfo2 &imageFormatInfo) const; |
| |
| VULKAN_HPP_NODISCARD std::vector<VULKAN_HPP_NAMESPACE::QueueFamilyProperties2> getQueueFamilyProperties2() const VULKAN_HPP_NOEXCEPT; |
| |
| template<typename StructureChain> |
| VULKAN_HPP_NODISCARD std::vector<StructureChain> getQueueFamilyProperties2() const; |
| |
| VULKAN_HPP_NODISCARD VULKAN_HPP_NAMESPACE::PhysicalDeviceMemoryProperties2 getMemoryProperties2() const VULKAN_HPP_NOEXCEPT; |
| |
| template<typename X, typename Y, typename... Z> |
| VULKAN_HPP_NODISCARD StructureChain<X, Y, Z...> getMemoryProperties2() const VULKAN_HPP_NOEXCEPT; |
| |
| VULKAN_HPP_NODISCARD std::vector<VULKAN_HPP_NAMESPACE::SparseImageFormatProperties2> |
| getSparseImageFormatProperties2(const VULKAN_HPP_NAMESPACE::PhysicalDeviceSparseImageFormatInfo2 &formatInfo) const VULKAN_HPP_NOEXCEPT; |
| |
| VULKAN_HPP_NODISCARD VULKAN_HPP_NAMESPACE::ExternalBufferProperties |
| getExternalBufferProperties(const VULKAN_HPP_NAMESPACE::PhysicalDeviceExternalBufferInfo &externalBufferInfo) const VULKAN_HPP_NOEXCEPT; |
| |
| VULKAN_HPP_NODISCARD VULKAN_HPP_NAMESPACE::ExternalFenceProperties |
| getExternalFenceProperties(const VULKAN_HPP_NAMESPACE::PhysicalDeviceExternalFenceInfo &externalFenceInfo) const VULKAN_HPP_NOEXCEPT; |
| |
| VULKAN_HPP_NODISCARD VULKAN_HPP_NAMESPACE::ExternalSemaphoreProperties |
| getExternalSemaphoreProperties(const VULKAN_HPP_NAMESPACE::PhysicalDeviceExternalSemaphoreInfo &externalSemaphoreInfo) const VULKAN_HPP_NOEXCEPT; |
| |
| //=== VK_VERSION_1_3 === |
| |
| VULKAN_HPP_NODISCARD std::vector<VULKAN_HPP_NAMESPACE::PhysicalDeviceToolProperties> getToolProperties() const; |
| |
| //=== VK_KHR_surface === |
| |
| VULKAN_HPP_NODISCARD VULKAN_HPP_NAMESPACE::Bool32 getSurfaceSupportKHR(uint32_t queueFamilyIndex, VULKAN_HPP_NAMESPACE::SurfaceKHR surface) const; |
| |
| VULKAN_HPP_NODISCARD VULKAN_HPP_NAMESPACE::SurfaceCapabilitiesKHR getSurfaceCapabilitiesKHR(VULKAN_HPP_NAMESPACE::SurfaceKHR surface) const; |
| |
| VULKAN_HPP_NODISCARD std::vector<VULKAN_HPP_NAMESPACE::SurfaceFormatKHR> |
| getSurfaceFormatsKHR(VULKAN_HPP_NAMESPACE::SurfaceKHR surface VULKAN_HPP_DEFAULT_ARGUMENT_ASSIGNMENT) const; |
| |
| VULKAN_HPP_NODISCARD std::vector<VULKAN_HPP_NAMESPACE::PresentModeKHR> |
| getSurfacePresentModesKHR(VULKAN_HPP_NAMESPACE::SurfaceKHR surface VULKAN_HPP_DEFAULT_ARGUMENT_ASSIGNMENT) const; |
| |
| //=== VK_KHR_swapchain === |
| |
| VULKAN_HPP_NODISCARD std::vector<VULKAN_HPP_NAMESPACE::Rect2D> getPresentRectanglesKHR(VULKAN_HPP_NAMESPACE::SurfaceKHR surface) const; |
| |
| //=== VK_KHR_display === |
| |
| VULKAN_HPP_NODISCARD std::vector<VULKAN_HPP_NAMESPACE::DisplayPropertiesKHR> getDisplayPropertiesKHR() const; |
| |
| VULKAN_HPP_NODISCARD std::vector<VULKAN_HPP_NAMESPACE::DisplayPlanePropertiesKHR> getDisplayPlanePropertiesKHR() const; |
| |
| VULKAN_HPP_NODISCARD std::vector<VULKAN_HPP_RAII_NAMESPACE::DisplayKHR> getDisplayPlaneSupportedDisplaysKHR(uint32_t planeIndex) const; |
| |
| # if defined(VK_USE_PLATFORM_XLIB_KHR) |
| //=== VK_KHR_xlib_surface === |
| |
| VULKAN_HPP_NODISCARD VULKAN_HPP_NAMESPACE::Bool32 |
| getXlibPresentationSupportKHR(uint32_t queueFamilyIndex, Display &dpy, VisualID visualID) const VULKAN_HPP_NOEXCEPT; |
| # endif /*VK_USE_PLATFORM_XLIB_KHR*/ |
| |
| # if defined(VK_USE_PLATFORM_XCB_KHR) |
| //=== VK_KHR_xcb_surface === |
| |
| VULKAN_HPP_NODISCARD VULKAN_HPP_NAMESPACE::Bool32 |
| getXcbPresentationSupportKHR(uint32_t queueFamilyIndex, xcb_connection_t &connection, xcb_visualid_t visual_id) const VULKAN_HPP_NOEXCEPT; |
| # endif /*VK_USE_PLATFORM_XCB_KHR*/ |
| |
| # if defined(VK_USE_PLATFORM_WAYLAND_KHR) |
| //=== VK_KHR_wayland_surface === |
| |
| VULKAN_HPP_NODISCARD VULKAN_HPP_NAMESPACE::Bool32 getWaylandPresentationSupportKHR(uint32_t queueFamilyIndex, |
| struct wl_display &display) const VULKAN_HPP_NOEXCEPT; |
| # endif /*VK_USE_PLATFORM_WAYLAND_KHR*/ |
| |
| # if defined(VK_USE_PLATFORM_WIN32_KHR) |
| //=== VK_KHR_win32_surface === |
| |
| VULKAN_HPP_NODISCARD VULKAN_HPP_NAMESPACE::Bool32 getWin32PresentationSupportKHR(uint32_t queueFamilyIndex) const VULKAN_HPP_NOEXCEPT; |
| # endif /*VK_USE_PLATFORM_WIN32_KHR*/ |
| |
| # if defined(VK_ENABLE_BETA_EXTENSIONS) |
| //=== VK_KHR_video_queue === |
| |
| VULKAN_HPP_NODISCARD VULKAN_HPP_NAMESPACE::VideoCapabilitiesKHR |
| getVideoCapabilitiesKHR(const VULKAN_HPP_NAMESPACE::VideoProfileKHR &videoProfile) const; |
| |
| template<typename X, typename Y, typename... Z> |
| VULKAN_HPP_NODISCARD StructureChain<X, Y, Z...> getVideoCapabilitiesKHR(const VULKAN_HPP_NAMESPACE::VideoProfileKHR &videoProfile) const; |
| |
| VULKAN_HPP_NODISCARD std::vector<VULKAN_HPP_NAMESPACE::VideoFormatPropertiesKHR> |
| getVideoFormatPropertiesKHR(const VULKAN_HPP_NAMESPACE::PhysicalDeviceVideoFormatInfoKHR &videoFormatInfo) const; |
| # endif /*VK_ENABLE_BETA_EXTENSIONS*/ |
| |
| //=== VK_NV_external_memory_capabilities === |
| |
| VULKAN_HPP_NODISCARD VULKAN_HPP_NAMESPACE::ExternalImageFormatPropertiesNV getExternalImageFormatPropertiesNV( |
| VULKAN_HPP_NAMESPACE::Format format, |
| VULKAN_HPP_NAMESPACE::ImageType type, |
| VULKAN_HPP_NAMESPACE::ImageTiling tiling, |
| VULKAN_HPP_NAMESPACE::ImageUsageFlags usage, |
| VULKAN_HPP_NAMESPACE::ImageCreateFlags flags VULKAN_HPP_DEFAULT_ARGUMENT_ASSIGNMENT, |
| VULKAN_HPP_NAMESPACE::ExternalMemoryHandleTypeFlagsNV externalHandleType VULKAN_HPP_DEFAULT_ARGUMENT_ASSIGNMENT) const; |
| |
| //=== VK_KHR_get_physical_device_properties2 === |
| |
| VULKAN_HPP_NODISCARD VULKAN_HPP_NAMESPACE::PhysicalDeviceFeatures2 getFeatures2KHR() const VULKAN_HPP_NOEXCEPT; |
| |
| template<typename X, typename Y, typename... Z> |
| VULKAN_HPP_NODISCARD StructureChain<X, Y, Z...> getFeatures2KHR() const VULKAN_HPP_NOEXCEPT; |
| |
| VULKAN_HPP_NODISCARD VULKAN_HPP_NAMESPACE::PhysicalDeviceProperties2 getProperties2KHR() const VULKAN_HPP_NOEXCEPT; |
| |
| template<typename X, typename Y, typename... Z> |
| VULKAN_HPP_NODISCARD StructureChain<X, Y, Z...> getProperties2KHR() const VULKAN_HPP_NOEXCEPT; |
| |
| VULKAN_HPP_NODISCARD VULKAN_HPP_NAMESPACE::FormatProperties2 getFormatProperties2KHR(VULKAN_HPP_NAMESPACE::Format format) const VULKAN_HPP_NOEXCEPT; |
| |
| template<typename X, typename Y, typename... Z> |
| VULKAN_HPP_NODISCARD StructureChain<X, Y, Z...> getFormatProperties2KHR(VULKAN_HPP_NAMESPACE::Format format) const VULKAN_HPP_NOEXCEPT; |
| |
| VULKAN_HPP_NODISCARD VULKAN_HPP_NAMESPACE::ImageFormatProperties2 |
| getImageFormatProperties2KHR(const VULKAN_HPP_NAMESPACE::PhysicalDeviceImageFormatInfo2 &imageFormatInfo) const; |
| |
| template<typename X, typename Y, typename... Z> |
| VULKAN_HPP_NODISCARD StructureChain<X, Y, Z...> |
| getImageFormatProperties2KHR(const VULKAN_HPP_NAMESPACE::PhysicalDeviceImageFormatInfo2 &imageFormatInfo) const; |
| |
| VULKAN_HPP_NODISCARD std::vector<VULKAN_HPP_NAMESPACE::QueueFamilyProperties2> getQueueFamilyProperties2KHR() const VULKAN_HPP_NOEXCEPT; |
| |
| template<typename StructureChain> |
| VULKAN_HPP_NODISCARD std::vector<StructureChain> getQueueFamilyProperties2KHR() const; |
| |
| VULKAN_HPP_NODISCARD VULKAN_HPP_NAMESPACE::PhysicalDeviceMemoryProperties2 getMemoryProperties2KHR() const VULKAN_HPP_NOEXCEPT; |
| |
| template<typename X, typename Y, typename... Z> |
| VULKAN_HPP_NODISCARD StructureChain<X, Y, Z...> getMemoryProperties2KHR() const VULKAN_HPP_NOEXCEPT; |
| |
| VULKAN_HPP_NODISCARD std::vector<VULKAN_HPP_NAMESPACE::SparseImageFormatProperties2> |
| getSparseImageFormatProperties2KHR(const VULKAN_HPP_NAMESPACE::PhysicalDeviceSparseImageFormatInfo2 &formatInfo) const VULKAN_HPP_NOEXCEPT; |
| |
| //=== VK_KHR_external_memory_capabilities === |
| |
| VULKAN_HPP_NODISCARD VULKAN_HPP_NAMESPACE::ExternalBufferProperties |
| getExternalBufferPropertiesKHR(const VULKAN_HPP_NAMESPACE::PhysicalDeviceExternalBufferInfo &externalBufferInfo) const VULKAN_HPP_NOEXCEPT; |
| |
| //=== VK_KHR_external_semaphore_capabilities === |
| |
| VULKAN_HPP_NODISCARD VULKAN_HPP_NAMESPACE::ExternalSemaphoreProperties |
| getExternalSemaphorePropertiesKHR(const VULKAN_HPP_NAMESPACE::PhysicalDeviceExternalSemaphoreInfo &externalSemaphoreInfo) const VULKAN_HPP_NOEXCEPT; |
| |
| # if defined(VK_USE_PLATFORM_XLIB_XRANDR_EXT) |
| //=== VK_EXT_acquire_xlib_display === |
| |
| void acquireXlibDisplayEXT(Display &dpy, VULKAN_HPP_NAMESPACE::DisplayKHR display) const; |
| |
| VULKAN_HPP_NODISCARD VULKAN_HPP_RAII_NAMESPACE::DisplayKHR getRandROutputDisplayEXT(Display &dpy, RROutput rrOutput) const; |
| # endif /*VK_USE_PLATFORM_XLIB_XRANDR_EXT*/ |
| |
| //=== VK_EXT_display_surface_counter === |
| |
| VULKAN_HPP_NODISCARD VULKAN_HPP_NAMESPACE::SurfaceCapabilities2EXT getSurfaceCapabilities2EXT(VULKAN_HPP_NAMESPACE::SurfaceKHR surface) const; |
| |
| //=== VK_KHR_external_fence_capabilities === |
| |
| VULKAN_HPP_NODISCARD VULKAN_HPP_NAMESPACE::ExternalFenceProperties |
| getExternalFencePropertiesKHR(const VULKAN_HPP_NAMESPACE::PhysicalDeviceExternalFenceInfo &externalFenceInfo) const VULKAN_HPP_NOEXCEPT; |
| |
| //=== VK_KHR_performance_query === |
| |
| VULKAN_HPP_NODISCARD std::pair<std::vector<PerformanceCounterKHR>, std::vector<PerformanceCounterDescriptionKHR>> |
| enumerateQueueFamilyPerformanceQueryCountersKHR(uint32_t queueFamilyIndex) const; |
| |
| VULKAN_HPP_NODISCARD uint32_t getQueueFamilyPerformanceQueryPassesKHR( |
| const VULKAN_HPP_NAMESPACE::QueryPoolPerformanceCreateInfoKHR &performanceQueryCreateInfo) const VULKAN_HPP_NOEXCEPT; |
| |
| //=== VK_KHR_get_surface_capabilities2 === |
| |
| VULKAN_HPP_NODISCARD VULKAN_HPP_NAMESPACE::SurfaceCapabilities2KHR |
| getSurfaceCapabilities2KHR(const VULKAN_HPP_NAMESPACE::PhysicalDeviceSurfaceInfo2KHR &surfaceInfo) const; |
| |
| template<typename X, typename Y, typename... Z> |
| VULKAN_HPP_NODISCARD StructureChain<X, Y, Z...> |
| getSurfaceCapabilities2KHR(const VULKAN_HPP_NAMESPACE::PhysicalDeviceSurfaceInfo2KHR &surfaceInfo) const; |
| |
| VULKAN_HPP_NODISCARD std::vector<VULKAN_HPP_NAMESPACE::SurfaceFormat2KHR> |
| getSurfaceFormats2KHR(const VULKAN_HPP_NAMESPACE::PhysicalDeviceSurfaceInfo2KHR &surfaceInfo) const; |
| |
| //=== VK_KHR_get_display_properties2 === |
| |
| VULKAN_HPP_NODISCARD std::vector<VULKAN_HPP_NAMESPACE::DisplayProperties2KHR> getDisplayProperties2KHR() const; |
| |
| VULKAN_HPP_NODISCARD std::vector<VULKAN_HPP_NAMESPACE::DisplayPlaneProperties2KHR> getDisplayPlaneProperties2KHR() const; |
| |
| VULKAN_HPP_NODISCARD VULKAN_HPP_NAMESPACE::DisplayPlaneCapabilities2KHR |
| getDisplayPlaneCapabilities2KHR(const VULKAN_HPP_NAMESPACE::DisplayPlaneInfo2KHR &displayPlaneInfo) const; |
| |
| //=== VK_EXT_sample_locations === |
| |
| VULKAN_HPP_NODISCARD VULKAN_HPP_NAMESPACE::MultisamplePropertiesEXT |
| getMultisamplePropertiesEXT(VULKAN_HPP_NAMESPACE::SampleCountFlagBits samples) const VULKAN_HPP_NOEXCEPT; |
| |
| //=== VK_EXT_calibrated_timestamps === |
| |
| VULKAN_HPP_NODISCARD std::vector<VULKAN_HPP_NAMESPACE::TimeDomainEXT> getCalibrateableTimeDomainsEXT() const; |
| |
| //=== VK_KHR_fragment_shading_rate === |
| |
| VULKAN_HPP_NODISCARD std::vector<VULKAN_HPP_NAMESPACE::PhysicalDeviceFragmentShadingRateKHR> getFragmentShadingRatesKHR() const; |
| |
| //=== VK_EXT_tooling_info === |
| |
| VULKAN_HPP_NODISCARD std::vector<VULKAN_HPP_NAMESPACE::PhysicalDeviceToolProperties> getToolPropertiesEXT() const; |
| |
| //=== VK_NV_cooperative_matrix === |
| |
| VULKAN_HPP_NODISCARD std::vector<VULKAN_HPP_NAMESPACE::CooperativeMatrixPropertiesNV> getCooperativeMatrixPropertiesNV() const; |
| |
| //=== VK_NV_coverage_reduction_mode === |
| |
| VULKAN_HPP_NODISCARD std::vector<VULKAN_HPP_NAMESPACE::FramebufferMixedSamplesCombinationNV> getSupportedFramebufferMixedSamplesCombinationsNV() const; |
| |
| # if defined(VK_USE_PLATFORM_WIN32_KHR) |
| //=== VK_EXT_full_screen_exclusive === |
| |
| VULKAN_HPP_NODISCARD std::vector<VULKAN_HPP_NAMESPACE::PresentModeKHR> |
| getSurfacePresentModes2EXT(const VULKAN_HPP_NAMESPACE::PhysicalDeviceSurfaceInfo2KHR &surfaceInfo) const; |
| # endif /*VK_USE_PLATFORM_WIN32_KHR*/ |
| |
| //=== VK_EXT_acquire_drm_display === |
| |
| void acquireDrmDisplayEXT(int32_t drmFd, VULKAN_HPP_NAMESPACE::DisplayKHR display) const; |
| |
| VULKAN_HPP_NODISCARD VULKAN_HPP_RAII_NAMESPACE::DisplayKHR getDrmDisplayEXT(int32_t drmFd, uint32_t connectorId) const; |
| |
| # if defined(VK_USE_PLATFORM_WIN32_KHR) |
| //=== VK_NV_acquire_winrt_display === |
| |
| VULKAN_HPP_NODISCARD VULKAN_HPP_RAII_NAMESPACE::DisplayKHR getWinrtDisplayNV(uint32_t deviceRelativeId) const; |
| # endif /*VK_USE_PLATFORM_WIN32_KHR*/ |
| |
| # if defined(VK_USE_PLATFORM_DIRECTFB_EXT) |
| //=== VK_EXT_directfb_surface === |
| |
| VULKAN_HPP_NODISCARD VULKAN_HPP_NAMESPACE::Bool32 getDirectFBPresentationSupportEXT(uint32_t queueFamilyIndex, |
| IDirectFB &dfb) const VULKAN_HPP_NOEXCEPT; |
| # endif /*VK_USE_PLATFORM_DIRECTFB_EXT*/ |
| |
| # if defined(VK_USE_PLATFORM_SCREEN_QNX) |
| //=== VK_QNX_screen_surface === |
| |
| VULKAN_HPP_NODISCARD VULKAN_HPP_NAMESPACE::Bool32 getScreenPresentationSupportQNX(uint32_t queueFamilyIndex, |
| struct _screen_window &window) const VULKAN_HPP_NOEXCEPT; |
| # endif /*VK_USE_PLATFORM_SCREEN_QNX*/ |
| |
| private: |
| VULKAN_HPP_NAMESPACE::PhysicalDevice m_physicalDevice = {}; |
| VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::InstanceDispatcher const *m_dispatcher = nullptr; |
| }; |
| |
| class PhysicalDevices : public std::vector<VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::PhysicalDevice> |
| { |
| public: |
| PhysicalDevices(VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::Instance const &instance) |
| { |
| VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::InstanceDispatcher const *dispatcher = instance.getDispatcher(); |
| std::vector<VkPhysicalDevice> physicalDevices; |
| uint32_t physicalDeviceCount; |
| VULKAN_HPP_NAMESPACE::Result result; |
| do |
| { |
| result = static_cast<VULKAN_HPP_NAMESPACE::Result>( |
| dispatcher->vkEnumeratePhysicalDevices(static_cast<VkInstance>(*instance), &physicalDeviceCount, nullptr)); |
| if((result == VULKAN_HPP_NAMESPACE::Result::eSuccess) && physicalDeviceCount) |
| { |
| physicalDevices.resize(physicalDeviceCount); |
| result = static_cast<VULKAN_HPP_NAMESPACE::Result>( |
| dispatcher->vkEnumeratePhysicalDevices(static_cast<VkInstance>(*instance), &physicalDeviceCount, physicalDevices.data())); |
| } |
| } while(result == VULKAN_HPP_NAMESPACE::Result::eIncomplete); |
| if(result == VULKAN_HPP_NAMESPACE::Result::eSuccess) |
| { |
| VULKAN_HPP_ASSERT(physicalDeviceCount <= physicalDevices.size()); |
| this->reserve(physicalDeviceCount); |
| for(auto const &physicalDevice : physicalDevices) |
| { |
| this->emplace_back(instance, physicalDevice); |
| } |
| } |
| else |
| { |
| throwResultException(result, "vkEnumeratePhysicalDevices"); |
| } |
| } |
| |
| PhysicalDevices(std::nullptr_t) {} |
| |
| PhysicalDevices() = delete; |
| PhysicalDevices(PhysicalDevices const &) = delete; |
| PhysicalDevices(PhysicalDevices &&rhs) = default; |
| PhysicalDevices &operator=(PhysicalDevices const &) = delete; |
| PhysicalDevices &operator=(PhysicalDevices &&rhs) = default; |
| }; |
| |
| class Device |
| { |
| public: |
| using CType = VkDevice; |
| |
| static VULKAN_HPP_CONST_OR_CONSTEXPR VULKAN_HPP_NAMESPACE::ObjectType objectType = VULKAN_HPP_NAMESPACE::ObjectType::eDevice; |
| static VULKAN_HPP_CONST_OR_CONSTEXPR VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT debugReportObjectType = |
| VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT::eDevice; |
| |
| public: |
| Device(VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::PhysicalDevice const &physicalDevice, |
| VULKAN_HPP_NAMESPACE::DeviceCreateInfo const &createInfo, |
| VULKAN_HPP_NAMESPACE::Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator = nullptr) |
| : m_allocator(static_cast<const VULKAN_HPP_NAMESPACE::AllocationCallbacks *>(allocator)) |
| { |
| VULKAN_HPP_NAMESPACE::Result result = static_cast<VULKAN_HPP_NAMESPACE::Result>( |
| physicalDevice.getDispatcher()->vkCreateDevice(static_cast<VkPhysicalDevice>(*physicalDevice), |
| reinterpret_cast<const VkDeviceCreateInfo *>(&createInfo), |
| reinterpret_cast<const VkAllocationCallbacks *>(m_allocator), |
| reinterpret_cast<VkDevice *>(&m_device))); |
| if(result != VULKAN_HPP_NAMESPACE::Result::eSuccess) |
| { |
| throwResultException(result, "vkCreateDevice"); |
| } |
| m_dispatcher.reset(new VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::DeviceDispatcher(physicalDevice.getDispatcher()->vkGetDeviceProcAddr, |
| static_cast<VkDevice>(m_device))); |
| } |
| |
| Device(VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::PhysicalDevice const &physicalDevice, |
| VkDevice device, |
| VULKAN_HPP_NAMESPACE::Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator = nullptr) |
| : m_device(device) |
| , m_allocator(static_cast<const VULKAN_HPP_NAMESPACE::AllocationCallbacks *>(allocator)) |
| { |
| m_dispatcher.reset(new VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::DeviceDispatcher(physicalDevice.getDispatcher()->vkGetDeviceProcAddr, |
| static_cast<VkDevice>(m_device))); |
| } |
| |
| Device(std::nullptr_t) {} |
| |
| ~Device() |
| { |
| clear(); |
| } |
| |
| Device() = delete; |
| Device(Device const &) = delete; |
| Device(Device &&rhs) VULKAN_HPP_NOEXCEPT |
| : m_device(VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange(rhs.m_device, {})), |
| m_allocator(VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange(rhs.m_allocator, {})), |
| m_dispatcher(rhs.m_dispatcher.release()) |
| { |
| } |
| Device &operator=(Device const &) = delete; |
| Device &operator=(Device &&rhs) VULKAN_HPP_NOEXCEPT |
| { |
| if(this != &rhs) |
| { |
| clear(); |
| m_device = VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange(rhs.m_device, {}); |
| m_allocator = VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange(rhs.m_allocator, {}); |
| m_dispatcher.reset(rhs.m_dispatcher.release()); |
| } |
| return *this; |
| } |
| |
| VULKAN_HPP_NAMESPACE::Device const &operator*() const VULKAN_HPP_NOEXCEPT |
| { |
| return m_device; |
| } |
| |
| void clear() VULKAN_HPP_NOEXCEPT |
| { |
| if(m_device) |
| { |
| getDispatcher()->vkDestroyDevice(static_cast<VkDevice>(m_device), reinterpret_cast<const VkAllocationCallbacks *>(m_allocator)); |
| } |
| m_device = nullptr; |
| m_allocator = nullptr; |
| m_dispatcher = nullptr; |
| } |
| |
| VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::DeviceDispatcher const *getDispatcher() const |
| { |
| VULKAN_HPP_ASSERT(m_dispatcher->getVkHeaderVersion() == VK_HEADER_VERSION); |
| return &*m_dispatcher; |
| } |
| |
| void swap(VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::Device &rhs) VULKAN_HPP_NOEXCEPT |
| { |
| std::swap(m_device, rhs.m_device); |
| std::swap(m_allocator, rhs.m_allocator); |
| std::swap(m_dispatcher, rhs.m_dispatcher); |
| } |
| |
| //=== VK_VERSION_1_0 === |
| |
| VULKAN_HPP_NODISCARD PFN_vkVoidFunction getProcAddr(const std::string &name) const VULKAN_HPP_NOEXCEPT; |
| |
| VULKAN_HPP_NODISCARD VULKAN_HPP_RAII_NAMESPACE::Queue getQueue(uint32_t queueFamilyIndex, uint32_t queueIndex) const; |
| |
| void waitIdle() const; |
| |
| VULKAN_HPP_NODISCARD VULKAN_HPP_RAII_NAMESPACE::DeviceMemory |
| allocateMemory(VULKAN_HPP_NAMESPACE::MemoryAllocateInfo const &allocateInfo, |
| VULKAN_HPP_NAMESPACE::Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator = nullptr) const; |
| |
| void flushMappedMemoryRanges(ArrayProxy<const VULKAN_HPP_NAMESPACE::MappedMemoryRange> const &memoryRanges) const; |
| |
| void invalidateMappedMemoryRanges(ArrayProxy<const VULKAN_HPP_NAMESPACE::MappedMemoryRange> const &memoryRanges) const; |
| |
| VULKAN_HPP_NODISCARD VULKAN_HPP_RAII_NAMESPACE::Fence |
| createFence(VULKAN_HPP_NAMESPACE::FenceCreateInfo const &createInfo, |
| VULKAN_HPP_NAMESPACE::Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator = nullptr) const; |
| |
| void resetFences(ArrayProxy<const VULKAN_HPP_NAMESPACE::Fence> const &fences) const; |
| |
| VULKAN_HPP_NODISCARD VULKAN_HPP_NAMESPACE::Result |
| waitForFences(ArrayProxy<const VULKAN_HPP_NAMESPACE::Fence> const &fences, VULKAN_HPP_NAMESPACE::Bool32 waitAll, uint64_t timeout) const; |
| |
| VULKAN_HPP_NODISCARD VULKAN_HPP_RAII_NAMESPACE::Semaphore |
| createSemaphore(VULKAN_HPP_NAMESPACE::SemaphoreCreateInfo const &createInfo, |
| VULKAN_HPP_NAMESPACE::Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator = nullptr) const; |
| |
| VULKAN_HPP_NODISCARD VULKAN_HPP_RAII_NAMESPACE::Event |
| createEvent(VULKAN_HPP_NAMESPACE::EventCreateInfo const &createInfo, |
| VULKAN_HPP_NAMESPACE::Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator = nullptr) const; |
| |
| VULKAN_HPP_NODISCARD VULKAN_HPP_RAII_NAMESPACE::QueryPool |
| createQueryPool(VULKAN_HPP_NAMESPACE::QueryPoolCreateInfo const &createInfo, |
| VULKAN_HPP_NAMESPACE::Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator = nullptr) const; |
| |
| VULKAN_HPP_NODISCARD VULKAN_HPP_RAII_NAMESPACE::Buffer |
| createBuffer(VULKAN_HPP_NAMESPACE::BufferCreateInfo const &createInfo, |
| VULKAN_HPP_NAMESPACE::Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator = nullptr) const; |
| |
| VULKAN_HPP_NODISCARD VULKAN_HPP_RAII_NAMESPACE::BufferView |
| createBufferView(VULKAN_HPP_NAMESPACE::BufferViewCreateInfo const &createInfo, |
| VULKAN_HPP_NAMESPACE::Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator = nullptr) const; |
| |
| VULKAN_HPP_NODISCARD VULKAN_HPP_RAII_NAMESPACE::Image |
| createImage(VULKAN_HPP_NAMESPACE::ImageCreateInfo const &createInfo, |
| VULKAN_HPP_NAMESPACE::Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator = nullptr) const; |
| |
| VULKAN_HPP_NODISCARD VULKAN_HPP_RAII_NAMESPACE::ImageView |
| createImageView(VULKAN_HPP_NAMESPACE::ImageViewCreateInfo const &createInfo, |
| VULKAN_HPP_NAMESPACE::Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator = nullptr) const; |
| |
| VULKAN_HPP_NODISCARD VULKAN_HPP_RAII_NAMESPACE::ShaderModule |
| createShaderModule(VULKAN_HPP_NAMESPACE::ShaderModuleCreateInfo const &createInfo, |
| VULKAN_HPP_NAMESPACE::Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator = nullptr) const; |
| |
| VULKAN_HPP_NODISCARD VULKAN_HPP_RAII_NAMESPACE::PipelineCache |
| createPipelineCache(VULKAN_HPP_NAMESPACE::PipelineCacheCreateInfo const &createInfo, |
| VULKAN_HPP_NAMESPACE::Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator = nullptr) const; |
| |
| VULKAN_HPP_NODISCARD std::vector<VULKAN_HPP_RAII_NAMESPACE::Pipeline> |
| createGraphicsPipelines(VULKAN_HPP_NAMESPACE::Optional<const VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::PipelineCache> const &pipelineCache, |
| VULKAN_HPP_NAMESPACE::ArrayProxy<VULKAN_HPP_NAMESPACE::GraphicsPipelineCreateInfo> const &createInfos, |
| VULKAN_HPP_NAMESPACE::Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator = nullptr) const; |
| |
| VULKAN_HPP_NODISCARD VULKAN_HPP_RAII_NAMESPACE::Pipeline |
| createGraphicsPipeline(VULKAN_HPP_NAMESPACE::Optional<const VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::PipelineCache> const &pipelineCache, |
| VULKAN_HPP_NAMESPACE::GraphicsPipelineCreateInfo const &createInfo, |
| VULKAN_HPP_NAMESPACE::Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator = nullptr) const; |
| |
| VULKAN_HPP_NODISCARD std::vector<VULKAN_HPP_RAII_NAMESPACE::Pipeline> |
| createComputePipelines(VULKAN_HPP_NAMESPACE::Optional<const VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::PipelineCache> const &pipelineCache, |
| VULKAN_HPP_NAMESPACE::ArrayProxy<VULKAN_HPP_NAMESPACE::ComputePipelineCreateInfo> const &createInfos, |
| VULKAN_HPP_NAMESPACE::Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator = nullptr) const; |
| |
| VULKAN_HPP_NODISCARD VULKAN_HPP_RAII_NAMESPACE::Pipeline |
| createComputePipeline(VULKAN_HPP_NAMESPACE::Optional<const VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::PipelineCache> const &pipelineCache, |
| VULKAN_HPP_NAMESPACE::ComputePipelineCreateInfo const &createInfo, |
| VULKAN_HPP_NAMESPACE::Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator = nullptr) const; |
| |
| VULKAN_HPP_NODISCARD VULKAN_HPP_RAII_NAMESPACE::PipelineLayout |
| createPipelineLayout(VULKAN_HPP_NAMESPACE::PipelineLayoutCreateInfo const &createInfo, |
| VULKAN_HPP_NAMESPACE::Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator = nullptr) const; |
| |
| VULKAN_HPP_NODISCARD VULKAN_HPP_RAII_NAMESPACE::Sampler |
| createSampler(VULKAN_HPP_NAMESPACE::SamplerCreateInfo const &createInfo, |
| VULKAN_HPP_NAMESPACE::Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator = nullptr) const; |
| |
| VULKAN_HPP_NODISCARD VULKAN_HPP_RAII_NAMESPACE::DescriptorSetLayout |
| createDescriptorSetLayout(VULKAN_HPP_NAMESPACE::DescriptorSetLayoutCreateInfo const &createInfo, |
| VULKAN_HPP_NAMESPACE::Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator = nullptr) const; |
| |
| VULKAN_HPP_NODISCARD VULKAN_HPP_RAII_NAMESPACE::DescriptorPool |
| createDescriptorPool(VULKAN_HPP_NAMESPACE::DescriptorPoolCreateInfo const &createInfo, |
| VULKAN_HPP_NAMESPACE::Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator = nullptr) const; |
| |
| VULKAN_HPP_NODISCARD std::vector<VULKAN_HPP_RAII_NAMESPACE::DescriptorSet> |
| allocateDescriptorSets(VULKAN_HPP_NAMESPACE::DescriptorSetAllocateInfo const &allocateInfo) const; |
| |
| void updateDescriptorSets(ArrayProxy<const VULKAN_HPP_NAMESPACE::WriteDescriptorSet> const &descriptorWrites, |
| ArrayProxy<const VULKAN_HPP_NAMESPACE::CopyDescriptorSet> const &descriptorCopies) const VULKAN_HPP_NOEXCEPT; |
| |
| VULKAN_HPP_NODISCARD VULKAN_HPP_RAII_NAMESPACE::Framebuffer |
| createFramebuffer(VULKAN_HPP_NAMESPACE::FramebufferCreateInfo const &createInfo, |
| VULKAN_HPP_NAMESPACE::Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator = nullptr) const; |
| |
| VULKAN_HPP_NODISCARD VULKAN_HPP_RAII_NAMESPACE::RenderPass |
| createRenderPass(VULKAN_HPP_NAMESPACE::RenderPassCreateInfo const &createInfo, |
| VULKAN_HPP_NAMESPACE::Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator = nullptr) const; |
| |
| VULKAN_HPP_NODISCARD VULKAN_HPP_RAII_NAMESPACE::CommandPool |
| createCommandPool(VULKAN_HPP_NAMESPACE::CommandPoolCreateInfo const &createInfo, |
| VULKAN_HPP_NAMESPACE::Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator = nullptr) const; |
| |
| VULKAN_HPP_NODISCARD std::vector<VULKAN_HPP_RAII_NAMESPACE::CommandBuffer> |
| allocateCommandBuffers(VULKAN_HPP_NAMESPACE::CommandBufferAllocateInfo const &allocateInfo) const; |
| |
| //=== VK_VERSION_1_1 === |
| |
| void bindBufferMemory2(ArrayProxy<const VULKAN_HPP_NAMESPACE::BindBufferMemoryInfo> const &bindInfos) const; |
| |
| void bindImageMemory2(ArrayProxy<const VULKAN_HPP_NAMESPACE::BindImageMemoryInfo> const &bindInfos) const; |
| |
| VULKAN_HPP_NODISCARD VULKAN_HPP_NAMESPACE::PeerMemoryFeatureFlags |
| getGroupPeerMemoryFeatures(uint32_t heapIndex, uint32_t localDeviceIndex, uint32_t remoteDeviceIndex) const VULKAN_HPP_NOEXCEPT; |
| |
| VULKAN_HPP_NODISCARD VULKAN_HPP_NAMESPACE::MemoryRequirements2 |
| getImageMemoryRequirements2(const VULKAN_HPP_NAMESPACE::ImageMemoryRequirementsInfo2 &info) const VULKAN_HPP_NOEXCEPT; |
| |
| template<typename X, typename Y, typename... Z> |
| VULKAN_HPP_NODISCARD StructureChain<X, Y, Z...> |
| getImageMemoryRequirements2(const VULKAN_HPP_NAMESPACE::ImageMemoryRequirementsInfo2 &info) const VULKAN_HPP_NOEXCEPT; |
| |
| VULKAN_HPP_NODISCARD VULKAN_HPP_NAMESPACE::MemoryRequirements2 |
| getBufferMemoryRequirements2(const VULKAN_HPP_NAMESPACE::BufferMemoryRequirementsInfo2 &info) const VULKAN_HPP_NOEXCEPT; |
| |
| template<typename X, typename Y, typename... Z> |
| VULKAN_HPP_NODISCARD StructureChain<X, Y, Z...> |
| getBufferMemoryRequirements2(const VULKAN_HPP_NAMESPACE::BufferMemoryRequirementsInfo2 &info) const VULKAN_HPP_NOEXCEPT; |
| |
| VULKAN_HPP_NODISCARD std::vector<VULKAN_HPP_NAMESPACE::SparseImageMemoryRequirements2> |
| getImageSparseMemoryRequirements2(const VULKAN_HPP_NAMESPACE::ImageSparseMemoryRequirementsInfo2 &info) const VULKAN_HPP_NOEXCEPT; |
| |
| VULKAN_HPP_NODISCARD VULKAN_HPP_RAII_NAMESPACE::Queue getQueue2(VULKAN_HPP_NAMESPACE::DeviceQueueInfo2 const &queueInfo) const; |
| |
| VULKAN_HPP_NODISCARD VULKAN_HPP_RAII_NAMESPACE::SamplerYcbcrConversion |
| createSamplerYcbcrConversion(VULKAN_HPP_NAMESPACE::SamplerYcbcrConversionCreateInfo const &createInfo, |
| VULKAN_HPP_NAMESPACE::Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator = nullptr) const; |
| |
| VULKAN_HPP_NODISCARD VULKAN_HPP_RAII_NAMESPACE::DescriptorUpdateTemplate |
| createDescriptorUpdateTemplate(VULKAN_HPP_NAMESPACE::DescriptorUpdateTemplateCreateInfo const &createInfo, |
| VULKAN_HPP_NAMESPACE::Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator = nullptr) const; |
| |
| VULKAN_HPP_NODISCARD VULKAN_HPP_NAMESPACE::DescriptorSetLayoutSupport |
| getDescriptorSetLayoutSupport(const VULKAN_HPP_NAMESPACE::DescriptorSetLayoutCreateInfo &createInfo) const VULKAN_HPP_NOEXCEPT; |
| |
| template<typename X, typename Y, typename... Z> |
| VULKAN_HPP_NODISCARD StructureChain<X, Y, Z...> |
| getDescriptorSetLayoutSupport(const VULKAN_HPP_NAMESPACE::DescriptorSetLayoutCreateInfo &createInfo) const VULKAN_HPP_NOEXCEPT; |
| |
| //=== VK_VERSION_1_2 === |
| |
| VULKAN_HPP_NODISCARD VULKAN_HPP_RAII_NAMESPACE::RenderPass |
| createRenderPass2(VULKAN_HPP_NAMESPACE::RenderPassCreateInfo2 const &createInfo, |
| VULKAN_HPP_NAMESPACE::Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator = nullptr) const; |
| |
| VULKAN_HPP_NODISCARD VULKAN_HPP_NAMESPACE::Result waitSemaphores(const VULKAN_HPP_NAMESPACE::SemaphoreWaitInfo &waitInfo, uint64_t timeout) const; |
| |
| void signalSemaphore(const VULKAN_HPP_NAMESPACE::SemaphoreSignalInfo &signalInfo) const; |
| |
| VULKAN_HPP_NODISCARD VULKAN_HPP_NAMESPACE::DeviceAddress |
| getBufferAddress(const VULKAN_HPP_NAMESPACE::BufferDeviceAddressInfo &info) const VULKAN_HPP_NOEXCEPT; |
| |
| VULKAN_HPP_NODISCARD uint64_t getBufferOpaqueCaptureAddress(const VULKAN_HPP_NAMESPACE::BufferDeviceAddressInfo &info) const VULKAN_HPP_NOEXCEPT; |
| |
| VULKAN_HPP_NODISCARD uint64_t |
| getMemoryOpaqueCaptureAddress(const VULKAN_HPP_NAMESPACE::DeviceMemoryOpaqueCaptureAddressInfo &info) const VULKAN_HPP_NOEXCEPT; |
| |
| //=== VK_VERSION_1_3 === |
| |
| VULKAN_HPP_NODISCARD VULKAN_HPP_RAII_NAMESPACE::PrivateDataSlot |
| createPrivateDataSlot(VULKAN_HPP_NAMESPACE::PrivateDataSlotCreateInfo const &createInfo, |
| VULKAN_HPP_NAMESPACE::Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator = nullptr) const; |
| |
| void setPrivateData(VULKAN_HPP_NAMESPACE::ObjectType objectType_, |
| uint64_t objectHandle, |
| VULKAN_HPP_NAMESPACE::PrivateDataSlot privateDataSlot, |
| uint64_t data) const; |
| |
| VULKAN_HPP_NODISCARD uint64_t getPrivateData(VULKAN_HPP_NAMESPACE::ObjectType objectType_, |
| uint64_t objectHandle, |
| VULKAN_HPP_NAMESPACE::PrivateDataSlot privateDataSlot) const VULKAN_HPP_NOEXCEPT; |
| |
| VULKAN_HPP_NODISCARD VULKAN_HPP_NAMESPACE::MemoryRequirements2 |
| getBufferMemoryRequirements(const VULKAN_HPP_NAMESPACE::DeviceBufferMemoryRequirements &info) const VULKAN_HPP_NOEXCEPT; |
| |
| template<typename X, typename Y, typename... Z> |
| VULKAN_HPP_NODISCARD StructureChain<X, Y, Z...> |
| getBufferMemoryRequirements(const VULKAN_HPP_NAMESPACE::DeviceBufferMemoryRequirements &info) const VULKAN_HPP_NOEXCEPT; |
| |
| VULKAN_HPP_NODISCARD VULKAN_HPP_NAMESPACE::MemoryRequirements2 |
| getImageMemoryRequirements(const VULKAN_HPP_NAMESPACE::DeviceImageMemoryRequirements &info) const VULKAN_HPP_NOEXCEPT; |
| |
| template<typename X, typename Y, typename... Z> |
| VULKAN_HPP_NODISCARD StructureChain<X, Y, Z...> |
| getImageMemoryRequirements(const VULKAN_HPP_NAMESPACE::DeviceImageMemoryRequirements &info) const VULKAN_HPP_NOEXCEPT; |
| |
| VULKAN_HPP_NODISCARD std::vector<VULKAN_HPP_NAMESPACE::SparseImageMemoryRequirements2> |
| getImageSparseMemoryRequirements(const VULKAN_HPP_NAMESPACE::DeviceImageMemoryRequirements &info) const VULKAN_HPP_NOEXCEPT; |
| |
| //=== VK_KHR_swapchain === |
| |
| VULKAN_HPP_NODISCARD VULKAN_HPP_RAII_NAMESPACE::SwapchainKHR |
| createSwapchainKHR(VULKAN_HPP_NAMESPACE::SwapchainCreateInfoKHR const &createInfo, |
| VULKAN_HPP_NAMESPACE::Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator = nullptr) const; |
| |
| VULKAN_HPP_NODISCARD VULKAN_HPP_NAMESPACE::DeviceGroupPresentCapabilitiesKHR getGroupPresentCapabilitiesKHR() const; |
| |
| VULKAN_HPP_NODISCARD VULKAN_HPP_NAMESPACE::DeviceGroupPresentModeFlagsKHR |
| getGroupSurfacePresentModesKHR(VULKAN_HPP_NAMESPACE::SurfaceKHR surface) const; |
| |
| VULKAN_HPP_NODISCARD std::pair<VULKAN_HPP_NAMESPACE::Result, uint32_t> |
| acquireNextImage2KHR(const VULKAN_HPP_NAMESPACE::AcquireNextImageInfoKHR &acquireInfo) const; |
| |
| //=== VK_KHR_display_swapchain === |
| |
| VULKAN_HPP_NODISCARD std::vector<VULKAN_HPP_RAII_NAMESPACE::SwapchainKHR> |
| createSharedSwapchainsKHR(VULKAN_HPP_NAMESPACE::ArrayProxy<VULKAN_HPP_NAMESPACE::SwapchainCreateInfoKHR> const &createInfos, |
| VULKAN_HPP_NAMESPACE::Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator = nullptr) const; |
| |
| VULKAN_HPP_NODISCARD VULKAN_HPP_RAII_NAMESPACE::SwapchainKHR |
| createSharedSwapchainKHR(VULKAN_HPP_NAMESPACE::SwapchainCreateInfoKHR const &createInfo, |
| VULKAN_HPP_NAMESPACE::Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator = nullptr) const; |
| |
| //=== VK_EXT_debug_marker === |
| |
| void debugMarkerSetObjectTagEXT(const VULKAN_HPP_NAMESPACE::DebugMarkerObjectTagInfoEXT &tagInfo) const; |
| |
| void debugMarkerSetObjectNameEXT(const VULKAN_HPP_NAMESPACE::DebugMarkerObjectNameInfoEXT &nameInfo) const; |
| |
| # if defined(VK_ENABLE_BETA_EXTENSIONS) |
| //=== VK_KHR_video_queue === |
| |
| VULKAN_HPP_NODISCARD VULKAN_HPP_RAII_NAMESPACE::VideoSessionKHR |
| createVideoSessionKHR(VULKAN_HPP_NAMESPACE::VideoSessionCreateInfoKHR const &createInfo, |
| VULKAN_HPP_NAMESPACE::Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator = nullptr) const; |
| |
| VULKAN_HPP_NODISCARD VULKAN_HPP_RAII_NAMESPACE::VideoSessionParametersKHR |
| createVideoSessionParametersKHR(VULKAN_HPP_NAMESPACE::VideoSessionParametersCreateInfoKHR const &createInfo, |
| VULKAN_HPP_NAMESPACE::Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator = nullptr) const; |
| # endif /*VK_ENABLE_BETA_EXTENSIONS*/ |
| |
| //=== VK_NVX_binary_import === |
| |
| VULKAN_HPP_NODISCARD VULKAN_HPP_RAII_NAMESPACE::CuModuleNVX |
| createCuModuleNVX(VULKAN_HPP_NAMESPACE::CuModuleCreateInfoNVX const &createInfo, |
| VULKAN_HPP_NAMESPACE::Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator = nullptr) const; |
| |
| VULKAN_HPP_NODISCARD VULKAN_HPP_RAII_NAMESPACE::CuFunctionNVX |
| createCuFunctionNVX(VULKAN_HPP_NAMESPACE::CuFunctionCreateInfoNVX const &createInfo, |
| VULKAN_HPP_NAMESPACE::Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator = nullptr) const; |
| |
| //=== VK_NVX_image_view_handle === |
| |
| VULKAN_HPP_NODISCARD uint32_t getImageViewHandleNVX(const VULKAN_HPP_NAMESPACE::ImageViewHandleInfoNVX &info) const VULKAN_HPP_NOEXCEPT; |
| |
| //=== VK_KHR_device_group === |
| |
| VULKAN_HPP_NODISCARD VULKAN_HPP_NAMESPACE::PeerMemoryFeatureFlags |
| getGroupPeerMemoryFeaturesKHR(uint32_t heapIndex, uint32_t localDeviceIndex, uint32_t remoteDeviceIndex) const VULKAN_HPP_NOEXCEPT; |
| |
| # if defined(VK_USE_PLATFORM_WIN32_KHR) |
| //=== VK_KHR_external_memory_win32 === |
| |
| VULKAN_HPP_NODISCARD HANDLE getMemoryWin32HandleKHR(const VULKAN_HPP_NAMESPACE::MemoryGetWin32HandleInfoKHR &getWin32HandleInfo) const; |
| |
| VULKAN_HPP_NODISCARD VULKAN_HPP_NAMESPACE::MemoryWin32HandlePropertiesKHR |
| getMemoryWin32HandlePropertiesKHR(VULKAN_HPP_NAMESPACE::ExternalMemoryHandleTypeFlagBits handleType, HANDLE handle) const; |
| # endif /*VK_USE_PLATFORM_WIN32_KHR*/ |
| |
| //=== VK_KHR_external_memory_fd === |
| |
| VULKAN_HPP_NODISCARD int getMemoryFdKHR(const VULKAN_HPP_NAMESPACE::MemoryGetFdInfoKHR &getFdInfo) const; |
| |
| VULKAN_HPP_NODISCARD VULKAN_HPP_NAMESPACE::MemoryFdPropertiesKHR |
| getMemoryFdPropertiesKHR(VULKAN_HPP_NAMESPACE::ExternalMemoryHandleTypeFlagBits handleType, int fd) const; |
| |
| # if defined(VK_USE_PLATFORM_WIN32_KHR) |
| //=== VK_KHR_external_semaphore_win32 === |
| |
| void importSemaphoreWin32HandleKHR(const VULKAN_HPP_NAMESPACE::ImportSemaphoreWin32HandleInfoKHR &importSemaphoreWin32HandleInfo) const; |
| |
| VULKAN_HPP_NODISCARD HANDLE getSemaphoreWin32HandleKHR(const VULKAN_HPP_NAMESPACE::SemaphoreGetWin32HandleInfoKHR &getWin32HandleInfo) const; |
| # endif /*VK_USE_PLATFORM_WIN32_KHR*/ |
| |
| //=== VK_KHR_external_semaphore_fd === |
| |
| void importSemaphoreFdKHR(const VULKAN_HPP_NAMESPACE::ImportSemaphoreFdInfoKHR &importSemaphoreFdInfo) const; |
| |
| VULKAN_HPP_NODISCARD int getSemaphoreFdKHR(const VULKAN_HPP_NAMESPACE::SemaphoreGetFdInfoKHR &getFdInfo) const; |
| |
| //=== VK_KHR_descriptor_update_template === |
| |
| VULKAN_HPP_NODISCARD VULKAN_HPP_RAII_NAMESPACE::DescriptorUpdateTemplate |
| createDescriptorUpdateTemplateKHR(VULKAN_HPP_NAMESPACE::DescriptorUpdateTemplateCreateInfo const &createInfo, |
| VULKAN_HPP_NAMESPACE::Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator = nullptr) const; |
| |
| void destroyDescriptorUpdateTemplateKHR(VULKAN_HPP_NAMESPACE::DescriptorUpdateTemplate descriptorUpdateTemplate VULKAN_HPP_DEFAULT_ARGUMENT_ASSIGNMENT, |
| Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator |
| VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT; |
| |
| //=== VK_EXT_display_control === |
| |
| void displayPowerControlEXT(VULKAN_HPP_NAMESPACE::DisplayKHR display, const VULKAN_HPP_NAMESPACE::DisplayPowerInfoEXT &displayPowerInfo) const; |
| |
| VULKAN_HPP_NODISCARD VULKAN_HPP_RAII_NAMESPACE::Fence |
| registerEventEXT(VULKAN_HPP_NAMESPACE::DeviceEventInfoEXT const &deviceEventInfo, |
| VULKAN_HPP_NAMESPACE::Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator = nullptr) const; |
| |
| VULKAN_HPP_NODISCARD VULKAN_HPP_RAII_NAMESPACE::Fence |
| registerDisplayEventEXT(VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::DisplayKHR const &display, |
| VULKAN_HPP_NAMESPACE::DisplayEventInfoEXT const &displayEventInfo, |
| VULKAN_HPP_NAMESPACE::Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator = nullptr) const; |
| |
| //=== VK_EXT_hdr_metadata === |
| |
| void setHdrMetadataEXT(ArrayProxy<const VULKAN_HPP_NAMESPACE::SwapchainKHR> const &swapchains, |
| ArrayProxy<const VULKAN_HPP_NAMESPACE::HdrMetadataEXT> const &metadata) const; |
| |
| //=== VK_KHR_create_renderpass2 === |
| |
| VULKAN_HPP_NODISCARD VULKAN_HPP_RAII_NAMESPACE::RenderPass |
| createRenderPass2KHR(VULKAN_HPP_NAMESPACE::RenderPassCreateInfo2 const &createInfo, |
| VULKAN_HPP_NAMESPACE::Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator = nullptr) const; |
| |
| # if defined(VK_USE_PLATFORM_WIN32_KHR) |
| //=== VK_KHR_external_fence_win32 === |
| |
| void importFenceWin32HandleKHR(const VULKAN_HPP_NAMESPACE::ImportFenceWin32HandleInfoKHR &importFenceWin32HandleInfo) const; |
| |
| VULKAN_HPP_NODISCARD HANDLE getFenceWin32HandleKHR(const VULKAN_HPP_NAMESPACE::FenceGetWin32HandleInfoKHR &getWin32HandleInfo) const; |
| # endif /*VK_USE_PLATFORM_WIN32_KHR*/ |
| |
| //=== VK_KHR_external_fence_fd === |
| |
| void importFenceFdKHR(const VULKAN_HPP_NAMESPACE::ImportFenceFdInfoKHR &importFenceFdInfo) const; |
| |
| VULKAN_HPP_NODISCARD int getFenceFdKHR(const VULKAN_HPP_NAMESPACE::FenceGetFdInfoKHR &getFdInfo) const; |
| |
| //=== VK_KHR_performance_query === |
| |
| void acquireProfilingLockKHR(const VULKAN_HPP_NAMESPACE::AcquireProfilingLockInfoKHR &info) const; |
| |
| void releaseProfilingLockKHR() const VULKAN_HPP_NOEXCEPT; |
| |
| //=== VK_EXT_debug_utils === |
| |
| void setDebugUtilsObjectNameEXT(const VULKAN_HPP_NAMESPACE::DebugUtilsObjectNameInfoEXT &nameInfo) const; |
| |
| void setDebugUtilsObjectTagEXT(const VULKAN_HPP_NAMESPACE::DebugUtilsObjectTagInfoEXT &tagInfo) const; |
| |
| # if defined(VK_USE_PLATFORM_ANDROID_KHR) |
| //=== VK_ANDROID_external_memory_android_hardware_buffer === |
| |
| VULKAN_HPP_NODISCARD VULKAN_HPP_NAMESPACE::AndroidHardwareBufferPropertiesANDROID |
| getAndroidHardwareBufferPropertiesANDROID(const struct AHardwareBuffer &buffer) const; |
| |
| template<typename X, typename Y, typename... Z> |
| VULKAN_HPP_NODISCARD StructureChain<X, Y, Z...> getAndroidHardwareBufferPropertiesANDROID(const struct AHardwareBuffer &buffer) const; |
| |
| VULKAN_HPP_NODISCARD struct AHardwareBuffer * |
| getMemoryAndroidHardwareBufferANDROID(const VULKAN_HPP_NAMESPACE::MemoryGetAndroidHardwareBufferInfoANDROID &info) const; |
| # endif /*VK_USE_PLATFORM_ANDROID_KHR*/ |
| |
| //=== VK_KHR_get_memory_requirements2 === |
| |
| VULKAN_HPP_NODISCARD VULKAN_HPP_NAMESPACE::MemoryRequirements2 |
| getImageMemoryRequirements2KHR(const VULKAN_HPP_NAMESPACE::ImageMemoryRequirementsInfo2 &info) const VULKAN_HPP_NOEXCEPT; |
| |
| template<typename X, typename Y, typename... Z> |
| VULKAN_HPP_NODISCARD StructureChain<X, Y, Z...> |
| getImageMemoryRequirements2KHR(const VULKAN_HPP_NAMESPACE::ImageMemoryRequirementsInfo2 &info) const VULKAN_HPP_NOEXCEPT; |
| |
| VULKAN_HPP_NODISCARD VULKAN_HPP_NAMESPACE::MemoryRequirements2 |
| getBufferMemoryRequirements2KHR(const VULKAN_HPP_NAMESPACE::BufferMemoryRequirementsInfo2 &info) const VULKAN_HPP_NOEXCEPT; |
| |
| template<typename X, typename Y, typename... Z> |
| VULKAN_HPP_NODISCARD StructureChain<X, Y, Z...> |
| getBufferMemoryRequirements2KHR(const VULKAN_HPP_NAMESPACE::BufferMemoryRequirementsInfo2 &info) const VULKAN_HPP_NOEXCEPT; |
| |
| VULKAN_HPP_NODISCARD std::vector<VULKAN_HPP_NAMESPACE::SparseImageMemoryRequirements2> |
| getImageSparseMemoryRequirements2KHR(const VULKAN_HPP_NAMESPACE::ImageSparseMemoryRequirementsInfo2 &info) const VULKAN_HPP_NOEXCEPT; |
| |
| //=== VK_KHR_acceleration_structure === |
| |
| VULKAN_HPP_NODISCARD VULKAN_HPP_RAII_NAMESPACE::AccelerationStructureKHR |
| createAccelerationStructureKHR(VULKAN_HPP_NAMESPACE::AccelerationStructureCreateInfoKHR const &createInfo, |
| VULKAN_HPP_NAMESPACE::Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator = nullptr) const; |
| |
| VULKAN_HPP_NODISCARD VULKAN_HPP_NAMESPACE::Result |
| buildAccelerationStructuresKHR(VULKAN_HPP_NAMESPACE::DeferredOperationKHR deferredOperation, |
| ArrayProxy<const VULKAN_HPP_NAMESPACE::AccelerationStructureBuildGeometryInfoKHR> const &infos, |
| ArrayProxy<const VULKAN_HPP_NAMESPACE::AccelerationStructureBuildRangeInfoKHR *const> const &pBuildRangeInfos) const; |
| |
| VULKAN_HPP_NODISCARD VULKAN_HPP_NAMESPACE::Result |
| copyAccelerationStructureKHR(VULKAN_HPP_NAMESPACE::DeferredOperationKHR deferredOperation, |
| const VULKAN_HPP_NAMESPACE::CopyAccelerationStructureInfoKHR &info) const; |
| |
| VULKAN_HPP_NODISCARD VULKAN_HPP_NAMESPACE::Result |
| copyAccelerationStructureToMemoryKHR(VULKAN_HPP_NAMESPACE::DeferredOperationKHR deferredOperation, |
| const VULKAN_HPP_NAMESPACE::CopyAccelerationStructureToMemoryInfoKHR &info) const; |
| |
| VULKAN_HPP_NODISCARD VULKAN_HPP_NAMESPACE::Result |
| copyMemoryToAccelerationStructureKHR(VULKAN_HPP_NAMESPACE::DeferredOperationKHR deferredOperation, |
| const VULKAN_HPP_NAMESPACE::CopyMemoryToAccelerationStructureInfoKHR &info) const; |
| |
| template<typename DataType> |
| VULKAN_HPP_NODISCARD std::vector<DataType> |
| writeAccelerationStructuresPropertiesKHR(ArrayProxy<const VULKAN_HPP_NAMESPACE::AccelerationStructureKHR> const &accelerationStructures, |
| VULKAN_HPP_NAMESPACE::QueryType queryType, |
| size_t dataSize, |
| size_t stride) const; |
| |
| template<typename DataType> |
| VULKAN_HPP_NODISCARD DataType |
| writeAccelerationStructuresPropertyKHR(ArrayProxy<const VULKAN_HPP_NAMESPACE::AccelerationStructureKHR> const &accelerationStructures, |
| VULKAN_HPP_NAMESPACE::QueryType queryType, |
| size_t stride) const; |
| |
| VULKAN_HPP_NODISCARD VULKAN_HPP_NAMESPACE::DeviceAddress |
| getAccelerationStructureAddressKHR(const VULKAN_HPP_NAMESPACE::AccelerationStructureDeviceAddressInfoKHR &info) const VULKAN_HPP_NOEXCEPT; |
| |
| VULKAN_HPP_NODISCARD VULKAN_HPP_NAMESPACE::AccelerationStructureCompatibilityKHR |
| getAccelerationStructureCompatibilityKHR(const VULKAN_HPP_NAMESPACE::AccelerationStructureVersionInfoKHR &versionInfo) const VULKAN_HPP_NOEXCEPT; |
| |
| VULKAN_HPP_NODISCARD VULKAN_HPP_NAMESPACE::AccelerationStructureBuildSizesInfoKHR |
| getAccelerationStructureBuildSizesKHR(VULKAN_HPP_NAMESPACE::AccelerationStructureBuildTypeKHR buildType, |
| const VULKAN_HPP_NAMESPACE::AccelerationStructureBuildGeometryInfoKHR &buildInfo, |
| ArrayProxy<const uint32_t> const &maxPrimitiveCounts VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT) const; |
| |
| //=== VK_KHR_sampler_ycbcr_conversion === |
| |
| VULKAN_HPP_NODISCARD VULKAN_HPP_RAII_NAMESPACE::SamplerYcbcrConversion |
| createSamplerYcbcrConversionKHR(VULKAN_HPP_NAMESPACE::SamplerYcbcrConversionCreateInfo const &createInfo, |
| VULKAN_HPP_NAMESPACE::Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator = nullptr) const; |
| |
| void destroySamplerYcbcrConversionKHR(VULKAN_HPP_NAMESPACE::SamplerYcbcrConversion ycbcrConversion VULKAN_HPP_DEFAULT_ARGUMENT_ASSIGNMENT, |
| Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator |
| VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT; |
| |
| //=== VK_KHR_bind_memory2 === |
| |
| void bindBufferMemory2KHR(ArrayProxy<const VULKAN_HPP_NAMESPACE::BindBufferMemoryInfo> const &bindInfos) const; |
| |
| void bindImageMemory2KHR(ArrayProxy<const VULKAN_HPP_NAMESPACE::BindImageMemoryInfo> const &bindInfos) const; |
| |
| //=== VK_EXT_validation_cache === |
| |
| VULKAN_HPP_NODISCARD VULKAN_HPP_RAII_NAMESPACE::ValidationCacheEXT |
| createValidationCacheEXT(VULKAN_HPP_NAMESPACE::ValidationCacheCreateInfoEXT const &createInfo, |
| VULKAN_HPP_NAMESPACE::Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator = nullptr) const; |
| |
| //=== VK_NV_ray_tracing === |
| |
| VULKAN_HPP_NODISCARD VULKAN_HPP_RAII_NAMESPACE::AccelerationStructureNV |
| createAccelerationStructureNV(VULKAN_HPP_NAMESPACE::AccelerationStructureCreateInfoNV const &createInfo, |
| VULKAN_HPP_NAMESPACE::Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator = nullptr) const; |
| |
| VULKAN_HPP_NODISCARD VULKAN_HPP_NAMESPACE::MemoryRequirements2KHR getAccelerationStructureMemoryRequirementsNV( |
| const VULKAN_HPP_NAMESPACE::AccelerationStructureMemoryRequirementsInfoNV &info) const VULKAN_HPP_NOEXCEPT; |
| |
| template<typename X, typename Y, typename... Z> |
| VULKAN_HPP_NODISCARD StructureChain<X, Y, Z...> getAccelerationStructureMemoryRequirementsNV( |
| const VULKAN_HPP_NAMESPACE::AccelerationStructureMemoryRequirementsInfoNV &info) const VULKAN_HPP_NOEXCEPT; |
| |
| void bindAccelerationStructureMemoryNV(ArrayProxy<const VULKAN_HPP_NAMESPACE::BindAccelerationStructureMemoryInfoNV> const &bindInfos) const; |
| |
| VULKAN_HPP_NODISCARD std::vector<VULKAN_HPP_RAII_NAMESPACE::Pipeline> |
| createRayTracingPipelinesNV(VULKAN_HPP_NAMESPACE::Optional<const VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::PipelineCache> const &pipelineCache, |
| VULKAN_HPP_NAMESPACE::ArrayProxy<VULKAN_HPP_NAMESPACE::RayTracingPipelineCreateInfoNV> const &createInfos, |
| VULKAN_HPP_NAMESPACE::Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator = nullptr) const; |
| |
| VULKAN_HPP_NODISCARD VULKAN_HPP_RAII_NAMESPACE::Pipeline |
| createRayTracingPipelineNV(VULKAN_HPP_NAMESPACE::Optional<const VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::PipelineCache> const &pipelineCache, |
| VULKAN_HPP_NAMESPACE::RayTracingPipelineCreateInfoNV const &createInfo, |
| VULKAN_HPP_NAMESPACE::Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator = nullptr) const; |
| |
| //=== VK_KHR_maintenance3 === |
| |
| VULKAN_HPP_NODISCARD VULKAN_HPP_NAMESPACE::DescriptorSetLayoutSupport |
| getDescriptorSetLayoutSupportKHR(const VULKAN_HPP_NAMESPACE::DescriptorSetLayoutCreateInfo &createInfo) const VULKAN_HPP_NOEXCEPT; |
| |
| template<typename X, typename Y, typename... Z> |
| VULKAN_HPP_NODISCARD StructureChain<X, Y, Z...> |
| getDescriptorSetLayoutSupportKHR(const VULKAN_HPP_NAMESPACE::DescriptorSetLayoutCreateInfo &createInfo) const VULKAN_HPP_NOEXCEPT; |
| |
| //=== VK_EXT_external_memory_host === |
| |
| VULKAN_HPP_NODISCARD VULKAN_HPP_NAMESPACE::MemoryHostPointerPropertiesEXT |
| getMemoryHostPointerPropertiesEXT(VULKAN_HPP_NAMESPACE::ExternalMemoryHandleTypeFlagBits handleType, const void *pHostPointer) const; |
| |
| //=== VK_EXT_calibrated_timestamps === |
| |
| VULKAN_HPP_NODISCARD std::pair<std::vector<uint64_t>, uint64_t> |
| getCalibratedTimestampsEXT(ArrayProxy<const VULKAN_HPP_NAMESPACE::CalibratedTimestampInfoEXT> const ×tampInfos) const; |
| |
| VULKAN_HPP_NODISCARD std::pair<uint64_t, uint64_t> |
| getCalibratedTimestampEXT(const VULKAN_HPP_NAMESPACE::CalibratedTimestampInfoEXT ×tampInfo) const; |
| |
| //=== VK_KHR_timeline_semaphore === |
| |
| VULKAN_HPP_NODISCARD VULKAN_HPP_NAMESPACE::Result waitSemaphoresKHR(const VULKAN_HPP_NAMESPACE::SemaphoreWaitInfo &waitInfo, uint64_t timeout) const; |
| |
| void signalSemaphoreKHR(const VULKAN_HPP_NAMESPACE::SemaphoreSignalInfo &signalInfo) const; |
| |
| //=== VK_INTEL_performance_query === |
| |
| void initializePerformanceApiINTEL(const VULKAN_HPP_NAMESPACE::InitializePerformanceApiInfoINTEL &initializeInfo) const; |
| |
| void uninitializePerformanceApiINTEL() const VULKAN_HPP_NOEXCEPT; |
| |
| VULKAN_HPP_NODISCARD VULKAN_HPP_RAII_NAMESPACE::PerformanceConfigurationINTEL |
| acquirePerformanceConfigurationINTEL(VULKAN_HPP_NAMESPACE::PerformanceConfigurationAcquireInfoINTEL const &acquireInfo) const; |
| |
| VULKAN_HPP_NODISCARD VULKAN_HPP_NAMESPACE::PerformanceValueINTEL |
| getPerformanceParameterINTEL(VULKAN_HPP_NAMESPACE::PerformanceParameterTypeINTEL parameter) const; |
| |
| //=== VK_EXT_buffer_device_address === |
| |
| VULKAN_HPP_NODISCARD VULKAN_HPP_NAMESPACE::DeviceAddress |
| getBufferAddressEXT(const VULKAN_HPP_NAMESPACE::BufferDeviceAddressInfo &info) const VULKAN_HPP_NOEXCEPT; |
| |
| # if defined(VK_USE_PLATFORM_WIN32_KHR) |
| //=== VK_EXT_full_screen_exclusive === |
| |
| VULKAN_HPP_NODISCARD VULKAN_HPP_NAMESPACE::DeviceGroupPresentModeFlagsKHR |
| getGroupSurfacePresentModes2EXT(const VULKAN_HPP_NAMESPACE::PhysicalDeviceSurfaceInfo2KHR &surfaceInfo) const; |
| # endif /*VK_USE_PLATFORM_WIN32_KHR*/ |
| |
| //=== VK_KHR_buffer_device_address === |
| |
| VULKAN_HPP_NODISCARD VULKAN_HPP_NAMESPACE::DeviceAddress |
| getBufferAddressKHR(const VULKAN_HPP_NAMESPACE::BufferDeviceAddressInfo &info) const VULKAN_HPP_NOEXCEPT; |
| |
| VULKAN_HPP_NODISCARD uint64_t getBufferOpaqueCaptureAddressKHR(const VULKAN_HPP_NAMESPACE::BufferDeviceAddressInfo &info) const VULKAN_HPP_NOEXCEPT; |
| |
| VULKAN_HPP_NODISCARD uint64_t |
| getMemoryOpaqueCaptureAddressKHR(const VULKAN_HPP_NAMESPACE::DeviceMemoryOpaqueCaptureAddressInfo &info) const VULKAN_HPP_NOEXCEPT; |
| |
| //=== VK_KHR_deferred_host_operations === |
| |
| VULKAN_HPP_NODISCARD VULKAN_HPP_RAII_NAMESPACE::DeferredOperationKHR |
| createDeferredOperationKHR(VULKAN_HPP_NAMESPACE::Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator = nullptr) const; |
| |
| //=== VK_KHR_pipeline_executable_properties === |
| |
| VULKAN_HPP_NODISCARD std::vector<VULKAN_HPP_NAMESPACE::PipelineExecutablePropertiesKHR> |
| getPipelineExecutablePropertiesKHR(const VULKAN_HPP_NAMESPACE::PipelineInfoKHR &pipelineInfo) const; |
| |
| VULKAN_HPP_NODISCARD std::vector<VULKAN_HPP_NAMESPACE::PipelineExecutableStatisticKHR> |
| getPipelineExecutableStatisticsKHR(const VULKAN_HPP_NAMESPACE::PipelineExecutableInfoKHR &executableInfo) const; |
| |
| VULKAN_HPP_NODISCARD std::vector<VULKAN_HPP_NAMESPACE::PipelineExecutableInternalRepresentationKHR> |
| getPipelineExecutableInternalRepresentationsKHR(const VULKAN_HPP_NAMESPACE::PipelineExecutableInfoKHR &executableInfo) const; |
| |
| //=== VK_NV_device_generated_commands === |
| |
| VULKAN_HPP_NODISCARD VULKAN_HPP_NAMESPACE::MemoryRequirements2 |
| getGeneratedCommandsMemoryRequirementsNV(const VULKAN_HPP_NAMESPACE::GeneratedCommandsMemoryRequirementsInfoNV &info) const VULKAN_HPP_NOEXCEPT; |
| |
| template<typename X, typename Y, typename... Z> |
| VULKAN_HPP_NODISCARD StructureChain<X, Y, Z...> |
| getGeneratedCommandsMemoryRequirementsNV(const VULKAN_HPP_NAMESPACE::GeneratedCommandsMemoryRequirementsInfoNV &info) const VULKAN_HPP_NOEXCEPT; |
| |
| VULKAN_HPP_NODISCARD VULKAN_HPP_RAII_NAMESPACE::IndirectCommandsLayoutNV |
| createIndirectCommandsLayoutNV(VULKAN_HPP_NAMESPACE::IndirectCommandsLayoutCreateInfoNV const &createInfo, |
| VULKAN_HPP_NAMESPACE::Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator = nullptr) const; |
| |
| //=== VK_EXT_private_data === |
| |
| VULKAN_HPP_NODISCARD VULKAN_HPP_RAII_NAMESPACE::PrivateDataSlot |
| createPrivateDataSlotEXT(VULKAN_HPP_NAMESPACE::PrivateDataSlotCreateInfo const &createInfo, |
| VULKAN_HPP_NAMESPACE::Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator = nullptr) const; |
| |
| void destroyPrivateDataSlotEXT(VULKAN_HPP_NAMESPACE::PrivateDataSlot privateDataSlot VULKAN_HPP_DEFAULT_ARGUMENT_ASSIGNMENT, |
| Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator |
| VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT; |
| |
| void setPrivateDataEXT(VULKAN_HPP_NAMESPACE::ObjectType objectType_, |
| uint64_t objectHandle, |
| VULKAN_HPP_NAMESPACE::PrivateDataSlot privateDataSlot, |
| uint64_t data) const; |
| |
| VULKAN_HPP_NODISCARD uint64_t getPrivateDataEXT(VULKAN_HPP_NAMESPACE::ObjectType objectType_, |
| uint64_t objectHandle, |
| VULKAN_HPP_NAMESPACE::PrivateDataSlot privateDataSlot) const VULKAN_HPP_NOEXCEPT; |
| |
| //=== VK_KHR_ray_tracing_pipeline === |
| |
| VULKAN_HPP_NODISCARD std::vector<VULKAN_HPP_RAII_NAMESPACE::Pipeline> createRayTracingPipelinesKHR( |
| VULKAN_HPP_NAMESPACE::Optional<const VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::DeferredOperationKHR> const &deferredOperation, |
| VULKAN_HPP_NAMESPACE::Optional<const VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::PipelineCache> const &pipelineCache, |
| VULKAN_HPP_NAMESPACE::ArrayProxy<VULKAN_HPP_NAMESPACE::RayTracingPipelineCreateInfoKHR> const &createInfos, |
| VULKAN_HPP_NAMESPACE::Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator = nullptr) const; |
| |
| VULKAN_HPP_NODISCARD VULKAN_HPP_RAII_NAMESPACE::Pipeline createRayTracingPipelineKHR( |
| VULKAN_HPP_NAMESPACE::Optional<const VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::DeferredOperationKHR> const &deferredOperation, |
| VULKAN_HPP_NAMESPACE::Optional<const VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::PipelineCache> const &pipelineCache, |
| VULKAN_HPP_NAMESPACE::RayTracingPipelineCreateInfoKHR const &createInfo, |
| VULKAN_HPP_NAMESPACE::Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator = nullptr) const; |
| |
| # if defined(VK_USE_PLATFORM_FUCHSIA) |
| //=== VK_FUCHSIA_external_memory === |
| |
| VULKAN_HPP_NODISCARD zx_handle_t getMemoryZirconHandleFUCHSIA(const VULKAN_HPP_NAMESPACE::MemoryGetZirconHandleInfoFUCHSIA &getZirconHandleInfo) const; |
| |
| VULKAN_HPP_NODISCARD VULKAN_HPP_NAMESPACE::MemoryZirconHandlePropertiesFUCHSIA |
| getMemoryZirconHandlePropertiesFUCHSIA(VULKAN_HPP_NAMESPACE::ExternalMemoryHandleTypeFlagBits handleType, zx_handle_t zirconHandle) const; |
| # endif /*VK_USE_PLATFORM_FUCHSIA*/ |
| |
| # if defined(VK_USE_PLATFORM_FUCHSIA) |
| //=== VK_FUCHSIA_external_semaphore === |
| |
| void importSemaphoreZirconHandleFUCHSIA(const VULKAN_HPP_NAMESPACE::ImportSemaphoreZirconHandleInfoFUCHSIA &importSemaphoreZirconHandleInfo) const; |
| |
| VULKAN_HPP_NODISCARD zx_handle_t |
| getSemaphoreZirconHandleFUCHSIA(const VULKAN_HPP_NAMESPACE::SemaphoreGetZirconHandleInfoFUCHSIA &getZirconHandleInfo) const; |
| # endif /*VK_USE_PLATFORM_FUCHSIA*/ |
| |
| # if defined(VK_USE_PLATFORM_FUCHSIA) |
| //=== VK_FUCHSIA_buffer_collection === |
| |
| VULKAN_HPP_NODISCARD VULKAN_HPP_RAII_NAMESPACE::BufferCollectionFUCHSIA |
| createBufferCollectionFUCHSIA(VULKAN_HPP_NAMESPACE::BufferCollectionCreateInfoFUCHSIA const &createInfo, |
| VULKAN_HPP_NAMESPACE::Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator = nullptr) const; |
| # endif /*VK_USE_PLATFORM_FUCHSIA*/ |
| |
| //=== VK_NV_external_memory_rdma === |
| |
| VULKAN_HPP_NODISCARD VULKAN_HPP_NAMESPACE::RemoteAddressNV |
| getMemoryRemoteAddressNV(const VULKAN_HPP_NAMESPACE::MemoryGetRemoteAddressInfoNV &memoryGetRemoteAddressInfo) const; |
| |
| //=== VK_KHR_maintenance4 === |
| |
| VULKAN_HPP_NODISCARD VULKAN_HPP_NAMESPACE::MemoryRequirements2 |
| getBufferMemoryRequirementsKHR(const VULKAN_HPP_NAMESPACE::DeviceBufferMemoryRequirements &info) const VULKAN_HPP_NOEXCEPT; |
| |
| template<typename X, typename Y, typename... Z> |
| VULKAN_HPP_NODISCARD StructureChain<X, Y, Z...> |
| getBufferMemoryRequirementsKHR(const VULKAN_HPP_NAMESPACE::DeviceBufferMemoryRequirements &info) const VULKAN_HPP_NOEXCEPT; |
| |
| VULKAN_HPP_NODISCARD VULKAN_HPP_NAMESPACE::MemoryRequirements2 |
| getImageMemoryRequirementsKHR(const VULKAN_HPP_NAMESPACE::DeviceImageMemoryRequirements &info) const VULKAN_HPP_NOEXCEPT; |
| |
| template<typename X, typename Y, typename... Z> |
| VULKAN_HPP_NODISCARD StructureChain<X, Y, Z...> |
| getImageMemoryRequirementsKHR(const VULKAN_HPP_NAMESPACE::DeviceImageMemoryRequirements &info) const VULKAN_HPP_NOEXCEPT; |
| |
| VULKAN_HPP_NODISCARD std::vector<VULKAN_HPP_NAMESPACE::SparseImageMemoryRequirements2> |
| getImageSparseMemoryRequirementsKHR(const VULKAN_HPP_NAMESPACE::DeviceImageMemoryRequirements &info) const VULKAN_HPP_NOEXCEPT; |
| |
| //=== VK_VALVE_descriptor_set_host_mapping === |
| |
| VULKAN_HPP_NODISCARD VULKAN_HPP_NAMESPACE::DescriptorSetLayoutHostMappingInfoVALVE getDescriptorSetLayoutHostMappingInfoVALVE( |
| const VULKAN_HPP_NAMESPACE::DescriptorSetBindingReferenceVALVE &bindingReference) const VULKAN_HPP_NOEXCEPT; |
| |
| private: |
| VULKAN_HPP_NAMESPACE::Device m_device = {}; |
| const VULKAN_HPP_NAMESPACE::AllocationCallbacks *m_allocator = {}; |
| std::unique_ptr<VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::DeviceDispatcher> m_dispatcher; |
| }; |
| |
| class AccelerationStructureKHR |
| { |
| public: |
| using CType = VkAccelerationStructureKHR; |
| |
| static VULKAN_HPP_CONST_OR_CONSTEXPR VULKAN_HPP_NAMESPACE::ObjectType objectType = VULKAN_HPP_NAMESPACE::ObjectType::eAccelerationStructureKHR; |
| static VULKAN_HPP_CONST_OR_CONSTEXPR VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT debugReportObjectType = |
| VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT::eAccelerationStructureKHR; |
| |
| public: |
| AccelerationStructureKHR(VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::Device const &device, |
| VULKAN_HPP_NAMESPACE::AccelerationStructureCreateInfoKHR const &createInfo, |
| VULKAN_HPP_NAMESPACE::Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator = nullptr) |
| : m_device(*device) |
| , m_allocator(static_cast<const VULKAN_HPP_NAMESPACE::AllocationCallbacks *>(allocator)) |
| , m_dispatcher(device.getDispatcher()) |
| { |
| VULKAN_HPP_NAMESPACE::Result result = static_cast<VULKAN_HPP_NAMESPACE::Result>( |
| device.getDispatcher()->vkCreateAccelerationStructureKHR(static_cast<VkDevice>(*device), |
| reinterpret_cast<const VkAccelerationStructureCreateInfoKHR *>(&createInfo), |
| reinterpret_cast<const VkAllocationCallbacks *>(m_allocator), |
| reinterpret_cast<VkAccelerationStructureKHR *>(&m_accelerationStructure))); |
| if(result != VULKAN_HPP_NAMESPACE::Result::eSuccess) |
| { |
| throwResultException(result, "vkCreateAccelerationStructureKHR"); |
| } |
| } |
| |
| AccelerationStructureKHR(VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::Device const &device, |
| VkAccelerationStructureKHR accelerationStructure, |
| VULKAN_HPP_NAMESPACE::Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator = nullptr) |
| : m_device(*device) |
| , m_accelerationStructure(accelerationStructure) |
| , m_allocator(static_cast<const VULKAN_HPP_NAMESPACE::AllocationCallbacks *>(allocator)) |
| , m_dispatcher(device.getDispatcher()) |
| { |
| } |
| |
| AccelerationStructureKHR(std::nullptr_t) {} |
| |
| ~AccelerationStructureKHR() |
| { |
| clear(); |
| } |
| |
| AccelerationStructureKHR() = delete; |
| AccelerationStructureKHR(AccelerationStructureKHR const &) = delete; |
| AccelerationStructureKHR(AccelerationStructureKHR &&rhs) VULKAN_HPP_NOEXCEPT |
| : m_device(VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange(rhs.m_device, {})), |
| m_accelerationStructure(VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange(rhs.m_accelerationStructure, {})), |
| m_allocator(VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange(rhs.m_allocator, {})), |
| m_dispatcher(VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange(rhs.m_dispatcher, nullptr)) |
| { |
| } |
| AccelerationStructureKHR &operator=(AccelerationStructureKHR const &) = delete; |
| AccelerationStructureKHR &operator=(AccelerationStructureKHR &&rhs) VULKAN_HPP_NOEXCEPT |
| { |
| if(this != &rhs) |
| { |
| clear(); |
| m_device = VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange(rhs.m_device, {}); |
| m_accelerationStructure = VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange(rhs.m_accelerationStructure, {}); |
| m_allocator = VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange(rhs.m_allocator, {}); |
| m_dispatcher = VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange(rhs.m_dispatcher, nullptr); |
| } |
| return *this; |
| } |
| |
| VULKAN_HPP_NAMESPACE::AccelerationStructureKHR const &operator*() const VULKAN_HPP_NOEXCEPT |
| { |
| return m_accelerationStructure; |
| } |
| |
| void clear() VULKAN_HPP_NOEXCEPT |
| { |
| if(m_accelerationStructure) |
| { |
| getDispatcher()->vkDestroyAccelerationStructureKHR(static_cast<VkDevice>(m_device), |
| static_cast<VkAccelerationStructureKHR>(m_accelerationStructure), |
| reinterpret_cast<const VkAllocationCallbacks *>(m_allocator)); |
| } |
| m_device = nullptr; |
| m_accelerationStructure = nullptr; |
| m_allocator = nullptr; |
| m_dispatcher = nullptr; |
| } |
| |
| VULKAN_HPP_NAMESPACE::Device getDevice() const |
| { |
| return m_device; |
| } |
| |
| VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::DeviceDispatcher const *getDispatcher() const |
| { |
| VULKAN_HPP_ASSERT(m_dispatcher->getVkHeaderVersion() == VK_HEADER_VERSION); |
| return m_dispatcher; |
| } |
| |
| void swap(VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::AccelerationStructureKHR &rhs) VULKAN_HPP_NOEXCEPT |
| { |
| std::swap(m_device, rhs.m_device); |
| std::swap(m_accelerationStructure, rhs.m_accelerationStructure); |
| std::swap(m_allocator, rhs.m_allocator); |
| std::swap(m_dispatcher, rhs.m_dispatcher); |
| } |
| |
| private: |
| VULKAN_HPP_NAMESPACE::Device m_device = {}; |
| VULKAN_HPP_NAMESPACE::AccelerationStructureKHR m_accelerationStructure = {}; |
| const VULKAN_HPP_NAMESPACE::AllocationCallbacks *m_allocator = {}; |
| VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::DeviceDispatcher const *m_dispatcher = nullptr; |
| }; |
| |
| class AccelerationStructureNV |
| { |
| public: |
| using CType = VkAccelerationStructureNV; |
| |
| static VULKAN_HPP_CONST_OR_CONSTEXPR VULKAN_HPP_NAMESPACE::ObjectType objectType = VULKAN_HPP_NAMESPACE::ObjectType::eAccelerationStructureNV; |
| static VULKAN_HPP_CONST_OR_CONSTEXPR VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT debugReportObjectType = |
| VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT::eAccelerationStructureNV; |
| |
| public: |
| AccelerationStructureNV(VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::Device const &device, |
| VULKAN_HPP_NAMESPACE::AccelerationStructureCreateInfoNV const &createInfo, |
| VULKAN_HPP_NAMESPACE::Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator = nullptr) |
| : m_device(*device) |
| , m_allocator(static_cast<const VULKAN_HPP_NAMESPACE::AllocationCallbacks *>(allocator)) |
| , m_dispatcher(device.getDispatcher()) |
| { |
| VULKAN_HPP_NAMESPACE::Result result = static_cast<VULKAN_HPP_NAMESPACE::Result>( |
| device.getDispatcher()->vkCreateAccelerationStructureNV(static_cast<VkDevice>(*device), |
| reinterpret_cast<const VkAccelerationStructureCreateInfoNV *>(&createInfo), |
| reinterpret_cast<const VkAllocationCallbacks *>(m_allocator), |
| reinterpret_cast<VkAccelerationStructureNV *>(&m_accelerationStructure))); |
| if(result != VULKAN_HPP_NAMESPACE::Result::eSuccess) |
| { |
| throwResultException(result, "vkCreateAccelerationStructureNV"); |
| } |
| } |
| |
| AccelerationStructureNV(VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::Device const &device, |
| VkAccelerationStructureNV accelerationStructure, |
| VULKAN_HPP_NAMESPACE::Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator = nullptr) |
| : m_device(*device) |
| , m_accelerationStructure(accelerationStructure) |
| , m_allocator(static_cast<const VULKAN_HPP_NAMESPACE::AllocationCallbacks *>(allocator)) |
| , m_dispatcher(device.getDispatcher()) |
| { |
| } |
| |
| AccelerationStructureNV(std::nullptr_t) {} |
| |
| ~AccelerationStructureNV() |
| { |
| clear(); |
| } |
| |
| AccelerationStructureNV() = delete; |
| AccelerationStructureNV(AccelerationStructureNV const &) = delete; |
| AccelerationStructureNV(AccelerationStructureNV &&rhs) VULKAN_HPP_NOEXCEPT |
| : m_device(VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange(rhs.m_device, {})), |
| m_accelerationStructure(VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange(rhs.m_accelerationStructure, {})), |
| m_allocator(VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange(rhs.m_allocator, {})), |
| m_dispatcher(VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange(rhs.m_dispatcher, nullptr)) |
| { |
| } |
| AccelerationStructureNV &operator=(AccelerationStructureNV const &) = delete; |
| AccelerationStructureNV &operator=(AccelerationStructureNV &&rhs) VULKAN_HPP_NOEXCEPT |
| { |
| if(this != &rhs) |
| { |
| clear(); |
| m_device = VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange(rhs.m_device, {}); |
| m_accelerationStructure = VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange(rhs.m_accelerationStructure, {}); |
| m_allocator = VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange(rhs.m_allocator, {}); |
| m_dispatcher = VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange(rhs.m_dispatcher, nullptr); |
| } |
| return *this; |
| } |
| |
| VULKAN_HPP_NAMESPACE::AccelerationStructureNV const &operator*() const VULKAN_HPP_NOEXCEPT |
| { |
| return m_accelerationStructure; |
| } |
| |
| void clear() VULKAN_HPP_NOEXCEPT |
| { |
| if(m_accelerationStructure) |
| { |
| getDispatcher()->vkDestroyAccelerationStructureNV(static_cast<VkDevice>(m_device), |
| static_cast<VkAccelerationStructureNV>(m_accelerationStructure), |
| reinterpret_cast<const VkAllocationCallbacks *>(m_allocator)); |
| } |
| m_device = nullptr; |
| m_accelerationStructure = nullptr; |
| m_allocator = nullptr; |
| m_dispatcher = nullptr; |
| } |
| |
| VULKAN_HPP_NAMESPACE::Device getDevice() const |
| { |
| return m_device; |
| } |
| |
| VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::DeviceDispatcher const *getDispatcher() const |
| { |
| VULKAN_HPP_ASSERT(m_dispatcher->getVkHeaderVersion() == VK_HEADER_VERSION); |
| return m_dispatcher; |
| } |
| |
| void swap(VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::AccelerationStructureNV &rhs) VULKAN_HPP_NOEXCEPT |
| { |
| std::swap(m_device, rhs.m_device); |
| std::swap(m_accelerationStructure, rhs.m_accelerationStructure); |
| std::swap(m_allocator, rhs.m_allocator); |
| std::swap(m_dispatcher, rhs.m_dispatcher); |
| } |
| |
| //=== VK_NV_ray_tracing === |
| |
| template<typename DataType> |
| VULKAN_HPP_NODISCARD std::vector<DataType> getHandle(size_t dataSize) const; |
| |
| template<typename DataType> |
| VULKAN_HPP_NODISCARD DataType getHandle() const; |
| |
| private: |
| VULKAN_HPP_NAMESPACE::Device m_device = {}; |
| VULKAN_HPP_NAMESPACE::AccelerationStructureNV m_accelerationStructure = {}; |
| const VULKAN_HPP_NAMESPACE::AllocationCallbacks *m_allocator = {}; |
| VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::DeviceDispatcher const *m_dispatcher = nullptr; |
| }; |
| |
| class Buffer |
| { |
| public: |
| using CType = VkBuffer; |
| |
| static VULKAN_HPP_CONST_OR_CONSTEXPR VULKAN_HPP_NAMESPACE::ObjectType objectType = VULKAN_HPP_NAMESPACE::ObjectType::eBuffer; |
| static VULKAN_HPP_CONST_OR_CONSTEXPR VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT debugReportObjectType = |
| VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT::eBuffer; |
| |
| public: |
| Buffer(VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::Device const &device, |
| VULKAN_HPP_NAMESPACE::BufferCreateInfo const &createInfo, |
| VULKAN_HPP_NAMESPACE::Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator = nullptr) |
| : m_device(*device) |
| , m_allocator(static_cast<const VULKAN_HPP_NAMESPACE::AllocationCallbacks *>(allocator)) |
| , m_dispatcher(device.getDispatcher()) |
| { |
| VULKAN_HPP_NAMESPACE::Result result = |
| static_cast<VULKAN_HPP_NAMESPACE::Result>(device.getDispatcher()->vkCreateBuffer(static_cast<VkDevice>(*device), |
| reinterpret_cast<const VkBufferCreateInfo *>(&createInfo), |
| reinterpret_cast<const VkAllocationCallbacks *>(m_allocator), |
| reinterpret_cast<VkBuffer *>(&m_buffer))); |
| if(result != VULKAN_HPP_NAMESPACE::Result::eSuccess) |
| { |
| throwResultException(result, "vkCreateBuffer"); |
| } |
| } |
| |
| Buffer(VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::Device const &device, |
| VkBuffer buffer, |
| VULKAN_HPP_NAMESPACE::Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator = nullptr) |
| : m_device(*device) |
| , m_buffer(buffer) |
| , m_allocator(static_cast<const VULKAN_HPP_NAMESPACE::AllocationCallbacks *>(allocator)) |
| , m_dispatcher(device.getDispatcher()) |
| { |
| } |
| |
| Buffer(std::nullptr_t) {} |
| |
| ~Buffer() |
| { |
| clear(); |
| } |
| |
| Buffer() = delete; |
| Buffer(Buffer const &) = delete; |
| Buffer(Buffer &&rhs) VULKAN_HPP_NOEXCEPT |
| : m_device(VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange(rhs.m_device, {})), |
| m_buffer(VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange(rhs.m_buffer, {})), |
| m_allocator(VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange(rhs.m_allocator, {})), |
| m_dispatcher(VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange(rhs.m_dispatcher, nullptr)) |
| { |
| } |
| Buffer &operator=(Buffer const &) = delete; |
| Buffer &operator=(Buffer &&rhs) VULKAN_HPP_NOEXCEPT |
| { |
| if(this != &rhs) |
| { |
| clear(); |
| m_device = VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange(rhs.m_device, {}); |
| m_buffer = VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange(rhs.m_buffer, {}); |
| m_allocator = VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange(rhs.m_allocator, {}); |
| m_dispatcher = VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange(rhs.m_dispatcher, nullptr); |
| } |
| return *this; |
| } |
| |
| VULKAN_HPP_NAMESPACE::Buffer const &operator*() const VULKAN_HPP_NOEXCEPT |
| { |
| return m_buffer; |
| } |
| |
| void clear() VULKAN_HPP_NOEXCEPT |
| { |
| if(m_buffer) |
| { |
| getDispatcher()->vkDestroyBuffer( |
| static_cast<VkDevice>(m_device), static_cast<VkBuffer>(m_buffer), reinterpret_cast<const VkAllocationCallbacks *>(m_allocator)); |
| } |
| m_device = nullptr; |
| m_buffer = nullptr; |
| m_allocator = nullptr; |
| m_dispatcher = nullptr; |
| } |
| |
| VULKAN_HPP_NAMESPACE::Device getDevice() const |
| { |
| return m_device; |
| } |
| |
| VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::DeviceDispatcher const *getDispatcher() const |
| { |
| VULKAN_HPP_ASSERT(m_dispatcher->getVkHeaderVersion() == VK_HEADER_VERSION); |
| return m_dispatcher; |
| } |
| |
| void swap(VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::Buffer &rhs) VULKAN_HPP_NOEXCEPT |
| { |
| std::swap(m_device, rhs.m_device); |
| std::swap(m_buffer, rhs.m_buffer); |
| std::swap(m_allocator, rhs.m_allocator); |
| std::swap(m_dispatcher, rhs.m_dispatcher); |
| } |
| |
| //=== VK_VERSION_1_0 === |
| |
| void bindMemory(VULKAN_HPP_NAMESPACE::DeviceMemory memory, VULKAN_HPP_NAMESPACE::DeviceSize memoryOffset) const; |
| |
| VULKAN_HPP_NODISCARD VULKAN_HPP_NAMESPACE::MemoryRequirements getMemoryRequirements() const VULKAN_HPP_NOEXCEPT; |
| |
| private: |
| VULKAN_HPP_NAMESPACE::Device m_device = {}; |
| VULKAN_HPP_NAMESPACE::Buffer m_buffer = {}; |
| const VULKAN_HPP_NAMESPACE::AllocationCallbacks *m_allocator = {}; |
| VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::DeviceDispatcher const *m_dispatcher = nullptr; |
| }; |
| |
| # if defined(VK_USE_PLATFORM_FUCHSIA) |
| class BufferCollectionFUCHSIA |
| { |
| public: |
| using CType = VkBufferCollectionFUCHSIA; |
| |
| static VULKAN_HPP_CONST_OR_CONSTEXPR VULKAN_HPP_NAMESPACE::ObjectType objectType = VULKAN_HPP_NAMESPACE::ObjectType::eBufferCollectionFUCHSIA; |
| static VULKAN_HPP_CONST_OR_CONSTEXPR VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT debugReportObjectType = |
| VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT::eBufferCollectionFUCHSIA; |
| |
| public: |
| BufferCollectionFUCHSIA(VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::Device const &device, |
| VULKAN_HPP_NAMESPACE::BufferCollectionCreateInfoFUCHSIA const &createInfo, |
| VULKAN_HPP_NAMESPACE::Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator = nullptr) |
| : m_device(*device) |
| , m_allocator(static_cast<const VULKAN_HPP_NAMESPACE::AllocationCallbacks *>(allocator)) |
| , m_dispatcher(device.getDispatcher()) |
| { |
| VULKAN_HPP_NAMESPACE::Result result = static_cast<VULKAN_HPP_NAMESPACE::Result>( |
| device.getDispatcher()->vkCreateBufferCollectionFUCHSIA(static_cast<VkDevice>(*device), |
| reinterpret_cast<const VkBufferCollectionCreateInfoFUCHSIA *>(&createInfo), |
| reinterpret_cast<const VkAllocationCallbacks *>(m_allocator), |
| reinterpret_cast<VkBufferCollectionFUCHSIA *>(&m_collection))); |
| if(result != VULKAN_HPP_NAMESPACE::Result::eSuccess) |
| { |
| throwResultException(result, "vkCreateBufferCollectionFUCHSIA"); |
| } |
| } |
| |
| BufferCollectionFUCHSIA(VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::Device const &device, |
| VkBufferCollectionFUCHSIA collection, |
| VULKAN_HPP_NAMESPACE::Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator = nullptr) |
| : m_device(*device) |
| , m_collection(collection) |
| , m_allocator(static_cast<const VULKAN_HPP_NAMESPACE::AllocationCallbacks *>(allocator)) |
| , m_dispatcher(device.getDispatcher()) |
| { |
| } |
| |
| BufferCollectionFUCHSIA(std::nullptr_t) {} |
| |
| ~BufferCollectionFUCHSIA() |
| { |
| clear(); |
| } |
| |
| BufferCollectionFUCHSIA() = delete; |
| BufferCollectionFUCHSIA(BufferCollectionFUCHSIA const &) = delete; |
| BufferCollectionFUCHSIA(BufferCollectionFUCHSIA &&rhs) VULKAN_HPP_NOEXCEPT |
| : m_device(VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange(rhs.m_device, {})), |
| m_collection(VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange(rhs.m_collection, {})), |
| m_allocator(VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange(rhs.m_allocator, {})), |
| m_dispatcher(VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange(rhs.m_dispatcher, nullptr)) |
| { |
| } |
| BufferCollectionFUCHSIA &operator=(BufferCollectionFUCHSIA const &) = delete; |
| BufferCollectionFUCHSIA &operator=(BufferCollectionFUCHSIA &&rhs) VULKAN_HPP_NOEXCEPT |
| { |
| if(this != &rhs) |
| { |
| clear(); |
| m_device = VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange(rhs.m_device, {}); |
| m_collection = VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange(rhs.m_collection, {}); |
| m_allocator = VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange(rhs.m_allocator, {}); |
| m_dispatcher = VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange(rhs.m_dispatcher, nullptr); |
| } |
| return *this; |
| } |
| |
| VULKAN_HPP_NAMESPACE::BufferCollectionFUCHSIA const &operator*() const VULKAN_HPP_NOEXCEPT |
| { |
| return m_collection; |
| } |
| |
| void clear() VULKAN_HPP_NOEXCEPT |
| { |
| if(m_collection) |
| { |
| getDispatcher()->vkDestroyBufferCollectionFUCHSIA(static_cast<VkDevice>(m_device), |
| static_cast<VkBufferCollectionFUCHSIA>(m_collection), |
| reinterpret_cast<const VkAllocationCallbacks *>(m_allocator)); |
| } |
| m_device = nullptr; |
| m_collection = nullptr; |
| m_allocator = nullptr; |
| m_dispatcher = nullptr; |
| } |
| |
| VULKAN_HPP_NAMESPACE::Device getDevice() const |
| { |
| return m_device; |
| } |
| |
| VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::DeviceDispatcher const *getDispatcher() const |
| { |
| VULKAN_HPP_ASSERT(m_dispatcher->getVkHeaderVersion() == VK_HEADER_VERSION); |
| return m_dispatcher; |
| } |
| |
| void swap(VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::BufferCollectionFUCHSIA &rhs) VULKAN_HPP_NOEXCEPT |
| { |
| std::swap(m_device, rhs.m_device); |
| std::swap(m_collection, rhs.m_collection); |
| std::swap(m_allocator, rhs.m_allocator); |
| std::swap(m_dispatcher, rhs.m_dispatcher); |
| } |
| |
| //=== VK_FUCHSIA_buffer_collection === |
| |
| void setImageConstraints(const VULKAN_HPP_NAMESPACE::ImageConstraintsInfoFUCHSIA &imageConstraintsInfo) const; |
| |
| void setBufferConstraints(const VULKAN_HPP_NAMESPACE::BufferConstraintsInfoFUCHSIA &bufferConstraintsInfo) const; |
| |
| VULKAN_HPP_NODISCARD VULKAN_HPP_NAMESPACE::BufferCollectionPropertiesFUCHSIA getProperties() const; |
| |
| private: |
| VULKAN_HPP_NAMESPACE::Device m_device = {}; |
| VULKAN_HPP_NAMESPACE::BufferCollectionFUCHSIA m_collection = {}; |
| const VULKAN_HPP_NAMESPACE::AllocationCallbacks *m_allocator = {}; |
| VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::DeviceDispatcher const *m_dispatcher = nullptr; |
| }; |
| # endif /*VK_USE_PLATFORM_FUCHSIA*/ |
| |
| class BufferView |
| { |
| public: |
| using CType = VkBufferView; |
| |
| static VULKAN_HPP_CONST_OR_CONSTEXPR VULKAN_HPP_NAMESPACE::ObjectType objectType = VULKAN_HPP_NAMESPACE::ObjectType::eBufferView; |
| static VULKAN_HPP_CONST_OR_CONSTEXPR VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT debugReportObjectType = |
| VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT::eBufferView; |
| |
| public: |
| BufferView(VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::Device const &device, |
| VULKAN_HPP_NAMESPACE::BufferViewCreateInfo const &createInfo, |
| VULKAN_HPP_NAMESPACE::Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator = nullptr) |
| : m_device(*device) |
| , m_allocator(static_cast<const VULKAN_HPP_NAMESPACE::AllocationCallbacks *>(allocator)) |
| , m_dispatcher(device.getDispatcher()) |
| { |
| VULKAN_HPP_NAMESPACE::Result result = static_cast<VULKAN_HPP_NAMESPACE::Result>( |
| device.getDispatcher()->vkCreateBufferView(static_cast<VkDevice>(*device), |
| reinterpret_cast<const VkBufferViewCreateInfo *>(&createInfo), |
| reinterpret_cast<const VkAllocationCallbacks *>(m_allocator), |
| reinterpret_cast<VkBufferView *>(&m_bufferView))); |
| if(result != VULKAN_HPP_NAMESPACE::Result::eSuccess) |
| { |
| throwResultException(result, "vkCreateBufferView"); |
| } |
| } |
| |
| BufferView(VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::Device const &device, |
| VkBufferView bufferView, |
| VULKAN_HPP_NAMESPACE::Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator = nullptr) |
| : m_device(*device) |
| , m_bufferView(bufferView) |
| , m_allocator(static_cast<const VULKAN_HPP_NAMESPACE::AllocationCallbacks *>(allocator)) |
| , m_dispatcher(device.getDispatcher()) |
| { |
| } |
| |
| BufferView(std::nullptr_t) {} |
| |
| ~BufferView() |
| { |
| clear(); |
| } |
| |
| BufferView() = delete; |
| BufferView(BufferView const &) = delete; |
| BufferView(BufferView &&rhs) VULKAN_HPP_NOEXCEPT |
| : m_device(VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange(rhs.m_device, {})), |
| m_bufferView(VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange(rhs.m_bufferView, {})), |
| m_allocator(VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange(rhs.m_allocator, {})), |
| m_dispatcher(VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange(rhs.m_dispatcher, nullptr)) |
| { |
| } |
| BufferView &operator=(BufferView const &) = delete; |
| BufferView &operator=(BufferView &&rhs) VULKAN_HPP_NOEXCEPT |
| { |
| if(this != &rhs) |
| { |
| clear(); |
| m_device = VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange(rhs.m_device, {}); |
| m_bufferView = VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange(rhs.m_bufferView, {}); |
| m_allocator = VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange(rhs.m_allocator, {}); |
| m_dispatcher = VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange(rhs.m_dispatcher, nullptr); |
| } |
| return *this; |
| } |
| |
| VULKAN_HPP_NAMESPACE::BufferView const &operator*() const VULKAN_HPP_NOEXCEPT |
| { |
| return m_bufferView; |
| } |
| |
| void clear() VULKAN_HPP_NOEXCEPT |
| { |
| if(m_bufferView) |
| { |
| getDispatcher()->vkDestroyBufferView( |
| static_cast<VkDevice>(m_device), static_cast<VkBufferView>(m_bufferView), reinterpret_cast<const VkAllocationCallbacks *>(m_allocator)); |
| } |
| m_device = nullptr; |
| m_bufferView = nullptr; |
| m_allocator = nullptr; |
| m_dispatcher = nullptr; |
| } |
| |
| VULKAN_HPP_NAMESPACE::Device getDevice() const |
| { |
| return m_device; |
| } |
| |
| VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::DeviceDispatcher const *getDispatcher() const |
| { |
| VULKAN_HPP_ASSERT(m_dispatcher->getVkHeaderVersion() == VK_HEADER_VERSION); |
| return m_dispatcher; |
| } |
| |
| void swap(VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::BufferView &rhs) VULKAN_HPP_NOEXCEPT |
| { |
| std::swap(m_device, rhs.m_device); |
| std::swap(m_bufferView, rhs.m_bufferView); |
| std::swap(m_allocator, rhs.m_allocator); |
| std::swap(m_dispatcher, rhs.m_dispatcher); |
| } |
| |
| private: |
| VULKAN_HPP_NAMESPACE::Device m_device = {}; |
| VULKAN_HPP_NAMESPACE::BufferView m_bufferView = {}; |
| const VULKAN_HPP_NAMESPACE::AllocationCallbacks *m_allocator = {}; |
| VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::DeviceDispatcher const *m_dispatcher = nullptr; |
| }; |
| |
| class CommandPool |
| { |
| public: |
| using CType = VkCommandPool; |
| |
| static VULKAN_HPP_CONST_OR_CONSTEXPR VULKAN_HPP_NAMESPACE::ObjectType objectType = VULKAN_HPP_NAMESPACE::ObjectType::eCommandPool; |
| static VULKAN_HPP_CONST_OR_CONSTEXPR VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT debugReportObjectType = |
| VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT::eCommandPool; |
| |
| public: |
| CommandPool(VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::Device const &device, |
| VULKAN_HPP_NAMESPACE::CommandPoolCreateInfo const &createInfo, |
| VULKAN_HPP_NAMESPACE::Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator = nullptr) |
| : m_device(*device) |
| , m_allocator(static_cast<const VULKAN_HPP_NAMESPACE::AllocationCallbacks *>(allocator)) |
| , m_dispatcher(device.getDispatcher()) |
| { |
| VULKAN_HPP_NAMESPACE::Result result = static_cast<VULKAN_HPP_NAMESPACE::Result>( |
| device.getDispatcher()->vkCreateCommandPool(static_cast<VkDevice>(*device), |
| reinterpret_cast<const VkCommandPoolCreateInfo *>(&createInfo), |
| reinterpret_cast<const VkAllocationCallbacks *>(m_allocator), |
| reinterpret_cast<VkCommandPool *>(&m_commandPool))); |
| if(result != VULKAN_HPP_NAMESPACE::Result::eSuccess) |
| { |
| throwResultException(result, "vkCreateCommandPool"); |
| } |
| } |
| |
| CommandPool(VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::Device const &device, |
| VkCommandPool commandPool, |
| VULKAN_HPP_NAMESPACE::Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator = nullptr) |
| : m_device(*device) |
| , m_commandPool(commandPool) |
| , m_allocator(static_cast<const VULKAN_HPP_NAMESPACE::AllocationCallbacks *>(allocator)) |
| , m_dispatcher(device.getDispatcher()) |
| { |
| } |
| |
| CommandPool(std::nullptr_t) {} |
| |
| ~CommandPool() |
| { |
| clear(); |
| } |
| |
| CommandPool() = delete; |
| CommandPool(CommandPool const &) = delete; |
| CommandPool(CommandPool &&rhs) VULKAN_HPP_NOEXCEPT |
| : m_device(VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange(rhs.m_device, {})), |
| m_commandPool(VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange(rhs.m_commandPool, {})), |
| m_allocator(VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange(rhs.m_allocator, {})), |
| m_dispatcher(VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange(rhs.m_dispatcher, nullptr)) |
| { |
| } |
| CommandPool &operator=(CommandPool const &) = delete; |
| CommandPool &operator=(CommandPool &&rhs) VULKAN_HPP_NOEXCEPT |
| { |
| if(this != &rhs) |
| { |
| clear(); |
| m_device = VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange(rhs.m_device, {}); |
| m_commandPool = VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange(rhs.m_commandPool, {}); |
| m_allocator = VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange(rhs.m_allocator, {}); |
| m_dispatcher = VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange(rhs.m_dispatcher, nullptr); |
| } |
| return *this; |
| } |
| |
| VULKAN_HPP_NAMESPACE::CommandPool const &operator*() const VULKAN_HPP_NOEXCEPT |
| { |
| return m_commandPool; |
| } |
| |
| void clear() VULKAN_HPP_NOEXCEPT |
| { |
| if(m_commandPool) |
| { |
| getDispatcher()->vkDestroyCommandPool( |
| static_cast<VkDevice>(m_device), static_cast<VkCommandPool>(m_commandPool), reinterpret_cast<const VkAllocationCallbacks *>(m_allocator)); |
| } |
| m_device = nullptr; |
| m_commandPool = nullptr; |
| m_allocator = nullptr; |
| m_dispatcher = nullptr; |
| } |
| |
| VULKAN_HPP_NAMESPACE::Device getDevice() const |
| { |
| return m_device; |
| } |
| |
| VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::DeviceDispatcher const *getDispatcher() const |
| { |
| VULKAN_HPP_ASSERT(m_dispatcher->getVkHeaderVersion() == VK_HEADER_VERSION); |
| return m_dispatcher; |
| } |
| |
| void swap(VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::CommandPool &rhs) VULKAN_HPP_NOEXCEPT |
| { |
| std::swap(m_device, rhs.m_device); |
| std::swap(m_commandPool, rhs.m_commandPool); |
| std::swap(m_allocator, rhs.m_allocator); |
| std::swap(m_dispatcher, rhs.m_dispatcher); |
| } |
| |
| //=== VK_VERSION_1_0 === |
| |
| void reset(VULKAN_HPP_NAMESPACE::CommandPoolResetFlags flags VULKAN_HPP_DEFAULT_ARGUMENT_ASSIGNMENT) const; |
| |
| //=== VK_VERSION_1_1 === |
| |
| void trim(VULKAN_HPP_NAMESPACE::CommandPoolTrimFlags flags VULKAN_HPP_DEFAULT_ARGUMENT_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT; |
| |
| //=== VK_KHR_maintenance1 === |
| |
| void trimKHR(VULKAN_HPP_NAMESPACE::CommandPoolTrimFlags flags VULKAN_HPP_DEFAULT_ARGUMENT_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT; |
| |
| private: |
| VULKAN_HPP_NAMESPACE::Device m_device = {}; |
| VULKAN_HPP_NAMESPACE::CommandPool m_commandPool = {}; |
| const VULKAN_HPP_NAMESPACE::AllocationCallbacks *m_allocator = {}; |
| VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::DeviceDispatcher const *m_dispatcher = nullptr; |
| }; |
| |
| class CommandBuffer |
| { |
| public: |
| using CType = VkCommandBuffer; |
| |
| static VULKAN_HPP_CONST_OR_CONSTEXPR VULKAN_HPP_NAMESPACE::ObjectType objectType = VULKAN_HPP_NAMESPACE::ObjectType::eCommandBuffer; |
| static VULKAN_HPP_CONST_OR_CONSTEXPR VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT debugReportObjectType = |
| VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT::eCommandBuffer; |
| |
| public: |
| CommandBuffer(VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::Device const &device, VkCommandBuffer commandBuffer, VkCommandPool commandPool) |
| : m_device(*device) |
| , m_commandPool(commandPool) |
| , m_commandBuffer(commandBuffer) |
| , m_dispatcher(device.getDispatcher()) |
| { |
| } |
| |
| CommandBuffer(std::nullptr_t) {} |
| |
| ~CommandBuffer() |
| { |
| clear(); |
| } |
| |
| CommandBuffer() = delete; |
| CommandBuffer(CommandBuffer const &) = delete; |
| CommandBuffer(CommandBuffer &&rhs) VULKAN_HPP_NOEXCEPT |
| : m_device(VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange(rhs.m_device, {})), |
| m_commandPool(VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange(rhs.m_commandPool, {})), |
| m_commandBuffer(VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange(rhs.m_commandBuffer, {})), |
| m_dispatcher(VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange(rhs.m_dispatcher, nullptr)) |
| { |
| } |
| CommandBuffer &operator=(CommandBuffer const &) = delete; |
| CommandBuffer &operator=(CommandBuffer &&rhs) VULKAN_HPP_NOEXCEPT |
| { |
| if(this != &rhs) |
| { |
| clear(); |
| m_device = VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange(rhs.m_device, {}); |
| m_commandPool = VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange(rhs.m_commandPool, {}); |
| m_commandBuffer = VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange(rhs.m_commandBuffer, {}); |
| m_dispatcher = VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange(rhs.m_dispatcher, nullptr); |
| } |
| return *this; |
| } |
| |
| VULKAN_HPP_NAMESPACE::CommandBuffer const &operator*() const VULKAN_HPP_NOEXCEPT |
| { |
| return m_commandBuffer; |
| } |
| |
| void clear() VULKAN_HPP_NOEXCEPT |
| { |
| if(m_commandBuffer) |
| { |
| getDispatcher()->vkFreeCommandBuffers( |
| static_cast<VkDevice>(m_device), static_cast<VkCommandPool>(m_commandPool), 1, reinterpret_cast<VkCommandBuffer const *>(&m_commandBuffer)); |
| } |
| m_device = nullptr; |
| m_commandPool = nullptr; |
| m_commandBuffer = nullptr; |
| m_dispatcher = nullptr; |
| } |
| |
| VULKAN_HPP_NAMESPACE::Device getDevice() const |
| { |
| return m_device; |
| } |
| |
| VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::DeviceDispatcher const *getDispatcher() const |
| { |
| VULKAN_HPP_ASSERT(m_dispatcher->getVkHeaderVersion() == VK_HEADER_VERSION); |
| return m_dispatcher; |
| } |
| |
| void swap(VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::CommandBuffer &rhs) VULKAN_HPP_NOEXCEPT |
| { |
| std::swap(m_device, rhs.m_device); |
| std::swap(m_commandPool, rhs.m_commandPool); |
| std::swap(m_commandBuffer, rhs.m_commandBuffer); |
| std::swap(m_dispatcher, rhs.m_dispatcher); |
| } |
| |
| //=== VK_VERSION_1_0 === |
| |
| void begin(const VULKAN_HPP_NAMESPACE::CommandBufferBeginInfo &beginInfo) const; |
| |
| void end() const; |
| |
| void reset(VULKAN_HPP_NAMESPACE::CommandBufferResetFlags flags VULKAN_HPP_DEFAULT_ARGUMENT_ASSIGNMENT) const; |
| |
| void bindPipeline(VULKAN_HPP_NAMESPACE::PipelineBindPoint pipelineBindPoint, VULKAN_HPP_NAMESPACE::Pipeline pipeline) const VULKAN_HPP_NOEXCEPT; |
| |
| void setViewport(uint32_t firstViewport, ArrayProxy<const VULKAN_HPP_NAMESPACE::Viewport> const &viewports) const VULKAN_HPP_NOEXCEPT; |
| |
| void setScissor(uint32_t firstScissor, ArrayProxy<const VULKAN_HPP_NAMESPACE::Rect2D> const &scissors) const VULKAN_HPP_NOEXCEPT; |
| |
| void setLineWidth(float lineWidth) const VULKAN_HPP_NOEXCEPT; |
| |
| void setDepthBias(float depthBiasConstantFactor, float depthBiasClamp, float depthBiasSlopeFactor) const VULKAN_HPP_NOEXCEPT; |
| |
| void setBlendConstants(const float blendConstants[4]) const VULKAN_HPP_NOEXCEPT; |
| |
| void setDepthBounds(float minDepthBounds, float maxDepthBounds) const VULKAN_HPP_NOEXCEPT; |
| |
| void setStencilCompareMask(VULKAN_HPP_NAMESPACE::StencilFaceFlags faceMask, uint32_t compareMask) const VULKAN_HPP_NOEXCEPT; |
| |
| void setStencilWriteMask(VULKAN_HPP_NAMESPACE::StencilFaceFlags faceMask, uint32_t writeMask) const VULKAN_HPP_NOEXCEPT; |
| |
| void setStencilReference(VULKAN_HPP_NAMESPACE::StencilFaceFlags faceMask, uint32_t reference) const VULKAN_HPP_NOEXCEPT; |
| |
| void bindDescriptorSets(VULKAN_HPP_NAMESPACE::PipelineBindPoint pipelineBindPoint, |
| VULKAN_HPP_NAMESPACE::PipelineLayout layout, |
| uint32_t firstSet, |
| ArrayProxy<const VULKAN_HPP_NAMESPACE::DescriptorSet> const &descriptorSets, |
| ArrayProxy<const uint32_t> const &dynamicOffsets) const VULKAN_HPP_NOEXCEPT; |
| |
| void bindIndexBuffer(VULKAN_HPP_NAMESPACE::Buffer buffer, |
| VULKAN_HPP_NAMESPACE::DeviceSize offset, |
| VULKAN_HPP_NAMESPACE::IndexType indexType) const VULKAN_HPP_NOEXCEPT; |
| |
| void bindVertexBuffers(uint32_t firstBinding, |
| ArrayProxy<const VULKAN_HPP_NAMESPACE::Buffer> const &buffers, |
| ArrayProxy<const VULKAN_HPP_NAMESPACE::DeviceSize> const &offsets) const; |
| |
| void draw(uint32_t vertexCount, uint32_t instanceCount, uint32_t firstVertex, uint32_t firstInstance) const VULKAN_HPP_NOEXCEPT; |
| |
| void |
| drawIndexed(uint32_t indexCount, uint32_t instanceCount, uint32_t firstIndex, int32_t vertexOffset, uint32_t firstInstance) const VULKAN_HPP_NOEXCEPT; |
| |
| void drawIndirect(VULKAN_HPP_NAMESPACE::Buffer buffer, |
| VULKAN_HPP_NAMESPACE::DeviceSize offset, |
| uint32_t drawCount, |
| uint32_t stride) const VULKAN_HPP_NOEXCEPT; |
| |
| void drawIndexedIndirect(VULKAN_HPP_NAMESPACE::Buffer buffer, |
| VULKAN_HPP_NAMESPACE::DeviceSize offset, |
| uint32_t drawCount, |
| uint32_t stride) const VULKAN_HPP_NOEXCEPT; |
| |
| void dispatch(uint32_t groupCountX, uint32_t groupCountY, uint32_t groupCountZ) const VULKAN_HPP_NOEXCEPT; |
| |
| void dispatchIndirect(VULKAN_HPP_NAMESPACE::Buffer buffer, VULKAN_HPP_NAMESPACE::DeviceSize offset) const VULKAN_HPP_NOEXCEPT; |
| |
| void copyBuffer(VULKAN_HPP_NAMESPACE::Buffer srcBuffer, |
| VULKAN_HPP_NAMESPACE::Buffer dstBuffer, |
| ArrayProxy<const VULKAN_HPP_NAMESPACE::BufferCopy> const ®ions) const VULKAN_HPP_NOEXCEPT; |
| |
| void copyImage(VULKAN_HPP_NAMESPACE::Image srcImage, |
| VULKAN_HPP_NAMESPACE::ImageLayout srcImageLayout, |
| VULKAN_HPP_NAMESPACE::Image dstImage, |
| VULKAN_HPP_NAMESPACE::ImageLayout dstImageLayout, |
| ArrayProxy<const VULKAN_HPP_NAMESPACE::ImageCopy> const ®ions) const VULKAN_HPP_NOEXCEPT; |
| |
| void blitImage(VULKAN_HPP_NAMESPACE::Image srcImage, |
| VULKAN_HPP_NAMESPACE::ImageLayout srcImageLayout, |
| VULKAN_HPP_NAMESPACE::Image dstImage, |
| VULKAN_HPP_NAMESPACE::ImageLayout dstImageLayout, |
| ArrayProxy<const VULKAN_HPP_NAMESPACE::ImageBlit> const ®ions, |
| VULKAN_HPP_NAMESPACE::Filter filter) const VULKAN_HPP_NOEXCEPT; |
| |
| void copyBufferToImage(VULKAN_HPP_NAMESPACE::Buffer srcBuffer, |
| VULKAN_HPP_NAMESPACE::Image dstImage, |
| VULKAN_HPP_NAMESPACE::ImageLayout dstImageLayout, |
| ArrayProxy<const VULKAN_HPP_NAMESPACE::BufferImageCopy> const ®ions) const VULKAN_HPP_NOEXCEPT; |
| |
| void copyImageToBuffer(VULKAN_HPP_NAMESPACE::Image srcImage, |
| VULKAN_HPP_NAMESPACE::ImageLayout srcImageLayout, |
| VULKAN_HPP_NAMESPACE::Buffer dstBuffer, |
| ArrayProxy<const VULKAN_HPP_NAMESPACE::BufferImageCopy> const ®ions) const VULKAN_HPP_NOEXCEPT; |
| |
| template<typename DataType> |
| void updateBuffer(VULKAN_HPP_NAMESPACE::Buffer dstBuffer, |
| VULKAN_HPP_NAMESPACE::DeviceSize dstOffset, |
| ArrayProxy<const DataType> const &data) const VULKAN_HPP_NOEXCEPT; |
| |
| void fillBuffer(VULKAN_HPP_NAMESPACE::Buffer dstBuffer, |
| VULKAN_HPP_NAMESPACE::DeviceSize dstOffset, |
| VULKAN_HPP_NAMESPACE::DeviceSize size, |
| uint32_t data) const VULKAN_HPP_NOEXCEPT; |
| |
| void clearColorImage(VULKAN_HPP_NAMESPACE::Image image, |
| VULKAN_HPP_NAMESPACE::ImageLayout imageLayout, |
| const VULKAN_HPP_NAMESPACE::ClearColorValue &color, |
| ArrayProxy<const VULKAN_HPP_NAMESPACE::ImageSubresourceRange> const &ranges) const VULKAN_HPP_NOEXCEPT; |
| |
| void clearDepthStencilImage(VULKAN_HPP_NAMESPACE::Image image, |
| VULKAN_HPP_NAMESPACE::ImageLayout imageLayout, |
| const VULKAN_HPP_NAMESPACE::ClearDepthStencilValue &depthStencil, |
| ArrayProxy<const VULKAN_HPP_NAMESPACE::ImageSubresourceRange> const &ranges) const VULKAN_HPP_NOEXCEPT; |
| |
| void clearAttachments(ArrayProxy<const VULKAN_HPP_NAMESPACE::ClearAttachment> const &attachments, |
| ArrayProxy<const VULKAN_HPP_NAMESPACE::ClearRect> const &rects) const VULKAN_HPP_NOEXCEPT; |
| |
| void resolveImage(VULKAN_HPP_NAMESPACE::Image srcImage, |
| VULKAN_HPP_NAMESPACE::ImageLayout srcImageLayout, |
| VULKAN_HPP_NAMESPACE::Image dstImage, |
| VULKAN_HPP_NAMESPACE::ImageLayout dstImageLayout, |
| ArrayProxy<const VULKAN_HPP_NAMESPACE::ImageResolve> const ®ions) const VULKAN_HPP_NOEXCEPT; |
| |
| void setEvent(VULKAN_HPP_NAMESPACE::Event event, |
| VULKAN_HPP_NAMESPACE::PipelineStageFlags stageMask VULKAN_HPP_DEFAULT_ARGUMENT_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT; |
| |
| void resetEvent(VULKAN_HPP_NAMESPACE::Event event, |
| VULKAN_HPP_NAMESPACE::PipelineStageFlags stageMask VULKAN_HPP_DEFAULT_ARGUMENT_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT; |
| |
| void waitEvents(ArrayProxy<const VULKAN_HPP_NAMESPACE::Event> const &events, |
| VULKAN_HPP_NAMESPACE::PipelineStageFlags srcStageMask, |
| VULKAN_HPP_NAMESPACE::PipelineStageFlags dstStageMask, |
| ArrayProxy<const VULKAN_HPP_NAMESPACE::MemoryBarrier> const &memoryBarriers, |
| ArrayProxy<const VULKAN_HPP_NAMESPACE::BufferMemoryBarrier> const &bufferMemoryBarriers, |
| ArrayProxy<const VULKAN_HPP_NAMESPACE::ImageMemoryBarrier> const &imageMemoryBarriers) const VULKAN_HPP_NOEXCEPT; |
| |
| void pipelineBarrier(VULKAN_HPP_NAMESPACE::PipelineStageFlags srcStageMask, |
| VULKAN_HPP_NAMESPACE::PipelineStageFlags dstStageMask, |
| VULKAN_HPP_NAMESPACE::DependencyFlags dependencyFlags, |
| ArrayProxy<const VULKAN_HPP_NAMESPACE::MemoryBarrier> const &memoryBarriers, |
| ArrayProxy<const VULKAN_HPP_NAMESPACE::BufferMemoryBarrier> const &bufferMemoryBarriers, |
| ArrayProxy<const VULKAN_HPP_NAMESPACE::ImageMemoryBarrier> const &imageMemoryBarriers) const VULKAN_HPP_NOEXCEPT; |
| |
| void beginQuery(VULKAN_HPP_NAMESPACE::QueryPool queryPool, |
| uint32_t query, |
| VULKAN_HPP_NAMESPACE::QueryControlFlags flags VULKAN_HPP_DEFAULT_ARGUMENT_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT; |
| |
| void endQuery(VULKAN_HPP_NAMESPACE::QueryPool queryPool, uint32_t query) const VULKAN_HPP_NOEXCEPT; |
| |
| void resetQueryPool(VULKAN_HPP_NAMESPACE::QueryPool queryPool, uint32_t firstQuery, uint32_t queryCount) const VULKAN_HPP_NOEXCEPT; |
| |
| void writeTimestamp(VULKAN_HPP_NAMESPACE::PipelineStageFlagBits pipelineStage, |
| VULKAN_HPP_NAMESPACE::QueryPool queryPool, |
| uint32_t query) const VULKAN_HPP_NOEXCEPT; |
| |
| void copyQueryPoolResults(VULKAN_HPP_NAMESPACE::QueryPool queryPool, |
| uint32_t firstQuery, |
| uint32_t queryCount, |
| VULKAN_HPP_NAMESPACE::Buffer dstBuffer, |
| VULKAN_HPP_NAMESPACE::DeviceSize dstOffset, |
| VULKAN_HPP_NAMESPACE::DeviceSize stride, |
| VULKAN_HPP_NAMESPACE::QueryResultFlags flags VULKAN_HPP_DEFAULT_ARGUMENT_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT; |
| |
| template<typename ValuesType> |
| void pushConstants(VULKAN_HPP_NAMESPACE::PipelineLayout layout, |
| VULKAN_HPP_NAMESPACE::ShaderStageFlags stageFlags, |
| uint32_t offset, |
| ArrayProxy<const ValuesType> const &values) const VULKAN_HPP_NOEXCEPT; |
| |
| void beginRenderPass(const VULKAN_HPP_NAMESPACE::RenderPassBeginInfo &renderPassBegin, |
| VULKAN_HPP_NAMESPACE::SubpassContents contents) const VULKAN_HPP_NOEXCEPT; |
| |
| void nextSubpass(VULKAN_HPP_NAMESPACE::SubpassContents contents) const VULKAN_HPP_NOEXCEPT; |
| |
| void endRenderPass() const VULKAN_HPP_NOEXCEPT; |
| |
| void executeCommands(ArrayProxy<const VULKAN_HPP_NAMESPACE::CommandBuffer> const &commandBuffers) const VULKAN_HPP_NOEXCEPT; |
| |
| //=== VK_VERSION_1_1 === |
| |
| void setDeviceMask(uint32_t deviceMask) const VULKAN_HPP_NOEXCEPT; |
| |
| void dispatchBase(uint32_t baseGroupX, uint32_t baseGroupY, uint32_t baseGroupZ, uint32_t groupCountX, uint32_t groupCountY, uint32_t groupCountZ) const |
| VULKAN_HPP_NOEXCEPT; |
| |
| //=== VK_VERSION_1_2 === |
| |
| void drawIndirectCount(VULKAN_HPP_NAMESPACE::Buffer buffer, |
| VULKAN_HPP_NAMESPACE::DeviceSize offset, |
| VULKAN_HPP_NAMESPACE::Buffer countBuffer, |
| VULKAN_HPP_NAMESPACE::DeviceSize countBufferOffset, |
| uint32_t maxDrawCount, |
| uint32_t stride) const VULKAN_HPP_NOEXCEPT; |
| |
| void drawIndexedIndirectCount(VULKAN_HPP_NAMESPACE::Buffer buffer, |
| VULKAN_HPP_NAMESPACE::DeviceSize offset, |
| VULKAN_HPP_NAMESPACE::Buffer countBuffer, |
| VULKAN_HPP_NAMESPACE::DeviceSize countBufferOffset, |
| uint32_t maxDrawCount, |
| uint32_t stride) const VULKAN_HPP_NOEXCEPT; |
| |
| void beginRenderPass2(const VULKAN_HPP_NAMESPACE::RenderPassBeginInfo &renderPassBegin, |
| const VULKAN_HPP_NAMESPACE::SubpassBeginInfo &subpassBeginInfo) const VULKAN_HPP_NOEXCEPT; |
| |
| void nextSubpass2(const VULKAN_HPP_NAMESPACE::SubpassBeginInfo &subpassBeginInfo, |
| const VULKAN_HPP_NAMESPACE::SubpassEndInfo &subpassEndInfo) const VULKAN_HPP_NOEXCEPT; |
| |
| void endRenderPass2(const VULKAN_HPP_NAMESPACE::SubpassEndInfo &subpassEndInfo) const VULKAN_HPP_NOEXCEPT; |
| |
| //=== VK_VERSION_1_3 === |
| |
| void setEvent2(VULKAN_HPP_NAMESPACE::Event event, const VULKAN_HPP_NAMESPACE::DependencyInfo &dependencyInfo) const VULKAN_HPP_NOEXCEPT; |
| |
| void resetEvent2(VULKAN_HPP_NAMESPACE::Event event, |
| VULKAN_HPP_NAMESPACE::PipelineStageFlags2 stageMask VULKAN_HPP_DEFAULT_ARGUMENT_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT; |
| |
| void waitEvents2(ArrayProxy<const VULKAN_HPP_NAMESPACE::Event> const &events, |
| ArrayProxy<const VULKAN_HPP_NAMESPACE::DependencyInfo> const &dependencyInfos) const; |
| |
| void pipelineBarrier2(const VULKAN_HPP_NAMESPACE::DependencyInfo &dependencyInfo) const VULKAN_HPP_NOEXCEPT; |
| |
| void |
| writeTimestamp2(VULKAN_HPP_NAMESPACE::PipelineStageFlags2 stage, VULKAN_HPP_NAMESPACE::QueryPool queryPool, uint32_t query) const VULKAN_HPP_NOEXCEPT; |
| |
| void copyBuffer2(const VULKAN_HPP_NAMESPACE::CopyBufferInfo2 ©BufferInfo) const VULKAN_HPP_NOEXCEPT; |
| |
| void copyImage2(const VULKAN_HPP_NAMESPACE::CopyImageInfo2 ©ImageInfo) const VULKAN_HPP_NOEXCEPT; |
| |
| void copyBufferToImage2(const VULKAN_HPP_NAMESPACE::CopyBufferToImageInfo2 ©BufferToImageInfo) const VULKAN_HPP_NOEXCEPT; |
| |
| void copyImageToBuffer2(const VULKAN_HPP_NAMESPACE::CopyImageToBufferInfo2 ©ImageToBufferInfo) const VULKAN_HPP_NOEXCEPT; |
| |
| void blitImage2(const VULKAN_HPP_NAMESPACE::BlitImageInfo2 &blitImageInfo) const VULKAN_HPP_NOEXCEPT; |
| |
| void resolveImage2(const VULKAN_HPP_NAMESPACE::ResolveImageInfo2 &resolveImageInfo) const VULKAN_HPP_NOEXCEPT; |
| |
| void beginRendering(const VULKAN_HPP_NAMESPACE::RenderingInfo &renderingInfo) const VULKAN_HPP_NOEXCEPT; |
| |
| void endRendering() const VULKAN_HPP_NOEXCEPT; |
| |
| void setCullMode(VULKAN_HPP_NAMESPACE::CullModeFlags cullMode VULKAN_HPP_DEFAULT_ARGUMENT_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT; |
| |
| void setFrontFace(VULKAN_HPP_NAMESPACE::FrontFace frontFace) const VULKAN_HPP_NOEXCEPT; |
| |
| void setPrimitiveTopology(VULKAN_HPP_NAMESPACE::PrimitiveTopology primitiveTopology) const VULKAN_HPP_NOEXCEPT; |
| |
| void setViewportWithCount(ArrayProxy<const VULKAN_HPP_NAMESPACE::Viewport> const &viewports) const VULKAN_HPP_NOEXCEPT; |
| |
| void setScissorWithCount(ArrayProxy<const VULKAN_HPP_NAMESPACE::Rect2D> const &scissors) const VULKAN_HPP_NOEXCEPT; |
| |
| void bindVertexBuffers2(uint32_t firstBinding, |
| ArrayProxy<const VULKAN_HPP_NAMESPACE::Buffer> const &buffers, |
| ArrayProxy<const VULKAN_HPP_NAMESPACE::DeviceSize> const &offsets, |
| ArrayProxy<const VULKAN_HPP_NAMESPACE::DeviceSize> const &sizes VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT, |
| ArrayProxy<const VULKAN_HPP_NAMESPACE::DeviceSize> const &strides VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT) const; |
| |
| void setDepthTestEnable(VULKAN_HPP_NAMESPACE::Bool32 depthTestEnable) const VULKAN_HPP_NOEXCEPT; |
| |
| void setDepthWriteEnable(VULKAN_HPP_NAMESPACE::Bool32 depthWriteEnable) const VULKAN_HPP_NOEXCEPT; |
| |
| void setDepthCompareOp(VULKAN_HPP_NAMESPACE::CompareOp depthCompareOp) const VULKAN_HPP_NOEXCEPT; |
| |
| void setDepthBoundsTestEnable(VULKAN_HPP_NAMESPACE::Bool32 depthBoundsTestEnable) const VULKAN_HPP_NOEXCEPT; |
| |
| void setStencilTestEnable(VULKAN_HPP_NAMESPACE::Bool32 stencilTestEnable) const VULKAN_HPP_NOEXCEPT; |
| |
| void setStencilOp(VULKAN_HPP_NAMESPACE::StencilFaceFlags faceMask, |
| VULKAN_HPP_NAMESPACE::StencilOp failOp, |
| VULKAN_HPP_NAMESPACE::StencilOp passOp, |
| VULKAN_HPP_NAMESPACE::StencilOp depthFailOp, |
| VULKAN_HPP_NAMESPACE::CompareOp compareOp) const VULKAN_HPP_NOEXCEPT; |
| |
| void setRasterizerDiscardEnable(VULKAN_HPP_NAMESPACE::Bool32 rasterizerDiscardEnable) const VULKAN_HPP_NOEXCEPT; |
| |
| void setDepthBiasEnable(VULKAN_HPP_NAMESPACE::Bool32 depthBiasEnable) const VULKAN_HPP_NOEXCEPT; |
| |
| void setPrimitiveRestartEnable(VULKAN_HPP_NAMESPACE::Bool32 primitiveRestartEnable) const VULKAN_HPP_NOEXCEPT; |
| |
| //=== VK_EXT_debug_marker === |
| |
| void debugMarkerBeginEXT(const VULKAN_HPP_NAMESPACE::DebugMarkerMarkerInfoEXT &markerInfo) const VULKAN_HPP_NOEXCEPT; |
| |
| void debugMarkerEndEXT() const VULKAN_HPP_NOEXCEPT; |
| |
| void debugMarkerInsertEXT(const VULKAN_HPP_NAMESPACE::DebugMarkerMarkerInfoEXT &markerInfo) const VULKAN_HPP_NOEXCEPT; |
| |
| # if defined(VK_ENABLE_BETA_EXTENSIONS) |
| //=== VK_KHR_video_queue === |
| |
| void beginVideoCodingKHR(const VULKAN_HPP_NAMESPACE::VideoBeginCodingInfoKHR &beginInfo) const VULKAN_HPP_NOEXCEPT; |
| |
| void endVideoCodingKHR(const VULKAN_HPP_NAMESPACE::VideoEndCodingInfoKHR &endCodingInfo) const VULKAN_HPP_NOEXCEPT; |
| |
| void controlVideoCodingKHR(const VULKAN_HPP_NAMESPACE::VideoCodingControlInfoKHR &codingControlInfo) const VULKAN_HPP_NOEXCEPT; |
| # endif /*VK_ENABLE_BETA_EXTENSIONS*/ |
| |
| # if defined(VK_ENABLE_BETA_EXTENSIONS) |
| //=== VK_KHR_video_decode_queue === |
| |
| void decodeVideoKHR(const VULKAN_HPP_NAMESPACE::VideoDecodeInfoKHR &frameInfo) const VULKAN_HPP_NOEXCEPT; |
| # endif /*VK_ENABLE_BETA_EXTENSIONS*/ |
| |
| //=== VK_EXT_transform_feedback === |
| |
| void bindTransformFeedbackBuffersEXT(uint32_t firstBinding, |
| ArrayProxy<const VULKAN_HPP_NAMESPACE::Buffer> const &buffers, |
| ArrayProxy<const VULKAN_HPP_NAMESPACE::DeviceSize> const &offsets, |
| ArrayProxy<const VULKAN_HPP_NAMESPACE::DeviceSize> const &sizes |
| VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT) const; |
| |
| void beginTransformFeedbackEXT(uint32_t firstCounterBuffer, |
| ArrayProxy<const VULKAN_HPP_NAMESPACE::Buffer> const &counterBuffers, |
| ArrayProxy<const VULKAN_HPP_NAMESPACE::DeviceSize> const &counterBufferOffsets |
| VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT) const; |
| |
| void endTransformFeedbackEXT(uint32_t firstCounterBuffer, |
| ArrayProxy<const VULKAN_HPP_NAMESPACE::Buffer> const &counterBuffers, |
| ArrayProxy<const VULKAN_HPP_NAMESPACE::DeviceSize> const &counterBufferOffsets |
| VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT) const; |
| |
| void beginQueryIndexedEXT(VULKAN_HPP_NAMESPACE::QueryPool queryPool, |
| uint32_t query, |
| VULKAN_HPP_NAMESPACE::QueryControlFlags flags, |
| uint32_t index) const VULKAN_HPP_NOEXCEPT; |
| |
| void endQueryIndexedEXT(VULKAN_HPP_NAMESPACE::QueryPool queryPool, uint32_t query, uint32_t index) const VULKAN_HPP_NOEXCEPT; |
| |
| void drawIndirectByteCountEXT(uint32_t instanceCount, |
| uint32_t firstInstance, |
| VULKAN_HPP_NAMESPACE::Buffer counterBuffer, |
| VULKAN_HPP_NAMESPACE::DeviceSize counterBufferOffset, |
| uint32_t counterOffset, |
| uint32_t vertexStride) const VULKAN_HPP_NOEXCEPT; |
| |
| //=== VK_NVX_binary_import === |
| |
| void cuLaunchKernelNVX(const VULKAN_HPP_NAMESPACE::CuLaunchInfoNVX &launchInfo) const VULKAN_HPP_NOEXCEPT; |
| |
| //=== VK_AMD_draw_indirect_count === |
| |
| void drawIndirectCountAMD(VULKAN_HPP_NAMESPACE::Buffer buffer, |
| VULKAN_HPP_NAMESPACE::DeviceSize offset, |
| VULKAN_HPP_NAMESPACE::Buffer countBuffer, |
| VULKAN_HPP_NAMESPACE::DeviceSize countBufferOffset, |
| uint32_t maxDrawCount, |
| uint32_t stride) const VULKAN_HPP_NOEXCEPT; |
| |
| void drawIndexedIndirectCountAMD(VULKAN_HPP_NAMESPACE::Buffer buffer, |
| VULKAN_HPP_NAMESPACE::DeviceSize offset, |
| VULKAN_HPP_NAMESPACE::Buffer countBuffer, |
| VULKAN_HPP_NAMESPACE::DeviceSize countBufferOffset, |
| uint32_t maxDrawCount, |
| uint32_t stride) const VULKAN_HPP_NOEXCEPT; |
| |
| //=== VK_KHR_dynamic_rendering === |
| |
| void beginRenderingKHR(const VULKAN_HPP_NAMESPACE::RenderingInfo &renderingInfo) const VULKAN_HPP_NOEXCEPT; |
| |
| void endRenderingKHR() const VULKAN_HPP_NOEXCEPT; |
| |
| //=== VK_KHR_device_group === |
| |
| void setDeviceMaskKHR(uint32_t deviceMask) const VULKAN_HPP_NOEXCEPT; |
| |
| void dispatchBaseKHR(uint32_t baseGroupX, uint32_t baseGroupY, uint32_t baseGroupZ, uint32_t groupCountX, uint32_t groupCountY, uint32_t groupCountZ) |
| const VULKAN_HPP_NOEXCEPT; |
| |
| //=== VK_KHR_push_descriptor === |
| |
| void pushDescriptorSetKHR(VULKAN_HPP_NAMESPACE::PipelineBindPoint pipelineBindPoint, |
| VULKAN_HPP_NAMESPACE::PipelineLayout layout, |
| uint32_t set, |
| ArrayProxy<const VULKAN_HPP_NAMESPACE::WriteDescriptorSet> const &descriptorWrites) const VULKAN_HPP_NOEXCEPT; |
| |
| template<typename DataType> |
| void pushDescriptorSetWithTemplateKHR(VULKAN_HPP_NAMESPACE::DescriptorUpdateTemplate descriptorUpdateTemplate, |
| VULKAN_HPP_NAMESPACE::PipelineLayout layout, |
| uint32_t set, |
| DataType const &data) const VULKAN_HPP_NOEXCEPT; |
| |
| //=== VK_EXT_conditional_rendering === |
| |
| void beginConditionalRenderingEXT(const VULKAN_HPP_NAMESPACE::ConditionalRenderingBeginInfoEXT &conditionalRenderingBegin) const VULKAN_HPP_NOEXCEPT; |
| |
| void endConditionalRenderingEXT() const VULKAN_HPP_NOEXCEPT; |
| |
| //=== VK_NV_clip_space_w_scaling === |
| |
| void setViewportWScalingNV(uint32_t firstViewport, |
| ArrayProxy<const VULKAN_HPP_NAMESPACE::ViewportWScalingNV> const &viewportWScalings) const VULKAN_HPP_NOEXCEPT; |
| |
| //=== VK_EXT_discard_rectangles === |
| |
| void setDiscardRectangleEXT(uint32_t firstDiscardRectangle, |
| ArrayProxy<const VULKAN_HPP_NAMESPACE::Rect2D> const &discardRectangles) const VULKAN_HPP_NOEXCEPT; |
| |
| //=== VK_KHR_create_renderpass2 === |
| |
| void beginRenderPass2KHR(const VULKAN_HPP_NAMESPACE::RenderPassBeginInfo &renderPassBegin, |
| const VULKAN_HPP_NAMESPACE::SubpassBeginInfo &subpassBeginInfo) const VULKAN_HPP_NOEXCEPT; |
| |
| void nextSubpass2KHR(const VULKAN_HPP_NAMESPACE::SubpassBeginInfo &subpassBeginInfo, |
| const VULKAN_HPP_NAMESPACE::SubpassEndInfo &subpassEndInfo) const VULKAN_HPP_NOEXCEPT; |
| |
| void endRenderPass2KHR(const VULKAN_HPP_NAMESPACE::SubpassEndInfo &subpassEndInfo) const VULKAN_HPP_NOEXCEPT; |
| |
| //=== VK_EXT_debug_utils === |
| |
| void beginDebugUtilsLabelEXT(const VULKAN_HPP_NAMESPACE::DebugUtilsLabelEXT &labelInfo) const VULKAN_HPP_NOEXCEPT; |
| |
| void endDebugUtilsLabelEXT() const VULKAN_HPP_NOEXCEPT; |
| |
| void insertDebugUtilsLabelEXT(const VULKAN_HPP_NAMESPACE::DebugUtilsLabelEXT &labelInfo) const VULKAN_HPP_NOEXCEPT; |
| |
| //=== VK_EXT_sample_locations === |
| |
| void setSampleLocationsEXT(const VULKAN_HPP_NAMESPACE::SampleLocationsInfoEXT &sampleLocationsInfo) const VULKAN_HPP_NOEXCEPT; |
| |
| //=== VK_KHR_acceleration_structure === |
| |
| void |
| buildAccelerationStructuresKHR(ArrayProxy<const VULKAN_HPP_NAMESPACE::AccelerationStructureBuildGeometryInfoKHR> const &infos, |
| ArrayProxy<const VULKAN_HPP_NAMESPACE::AccelerationStructureBuildRangeInfoKHR *const> const &pBuildRangeInfos) const; |
| |
| void buildAccelerationStructuresIndirectKHR(ArrayProxy<const VULKAN_HPP_NAMESPACE::AccelerationStructureBuildGeometryInfoKHR> const &infos, |
| ArrayProxy<const VULKAN_HPP_NAMESPACE::DeviceAddress> const &indirectDeviceAddresses, |
| ArrayProxy<const uint32_t> const &indirectStrides, |
| ArrayProxy<const uint32_t *const> const &pMaxPrimitiveCounts) const; |
| |
| void copyAccelerationStructureKHR(const VULKAN_HPP_NAMESPACE::CopyAccelerationStructureInfoKHR &info) const VULKAN_HPP_NOEXCEPT; |
| |
| void copyAccelerationStructureToMemoryKHR(const VULKAN_HPP_NAMESPACE::CopyAccelerationStructureToMemoryInfoKHR &info) const VULKAN_HPP_NOEXCEPT; |
| |
| void copyMemoryToAccelerationStructureKHR(const VULKAN_HPP_NAMESPACE::CopyMemoryToAccelerationStructureInfoKHR &info) const VULKAN_HPP_NOEXCEPT; |
| |
| void writeAccelerationStructuresPropertiesKHR(ArrayProxy<const VULKAN_HPP_NAMESPACE::AccelerationStructureKHR> const &accelerationStructures, |
| VULKAN_HPP_NAMESPACE::QueryType queryType, |
| VULKAN_HPP_NAMESPACE::QueryPool queryPool, |
| uint32_t firstQuery) const VULKAN_HPP_NOEXCEPT; |
| |
| //=== VK_NV_shading_rate_image === |
| |
| void bindShadingRateImageNV(VULKAN_HPP_NAMESPACE::ImageView imageView, VULKAN_HPP_NAMESPACE::ImageLayout imageLayout) const VULKAN_HPP_NOEXCEPT; |
| |
| void |
| setViewportShadingRatePaletteNV(uint32_t firstViewport, |
| ArrayProxy<const VULKAN_HPP_NAMESPACE::ShadingRatePaletteNV> const &shadingRatePalettes) const VULKAN_HPP_NOEXCEPT; |
| |
| void setCoarseSampleOrderNV(VULKAN_HPP_NAMESPACE::CoarseSampleOrderTypeNV sampleOrderType, |
| ArrayProxy<const VULKAN_HPP_NAMESPACE::CoarseSampleOrderCustomNV> const &customSampleOrders) const VULKAN_HPP_NOEXCEPT; |
| |
| //=== VK_NV_ray_tracing === |
| |
| void buildAccelerationStructureNV(const VULKAN_HPP_NAMESPACE::AccelerationStructureInfoNV &info, |
| VULKAN_HPP_NAMESPACE::Buffer instanceData, |
| VULKAN_HPP_NAMESPACE::DeviceSize instanceOffset, |
| VULKAN_HPP_NAMESPACE::Bool32 update, |
| VULKAN_HPP_NAMESPACE::AccelerationStructureNV dst, |
| VULKAN_HPP_NAMESPACE::AccelerationStructureNV src, |
| VULKAN_HPP_NAMESPACE::Buffer scratch, |
| VULKAN_HPP_NAMESPACE::DeviceSize scratchOffset) const VULKAN_HPP_NOEXCEPT; |
| |
| void copyAccelerationStructureNV(VULKAN_HPP_NAMESPACE::AccelerationStructureNV dst, |
| VULKAN_HPP_NAMESPACE::AccelerationStructureNV src, |
| VULKAN_HPP_NAMESPACE::CopyAccelerationStructureModeKHR mode) const VULKAN_HPP_NOEXCEPT; |
| |
| void traceRaysNV(VULKAN_HPP_NAMESPACE::Buffer raygenShaderBindingTableBuffer, |
| VULKAN_HPP_NAMESPACE::DeviceSize raygenShaderBindingOffset, |
| VULKAN_HPP_NAMESPACE::Buffer missShaderBindingTableBuffer, |
| VULKAN_HPP_NAMESPACE::DeviceSize missShaderBindingOffset, |
| VULKAN_HPP_NAMESPACE::DeviceSize missShaderBindingStride, |
| VULKAN_HPP_NAMESPACE::Buffer hitShaderBindingTableBuffer, |
| VULKAN_HPP_NAMESPACE::DeviceSize hitShaderBindingOffset, |
| VULKAN_HPP_NAMESPACE::DeviceSize hitShaderBindingStride, |
| VULKAN_HPP_NAMESPACE::Buffer callableShaderBindingTableBuffer, |
| VULKAN_HPP_NAMESPACE::DeviceSize callableShaderBindingOffset, |
| VULKAN_HPP_NAMESPACE::DeviceSize callableShaderBindingStride, |
| uint32_t width, |
| uint32_t height, |
| uint32_t depth) const VULKAN_HPP_NOEXCEPT; |
| |
| void writeAccelerationStructuresPropertiesNV(ArrayProxy<const VULKAN_HPP_NAMESPACE::AccelerationStructureNV> const &accelerationStructures, |
| VULKAN_HPP_NAMESPACE::QueryType queryType, |
| VULKAN_HPP_NAMESPACE::QueryPool queryPool, |
| uint32_t firstQuery) const VULKAN_HPP_NOEXCEPT; |
| |
| //=== VK_KHR_draw_indirect_count === |
| |
| void drawIndirectCountKHR(VULKAN_HPP_NAMESPACE::Buffer buffer, |
| VULKAN_HPP_NAMESPACE::DeviceSize offset, |
| VULKAN_HPP_NAMESPACE::Buffer countBuffer, |
| VULKAN_HPP_NAMESPACE::DeviceSize countBufferOffset, |
| uint32_t maxDrawCount, |
| uint32_t stride) const VULKAN_HPP_NOEXCEPT; |
| |
| void drawIndexedIndirectCountKHR(VULKAN_HPP_NAMESPACE::Buffer buffer, |
| VULKAN_HPP_NAMESPACE::DeviceSize offset, |
| VULKAN_HPP_NAMESPACE::Buffer countBuffer, |
| VULKAN_HPP_NAMESPACE::DeviceSize countBufferOffset, |
| uint32_t maxDrawCount, |
| uint32_t stride) const VULKAN_HPP_NOEXCEPT; |
| |
| //=== VK_AMD_buffer_marker === |
| |
| void writeBufferMarkerAMD(VULKAN_HPP_NAMESPACE::PipelineStageFlagBits pipelineStage, |
| VULKAN_HPP_NAMESPACE::Buffer dstBuffer, |
| VULKAN_HPP_NAMESPACE::DeviceSize dstOffset, |
| uint32_t marker) const VULKAN_HPP_NOEXCEPT; |
| |
| //=== VK_NV_mesh_shader === |
| |
| void drawMeshTasksNV(uint32_t taskCount, uint32_t firstTask) const VULKAN_HPP_NOEXCEPT; |
| |
| void drawMeshTasksIndirectNV(VULKAN_HPP_NAMESPACE::Buffer buffer, |
| VULKAN_HPP_NAMESPACE::DeviceSize offset, |
| uint32_t drawCount, |
| uint32_t stride) const VULKAN_HPP_NOEXCEPT; |
| |
| void drawMeshTasksIndirectCountNV(VULKAN_HPP_NAMESPACE::Buffer buffer, |
| VULKAN_HPP_NAMESPACE::DeviceSize offset, |
| VULKAN_HPP_NAMESPACE::Buffer countBuffer, |
| VULKAN_HPP_NAMESPACE::DeviceSize countBufferOffset, |
| uint32_t maxDrawCount, |
| uint32_t stride) const VULKAN_HPP_NOEXCEPT; |
| |
| //=== VK_NV_scissor_exclusive === |
| |
| void setExclusiveScissorNV(uint32_t firstExclusiveScissor, |
| ArrayProxy<const VULKAN_HPP_NAMESPACE::Rect2D> const &exclusiveScissors) const VULKAN_HPP_NOEXCEPT; |
| |
| //=== VK_NV_device_diagnostic_checkpoints === |
| |
| template<typename CheckpointMarkerType> |
| void setCheckpointNV(CheckpointMarkerType const &checkpointMarker) const VULKAN_HPP_NOEXCEPT; |
| |
| //=== VK_INTEL_performance_query === |
| |
| void setPerformanceMarkerINTEL(const VULKAN_HPP_NAMESPACE::PerformanceMarkerInfoINTEL &markerInfo) const; |
| |
| void setPerformanceStreamMarkerINTEL(const VULKAN_HPP_NAMESPACE::PerformanceStreamMarkerInfoINTEL &markerInfo) const; |
| |
| void setPerformanceOverrideINTEL(const VULKAN_HPP_NAMESPACE::PerformanceOverrideInfoINTEL &overrideInfo) const; |
| |
| //=== VK_KHR_fragment_shading_rate === |
| |
| void setFragmentShadingRateKHR(const VULKAN_HPP_NAMESPACE::Extent2D &fragmentSize, |
| const VULKAN_HPP_NAMESPACE::FragmentShadingRateCombinerOpKHR combinerOps[2]) const VULKAN_HPP_NOEXCEPT; |
| |
| //=== VK_EXT_line_rasterization === |
| |
| void setLineStippleEXT(uint32_t lineStippleFactor, uint16_t lineStipplePattern) const VULKAN_HPP_NOEXCEPT; |
| |
| //=== VK_EXT_extended_dynamic_state === |
| |
| void setCullModeEXT(VULKAN_HPP_NAMESPACE::CullModeFlags cullMode VULKAN_HPP_DEFAULT_ARGUMENT_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT; |
| |
| void setFrontFaceEXT(VULKAN_HPP_NAMESPACE::FrontFace frontFace) const VULKAN_HPP_NOEXCEPT; |
| |
| void setPrimitiveTopologyEXT(VULKAN_HPP_NAMESPACE::PrimitiveTopology primitiveTopology) const VULKAN_HPP_NOEXCEPT; |
| |
| void setViewportWithCountEXT(ArrayProxy<const VULKAN_HPP_NAMESPACE::Viewport> const &viewports) const VULKAN_HPP_NOEXCEPT; |
| |
| void setScissorWithCountEXT(ArrayProxy<const VULKAN_HPP_NAMESPACE::Rect2D> const &scissors) const VULKAN_HPP_NOEXCEPT; |
| |
| void bindVertexBuffers2EXT(uint32_t firstBinding, |
| ArrayProxy<const VULKAN_HPP_NAMESPACE::Buffer> const &buffers, |
| ArrayProxy<const VULKAN_HPP_NAMESPACE::DeviceSize> const &offsets, |
| ArrayProxy<const VULKAN_HPP_NAMESPACE::DeviceSize> const &sizes VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT, |
| ArrayProxy<const VULKAN_HPP_NAMESPACE::DeviceSize> const &strides VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT) const; |
| |
| void setDepthTestEnableEXT(VULKAN_HPP_NAMESPACE::Bool32 depthTestEnable) const VULKAN_HPP_NOEXCEPT; |
| |
| void setDepthWriteEnableEXT(VULKAN_HPP_NAMESPACE::Bool32 depthWriteEnable) const VULKAN_HPP_NOEXCEPT; |
| |
| void setDepthCompareOpEXT(VULKAN_HPP_NAMESPACE::CompareOp depthCompareOp) const VULKAN_HPP_NOEXCEPT; |
| |
| void setDepthBoundsTestEnableEXT(VULKAN_HPP_NAMESPACE::Bool32 depthBoundsTestEnable) const VULKAN_HPP_NOEXCEPT; |
| |
| void setStencilTestEnableEXT(VULKAN_HPP_NAMESPACE::Bool32 stencilTestEnable) const VULKAN_HPP_NOEXCEPT; |
| |
| void setStencilOpEXT(VULKAN_HPP_NAMESPACE::StencilFaceFlags faceMask, |
| VULKAN_HPP_NAMESPACE::StencilOp failOp, |
| VULKAN_HPP_NAMESPACE::StencilOp passOp, |
| VULKAN_HPP_NAMESPACE::StencilOp depthFailOp, |
| VULKAN_HPP_NAMESPACE::CompareOp compareOp) const VULKAN_HPP_NOEXCEPT; |
| |
| //=== VK_NV_device_generated_commands === |
| |
| void preprocessGeneratedCommandsNV(const VULKAN_HPP_NAMESPACE::GeneratedCommandsInfoNV &generatedCommandsInfo) const VULKAN_HPP_NOEXCEPT; |
| |
| void executeGeneratedCommandsNV(VULKAN_HPP_NAMESPACE::Bool32 isPreprocessed, |
| const VULKAN_HPP_NAMESPACE::GeneratedCommandsInfoNV &generatedCommandsInfo) const VULKAN_HPP_NOEXCEPT; |
| |
| void bindPipelineShaderGroupNV(VULKAN_HPP_NAMESPACE::PipelineBindPoint pipelineBindPoint, |
| VULKAN_HPP_NAMESPACE::Pipeline pipeline, |
| uint32_t groupIndex) const VULKAN_HPP_NOEXCEPT; |
| |
| # if defined(VK_ENABLE_BETA_EXTENSIONS) |
| //=== VK_KHR_video_encode_queue === |
| |
| void encodeVideoKHR(const VULKAN_HPP_NAMESPACE::VideoEncodeInfoKHR &encodeInfo) const VULKAN_HPP_NOEXCEPT; |
| # endif /*VK_ENABLE_BETA_EXTENSIONS*/ |
| |
| //=== VK_KHR_synchronization2 === |
| |
| void setEvent2KHR(VULKAN_HPP_NAMESPACE::Event event, const VULKAN_HPP_NAMESPACE::DependencyInfo &dependencyInfo) const VULKAN_HPP_NOEXCEPT; |
| |
| void resetEvent2KHR(VULKAN_HPP_NAMESPACE::Event event, |
| VULKAN_HPP_NAMESPACE::PipelineStageFlags2 stageMask VULKAN_HPP_DEFAULT_ARGUMENT_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT; |
| |
| void waitEvents2KHR(ArrayProxy<const VULKAN_HPP_NAMESPACE::Event> const &events, |
| ArrayProxy<const VULKAN_HPP_NAMESPACE::DependencyInfo> const &dependencyInfos) const; |
| |
| void pipelineBarrier2KHR(const VULKAN_HPP_NAMESPACE::DependencyInfo &dependencyInfo) const VULKAN_HPP_NOEXCEPT; |
| |
| void writeTimestamp2KHR(VULKAN_HPP_NAMESPACE::PipelineStageFlags2 stage, |
| VULKAN_HPP_NAMESPACE::QueryPool queryPool, |
| uint32_t query) const VULKAN_HPP_NOEXCEPT; |
| |
| void writeBufferMarker2AMD(VULKAN_HPP_NAMESPACE::PipelineStageFlags2 stage, |
| VULKAN_HPP_NAMESPACE::Buffer dstBuffer, |
| VULKAN_HPP_NAMESPACE::DeviceSize dstOffset, |
| uint32_t marker) const VULKAN_HPP_NOEXCEPT; |
| |
| //=== VK_NV_fragment_shading_rate_enums === |
| |
| void setFragmentShadingRateEnumNV(VULKAN_HPP_NAMESPACE::FragmentShadingRateNV shadingRate, |
| const VULKAN_HPP_NAMESPACE::FragmentShadingRateCombinerOpKHR combinerOps[2]) const VULKAN_HPP_NOEXCEPT; |
| |
| //=== VK_KHR_copy_commands2 === |
| |
| void copyBuffer2KHR(const VULKAN_HPP_NAMESPACE::CopyBufferInfo2 ©BufferInfo) const VULKAN_HPP_NOEXCEPT; |
| |
| void copyImage2KHR(const VULKAN_HPP_NAMESPACE::CopyImageInfo2 ©ImageInfo) const VULKAN_HPP_NOEXCEPT; |
| |
| void copyBufferToImage2KHR(const VULKAN_HPP_NAMESPACE::CopyBufferToImageInfo2 ©BufferToImageInfo) const VULKAN_HPP_NOEXCEPT; |
| |
| void copyImageToBuffer2KHR(const VULKAN_HPP_NAMESPACE::CopyImageToBufferInfo2 ©ImageToBufferInfo) const VULKAN_HPP_NOEXCEPT; |
| |
| void blitImage2KHR(const VULKAN_HPP_NAMESPACE::BlitImageInfo2 &blitImageInfo) const VULKAN_HPP_NOEXCEPT; |
| |
| void resolveImage2KHR(const VULKAN_HPP_NAMESPACE::ResolveImageInfo2 &resolveImageInfo) const VULKAN_HPP_NOEXCEPT; |
| |
| //=== VK_KHR_ray_tracing_pipeline === |
| |
| void traceRaysKHR(const VULKAN_HPP_NAMESPACE::StridedDeviceAddressRegionKHR &raygenShaderBindingTable, |
| const VULKAN_HPP_NAMESPACE::StridedDeviceAddressRegionKHR &missShaderBindingTable, |
| const VULKAN_HPP_NAMESPACE::StridedDeviceAddressRegionKHR &hitShaderBindingTable, |
| const VULKAN_HPP_NAMESPACE::StridedDeviceAddressRegionKHR &callableShaderBindingTable, |
| uint32_t width, |
| uint32_t height, |
| uint32_t depth) const VULKAN_HPP_NOEXCEPT; |
| |
| void traceRaysIndirectKHR(const VULKAN_HPP_NAMESPACE::StridedDeviceAddressRegionKHR &raygenShaderBindingTable, |
| const VULKAN_HPP_NAMESPACE::StridedDeviceAddressRegionKHR &missShaderBindingTable, |
| const VULKAN_HPP_NAMESPACE::StridedDeviceAddressRegionKHR &hitShaderBindingTable, |
| const VULKAN_HPP_NAMESPACE::StridedDeviceAddressRegionKHR &callableShaderBindingTable, |
| VULKAN_HPP_NAMESPACE::DeviceAddress indirectDeviceAddress) const VULKAN_HPP_NOEXCEPT; |
| |
| void setRayTracingPipelineStackSizeKHR(uint32_t pipelineStackSize) const VULKAN_HPP_NOEXCEPT; |
| |
| //=== VK_EXT_vertex_input_dynamic_state === |
| |
| void setVertexInputEXT(ArrayProxy<const VULKAN_HPP_NAMESPACE::VertexInputBindingDescription2EXT> const &vertexBindingDescriptions, |
| ArrayProxy<const VULKAN_HPP_NAMESPACE::VertexInputAttributeDescription2EXT> const &vertexAttributeDescriptions) const |
| VULKAN_HPP_NOEXCEPT; |
| |
| //=== VK_HUAWEI_subpass_shading === |
| |
| void subpassShadingHUAWEI() const VULKAN_HPP_NOEXCEPT; |
| |
| //=== VK_HUAWEI_invocation_mask === |
| |
| void bindInvocationMaskHUAWEI(VULKAN_HPP_NAMESPACE::ImageView imageView, VULKAN_HPP_NAMESPACE::ImageLayout imageLayout) const VULKAN_HPP_NOEXCEPT; |
| |
| //=== VK_EXT_extended_dynamic_state2 === |
| |
| void setPatchControlPointsEXT(uint32_t patchControlPoints) const VULKAN_HPP_NOEXCEPT; |
| |
| void setRasterizerDiscardEnableEXT(VULKAN_HPP_NAMESPACE::Bool32 rasterizerDiscardEnable) const VULKAN_HPP_NOEXCEPT; |
| |
| void setDepthBiasEnableEXT(VULKAN_HPP_NAMESPACE::Bool32 depthBiasEnable) const VULKAN_HPP_NOEXCEPT; |
| |
| void setLogicOpEXT(VULKAN_HPP_NAMESPACE::LogicOp logicOp) const VULKAN_HPP_NOEXCEPT; |
| |
| void setPrimitiveRestartEnableEXT(VULKAN_HPP_NAMESPACE::Bool32 primitiveRestartEnable) const VULKAN_HPP_NOEXCEPT; |
| |
| //=== VK_EXT_color_write_enable === |
| |
| void setColorWriteEnableEXT(ArrayProxy<const VULKAN_HPP_NAMESPACE::Bool32> const &colorWriteEnables) const VULKAN_HPP_NOEXCEPT; |
| |
| //=== VK_EXT_multi_draw === |
| |
| void drawMultiEXT(ArrayProxy<const VULKAN_HPP_NAMESPACE::MultiDrawInfoEXT> const &vertexInfo, |
| uint32_t instanceCount, |
| uint32_t firstInstance, |
| uint32_t stride) const VULKAN_HPP_NOEXCEPT; |
| |
| void drawMultiIndexedEXT(ArrayProxy<const VULKAN_HPP_NAMESPACE::MultiDrawIndexedInfoEXT> const &indexInfo, |
| uint32_t instanceCount, |
| uint32_t firstInstance, |
| uint32_t stride, |
| Optional<const int32_t> vertexOffset VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT; |
| |
| private: |
| VULKAN_HPP_NAMESPACE::Device m_device = {}; |
| VULKAN_HPP_NAMESPACE::CommandPool m_commandPool = {}; |
| VULKAN_HPP_NAMESPACE::CommandBuffer m_commandBuffer = {}; |
| VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::DeviceDispatcher const *m_dispatcher = nullptr; |
| }; |
| |
| class CommandBuffers : public std::vector<VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::CommandBuffer> |
| { |
| public: |
| CommandBuffers(VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::Device const &device, |
| VULKAN_HPP_NAMESPACE::CommandBufferAllocateInfo const &allocateInfo) |
| { |
| VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::DeviceDispatcher const *dispatcher = device.getDispatcher(); |
| std::vector<VkCommandBuffer> commandBuffers(allocateInfo.commandBufferCount); |
| VULKAN_HPP_NAMESPACE::Result result = static_cast<VULKAN_HPP_NAMESPACE::Result>(dispatcher->vkAllocateCommandBuffers( |
| static_cast<VkDevice>(*device), reinterpret_cast<const VkCommandBufferAllocateInfo *>(&allocateInfo), commandBuffers.data())); |
| if(result == VULKAN_HPP_NAMESPACE::Result::eSuccess) |
| { |
| this->reserve(allocateInfo.commandBufferCount); |
| for(auto const &commandBuffer : commandBuffers) |
| { |
| this->emplace_back(device, commandBuffer, static_cast<VkCommandPool>(allocateInfo.commandPool)); |
| } |
| } |
| else |
| { |
| throwResultException(result, "vkAllocateCommandBuffers"); |
| } |
| } |
| |
| CommandBuffers(std::nullptr_t) {} |
| |
| CommandBuffers() = delete; |
| CommandBuffers(CommandBuffers const &) = delete; |
| CommandBuffers(CommandBuffers &&rhs) = default; |
| CommandBuffers &operator=(CommandBuffers const &) = delete; |
| CommandBuffers &operator=(CommandBuffers &&rhs) = default; |
| }; |
| |
| class CuFunctionNVX |
| { |
| public: |
| using CType = VkCuFunctionNVX; |
| |
| static VULKAN_HPP_CONST_OR_CONSTEXPR VULKAN_HPP_NAMESPACE::ObjectType objectType = VULKAN_HPP_NAMESPACE::ObjectType::eCuFunctionNVX; |
| static VULKAN_HPP_CONST_OR_CONSTEXPR VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT debugReportObjectType = |
| VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT::eCuFunctionNVX; |
| |
| public: |
| CuFunctionNVX(VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::Device const &device, |
| VULKAN_HPP_NAMESPACE::CuFunctionCreateInfoNVX const &createInfo, |
| VULKAN_HPP_NAMESPACE::Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator = nullptr) |
| : m_device(*device) |
| , m_allocator(static_cast<const VULKAN_HPP_NAMESPACE::AllocationCallbacks *>(allocator)) |
| , m_dispatcher(device.getDispatcher()) |
| { |
| VULKAN_HPP_NAMESPACE::Result result = static_cast<VULKAN_HPP_NAMESPACE::Result>( |
| device.getDispatcher()->vkCreateCuFunctionNVX(static_cast<VkDevice>(*device), |
| reinterpret_cast<const VkCuFunctionCreateInfoNVX *>(&createInfo), |
| reinterpret_cast<const VkAllocationCallbacks *>(m_allocator), |
| reinterpret_cast<VkCuFunctionNVX *>(&m_function))); |
| if(result != VULKAN_HPP_NAMESPACE::Result::eSuccess) |
| { |
| throwResultException(result, "vkCreateCuFunctionNVX"); |
| } |
| } |
| |
| CuFunctionNVX(VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::Device const &device, |
| VkCuFunctionNVX function, |
| VULKAN_HPP_NAMESPACE::Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator = nullptr) |
| : m_device(*device) |
| , m_function(function) |
| , m_allocator(static_cast<const VULKAN_HPP_NAMESPACE::AllocationCallbacks *>(allocator)) |
| , m_dispatcher(device.getDispatcher()) |
| { |
| } |
| |
| CuFunctionNVX(std::nullptr_t) {} |
| |
| ~CuFunctionNVX() |
| { |
| clear(); |
| } |
| |
| CuFunctionNVX() = delete; |
| CuFunctionNVX(CuFunctionNVX const &) = delete; |
| CuFunctionNVX(CuFunctionNVX &&rhs) VULKAN_HPP_NOEXCEPT |
| : m_device(VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange(rhs.m_device, {})), |
| m_function(VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange(rhs.m_function, {})), |
| m_allocator(VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange(rhs.m_allocator, {})), |
| m_dispatcher(VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange(rhs.m_dispatcher, nullptr)) |
| { |
| } |
| CuFunctionNVX &operator=(CuFunctionNVX const &) = delete; |
| CuFunctionNVX &operator=(CuFunctionNVX &&rhs) VULKAN_HPP_NOEXCEPT |
| { |
| if(this != &rhs) |
| { |
| clear(); |
| m_device = VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange(rhs.m_device, {}); |
| m_function = VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange(rhs.m_function, {}); |
| m_allocator = VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange(rhs.m_allocator, {}); |
| m_dispatcher = VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange(rhs.m_dispatcher, nullptr); |
| } |
| return *this; |
| } |
| |
| VULKAN_HPP_NAMESPACE::CuFunctionNVX const &operator*() const VULKAN_HPP_NOEXCEPT |
| { |
| return m_function; |
| } |
| |
| void clear() VULKAN_HPP_NOEXCEPT |
| { |
| if(m_function) |
| { |
| getDispatcher()->vkDestroyCuFunctionNVX( |
| static_cast<VkDevice>(m_device), static_cast<VkCuFunctionNVX>(m_function), reinterpret_cast<const VkAllocationCallbacks *>(m_allocator)); |
| } |
| m_device = nullptr; |
| m_function = nullptr; |
| m_allocator = nullptr; |
| m_dispatcher = nullptr; |
| } |
| |
| VULKAN_HPP_NAMESPACE::Device getDevice() const |
| { |
| return m_device; |
| } |
| |
| VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::DeviceDispatcher const *getDispatcher() const |
| { |
| VULKAN_HPP_ASSERT(m_dispatcher->getVkHeaderVersion() == VK_HEADER_VERSION); |
| return m_dispatcher; |
| } |
| |
| void swap(VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::CuFunctionNVX &rhs) VULKAN_HPP_NOEXCEPT |
| { |
| std::swap(m_device, rhs.m_device); |
| std::swap(m_function, rhs.m_function); |
| std::swap(m_allocator, rhs.m_allocator); |
| std::swap(m_dispatcher, rhs.m_dispatcher); |
| } |
| |
| private: |
| VULKAN_HPP_NAMESPACE::Device m_device = {}; |
| VULKAN_HPP_NAMESPACE::CuFunctionNVX m_function = {}; |
| const VULKAN_HPP_NAMESPACE::AllocationCallbacks *m_allocator = {}; |
| VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::DeviceDispatcher const *m_dispatcher = nullptr; |
| }; |
| |
| class CuModuleNVX |
| { |
| public: |
| using CType = VkCuModuleNVX; |
| |
| static VULKAN_HPP_CONST_OR_CONSTEXPR VULKAN_HPP_NAMESPACE::ObjectType objectType = VULKAN_HPP_NAMESPACE::ObjectType::eCuModuleNVX; |
| static VULKAN_HPP_CONST_OR_CONSTEXPR VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT debugReportObjectType = |
| VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT::eCuModuleNVX; |
| |
| public: |
| CuModuleNVX(VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::Device const &device, |
| VULKAN_HPP_NAMESPACE::CuModuleCreateInfoNVX const &createInfo, |
| VULKAN_HPP_NAMESPACE::Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator = nullptr) |
| : m_device(*device) |
| , m_allocator(static_cast<const VULKAN_HPP_NAMESPACE::AllocationCallbacks *>(allocator)) |
| , m_dispatcher(device.getDispatcher()) |
| { |
| VULKAN_HPP_NAMESPACE::Result result = static_cast<VULKAN_HPP_NAMESPACE::Result>( |
| device.getDispatcher()->vkCreateCuModuleNVX(static_cast<VkDevice>(*device), |
| reinterpret_cast<const VkCuModuleCreateInfoNVX *>(&createInfo), |
| reinterpret_cast<const VkAllocationCallbacks *>(m_allocator), |
| reinterpret_cast<VkCuModuleNVX *>(&m_module))); |
| if(result != VULKAN_HPP_NAMESPACE::Result::eSuccess) |
| { |
| throwResultException(result, "vkCreateCuModuleNVX"); |
| } |
| } |
| |
| CuModuleNVX(VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::Device const &device, |
| VkCuModuleNVX module, |
| VULKAN_HPP_NAMESPACE::Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator = nullptr) |
| : m_device(*device) |
| , m_module(module) |
| , m_allocator(static_cast<const VULKAN_HPP_NAMESPACE::AllocationCallbacks *>(allocator)) |
| , m_dispatcher(device.getDispatcher()) |
| { |
| } |
| |
| CuModuleNVX(std::nullptr_t) {} |
| |
| ~CuModuleNVX() |
| { |
| clear(); |
| } |
| |
| CuModuleNVX() = delete; |
| CuModuleNVX(CuModuleNVX const &) = delete; |
| CuModuleNVX(CuModuleNVX &&rhs) VULKAN_HPP_NOEXCEPT |
| : m_device(VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange(rhs.m_device, {})), |
| m_module(VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange(rhs.m_module, {})), |
| m_allocator(VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange(rhs.m_allocator, {})), |
| m_dispatcher(VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange(rhs.m_dispatcher, nullptr)) |
| { |
| } |
| CuModuleNVX &operator=(CuModuleNVX const &) = delete; |
| CuModuleNVX &operator=(CuModuleNVX &&rhs) VULKAN_HPP_NOEXCEPT |
| { |
| if(this != &rhs) |
| { |
| clear(); |
| m_device = VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange(rhs.m_device, {}); |
| m_module = VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange(rhs.m_module, {}); |
| m_allocator = VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange(rhs.m_allocator, {}); |
| m_dispatcher = VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange(rhs.m_dispatcher, nullptr); |
| } |
| return *this; |
| } |
| |
| VULKAN_HPP_NAMESPACE::CuModuleNVX const &operator*() const VULKAN_HPP_NOEXCEPT |
| { |
| return m_module; |
| } |
| |
| void clear() VULKAN_HPP_NOEXCEPT |
| { |
| if(m_module) |
| { |
| getDispatcher()->vkDestroyCuModuleNVX( |
| static_cast<VkDevice>(m_device), static_cast<VkCuModuleNVX>(m_module), reinterpret_cast<const VkAllocationCallbacks *>(m_allocator)); |
| } |
| m_device = nullptr; |
| m_module = nullptr; |
| m_allocator = nullptr; |
| m_dispatcher = nullptr; |
| } |
| |
| VULKAN_HPP_NAMESPACE::Device getDevice() const |
| { |
| return m_device; |
| } |
| |
| VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::DeviceDispatcher const *getDispatcher() const |
| { |
| VULKAN_HPP_ASSERT(m_dispatcher->getVkHeaderVersion() == VK_HEADER_VERSION); |
| return m_dispatcher; |
| } |
| |
| void swap(VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::CuModuleNVX &rhs) VULKAN_HPP_NOEXCEPT |
| { |
| std::swap(m_device, rhs.m_device); |
| std::swap(m_module, rhs.m_module); |
| std::swap(m_allocator, rhs.m_allocator); |
| std::swap(m_dispatcher, rhs.m_dispatcher); |
| } |
| |
| private: |
| VULKAN_HPP_NAMESPACE::Device m_device = {}; |
| VULKAN_HPP_NAMESPACE::CuModuleNVX m_module = {}; |
| const VULKAN_HPP_NAMESPACE::AllocationCallbacks *m_allocator = {}; |
| VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::DeviceDispatcher const *m_dispatcher = nullptr; |
| }; |
| |
| class DebugReportCallbackEXT |
| { |
| public: |
| using CType = VkDebugReportCallbackEXT; |
| |
| static VULKAN_HPP_CONST_OR_CONSTEXPR VULKAN_HPP_NAMESPACE::ObjectType objectType = VULKAN_HPP_NAMESPACE::ObjectType::eDebugReportCallbackEXT; |
| static VULKAN_HPP_CONST_OR_CONSTEXPR VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT debugReportObjectType = |
| VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT::eDebugReportCallbackEXT; |
| |
| public: |
| DebugReportCallbackEXT(VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::Instance const &instance, |
| VULKAN_HPP_NAMESPACE::DebugReportCallbackCreateInfoEXT const &createInfo, |
| VULKAN_HPP_NAMESPACE::Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator = nullptr) |
| : m_instance(*instance) |
| , m_allocator(static_cast<const VULKAN_HPP_NAMESPACE::AllocationCallbacks *>(allocator)) |
| , m_dispatcher(instance.getDispatcher()) |
| { |
| VULKAN_HPP_NAMESPACE::Result result = static_cast<VULKAN_HPP_NAMESPACE::Result>( |
| instance.getDispatcher()->vkCreateDebugReportCallbackEXT(static_cast<VkInstance>(*instance), |
| reinterpret_cast<const VkDebugReportCallbackCreateInfoEXT *>(&createInfo), |
| reinterpret_cast<const VkAllocationCallbacks *>(m_allocator), |
| reinterpret_cast<VkDebugReportCallbackEXT *>(&m_callback))); |
| if(result != VULKAN_HPP_NAMESPACE::Result::eSuccess) |
| { |
| throwResultException(result, "vkCreateDebugReportCallbackEXT"); |
| } |
| } |
| |
| DebugReportCallbackEXT(VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::Instance const &instance, |
| VkDebugReportCallbackEXT callback, |
| VULKAN_HPP_NAMESPACE::Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator = nullptr) |
| : m_instance(*instance) |
| , m_callback(callback) |
| , m_allocator(static_cast<const VULKAN_HPP_NAMESPACE::AllocationCallbacks *>(allocator)) |
| , m_dispatcher(instance.getDispatcher()) |
| { |
| } |
| |
| DebugReportCallbackEXT(std::nullptr_t) {} |
| |
| ~DebugReportCallbackEXT() |
| { |
| clear(); |
| } |
| |
| DebugReportCallbackEXT() = delete; |
| DebugReportCallbackEXT(DebugReportCallbackEXT const &) = delete; |
| DebugReportCallbackEXT(DebugReportCallbackEXT &&rhs) VULKAN_HPP_NOEXCEPT |
| : m_instance(VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange(rhs.m_instance, {})), |
| m_callback(VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange(rhs.m_callback, {})), |
| m_allocator(VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange(rhs.m_allocator, {})), |
| m_dispatcher(VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange(rhs.m_dispatcher, nullptr)) |
| { |
| } |
| DebugReportCallbackEXT &operator=(DebugReportCallbackEXT const &) = delete; |
| DebugReportCallbackEXT &operator=(DebugReportCallbackEXT &&rhs) VULKAN_HPP_NOEXCEPT |
| { |
| if(this != &rhs) |
| { |
| clear(); |
| m_instance = VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange(rhs.m_instance, {}); |
| m_callback = VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange(rhs.m_callback, {}); |
| m_allocator = VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange(rhs.m_allocator, {}); |
| m_dispatcher = VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange(rhs.m_dispatcher, nullptr); |
| } |
| return *this; |
| } |
| |
| VULKAN_HPP_NAMESPACE::DebugReportCallbackEXT const &operator*() const VULKAN_HPP_NOEXCEPT |
| { |
| return m_callback; |
| } |
| |
| void clear() VULKAN_HPP_NOEXCEPT |
| { |
| if(m_callback) |
| { |
| getDispatcher()->vkDestroyDebugReportCallbackEXT(static_cast<VkInstance>(m_instance), |
| static_cast<VkDebugReportCallbackEXT>(m_callback), |
| reinterpret_cast<const VkAllocationCallbacks *>(m_allocator)); |
| } |
| m_instance = nullptr; |
| m_callback = nullptr; |
| m_allocator = nullptr; |
| m_dispatcher = nullptr; |
| } |
| |
| VULKAN_HPP_NAMESPACE::Instance getInstance() const |
| { |
| return m_instance; |
| } |
| |
| VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::InstanceDispatcher const *getDispatcher() const |
| { |
| VULKAN_HPP_ASSERT(m_dispatcher->getVkHeaderVersion() == VK_HEADER_VERSION); |
| return m_dispatcher; |
| } |
| |
| void swap(VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::DebugReportCallbackEXT &rhs) VULKAN_HPP_NOEXCEPT |
| { |
| std::swap(m_instance, rhs.m_instance); |
| std::swap(m_callback, rhs.m_callback); |
| std::swap(m_allocator, rhs.m_allocator); |
| std::swap(m_dispatcher, rhs.m_dispatcher); |
| } |
| |
| private: |
| VULKAN_HPP_NAMESPACE::Instance m_instance = {}; |
| VULKAN_HPP_NAMESPACE::DebugReportCallbackEXT m_callback = {}; |
| const VULKAN_HPP_NAMESPACE::AllocationCallbacks *m_allocator = {}; |
| VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::InstanceDispatcher const *m_dispatcher = nullptr; |
| }; |
| |
| class DebugUtilsMessengerEXT |
| { |
| public: |
| using CType = VkDebugUtilsMessengerEXT; |
| |
| static VULKAN_HPP_CONST_OR_CONSTEXPR VULKAN_HPP_NAMESPACE::ObjectType objectType = VULKAN_HPP_NAMESPACE::ObjectType::eDebugUtilsMessengerEXT; |
| static VULKAN_HPP_CONST_OR_CONSTEXPR VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT debugReportObjectType = |
| VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT::eUnknown; |
| |
| public: |
| DebugUtilsMessengerEXT(VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::Instance const &instance, |
| VULKAN_HPP_NAMESPACE::DebugUtilsMessengerCreateInfoEXT const &createInfo, |
| VULKAN_HPP_NAMESPACE::Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator = nullptr) |
| : m_instance(*instance) |
| , m_allocator(static_cast<const VULKAN_HPP_NAMESPACE::AllocationCallbacks *>(allocator)) |
| , m_dispatcher(instance.getDispatcher()) |
| { |
| VULKAN_HPP_NAMESPACE::Result result = static_cast<VULKAN_HPP_NAMESPACE::Result>( |
| instance.getDispatcher()->vkCreateDebugUtilsMessengerEXT(static_cast<VkInstance>(*instance), |
| reinterpret_cast<const VkDebugUtilsMessengerCreateInfoEXT *>(&createInfo), |
| reinterpret_cast<const VkAllocationCallbacks *>(m_allocator), |
| reinterpret_cast<VkDebugUtilsMessengerEXT *>(&m_messenger))); |
| if(result != VULKAN_HPP_NAMESPACE::Result::eSuccess) |
| { |
| throwResultException(result, "vkCreateDebugUtilsMessengerEXT"); |
| } |
| } |
| |
| DebugUtilsMessengerEXT(VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::Instance const &instance, |
| VkDebugUtilsMessengerEXT messenger, |
| VULKAN_HPP_NAMESPACE::Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator = nullptr) |
| : m_instance(*instance) |
| , m_messenger(messenger) |
| , m_allocator(static_cast<const VULKAN_HPP_NAMESPACE::AllocationCallbacks *>(allocator)) |
| , m_dispatcher(instance.getDispatcher()) |
| { |
| } |
| |
| DebugUtilsMessengerEXT(std::nullptr_t) {} |
| |
| ~DebugUtilsMessengerEXT() |
| { |
| clear(); |
| } |
| |
| DebugUtilsMessengerEXT() = delete; |
| DebugUtilsMessengerEXT(DebugUtilsMessengerEXT const &) = delete; |
| DebugUtilsMessengerEXT(DebugUtilsMessengerEXT &&rhs) VULKAN_HPP_NOEXCEPT |
| : m_instance(VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange(rhs.m_instance, {})), |
| m_messenger(VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange(rhs.m_messenger, {})), |
| m_allocator(VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange(rhs.m_allocator, {})), |
| m_dispatcher(VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange(rhs.m_dispatcher, nullptr)) |
| { |
| } |
| DebugUtilsMessengerEXT &operator=(DebugUtilsMessengerEXT const &) = delete; |
| DebugUtilsMessengerEXT &operator=(DebugUtilsMessengerEXT &&rhs) VULKAN_HPP_NOEXCEPT |
| { |
| if(this != &rhs) |
| { |
| clear(); |
| m_instance = VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange(rhs.m_instance, {}); |
| m_messenger = VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange(rhs.m_messenger, {}); |
| m_allocator = VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange(rhs.m_allocator, {}); |
| m_dispatcher = VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange(rhs.m_dispatcher, nullptr); |
| } |
| return *this; |
| } |
| |
| VULKAN_HPP_NAMESPACE::DebugUtilsMessengerEXT const &operator*() const VULKAN_HPP_NOEXCEPT |
| { |
| return m_messenger; |
| } |
| |
| void clear() VULKAN_HPP_NOEXCEPT |
| { |
| if(m_messenger) |
| { |
| getDispatcher()->vkDestroyDebugUtilsMessengerEXT(static_cast<VkInstance>(m_instance), |
| static_cast<VkDebugUtilsMessengerEXT>(m_messenger), |
| reinterpret_cast<const VkAllocationCallbacks *>(m_allocator)); |
| } |
| m_instance = nullptr; |
| m_messenger = nullptr; |
| m_allocator = nullptr; |
| m_dispatcher = nullptr; |
| } |
| |
| VULKAN_HPP_NAMESPACE::Instance getInstance() const |
| { |
| return m_instance; |
| } |
| |
| VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::InstanceDispatcher const *getDispatcher() const |
| { |
| VULKAN_HPP_ASSERT(m_dispatcher->getVkHeaderVersion() == VK_HEADER_VERSION); |
| return m_dispatcher; |
| } |
| |
| void swap(VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::DebugUtilsMessengerEXT &rhs) VULKAN_HPP_NOEXCEPT |
| { |
| std::swap(m_instance, rhs.m_instance); |
| std::swap(m_messenger, rhs.m_messenger); |
| std::swap(m_allocator, rhs.m_allocator); |
| std::swap(m_dispatcher, rhs.m_dispatcher); |
| } |
| |
| private: |
| VULKAN_HPP_NAMESPACE::Instance m_instance = {}; |
| VULKAN_HPP_NAMESPACE::DebugUtilsMessengerEXT m_messenger = {}; |
| const VULKAN_HPP_NAMESPACE::AllocationCallbacks *m_allocator = {}; |
| VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::InstanceDispatcher const *m_dispatcher = nullptr; |
| }; |
| |
| class DeferredOperationKHR |
| { |
| public: |
| using CType = VkDeferredOperationKHR; |
| |
| static VULKAN_HPP_CONST_OR_CONSTEXPR VULKAN_HPP_NAMESPACE::ObjectType objectType = VULKAN_HPP_NAMESPACE::ObjectType::eDeferredOperationKHR; |
| static VULKAN_HPP_CONST_OR_CONSTEXPR VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT debugReportObjectType = |
| VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT::eUnknown; |
| |
| public: |
| DeferredOperationKHR(VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::Device const &device, |
| VULKAN_HPP_NAMESPACE::Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator = nullptr) |
| : m_device(*device) |
| , m_allocator(static_cast<const VULKAN_HPP_NAMESPACE::AllocationCallbacks *>(allocator)) |
| , m_dispatcher(device.getDispatcher()) |
| { |
| VULKAN_HPP_NAMESPACE::Result result = static_cast<VULKAN_HPP_NAMESPACE::Result>( |
| device.getDispatcher()->vkCreateDeferredOperationKHR(static_cast<VkDevice>(*device), |
| reinterpret_cast<const VkAllocationCallbacks *>(m_allocator), |
| reinterpret_cast<VkDeferredOperationKHR *>(&m_operation))); |
| if(result != VULKAN_HPP_NAMESPACE::Result::eSuccess) |
| { |
| throwResultException(result, "vkCreateDeferredOperationKHR"); |
| } |
| } |
| |
| DeferredOperationKHR(VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::Device const &device, |
| VkDeferredOperationKHR operation, |
| VULKAN_HPP_NAMESPACE::Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator = nullptr) |
| : m_device(*device) |
| , m_operation(operation) |
| , m_allocator(static_cast<const VULKAN_HPP_NAMESPACE::AllocationCallbacks *>(allocator)) |
| , m_dispatcher(device.getDispatcher()) |
| { |
| } |
| |
| DeferredOperationKHR(std::nullptr_t) {} |
| |
| ~DeferredOperationKHR() |
| { |
| clear(); |
| } |
| |
| DeferredOperationKHR() = delete; |
| DeferredOperationKHR(DeferredOperationKHR const &) = delete; |
| DeferredOperationKHR(DeferredOperationKHR &&rhs) VULKAN_HPP_NOEXCEPT |
| : m_device(VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange(rhs.m_device, {})), |
| m_operation(VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange(rhs.m_operation, {})), |
| m_allocator(VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange(rhs.m_allocator, {})), |
| m_dispatcher(VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange(rhs.m_dispatcher, nullptr)) |
| { |
| } |
| DeferredOperationKHR &operator=(DeferredOperationKHR const &) = delete; |
| DeferredOperationKHR &operator=(DeferredOperationKHR &&rhs) VULKAN_HPP_NOEXCEPT |
| { |
| if(this != &rhs) |
| { |
| clear(); |
| m_device = VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange(rhs.m_device, {}); |
| m_operation = VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange(rhs.m_operation, {}); |
| m_allocator = VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange(rhs.m_allocator, {}); |
| m_dispatcher = VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange(rhs.m_dispatcher, nullptr); |
| } |
| return *this; |
| } |
| |
| VULKAN_HPP_NAMESPACE::DeferredOperationKHR const &operator*() const VULKAN_HPP_NOEXCEPT |
| { |
| return m_operation; |
| } |
| |
| void clear() VULKAN_HPP_NOEXCEPT |
| { |
| if(m_operation) |
| { |
| getDispatcher()->vkDestroyDeferredOperationKHR(static_cast<VkDevice>(m_device), |
| static_cast<VkDeferredOperationKHR>(m_operation), |
| reinterpret_cast<const VkAllocationCallbacks *>(m_allocator)); |
| } |
| m_device = nullptr; |
| m_operation = nullptr; |
| m_allocator = nullptr; |
| m_dispatcher = nullptr; |
| } |
| |
| VULKAN_HPP_NAMESPACE::Device getDevice() const |
| { |
| return m_device; |
| } |
| |
| VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::DeviceDispatcher const *getDispatcher() const |
| { |
| VULKAN_HPP_ASSERT(m_dispatcher->getVkHeaderVersion() == VK_HEADER_VERSION); |
| return m_dispatcher; |
| } |
| |
| void swap(VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::DeferredOperationKHR &rhs) VULKAN_HPP_NOEXCEPT |
| { |
| std::swap(m_device, rhs.m_device); |
| std::swap(m_operation, rhs.m_operation); |
| std::swap(m_allocator, rhs.m_allocator); |
| std::swap(m_dispatcher, rhs.m_dispatcher); |
| } |
| |
| //=== VK_KHR_deferred_host_operations === |
| |
| VULKAN_HPP_NODISCARD uint32_t getMaxConcurrency() const VULKAN_HPP_NOEXCEPT; |
| |
| VULKAN_HPP_NODISCARD VULKAN_HPP_NAMESPACE::Result getResult() const VULKAN_HPP_NOEXCEPT; |
| |
| VULKAN_HPP_NODISCARD VULKAN_HPP_NAMESPACE::Result join() const; |
| |
| private: |
| VULKAN_HPP_NAMESPACE::Device m_device = {}; |
| VULKAN_HPP_NAMESPACE::DeferredOperationKHR m_operation = {}; |
| const VULKAN_HPP_NAMESPACE::AllocationCallbacks *m_allocator = {}; |
| VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::DeviceDispatcher const *m_dispatcher = nullptr; |
| }; |
| |
| class DescriptorPool |
| { |
| public: |
| using CType = VkDescriptorPool; |
| |
| static VULKAN_HPP_CONST_OR_CONSTEXPR VULKAN_HPP_NAMESPACE::ObjectType objectType = VULKAN_HPP_NAMESPACE::ObjectType::eDescriptorPool; |
| static VULKAN_HPP_CONST_OR_CONSTEXPR VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT debugReportObjectType = |
| VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT::eDescriptorPool; |
| |
| public: |
| DescriptorPool(VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::Device const &device, |
| VULKAN_HPP_NAMESPACE::DescriptorPoolCreateInfo const &createInfo, |
| VULKAN_HPP_NAMESPACE::Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator = nullptr) |
| : m_device(*device) |
| , m_allocator(static_cast<const VULKAN_HPP_NAMESPACE::AllocationCallbacks *>(allocator)) |
| , m_dispatcher(device.getDispatcher()) |
| { |
| VULKAN_HPP_NAMESPACE::Result result = static_cast<VULKAN_HPP_NAMESPACE::Result>( |
| device.getDispatcher()->vkCreateDescriptorPool(static_cast<VkDevice>(*device), |
| reinterpret_cast<const VkDescriptorPoolCreateInfo *>(&createInfo), |
| reinterpret_cast<const VkAllocationCallbacks *>(m_allocator), |
| reinterpret_cast<VkDescriptorPool *>(&m_descriptorPool))); |
| if(result != VULKAN_HPP_NAMESPACE::Result::eSuccess) |
| { |
| throwResultException(result, "vkCreateDescriptorPool"); |
| } |
| } |
| |
| DescriptorPool(VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::Device const &device, |
| VkDescriptorPool descriptorPool, |
| VULKAN_HPP_NAMESPACE::Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator = nullptr) |
| : m_device(*device) |
| , m_descriptorPool(descriptorPool) |
| , m_allocator(static_cast<const VULKAN_HPP_NAMESPACE::AllocationCallbacks *>(allocator)) |
| , m_dispatcher(device.getDispatcher()) |
| { |
| } |
| |
| DescriptorPool(std::nullptr_t) {} |
| |
| ~DescriptorPool() |
| { |
| clear(); |
| } |
| |
| DescriptorPool() = delete; |
| DescriptorPool(DescriptorPool const &) = delete; |
| DescriptorPool(DescriptorPool &&rhs) VULKAN_HPP_NOEXCEPT |
| : m_device(VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange(rhs.m_device, {})), |
| m_descriptorPool(VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange(rhs.m_descriptorPool, {})), |
| m_allocator(VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange(rhs.m_allocator, {})), |
| m_dispatcher(VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange(rhs.m_dispatcher, nullptr)) |
| { |
| } |
| DescriptorPool &operator=(DescriptorPool const &) = delete; |
| DescriptorPool &operator=(DescriptorPool &&rhs) VULKAN_HPP_NOEXCEPT |
| { |
| if(this != &rhs) |
| { |
| clear(); |
| m_device = VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange(rhs.m_device, {}); |
| m_descriptorPool = VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange(rhs.m_descriptorPool, {}); |
| m_allocator = VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange(rhs.m_allocator, {}); |
| m_dispatcher = VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange(rhs.m_dispatcher, nullptr); |
| } |
| return *this; |
| } |
| |
| VULKAN_HPP_NAMESPACE::DescriptorPool const &operator*() const VULKAN_HPP_NOEXCEPT |
| { |
| return m_descriptorPool; |
| } |
| |
| void clear() VULKAN_HPP_NOEXCEPT |
| { |
| if(m_descriptorPool) |
| { |
| getDispatcher()->vkDestroyDescriptorPool(static_cast<VkDevice>(m_device), |
| static_cast<VkDescriptorPool>(m_descriptorPool), |
| reinterpret_cast<const VkAllocationCallbacks *>(m_allocator)); |
| } |
| m_device = nullptr; |
| m_descriptorPool = nullptr; |
| m_allocator = nullptr; |
| m_dispatcher = nullptr; |
| } |
| |
| VULKAN_HPP_NAMESPACE::Device getDevice() const |
| { |
| return m_device; |
| } |
| |
| VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::DeviceDispatcher const *getDispatcher() const |
| { |
| VULKAN_HPP_ASSERT(m_dispatcher->getVkHeaderVersion() == VK_HEADER_VERSION); |
| return m_dispatcher; |
| } |
| |
| void swap(VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::DescriptorPool &rhs) VULKAN_HPP_NOEXCEPT |
| { |
| std::swap(m_device, rhs.m_device); |
| std::swap(m_descriptorPool, rhs.m_descriptorPool); |
| std::swap(m_allocator, rhs.m_allocator); |
| std::swap(m_dispatcher, rhs.m_dispatcher); |
| } |
| |
| //=== VK_VERSION_1_0 === |
| |
| void reset(VULKAN_HPP_NAMESPACE::DescriptorPoolResetFlags flags VULKAN_HPP_DEFAULT_ARGUMENT_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT; |
| |
| private: |
| VULKAN_HPP_NAMESPACE::Device m_device = {}; |
| VULKAN_HPP_NAMESPACE::DescriptorPool m_descriptorPool = {}; |
| const VULKAN_HPP_NAMESPACE::AllocationCallbacks *m_allocator = {}; |
| VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::DeviceDispatcher const *m_dispatcher = nullptr; |
| }; |
| |
| class DescriptorSet |
| { |
| public: |
| using CType = VkDescriptorSet; |
| |
| static VULKAN_HPP_CONST_OR_CONSTEXPR VULKAN_HPP_NAMESPACE::ObjectType objectType = VULKAN_HPP_NAMESPACE::ObjectType::eDescriptorSet; |
| static VULKAN_HPP_CONST_OR_CONSTEXPR VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT debugReportObjectType = |
| VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT::eDescriptorSet; |
| |
| public: |
| DescriptorSet(VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::Device const &device, VkDescriptorSet descriptorSet, VkDescriptorPool descriptorPool) |
| : m_device(*device) |
| , m_descriptorPool(descriptorPool) |
| , m_descriptorSet(descriptorSet) |
| , m_dispatcher(device.getDispatcher()) |
| { |
| } |
| |
| DescriptorSet(std::nullptr_t) {} |
| |
| ~DescriptorSet() |
| { |
| clear(); |
| } |
| |
| DescriptorSet() = delete; |
| DescriptorSet(DescriptorSet const &) = delete; |
| DescriptorSet(DescriptorSet &&rhs) VULKAN_HPP_NOEXCEPT |
| : m_device(VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange(rhs.m_device, {})), |
| m_descriptorPool(VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange(rhs.m_descriptorPool, {})), |
| m_descriptorSet(VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange(rhs.m_descriptorSet, {})), |
| m_dispatcher(VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange(rhs.m_dispatcher, nullptr)) |
| { |
| } |
| DescriptorSet &operator=(DescriptorSet const &) = delete; |
| DescriptorSet &operator=(DescriptorSet &&rhs) VULKAN_HPP_NOEXCEPT |
| { |
| if(this != &rhs) |
| { |
| clear(); |
| m_device = VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange(rhs.m_device, {}); |
| m_descriptorPool = VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange(rhs.m_descriptorPool, {}); |
| m_descriptorSet = VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange(rhs.m_descriptorSet, {}); |
| m_dispatcher = VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange(rhs.m_dispatcher, nullptr); |
| } |
| return *this; |
| } |
| |
| VULKAN_HPP_NAMESPACE::DescriptorSet const &operator*() const VULKAN_HPP_NOEXCEPT |
| { |
| return m_descriptorSet; |
| } |
| |
| void clear() VULKAN_HPP_NOEXCEPT |
| { |
| if(m_descriptorSet) |
| { |
| getDispatcher()->vkFreeDescriptorSets(static_cast<VkDevice>(m_device), |
| static_cast<VkDescriptorPool>(m_descriptorPool), |
| 1, |
| reinterpret_cast<VkDescriptorSet const *>(&m_descriptorSet)); |
| } |
| m_device = nullptr; |
| m_descriptorPool = nullptr; |
| m_descriptorSet = nullptr; |
| m_dispatcher = nullptr; |
| } |
| |
| VULKAN_HPP_NAMESPACE::Device getDevice() const |
| { |
| return m_device; |
| } |
| |
| VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::DeviceDispatcher const *getDispatcher() const |
| { |
| VULKAN_HPP_ASSERT(m_dispatcher->getVkHeaderVersion() == VK_HEADER_VERSION); |
| return m_dispatcher; |
| } |
| |
| void swap(VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::DescriptorSet &rhs) VULKAN_HPP_NOEXCEPT |
| { |
| std::swap(m_device, rhs.m_device); |
| std::swap(m_descriptorPool, rhs.m_descriptorPool); |
| std::swap(m_descriptorSet, rhs.m_descriptorSet); |
| std::swap(m_dispatcher, rhs.m_dispatcher); |
| } |
| |
| //=== VK_VERSION_1_1 === |
| |
| template<typename DataType> |
| void updateWithTemplate(VULKAN_HPP_NAMESPACE::DescriptorUpdateTemplate descriptorUpdateTemplate, DataType const &data) const VULKAN_HPP_NOEXCEPT; |
| |
| //=== VK_KHR_descriptor_update_template === |
| |
| template<typename DataType> |
| void updateWithTemplateKHR(VULKAN_HPP_NAMESPACE::DescriptorUpdateTemplate descriptorUpdateTemplate, DataType const &data) const VULKAN_HPP_NOEXCEPT; |
| |
| //=== VK_VALVE_descriptor_set_host_mapping === |
| |
| VULKAN_HPP_NODISCARD void *getHostMappingVALVE() const VULKAN_HPP_NOEXCEPT; |
| |
| private: |
| VULKAN_HPP_NAMESPACE::Device m_device = {}; |
| VULKAN_HPP_NAMESPACE::DescriptorPool m_descriptorPool = {}; |
| VULKAN_HPP_NAMESPACE::DescriptorSet m_descriptorSet = {}; |
| VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::DeviceDispatcher const *m_dispatcher = nullptr; |
| }; |
| |
| class DescriptorSets : public std::vector<VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::DescriptorSet> |
| { |
| public: |
| DescriptorSets(VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::Device const &device, |
| VULKAN_HPP_NAMESPACE::DescriptorSetAllocateInfo const &allocateInfo) |
| { |
| VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::DeviceDispatcher const *dispatcher = device.getDispatcher(); |
| std::vector<VkDescriptorSet> descriptorSets(allocateInfo.descriptorSetCount); |
| VULKAN_HPP_NAMESPACE::Result result = static_cast<VULKAN_HPP_NAMESPACE::Result>(dispatcher->vkAllocateDescriptorSets( |
| static_cast<VkDevice>(*device), reinterpret_cast<const VkDescriptorSetAllocateInfo *>(&allocateInfo), descriptorSets.data())); |
| if(result == VULKAN_HPP_NAMESPACE::Result::eSuccess) |
| { |
| this->reserve(allocateInfo.descriptorSetCount); |
| for(auto const &descriptorSet : descriptorSets) |
| { |
| this->emplace_back(device, descriptorSet, static_cast<VkDescriptorPool>(allocateInfo.descriptorPool)); |
| } |
| } |
| else |
| { |
| throwResultException(result, "vkAllocateDescriptorSets"); |
| } |
| } |
| |
| DescriptorSets(std::nullptr_t) {} |
| |
| DescriptorSets() = delete; |
| DescriptorSets(DescriptorSets const &) = delete; |
| DescriptorSets(DescriptorSets &&rhs) = default; |
| DescriptorSets &operator=(DescriptorSets const &) = delete; |
| DescriptorSets &operator=(DescriptorSets &&rhs) = default; |
| }; |
| |
| class DescriptorSetLayout |
| { |
| public: |
| using CType = VkDescriptorSetLayout; |
| |
| static VULKAN_HPP_CONST_OR_CONSTEXPR VULKAN_HPP_NAMESPACE::ObjectType objectType = VULKAN_HPP_NAMESPACE::ObjectType::eDescriptorSetLayout; |
| static VULKAN_HPP_CONST_OR_CONSTEXPR VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT debugReportObjectType = |
| VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT::eDescriptorSetLayout; |
| |
| public: |
| DescriptorSetLayout(VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::Device const &device, |
| VULKAN_HPP_NAMESPACE::DescriptorSetLayoutCreateInfo const &createInfo, |
| VULKAN_HPP_NAMESPACE::Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator = nullptr) |
| : m_device(*device) |
| , m_allocator(static_cast<const VULKAN_HPP_NAMESPACE::AllocationCallbacks *>(allocator)) |
| , m_dispatcher(device.getDispatcher()) |
| { |
| VULKAN_HPP_NAMESPACE::Result result = static_cast<VULKAN_HPP_NAMESPACE::Result>( |
| device.getDispatcher()->vkCreateDescriptorSetLayout(static_cast<VkDevice>(*device), |
| reinterpret_cast<const VkDescriptorSetLayoutCreateInfo *>(&createInfo), |
| reinterpret_cast<const VkAllocationCallbacks *>(m_allocator), |
| reinterpret_cast<VkDescriptorSetLayout *>(&m_descriptorSetLayout))); |
| if(result != VULKAN_HPP_NAMESPACE::Result::eSuccess) |
| { |
| throwResultException(result, "vkCreateDescriptorSetLayout"); |
| } |
| } |
| |
| DescriptorSetLayout(VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::Device const &device, |
| VkDescriptorSetLayout descriptorSetLayout, |
| VULKAN_HPP_NAMESPACE::Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator = nullptr) |
| : m_device(*device) |
| , m_descriptorSetLayout(descriptorSetLayout) |
| , m_allocator(static_cast<const VULKAN_HPP_NAMESPACE::AllocationCallbacks *>(allocator)) |
| , m_dispatcher(device.getDispatcher()) |
| { |
| } |
| |
| DescriptorSetLayout(std::nullptr_t) {} |
| |
| ~DescriptorSetLayout() |
| { |
| clear(); |
| } |
| |
| DescriptorSetLayout() = delete; |
| DescriptorSetLayout(DescriptorSetLayout const &) = delete; |
| DescriptorSetLayout(DescriptorSetLayout &&rhs) VULKAN_HPP_NOEXCEPT |
| : m_device(VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange(rhs.m_device, {})), |
| m_descriptorSetLayout(VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange(rhs.m_descriptorSetLayout, {})), |
| m_allocator(VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange(rhs.m_allocator, {})), |
| m_dispatcher(VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange(rhs.m_dispatcher, nullptr)) |
| { |
| } |
| DescriptorSetLayout &operator=(DescriptorSetLayout const &) = delete; |
| DescriptorSetLayout &operator=(DescriptorSetLayout &&rhs) VULKAN_HPP_NOEXCEPT |
| { |
| if(this != &rhs) |
| { |
| clear(); |
| m_device = VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange(rhs.m_device, {}); |
| m_descriptorSetLayout = VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange(rhs.m_descriptorSetLayout, {}); |
| m_allocator = VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange(rhs.m_allocator, {}); |
| m_dispatcher = VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange(rhs.m_dispatcher, nullptr); |
| } |
| return *this; |
| } |
| |
| VULKAN_HPP_NAMESPACE::DescriptorSetLayout const &operator*() const VULKAN_HPP_NOEXCEPT |
| { |
| return m_descriptorSetLayout; |
| } |
| |
| void clear() VULKAN_HPP_NOEXCEPT |
| { |
| if(m_descriptorSetLayout) |
| { |
| getDispatcher()->vkDestroyDescriptorSetLayout(static_cast<VkDevice>(m_device), |
| static_cast<VkDescriptorSetLayout>(m_descriptorSetLayout), |
| reinterpret_cast<const VkAllocationCallbacks *>(m_allocator)); |
| } |
| m_device = nullptr; |
| m_descriptorSetLayout = nullptr; |
| m_allocator = nullptr; |
| m_dispatcher = nullptr; |
| } |
| |
| VULKAN_HPP_NAMESPACE::Device getDevice() const |
| { |
| return m_device; |
| } |
| |
| VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::DeviceDispatcher const *getDispatcher() const |
| { |
| VULKAN_HPP_ASSERT(m_dispatcher->getVkHeaderVersion() == VK_HEADER_VERSION); |
| return m_dispatcher; |
| } |
| |
| void swap(VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::DescriptorSetLayout &rhs) VULKAN_HPP_NOEXCEPT |
| { |
| std::swap(m_device, rhs.m_device); |
| std::swap(m_descriptorSetLayout, rhs.m_descriptorSetLayout); |
| std::swap(m_allocator, rhs.m_allocator); |
| std::swap(m_dispatcher, rhs.m_dispatcher); |
| } |
| |
| private: |
| VULKAN_HPP_NAMESPACE::Device m_device = {}; |
| VULKAN_HPP_NAMESPACE::DescriptorSetLayout m_descriptorSetLayout = {}; |
| const VULKAN_HPP_NAMESPACE::AllocationCallbacks *m_allocator = {}; |
| VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::DeviceDispatcher const *m_dispatcher = nullptr; |
| }; |
| |
| class DescriptorUpdateTemplate |
| { |
| public: |
| using CType = VkDescriptorUpdateTemplate; |
| |
| static VULKAN_HPP_CONST_OR_CONSTEXPR VULKAN_HPP_NAMESPACE::ObjectType objectType = VULKAN_HPP_NAMESPACE::ObjectType::eDescriptorUpdateTemplate; |
| static VULKAN_HPP_CONST_OR_CONSTEXPR VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT debugReportObjectType = |
| VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT::eDescriptorUpdateTemplate; |
| |
| public: |
| DescriptorUpdateTemplate(VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::Device const &device, |
| VULKAN_HPP_NAMESPACE::DescriptorUpdateTemplateCreateInfo const &createInfo, |
| VULKAN_HPP_NAMESPACE::Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator = nullptr) |
| : m_device(*device) |
| , m_allocator(static_cast<const VULKAN_HPP_NAMESPACE::AllocationCallbacks *>(allocator)) |
| , m_dispatcher(device.getDispatcher()) |
| { |
| VULKAN_HPP_NAMESPACE::Result result = static_cast<VULKAN_HPP_NAMESPACE::Result>( |
| device.getDispatcher()->vkCreateDescriptorUpdateTemplate(static_cast<VkDevice>(*device), |
| reinterpret_cast<const VkDescriptorUpdateTemplateCreateInfo *>(&createInfo), |
| reinterpret_cast<const VkAllocationCallbacks *>(m_allocator), |
| reinterpret_cast<VkDescriptorUpdateTemplate *>(&m_descriptorUpdateTemplate))); |
| if(result != VULKAN_HPP_NAMESPACE::Result::eSuccess) |
| { |
| throwResultException(result, "vkCreateDescriptorUpdateTemplate"); |
| } |
| } |
| |
| DescriptorUpdateTemplate(VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::Device const &device, |
| VkDescriptorUpdateTemplate descriptorUpdateTemplate, |
| VULKAN_HPP_NAMESPACE::Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator = nullptr) |
| : m_device(*device) |
| , m_descriptorUpdateTemplate(descriptorUpdateTemplate) |
| , m_allocator(static_cast<const VULKAN_HPP_NAMESPACE::AllocationCallbacks *>(allocator)) |
| , m_dispatcher(device.getDispatcher()) |
| { |
| } |
| |
| DescriptorUpdateTemplate(std::nullptr_t) {} |
| |
| ~DescriptorUpdateTemplate() |
| { |
| clear(); |
| } |
| |
| DescriptorUpdateTemplate() = delete; |
| DescriptorUpdateTemplate(DescriptorUpdateTemplate const &) = delete; |
| DescriptorUpdateTemplate(DescriptorUpdateTemplate &&rhs) VULKAN_HPP_NOEXCEPT |
| : m_device(VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange(rhs.m_device, {})), |
| m_descriptorUpdateTemplate(VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange(rhs.m_descriptorUpdateTemplate, {})), |
| m_allocator(VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange(rhs.m_allocator, {})), |
| m_dispatcher(VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange(rhs.m_dispatcher, nullptr)) |
| { |
| } |
| DescriptorUpdateTemplate &operator=(DescriptorUpdateTemplate const &) = delete; |
| DescriptorUpdateTemplate &operator=(DescriptorUpdateTemplate &&rhs) VULKAN_HPP_NOEXCEPT |
| { |
| if(this != &rhs) |
| { |
| clear(); |
| m_device = VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange(rhs.m_device, {}); |
| m_descriptorUpdateTemplate = VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange(rhs.m_descriptorUpdateTemplate, {}); |
| m_allocator = VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange(rhs.m_allocator, {}); |
| m_dispatcher = VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange(rhs.m_dispatcher, nullptr); |
| } |
| return *this; |
| } |
| |
| VULKAN_HPP_NAMESPACE::DescriptorUpdateTemplate const &operator*() const VULKAN_HPP_NOEXCEPT |
| { |
| return m_descriptorUpdateTemplate; |
| } |
| |
| void clear() VULKAN_HPP_NOEXCEPT |
| { |
| if(m_descriptorUpdateTemplate) |
| { |
| getDispatcher()->vkDestroyDescriptorUpdateTemplate(static_cast<VkDevice>(m_device), |
| static_cast<VkDescriptorUpdateTemplate>(m_descriptorUpdateTemplate), |
| reinterpret_cast<const VkAllocationCallbacks *>(m_allocator)); |
| } |
| m_device = nullptr; |
| m_descriptorUpdateTemplate = nullptr; |
| m_allocator = nullptr; |
| m_dispatcher = nullptr; |
| } |
| |
| VULKAN_HPP_NAMESPACE::Device getDevice() const |
| { |
| return m_device; |
| } |
| |
| VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::DeviceDispatcher const *getDispatcher() const |
| { |
| VULKAN_HPP_ASSERT(m_dispatcher->getVkHeaderVersion() == VK_HEADER_VERSION); |
| return m_dispatcher; |
| } |
| |
| void swap(VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::DescriptorUpdateTemplate &rhs) VULKAN_HPP_NOEXCEPT |
| { |
| std::swap(m_device, rhs.m_device); |
| std::swap(m_descriptorUpdateTemplate, rhs.m_descriptorUpdateTemplate); |
| std::swap(m_allocator, rhs.m_allocator); |
| std::swap(m_dispatcher, rhs.m_dispatcher); |
| } |
| |
| private: |
| VULKAN_HPP_NAMESPACE::Device m_device = {}; |
| VULKAN_HPP_NAMESPACE::DescriptorUpdateTemplate m_descriptorUpdateTemplate = {}; |
| const VULKAN_HPP_NAMESPACE::AllocationCallbacks *m_allocator = {}; |
| VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::DeviceDispatcher const *m_dispatcher = nullptr; |
| }; |
| |
| class DeviceMemory |
| { |
| public: |
| using CType = VkDeviceMemory; |
| |
| static VULKAN_HPP_CONST_OR_CONSTEXPR VULKAN_HPP_NAMESPACE::ObjectType objectType = VULKAN_HPP_NAMESPACE::ObjectType::eDeviceMemory; |
| static VULKAN_HPP_CONST_OR_CONSTEXPR VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT debugReportObjectType = |
| VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT::eDeviceMemory; |
| |
| public: |
| DeviceMemory(VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::Device const &device, |
| VULKAN_HPP_NAMESPACE::MemoryAllocateInfo const &allocateInfo, |
| VULKAN_HPP_NAMESPACE::Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator = nullptr) |
| : m_device(*device) |
| , m_allocator(static_cast<const VULKAN_HPP_NAMESPACE::AllocationCallbacks *>(allocator)) |
| , m_dispatcher(device.getDispatcher()) |
| { |
| VULKAN_HPP_NAMESPACE::Result result = |
| static_cast<VULKAN_HPP_NAMESPACE::Result>(device.getDispatcher()->vkAllocateMemory(static_cast<VkDevice>(*device), |
| reinterpret_cast<const VkMemoryAllocateInfo *>(&allocateInfo), |
| reinterpret_cast<const VkAllocationCallbacks *>(m_allocator), |
| reinterpret_cast<VkDeviceMemory *>(&m_memory))); |
| if(result != VULKAN_HPP_NAMESPACE::Result::eSuccess) |
| { |
| throwResultException(result, "vkAllocateMemory"); |
| } |
| } |
| |
| DeviceMemory(VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::Device const &device, |
| VkDeviceMemory memory, |
| VULKAN_HPP_NAMESPACE::Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator = nullptr) |
| : m_device(*device) |
| , m_memory(memory) |
| , m_allocator(static_cast<const VULKAN_HPP_NAMESPACE::AllocationCallbacks *>(allocator)) |
| , m_dispatcher(device.getDispatcher()) |
| { |
| } |
| |
| DeviceMemory(std::nullptr_t) {} |
| |
| ~DeviceMemory() |
| { |
| clear(); |
| } |
| |
| DeviceMemory() = delete; |
| DeviceMemory(DeviceMemory const &) = delete; |
| DeviceMemory(DeviceMemory &&rhs) VULKAN_HPP_NOEXCEPT |
| : m_device(VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange(rhs.m_device, {})), |
| m_memory(VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange(rhs.m_memory, {})), |
| m_allocator(VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange(rhs.m_allocator, {})), |
| m_dispatcher(VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange(rhs.m_dispatcher, nullptr)) |
| { |
| } |
| DeviceMemory &operator=(DeviceMemory const &) = delete; |
| DeviceMemory &operator=(DeviceMemory &&rhs) VULKAN_HPP_NOEXCEPT |
| { |
| if(this != &rhs) |
| { |
| clear(); |
| m_device = VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange(rhs.m_device, {}); |
| m_memory = VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange(rhs.m_memory, {}); |
| m_allocator = VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange(rhs.m_allocator, {}); |
| m_dispatcher = VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange(rhs.m_dispatcher, nullptr); |
| } |
| return *this; |
| } |
| |
| VULKAN_HPP_NAMESPACE::DeviceMemory const &operator*() const VULKAN_HPP_NOEXCEPT |
| { |
| return m_memory; |
| } |
| |
| void clear() VULKAN_HPP_NOEXCEPT |
| { |
| if(m_memory) |
| { |
| getDispatcher()->vkFreeMemory( |
| static_cast<VkDevice>(m_device), static_cast<VkDeviceMemory>(m_memory), reinterpret_cast<const VkAllocationCallbacks *>(m_allocator)); |
| } |
| m_device = nullptr; |
| m_memory = nullptr; |
| m_allocator = nullptr; |
| m_dispatcher = nullptr; |
| } |
| |
| VULKAN_HPP_NAMESPACE::Device getDevice() const |
| { |
| return m_device; |
| } |
| |
| VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::DeviceDispatcher const *getDispatcher() const |
| { |
| VULKAN_HPP_ASSERT(m_dispatcher->getVkHeaderVersion() == VK_HEADER_VERSION); |
| return m_dispatcher; |
| } |
| |
| void swap(VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::DeviceMemory &rhs) VULKAN_HPP_NOEXCEPT |
| { |
| std::swap(m_device, rhs.m_device); |
| std::swap(m_memory, rhs.m_memory); |
| std::swap(m_allocator, rhs.m_allocator); |
| std::swap(m_dispatcher, rhs.m_dispatcher); |
| } |
| |
| //=== VK_VERSION_1_0 === |
| |
| VULKAN_HPP_NODISCARD void *mapMemory(VULKAN_HPP_NAMESPACE::DeviceSize offset, |
| VULKAN_HPP_NAMESPACE::DeviceSize size, |
| VULKAN_HPP_NAMESPACE::MemoryMapFlags flags VULKAN_HPP_DEFAULT_ARGUMENT_ASSIGNMENT) const; |
| |
| void unmapMemory() const VULKAN_HPP_NOEXCEPT; |
| |
| VULKAN_HPP_NODISCARD VULKAN_HPP_NAMESPACE::DeviceSize getCommitment() const VULKAN_HPP_NOEXCEPT; |
| |
| # if defined(VK_USE_PLATFORM_WIN32_KHR) |
| //=== VK_NV_external_memory_win32 === |
| |
| VULKAN_HPP_NODISCARD HANDLE getMemoryWin32HandleNV(VULKAN_HPP_NAMESPACE::ExternalMemoryHandleTypeFlagsNV handleType) const; |
| # endif /*VK_USE_PLATFORM_WIN32_KHR*/ |
| |
| //=== VK_EXT_pageable_device_local_memory === |
| |
| void setPriorityEXT(float priority) const VULKAN_HPP_NOEXCEPT; |
| |
| private: |
| VULKAN_HPP_NAMESPACE::Device m_device = {}; |
| VULKAN_HPP_NAMESPACE::DeviceMemory m_memory = {}; |
| const VULKAN_HPP_NAMESPACE::AllocationCallbacks *m_allocator = {}; |
| VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::DeviceDispatcher const *m_dispatcher = nullptr; |
| }; |
| |
| class DisplayKHR |
| { |
| public: |
| using CType = VkDisplayKHR; |
| |
| static VULKAN_HPP_CONST_OR_CONSTEXPR VULKAN_HPP_NAMESPACE::ObjectType objectType = VULKAN_HPP_NAMESPACE::ObjectType::eDisplayKHR; |
| static VULKAN_HPP_CONST_OR_CONSTEXPR VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT debugReportObjectType = |
| VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT::eDisplayKHR; |
| |
| public: |
| DisplayKHR(VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::PhysicalDevice const &physicalDevice, int32_t drmFd, uint32_t connectorId) |
| : m_physicalDevice(*physicalDevice) |
| , m_dispatcher(physicalDevice.getDispatcher()) |
| { |
| VULKAN_HPP_NAMESPACE::Result result = static_cast<VULKAN_HPP_NAMESPACE::Result>(physicalDevice.getDispatcher()->vkGetDrmDisplayEXT( |
| static_cast<VkPhysicalDevice>(*physicalDevice), drmFd, connectorId, reinterpret_cast<VkDisplayKHR *>(&m_display))); |
| if(result != VULKAN_HPP_NAMESPACE::Result::eSuccess) |
| { |
| throwResultException(result, "vkGetDrmDisplayEXT"); |
| } |
| } |
| |
| # if defined(VK_USE_PLATFORM_XLIB_XRANDR_EXT) |
| DisplayKHR(VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::PhysicalDevice const &physicalDevice, Display &dpy, RROutput rrOutput) |
| : m_physicalDevice(*physicalDevice) |
| , m_dispatcher(physicalDevice.getDispatcher()) |
| { |
| VULKAN_HPP_NAMESPACE::Result result = static_cast<VULKAN_HPP_NAMESPACE::Result>(physicalDevice.getDispatcher()->vkGetRandROutputDisplayEXT( |
| static_cast<VkPhysicalDevice>(*physicalDevice), &dpy, rrOutput, reinterpret_cast<VkDisplayKHR *>(&m_display))); |
| if(result != VULKAN_HPP_NAMESPACE::Result::eSuccess) |
| { |
| throwResultException(result, "vkGetRandROutputDisplayEXT"); |
| } |
| } |
| # endif /*VK_USE_PLATFORM_XLIB_XRANDR_EXT*/ |
| |
| # if defined(VK_USE_PLATFORM_WIN32_KHR) |
| DisplayKHR(VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::PhysicalDevice const &physicalDevice, uint32_t deviceRelativeId) |
| : m_physicalDevice(*physicalDevice) |
| , m_dispatcher(physicalDevice.getDispatcher()) |
| { |
| VULKAN_HPP_NAMESPACE::Result result = static_cast<VULKAN_HPP_NAMESPACE::Result>(physicalDevice.getDispatcher()->vkGetWinrtDisplayNV( |
| static_cast<VkPhysicalDevice>(*physicalDevice), deviceRelativeId, reinterpret_cast<VkDisplayKHR *>(&m_display))); |
| if(result != VULKAN_HPP_NAMESPACE::Result::eSuccess) |
| { |
| throwResultException(result, "vkGetWinrtDisplayNV"); |
| } |
| } |
| # endif /*VK_USE_PLATFORM_WIN32_KHR*/ |
| |
| DisplayKHR(VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::PhysicalDevice const &physicalDevice, VkDisplayKHR display) |
| : m_physicalDevice(*physicalDevice) |
| , m_display(display) |
| , m_dispatcher(physicalDevice.getDispatcher()) |
| { |
| } |
| |
| DisplayKHR(std::nullptr_t) {} |
| |
| ~DisplayKHR() |
| { |
| clear(); |
| } |
| |
| DisplayKHR() = delete; |
| DisplayKHR(DisplayKHR const &) = delete; |
| DisplayKHR(DisplayKHR &&rhs) VULKAN_HPP_NOEXCEPT |
| : m_physicalDevice(VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange(rhs.m_physicalDevice, {})), |
| m_display(VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange(rhs.m_display, {})), |
| m_dispatcher(VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange(rhs.m_dispatcher, nullptr)) |
| { |
| } |
| DisplayKHR &operator=(DisplayKHR const &) = delete; |
| DisplayKHR &operator=(DisplayKHR &&rhs) VULKAN_HPP_NOEXCEPT |
| { |
| if(this != &rhs) |
| { |
| clear(); |
| m_physicalDevice = VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange(rhs.m_physicalDevice, {}); |
| m_display = VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange(rhs.m_display, {}); |
| m_dispatcher = VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange(rhs.m_dispatcher, nullptr); |
| } |
| return *this; |
| } |
| |
| VULKAN_HPP_NAMESPACE::DisplayKHR const &operator*() const VULKAN_HPP_NOEXCEPT |
| { |
| return m_display; |
| } |
| |
| void clear() VULKAN_HPP_NOEXCEPT |
| { |
| if(m_display) |
| { |
| getDispatcher()->vkReleaseDisplayEXT(static_cast<VkPhysicalDevice>(m_physicalDevice), static_cast<VkDisplayKHR>(m_display)); |
| } |
| m_physicalDevice = nullptr; |
| m_display = nullptr; |
| m_dispatcher = nullptr; |
| } |
| |
| VULKAN_HPP_NAMESPACE::PhysicalDevice getPhysicalDevice() const |
| { |
| return m_physicalDevice; |
| } |
| |
| VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::InstanceDispatcher const *getDispatcher() const |
| { |
| VULKAN_HPP_ASSERT(m_dispatcher->getVkHeaderVersion() == VK_HEADER_VERSION); |
| return m_dispatcher; |
| } |
| |
| void swap(VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::DisplayKHR &rhs) VULKAN_HPP_NOEXCEPT |
| { |
| std::swap(m_physicalDevice, rhs.m_physicalDevice); |
| std::swap(m_display, rhs.m_display); |
| std::swap(m_dispatcher, rhs.m_dispatcher); |
| } |
| |
| //=== VK_KHR_display === |
| |
| VULKAN_HPP_NODISCARD std::vector<VULKAN_HPP_NAMESPACE::DisplayModePropertiesKHR> getModeProperties() const; |
| |
| VULKAN_HPP_NODISCARD VULKAN_HPP_RAII_NAMESPACE::DisplayModeKHR |
| createMode(VULKAN_HPP_NAMESPACE::DisplayModeCreateInfoKHR const &createInfo, |
| VULKAN_HPP_NAMESPACE::Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator = nullptr) const; |
| |
| //=== VK_KHR_get_display_properties2 === |
| |
| VULKAN_HPP_NODISCARD std::vector<VULKAN_HPP_NAMESPACE::DisplayModeProperties2KHR> getModeProperties2() const; |
| |
| # if defined(VK_USE_PLATFORM_WIN32_KHR) |
| //=== VK_NV_acquire_winrt_display === |
| |
| void acquireWinrtNV() const; |
| # endif /*VK_USE_PLATFORM_WIN32_KHR*/ |
| |
| private: |
| VULKAN_HPP_NAMESPACE::PhysicalDevice m_physicalDevice = {}; |
| VULKAN_HPP_NAMESPACE::DisplayKHR m_display = {}; |
| VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::InstanceDispatcher const *m_dispatcher = nullptr; |
| }; |
| |
| class DisplayKHRs : public std::vector<VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::DisplayKHR> |
| { |
| public: |
| DisplayKHRs(VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::PhysicalDevice const &physicalDevice, uint32_t planeIndex) |
| { |
| VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::InstanceDispatcher const *dispatcher = physicalDevice.getDispatcher(); |
| std::vector<VkDisplayKHR> displays; |
| uint32_t displayCount; |
| VULKAN_HPP_NAMESPACE::Result result; |
| do |
| { |
| result = static_cast<VULKAN_HPP_NAMESPACE::Result>( |
| dispatcher->vkGetDisplayPlaneSupportedDisplaysKHR(static_cast<VkPhysicalDevice>(*physicalDevice), planeIndex, &displayCount, nullptr)); |
| if((result == VULKAN_HPP_NAMESPACE::Result::eSuccess) && displayCount) |
| { |
| displays.resize(displayCount); |
| result = static_cast<VULKAN_HPP_NAMESPACE::Result>(dispatcher->vkGetDisplayPlaneSupportedDisplaysKHR( |
| static_cast<VkPhysicalDevice>(*physicalDevice), planeIndex, &displayCount, displays.data())); |
| } |
| } while(result == VULKAN_HPP_NAMESPACE::Result::eIncomplete); |
| if(result == VULKAN_HPP_NAMESPACE::Result::eSuccess) |
| { |
| VULKAN_HPP_ASSERT(displayCount <= displays.size()); |
| this->reserve(displayCount); |
| for(auto const &displayKHR : displays) |
| { |
| this->emplace_back(physicalDevice, displayKHR); |
| } |
| } |
| else |
| { |
| throwResultException(result, "vkGetDisplayPlaneSupportedDisplaysKHR"); |
| } |
| } |
| |
| DisplayKHRs(std::nullptr_t) {} |
| |
| DisplayKHRs() = delete; |
| DisplayKHRs(DisplayKHRs const &) = delete; |
| DisplayKHRs(DisplayKHRs &&rhs) = default; |
| DisplayKHRs &operator=(DisplayKHRs const &) = delete; |
| DisplayKHRs &operator=(DisplayKHRs &&rhs) = default; |
| }; |
| |
| class DisplayModeKHR |
| { |
| public: |
| using CType = VkDisplayModeKHR; |
| |
| static VULKAN_HPP_CONST_OR_CONSTEXPR VULKAN_HPP_NAMESPACE::ObjectType objectType = VULKAN_HPP_NAMESPACE::ObjectType::eDisplayModeKHR; |
| static VULKAN_HPP_CONST_OR_CONSTEXPR VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT debugReportObjectType = |
| VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT::eDisplayModeKHR; |
| |
| public: |
| DisplayModeKHR(VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::DisplayKHR const &display, |
| VULKAN_HPP_NAMESPACE::DisplayModeCreateInfoKHR const &createInfo, |
| VULKAN_HPP_NAMESPACE::Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator = nullptr) |
| : m_physicalDevice(display.getPhysicalDevice()) |
| , m_dispatcher(display.getDispatcher()) |
| { |
| VULKAN_HPP_NAMESPACE::Result result = static_cast<VULKAN_HPP_NAMESPACE::Result>(display.getDispatcher()->vkCreateDisplayModeKHR( |
| static_cast<VkPhysicalDevice>(display.getPhysicalDevice()), |
| static_cast<VkDisplayKHR>(*display), |
| reinterpret_cast<const VkDisplayModeCreateInfoKHR *>(&createInfo), |
| reinterpret_cast<const VkAllocationCallbacks *>(static_cast<const VULKAN_HPP_NAMESPACE::AllocationCallbacks *>(allocator)), |
| reinterpret_cast<VkDisplayModeKHR *>(&m_displayModeKHR))); |
| if(result != VULKAN_HPP_NAMESPACE::Result::eSuccess) |
| { |
| throwResultException(result, "vkCreateDisplayModeKHR"); |
| } |
| } |
| |
| DisplayModeKHR(VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::DisplayKHR const &display, VkDisplayModeKHR displayModeKHR) |
| : m_physicalDevice(display.getPhysicalDevice()) |
| , m_displayModeKHR(displayModeKHR) |
| , m_dispatcher(display.getDispatcher()) |
| { |
| } |
| |
| DisplayModeKHR(std::nullptr_t) {} |
| |
| ~DisplayModeKHR() |
| { |
| clear(); |
| } |
| |
| DisplayModeKHR() = delete; |
| DisplayModeKHR(DisplayModeKHR const &rhs) |
| : m_displayModeKHR(rhs.m_displayModeKHR) |
| , m_dispatcher(rhs.m_dispatcher) |
| {} |
| DisplayModeKHR(DisplayModeKHR &&rhs) VULKAN_HPP_NOEXCEPT |
| : m_physicalDevice(VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange(rhs.m_physicalDevice, {})), |
| m_displayModeKHR(VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange(rhs.m_displayModeKHR, {})), |
| m_dispatcher(VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange(rhs.m_dispatcher, nullptr)) |
| { |
| } |
| DisplayModeKHR &operator=(DisplayModeKHR const &rhs) |
| { |
| m_displayModeKHR = rhs.m_displayModeKHR; |
| m_dispatcher = rhs.m_dispatcher; |
| return *this; |
| } |
| DisplayModeKHR &operator=(DisplayModeKHR &&rhs) VULKAN_HPP_NOEXCEPT |
| { |
| if(this != &rhs) |
| { |
| m_physicalDevice = VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange(rhs.m_physicalDevice, {}); |
| m_displayModeKHR = VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange(rhs.m_displayModeKHR, {}); |
| m_dispatcher = VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange(rhs.m_dispatcher, nullptr); |
| } |
| return *this; |
| } |
| |
| VULKAN_HPP_NAMESPACE::DisplayModeKHR const &operator*() const VULKAN_HPP_NOEXCEPT |
| { |
| return m_displayModeKHR; |
| } |
| |
| void clear() VULKAN_HPP_NOEXCEPT |
| { |
| m_physicalDevice = nullptr; |
| m_displayModeKHR = nullptr; |
| m_dispatcher = nullptr; |
| } |
| |
| VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::InstanceDispatcher const *getDispatcher() const |
| { |
| VULKAN_HPP_ASSERT(m_dispatcher->getVkHeaderVersion() == VK_HEADER_VERSION); |
| return m_dispatcher; |
| } |
| |
| void swap(VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::DisplayModeKHR &rhs) VULKAN_HPP_NOEXCEPT |
| { |
| std::swap(m_physicalDevice, rhs.m_physicalDevice); |
| std::swap(m_displayModeKHR, rhs.m_displayModeKHR); |
| std::swap(m_dispatcher, rhs.m_dispatcher); |
| } |
| |
| //=== VK_KHR_display === |
| |
| VULKAN_HPP_NODISCARD VULKAN_HPP_NAMESPACE::DisplayPlaneCapabilitiesKHR getDisplayPlaneCapabilities(uint32_t planeIndex) const; |
| |
| private: |
| VULKAN_HPP_NAMESPACE::PhysicalDevice m_physicalDevice = {}; |
| VULKAN_HPP_NAMESPACE::DisplayModeKHR m_displayModeKHR = {}; |
| VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::InstanceDispatcher const *m_dispatcher = nullptr; |
| }; |
| |
| class Event |
| { |
| public: |
| using CType = VkEvent; |
| |
| static VULKAN_HPP_CONST_OR_CONSTEXPR VULKAN_HPP_NAMESPACE::ObjectType objectType = VULKAN_HPP_NAMESPACE::ObjectType::eEvent; |
| static VULKAN_HPP_CONST_OR_CONSTEXPR VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT debugReportObjectType = |
| VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT::eEvent; |
| |
| public: |
| Event(VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::Device const &device, |
| VULKAN_HPP_NAMESPACE::EventCreateInfo const &createInfo, |
| VULKAN_HPP_NAMESPACE::Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator = nullptr) |
| : m_device(*device) |
| , m_allocator(static_cast<const VULKAN_HPP_NAMESPACE::AllocationCallbacks *>(allocator)) |
| , m_dispatcher(device.getDispatcher()) |
| { |
| VULKAN_HPP_NAMESPACE::Result result = |
| static_cast<VULKAN_HPP_NAMESPACE::Result>(device.getDispatcher()->vkCreateEvent(static_cast<VkDevice>(*device), |
| reinterpret_cast<const VkEventCreateInfo *>(&createInfo), |
| reinterpret_cast<const VkAllocationCallbacks *>(m_allocator), |
| reinterpret_cast<VkEvent *>(&m_event))); |
| if(result != VULKAN_HPP_NAMESPACE::Result::eSuccess) |
| { |
| throwResultException(result, "vkCreateEvent"); |
| } |
| } |
| |
| Event(VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::Device const &device, |
| VkEvent event, |
| VULKAN_HPP_NAMESPACE::Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator = nullptr) |
| : m_device(*device) |
| , m_event(event) |
| , m_allocator(static_cast<const VULKAN_HPP_NAMESPACE::AllocationCallbacks *>(allocator)) |
| , m_dispatcher(device.getDispatcher()) |
| { |
| } |
| |
| Event(std::nullptr_t) {} |
| |
| ~Event() |
| { |
| clear(); |
| } |
| |
| Event() = delete; |
| Event(Event const &) = delete; |
| Event(Event &&rhs) VULKAN_HPP_NOEXCEPT |
| : m_device(VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange(rhs.m_device, {})), |
| m_event(VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange(rhs.m_event, {})), |
| m_allocator(VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange(rhs.m_allocator, {})), |
| m_dispatcher(VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange(rhs.m_dispatcher, nullptr)) |
| { |
| } |
| Event &operator=(Event const &) = delete; |
| Event &operator=(Event &&rhs) VULKAN_HPP_NOEXCEPT |
| { |
| if(this != &rhs) |
| { |
| clear(); |
| m_device = VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange(rhs.m_device, {}); |
| m_event = VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange(rhs.m_event, {}); |
| m_allocator = VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange(rhs.m_allocator, {}); |
| m_dispatcher = VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange(rhs.m_dispatcher, nullptr); |
| } |
| return *this; |
| } |
| |
| VULKAN_HPP_NAMESPACE::Event const &operator*() const VULKAN_HPP_NOEXCEPT |
| { |
| return m_event; |
| } |
| |
| void clear() VULKAN_HPP_NOEXCEPT |
| { |
| if(m_event) |
| { |
| getDispatcher()->vkDestroyEvent( |
| static_cast<VkDevice>(m_device), static_cast<VkEvent>(m_event), reinterpret_cast<const VkAllocationCallbacks *>(m_allocator)); |
| } |
| m_device = nullptr; |
| m_event = nullptr; |
| m_allocator = nullptr; |
| m_dispatcher = nullptr; |
| } |
| |
| VULKAN_HPP_NAMESPACE::Device getDevice() const |
| { |
| return m_device; |
| } |
| |
| VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::DeviceDispatcher const *getDispatcher() const |
| { |
| VULKAN_HPP_ASSERT(m_dispatcher->getVkHeaderVersion() == VK_HEADER_VERSION); |
| return m_dispatcher; |
| } |
| |
| void swap(VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::Event &rhs) VULKAN_HPP_NOEXCEPT |
| { |
| std::swap(m_device, rhs.m_device); |
| std::swap(m_event, rhs.m_event); |
| std::swap(m_allocator, rhs.m_allocator); |
| std::swap(m_dispatcher, rhs.m_dispatcher); |
| } |
| |
| //=== VK_VERSION_1_0 === |
| |
| VULKAN_HPP_NODISCARD VULKAN_HPP_NAMESPACE::Result getStatus() const; |
| |
| void set() const; |
| |
| void reset() const; |
| |
| private: |
| VULKAN_HPP_NAMESPACE::Device m_device = {}; |
| VULKAN_HPP_NAMESPACE::Event m_event = {}; |
| const VULKAN_HPP_NAMESPACE::AllocationCallbacks *m_allocator = {}; |
| VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::DeviceDispatcher const *m_dispatcher = nullptr; |
| }; |
| |
| class Fence |
| { |
| public: |
| using CType = VkFence; |
| |
| static VULKAN_HPP_CONST_OR_CONSTEXPR VULKAN_HPP_NAMESPACE::ObjectType objectType = VULKAN_HPP_NAMESPACE::ObjectType::eFence; |
| static VULKAN_HPP_CONST_OR_CONSTEXPR VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT debugReportObjectType = |
| VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT::eFence; |
| |
| public: |
| Fence(VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::Device const &device, |
| VULKAN_HPP_NAMESPACE::FenceCreateInfo const &createInfo, |
| VULKAN_HPP_NAMESPACE::Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator = nullptr) |
| : m_device(*device) |
| , m_allocator(static_cast<const VULKAN_HPP_NAMESPACE::AllocationCallbacks *>(allocator)) |
| , m_dispatcher(device.getDispatcher()) |
| { |
| VULKAN_HPP_NAMESPACE::Result result = |
| static_cast<VULKAN_HPP_NAMESPACE::Result>(device.getDispatcher()->vkCreateFence(static_cast<VkDevice>(*device), |
| reinterpret_cast<const VkFenceCreateInfo *>(&createInfo), |
| reinterpret_cast<const VkAllocationCallbacks *>(m_allocator), |
| reinterpret_cast<VkFence *>(&m_fence))); |
| if(result != VULKAN_HPP_NAMESPACE::Result::eSuccess) |
| { |
| throwResultException(result, "vkCreateFence"); |
| } |
| } |
| |
| Fence(VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::Device const &device, |
| VULKAN_HPP_NAMESPACE::DeviceEventInfoEXT const &deviceEventInfo, |
| VULKAN_HPP_NAMESPACE::Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator = nullptr) |
| : m_device(*device) |
| , m_allocator(static_cast<const VULKAN_HPP_NAMESPACE::AllocationCallbacks *>(allocator)) |
| , m_dispatcher(device.getDispatcher()) |
| { |
| VULKAN_HPP_NAMESPACE::Result result = static_cast<VULKAN_HPP_NAMESPACE::Result>( |
| device.getDispatcher()->vkRegisterDeviceEventEXT(static_cast<VkDevice>(*device), |
| reinterpret_cast<const VkDeviceEventInfoEXT *>(&deviceEventInfo), |
| reinterpret_cast<const VkAllocationCallbacks *>(m_allocator), |
| reinterpret_cast<VkFence *>(&m_fence))); |
| if(result != VULKAN_HPP_NAMESPACE::Result::eSuccess) |
| { |
| throwResultException(result, "vkRegisterDeviceEventEXT"); |
| } |
| } |
| |
| Fence(VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::Device const &device, |
| VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::DisplayKHR const &display, |
| VULKAN_HPP_NAMESPACE::DisplayEventInfoEXT const &displayEventInfo, |
| VULKAN_HPP_NAMESPACE::Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator = nullptr) |
| : m_device(*device) |
| , m_allocator(static_cast<const VULKAN_HPP_NAMESPACE::AllocationCallbacks *>(allocator)) |
| , m_dispatcher(device.getDispatcher()) |
| { |
| VULKAN_HPP_NAMESPACE::Result result = static_cast<VULKAN_HPP_NAMESPACE::Result>( |
| device.getDispatcher()->vkRegisterDisplayEventEXT(static_cast<VkDevice>(*device), |
| static_cast<VkDisplayKHR>(*display), |
| reinterpret_cast<const VkDisplayEventInfoEXT *>(&displayEventInfo), |
| reinterpret_cast<const VkAllocationCallbacks *>(m_allocator), |
| reinterpret_cast<VkFence *>(&m_fence))); |
| if(result != VULKAN_HPP_NAMESPACE::Result::eSuccess) |
| { |
| throwResultException(result, "vkRegisterDisplayEventEXT"); |
| } |
| } |
| |
| Fence(VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::Device const &device, |
| VkFence fence, |
| VULKAN_HPP_NAMESPACE::Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator = nullptr) |
| : m_device(*device) |
| , m_fence(fence) |
| , m_allocator(static_cast<const VULKAN_HPP_NAMESPACE::AllocationCallbacks *>(allocator)) |
| , m_dispatcher(device.getDispatcher()) |
| { |
| } |
| |
| Fence(std::nullptr_t) {} |
| |
| ~Fence() |
| { |
| clear(); |
| } |
| |
| Fence() = delete; |
| Fence(Fence const &) = delete; |
| Fence(Fence &&rhs) VULKAN_HPP_NOEXCEPT |
| : m_device(VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange(rhs.m_device, {})), |
| m_fence(VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange(rhs.m_fence, {})), |
| m_allocator(VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange(rhs.m_allocator, {})), |
| m_dispatcher(VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange(rhs.m_dispatcher, nullptr)) |
| { |
| } |
| Fence &operator=(Fence const &) = delete; |
| Fence &operator=(Fence &&rhs) VULKAN_HPP_NOEXCEPT |
| { |
| if(this != &rhs) |
| { |
| clear(); |
| m_device = VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange(rhs.m_device, {}); |
| m_fence = VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange(rhs.m_fence, {}); |
| m_allocator = VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange(rhs.m_allocator, {}); |
| m_dispatcher = VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange(rhs.m_dispatcher, nullptr); |
| } |
| return *this; |
| } |
| |
| VULKAN_HPP_NAMESPACE::Fence const &operator*() const VULKAN_HPP_NOEXCEPT |
| { |
| return m_fence; |
| } |
| |
| void clear() VULKAN_HPP_NOEXCEPT |
| { |
| if(m_fence) |
| { |
| getDispatcher()->vkDestroyFence( |
| static_cast<VkDevice>(m_device), static_cast<VkFence>(m_fence), reinterpret_cast<const VkAllocationCallbacks *>(m_allocator)); |
| } |
| m_device = nullptr; |
| m_fence = nullptr; |
| m_allocator = nullptr; |
| m_dispatcher = nullptr; |
| } |
| |
| VULKAN_HPP_NAMESPACE::Device getDevice() const |
| { |
| return m_device; |
| } |
| |
| VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::DeviceDispatcher const *getDispatcher() const |
| { |
| VULKAN_HPP_ASSERT(m_dispatcher->getVkHeaderVersion() == VK_HEADER_VERSION); |
| return m_dispatcher; |
| } |
| |
| void swap(VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::Fence &rhs) VULKAN_HPP_NOEXCEPT |
| { |
| std::swap(m_device, rhs.m_device); |
| std::swap(m_fence, rhs.m_fence); |
| std::swap(m_allocator, rhs.m_allocator); |
| std::swap(m_dispatcher, rhs.m_dispatcher); |
| } |
| |
| //=== VK_VERSION_1_0 === |
| |
| VULKAN_HPP_NODISCARD VULKAN_HPP_NAMESPACE::Result getStatus() const; |
| |
| private: |
| VULKAN_HPP_NAMESPACE::Device m_device = {}; |
| VULKAN_HPP_NAMESPACE::Fence m_fence = {}; |
| const VULKAN_HPP_NAMESPACE::AllocationCallbacks *m_allocator = {}; |
| VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::DeviceDispatcher const *m_dispatcher = nullptr; |
| }; |
| |
| class Framebuffer |
| { |
| public: |
| using CType = VkFramebuffer; |
| |
| static VULKAN_HPP_CONST_OR_CONSTEXPR VULKAN_HPP_NAMESPACE::ObjectType objectType = VULKAN_HPP_NAMESPACE::ObjectType::eFramebuffer; |
| static VULKAN_HPP_CONST_OR_CONSTEXPR VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT debugReportObjectType = |
| VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT::eFramebuffer; |
| |
| public: |
| Framebuffer(VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::Device const &device, |
| VULKAN_HPP_NAMESPACE::FramebufferCreateInfo const &createInfo, |
| VULKAN_HPP_NAMESPACE::Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator = nullptr) |
| : m_device(*device) |
| , m_allocator(static_cast<const VULKAN_HPP_NAMESPACE::AllocationCallbacks *>(allocator)) |
| , m_dispatcher(device.getDispatcher()) |
| { |
| VULKAN_HPP_NAMESPACE::Result result = static_cast<VULKAN_HPP_NAMESPACE::Result>( |
| device.getDispatcher()->vkCreateFramebuffer(static_cast<VkDevice>(*device), |
| reinterpret_cast<const VkFramebufferCreateInfo *>(&createInfo), |
| reinterpret_cast<const VkAllocationCallbacks *>(m_allocator), |
| reinterpret_cast<VkFramebuffer *>(&m_framebuffer))); |
| if(result != VULKAN_HPP_NAMESPACE::Result::eSuccess) |
| { |
| throwResultException(result, "vkCreateFramebuffer"); |
| } |
| } |
| |
| Framebuffer(VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::Device const &device, |
| VkFramebuffer framebuffer, |
| VULKAN_HPP_NAMESPACE::Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator = nullptr) |
| : m_device(*device) |
| , m_framebuffer(framebuffer) |
| , m_allocator(static_cast<const VULKAN_HPP_NAMESPACE::AllocationCallbacks *>(allocator)) |
| , m_dispatcher(device.getDispatcher()) |
| { |
| } |
| |
| Framebuffer(std::nullptr_t) {} |
| |
| ~Framebuffer() |
| { |
| clear(); |
| } |
| |
| Framebuffer() = delete; |
| Framebuffer(Framebuffer const &) = delete; |
| Framebuffer(Framebuffer &&rhs) VULKAN_HPP_NOEXCEPT |
| : m_device(VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange(rhs.m_device, {})), |
| m_framebuffer(VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange(rhs.m_framebuffer, {})), |
| m_allocator(VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange(rhs.m_allocator, {})), |
| m_dispatcher(VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange(rhs.m_dispatcher, nullptr)) |
| { |
| } |
| Framebuffer &operator=(Framebuffer const &) = delete; |
| Framebuffer &operator=(Framebuffer &&rhs) VULKAN_HPP_NOEXCEPT |
| { |
| if(this != &rhs) |
| { |
| clear(); |
| m_device = VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange(rhs.m_device, {}); |
| m_framebuffer = VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange(rhs.m_framebuffer, {}); |
| m_allocator = VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange(rhs.m_allocator, {}); |
| m_dispatcher = VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange(rhs.m_dispatcher, nullptr); |
| } |
| return *this; |
| } |
| |
| VULKAN_HPP_NAMESPACE::Framebuffer const &operator*() const VULKAN_HPP_NOEXCEPT |
| { |
| return m_framebuffer; |
| } |
| |
| void clear() VULKAN_HPP_NOEXCEPT |
| { |
| if(m_framebuffer) |
| { |
| getDispatcher()->vkDestroyFramebuffer( |
| static_cast<VkDevice>(m_device), static_cast<VkFramebuffer>(m_framebuffer), reinterpret_cast<const VkAllocationCallbacks *>(m_allocator)); |
| } |
| m_device = nullptr; |
| m_framebuffer = nullptr; |
| m_allocator = nullptr; |
| m_dispatcher = nullptr; |
| } |
| |
| VULKAN_HPP_NAMESPACE::Device getDevice() const |
| { |
| return m_device; |
| } |
| |
| VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::DeviceDispatcher const *getDispatcher() const |
| { |
| VULKAN_HPP_ASSERT(m_dispatcher->getVkHeaderVersion() == VK_HEADER_VERSION); |
| return m_dispatcher; |
| } |
| |
| void swap(VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::Framebuffer &rhs) VULKAN_HPP_NOEXCEPT |
| { |
| std::swap(m_device, rhs.m_device); |
| std::swap(m_framebuffer, rhs.m_framebuffer); |
| std::swap(m_allocator, rhs.m_allocator); |
| std::swap(m_dispatcher, rhs.m_dispatcher); |
| } |
| |
| private: |
| VULKAN_HPP_NAMESPACE::Device m_device = {}; |
| VULKAN_HPP_NAMESPACE::Framebuffer m_framebuffer = {}; |
| const VULKAN_HPP_NAMESPACE::AllocationCallbacks *m_allocator = {}; |
| VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::DeviceDispatcher const *m_dispatcher = nullptr; |
| }; |
| |
| class Image |
| { |
| public: |
| using CType = VkImage; |
| |
| static VULKAN_HPP_CONST_OR_CONSTEXPR VULKAN_HPP_NAMESPACE::ObjectType objectType = VULKAN_HPP_NAMESPACE::ObjectType::eImage; |
| static VULKAN_HPP_CONST_OR_CONSTEXPR VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT debugReportObjectType = |
| VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT::eImage; |
| |
| public: |
| Image(VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::Device const &device, |
| VULKAN_HPP_NAMESPACE::ImageCreateInfo const &createInfo, |
| VULKAN_HPP_NAMESPACE::Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator = nullptr) |
| : m_device(*device) |
| , m_allocator(static_cast<const VULKAN_HPP_NAMESPACE::AllocationCallbacks *>(allocator)) |
| , m_dispatcher(device.getDispatcher()) |
| { |
| VULKAN_HPP_NAMESPACE::Result result = |
| static_cast<VULKAN_HPP_NAMESPACE::Result>(device.getDispatcher()->vkCreateImage(static_cast<VkDevice>(*device), |
| reinterpret_cast<const VkImageCreateInfo *>(&createInfo), |
| reinterpret_cast<const VkAllocationCallbacks *>(m_allocator), |
| reinterpret_cast<VkImage *>(&m_image))); |
| if(result != VULKAN_HPP_NAMESPACE::Result::eSuccess) |
| { |
| throwResultException(result, "vkCreateImage"); |
| } |
| } |
| |
| Image(VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::Device const &device, |
| VkImage image, |
| VULKAN_HPP_NAMESPACE::Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator = nullptr) |
| : m_device(*device) |
| , m_image(image) |
| , m_allocator(static_cast<const VULKAN_HPP_NAMESPACE::AllocationCallbacks *>(allocator)) |
| , m_dispatcher(device.getDispatcher()) |
| { |
| } |
| |
| Image(std::nullptr_t) {} |
| |
| ~Image() |
| { |
| clear(); |
| } |
| |
| Image() = delete; |
| Image(Image const &) = delete; |
| Image(Image &&rhs) VULKAN_HPP_NOEXCEPT |
| : m_device(VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange(rhs.m_device, {})), |
| m_image(VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange(rhs.m_image, {})), |
| m_allocator(VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange(rhs.m_allocator, {})), |
| m_dispatcher(VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange(rhs.m_dispatcher, nullptr)) |
| { |
| } |
| Image &operator=(Image const &) = delete; |
| Image &operator=(Image &&rhs) VULKAN_HPP_NOEXCEPT |
| { |
| if(this != &rhs) |
| { |
| clear(); |
| m_device = VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange(rhs.m_device, {}); |
| m_image = VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange(rhs.m_image, {}); |
| m_allocator = VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange(rhs.m_allocator, {}); |
| m_dispatcher = VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange(rhs.m_dispatcher, nullptr); |
| } |
| return *this; |
| } |
| |
| VULKAN_HPP_NAMESPACE::Image const &operator*() const VULKAN_HPP_NOEXCEPT |
| { |
| return m_image; |
| } |
| |
| void clear() VULKAN_HPP_NOEXCEPT |
| { |
| if(m_image) |
| { |
| getDispatcher()->vkDestroyImage( |
| static_cast<VkDevice>(m_device), static_cast<VkImage>(m_image), reinterpret_cast<const VkAllocationCallbacks *>(m_allocator)); |
| } |
| m_device = nullptr; |
| m_image = nullptr; |
| m_allocator = nullptr; |
| m_dispatcher = nullptr; |
| } |
| |
| VULKAN_HPP_NAMESPACE::Device getDevice() const |
| { |
| return m_device; |
| } |
| |
| VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::DeviceDispatcher const *getDispatcher() const |
| { |
| VULKAN_HPP_ASSERT(m_dispatcher->getVkHeaderVersion() == VK_HEADER_VERSION); |
| return m_dispatcher; |
| } |
| |
| void swap(VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::Image &rhs) VULKAN_HPP_NOEXCEPT |
| { |
| std::swap(m_device, rhs.m_device); |
| std::swap(m_image, rhs.m_image); |
| std::swap(m_allocator, rhs.m_allocator); |
| std::swap(m_dispatcher, rhs.m_dispatcher); |
| } |
| |
| //=== VK_VERSION_1_0 === |
| |
| void bindMemory(VULKAN_HPP_NAMESPACE::DeviceMemory memory, VULKAN_HPP_NAMESPACE::DeviceSize memoryOffset) const; |
| |
| VULKAN_HPP_NODISCARD VULKAN_HPP_NAMESPACE::MemoryRequirements getMemoryRequirements() const VULKAN_HPP_NOEXCEPT; |
| |
| VULKAN_HPP_NODISCARD std::vector<VULKAN_HPP_NAMESPACE::SparseImageMemoryRequirements> getSparseMemoryRequirements() const VULKAN_HPP_NOEXCEPT; |
| |
| VULKAN_HPP_NODISCARD VULKAN_HPP_NAMESPACE::SubresourceLayout |
| getSubresourceLayout(const VULKAN_HPP_NAMESPACE::ImageSubresource &subresource) const VULKAN_HPP_NOEXCEPT; |
| |
| //=== VK_EXT_image_drm_format_modifier === |
| |
| VULKAN_HPP_NODISCARD VULKAN_HPP_NAMESPACE::ImageDrmFormatModifierPropertiesEXT getDrmFormatModifierPropertiesEXT() const; |
| |
| private: |
| VULKAN_HPP_NAMESPACE::Device m_device = {}; |
| VULKAN_HPP_NAMESPACE::Image m_image = {}; |
| const VULKAN_HPP_NAMESPACE::AllocationCallbacks *m_allocator = {}; |
| VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::DeviceDispatcher const *m_dispatcher = nullptr; |
| }; |
| |
| class ImageView |
| { |
| public: |
| using CType = VkImageView; |
| |
| static VULKAN_HPP_CONST_OR_CONSTEXPR VULKAN_HPP_NAMESPACE::ObjectType objectType = VULKAN_HPP_NAMESPACE::ObjectType::eImageView; |
| static VULKAN_HPP_CONST_OR_CONSTEXPR VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT debugReportObjectType = |
| VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT::eImageView; |
| |
| public: |
| ImageView(VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::Device const &device, |
| VULKAN_HPP_NAMESPACE::ImageViewCreateInfo const &createInfo, |
| VULKAN_HPP_NAMESPACE::Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator = nullptr) |
| : m_device(*device) |
| , m_allocator(static_cast<const VULKAN_HPP_NAMESPACE::AllocationCallbacks *>(allocator)) |
| , m_dispatcher(device.getDispatcher()) |
| { |
| VULKAN_HPP_NAMESPACE::Result result = |
| static_cast<VULKAN_HPP_NAMESPACE::Result>(device.getDispatcher()->vkCreateImageView(static_cast<VkDevice>(*device), |
| reinterpret_cast<const VkImageViewCreateInfo *>(&createInfo), |
| reinterpret_cast<const VkAllocationCallbacks *>(m_allocator), |
| reinterpret_cast<VkImageView *>(&m_imageView))); |
| if(result != VULKAN_HPP_NAMESPACE::Result::eSuccess) |
| { |
| throwResultException(result, "vkCreateImageView"); |
| } |
| } |
| |
| ImageView(VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::Device const &device, |
| VkImageView imageView, |
| VULKAN_HPP_NAMESPACE::Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator = nullptr) |
| : m_device(*device) |
| , m_imageView(imageView) |
| , m_allocator(static_cast<const VULKAN_HPP_NAMESPACE::AllocationCallbacks *>(allocator)) |
| , m_dispatcher(device.getDispatcher()) |
| { |
| } |
| |
| ImageView(std::nullptr_t) {} |
| |
| ~ImageView() |
| { |
| clear(); |
| } |
| |
| ImageView() = delete; |
| ImageView(ImageView const &) = delete; |
| ImageView(ImageView &&rhs) VULKAN_HPP_NOEXCEPT |
| : m_device(VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange(rhs.m_device, {})), |
| m_imageView(VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange(rhs.m_imageView, {})), |
| m_allocator(VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange(rhs.m_allocator, {})), |
| m_dispatcher(VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange(rhs.m_dispatcher, nullptr)) |
| { |
| } |
| ImageView &operator=(ImageView const &) = delete; |
| ImageView &operator=(ImageView &&rhs) VULKAN_HPP_NOEXCEPT |
| { |
| if(this != &rhs) |
| { |
| clear(); |
| m_device = VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange(rhs.m_device, {}); |
| m_imageView = VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange(rhs.m_imageView, {}); |
| m_allocator = VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange(rhs.m_allocator, {}); |
| m_dispatcher = VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange(rhs.m_dispatcher, nullptr); |
| } |
| return *this; |
| } |
| |
| VULKAN_HPP_NAMESPACE::ImageView const &operator*() const VULKAN_HPP_NOEXCEPT |
| { |
| return m_imageView; |
| } |
| |
| void clear() VULKAN_HPP_NOEXCEPT |
| { |
| if(m_imageView) |
| { |
| getDispatcher()->vkDestroyImageView( |
| static_cast<VkDevice>(m_device), static_cast<VkImageView>(m_imageView), reinterpret_cast<const VkAllocationCallbacks *>(m_allocator)); |
| } |
| m_device = nullptr; |
| m_imageView = nullptr; |
| m_allocator = nullptr; |
| m_dispatcher = nullptr; |
| } |
| |
| VULKAN_HPP_NAMESPACE::Device getDevice() const |
| { |
| return m_device; |
| } |
| |
| VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::DeviceDispatcher const *getDispatcher() const |
| { |
| VULKAN_HPP_ASSERT(m_dispatcher->getVkHeaderVersion() == VK_HEADER_VERSION); |
| return m_dispatcher; |
| } |
| |
| void swap(VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::ImageView &rhs) VULKAN_HPP_NOEXCEPT |
| { |
| std::swap(m_device, rhs.m_device); |
| std::swap(m_imageView, rhs.m_imageView); |
| std::swap(m_allocator, rhs.m_allocator); |
| std::swap(m_dispatcher, rhs.m_dispatcher); |
| } |
| |
| //=== VK_NVX_image_view_handle === |
| |
| VULKAN_HPP_NODISCARD VULKAN_HPP_NAMESPACE::ImageViewAddressPropertiesNVX getAddressNVX() const; |
| |
| private: |
| VULKAN_HPP_NAMESPACE::Device m_device = {}; |
| VULKAN_HPP_NAMESPACE::ImageView m_imageView = {}; |
| const VULKAN_HPP_NAMESPACE::AllocationCallbacks *m_allocator = {}; |
| VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::DeviceDispatcher const *m_dispatcher = nullptr; |
| }; |
| |
| class IndirectCommandsLayoutNV |
| { |
| public: |
| using CType = VkIndirectCommandsLayoutNV; |
| |
| static VULKAN_HPP_CONST_OR_CONSTEXPR VULKAN_HPP_NAMESPACE::ObjectType objectType = VULKAN_HPP_NAMESPACE::ObjectType::eIndirectCommandsLayoutNV; |
| static VULKAN_HPP_CONST_OR_CONSTEXPR VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT debugReportObjectType = |
| VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT::eUnknown; |
| |
| public: |
| IndirectCommandsLayoutNV(VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::Device const &device, |
| VULKAN_HPP_NAMESPACE::IndirectCommandsLayoutCreateInfoNV const &createInfo, |
| VULKAN_HPP_NAMESPACE::Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator = nullptr) |
| : m_device(*device) |
| , m_allocator(static_cast<const VULKAN_HPP_NAMESPACE::AllocationCallbacks *>(allocator)) |
| , m_dispatcher(device.getDispatcher()) |
| { |
| VULKAN_HPP_NAMESPACE::Result result = static_cast<VULKAN_HPP_NAMESPACE::Result>( |
| device.getDispatcher()->vkCreateIndirectCommandsLayoutNV(static_cast<VkDevice>(*device), |
| reinterpret_cast<const VkIndirectCommandsLayoutCreateInfoNV *>(&createInfo), |
| reinterpret_cast<const VkAllocationCallbacks *>(m_allocator), |
| reinterpret_cast<VkIndirectCommandsLayoutNV *>(&m_indirectCommandsLayout))); |
| if(result != VULKAN_HPP_NAMESPACE::Result::eSuccess) |
| { |
| throwResultException(result, "vkCreateIndirectCommandsLayoutNV"); |
| } |
| } |
| |
| IndirectCommandsLayoutNV(VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::Device const &device, |
| VkIndirectCommandsLayoutNV indirectCommandsLayout, |
| VULKAN_HPP_NAMESPACE::Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator = nullptr) |
| : m_device(*device) |
| , m_indirectCommandsLayout(indirectCommandsLayout) |
| , m_allocator(static_cast<const VULKAN_HPP_NAMESPACE::AllocationCallbacks *>(allocator)) |
| , m_dispatcher(device.getDispatcher()) |
| { |
| } |
| |
| IndirectCommandsLayoutNV(std::nullptr_t) {} |
| |
| ~IndirectCommandsLayoutNV() |
| { |
| clear(); |
| } |
| |
| IndirectCommandsLayoutNV() = delete; |
| IndirectCommandsLayoutNV(IndirectCommandsLayoutNV const &) = delete; |
| IndirectCommandsLayoutNV(IndirectCommandsLayoutNV &&rhs) VULKAN_HPP_NOEXCEPT |
| : m_device(VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange(rhs.m_device, {})), |
| m_indirectCommandsLayout(VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange(rhs.m_indirectCommandsLayout, {})), |
| m_allocator(VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange(rhs.m_allocator, {})), |
| m_dispatcher(VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange(rhs.m_dispatcher, nullptr)) |
| { |
| } |
| IndirectCommandsLayoutNV &operator=(IndirectCommandsLayoutNV const &) = delete; |
| IndirectCommandsLayoutNV &operator=(IndirectCommandsLayoutNV &&rhs) VULKAN_HPP_NOEXCEPT |
| { |
| if(this != &rhs) |
| { |
| clear(); |
| m_device = VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange(rhs.m_device, {}); |
| m_indirectCommandsLayout = VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange(rhs.m_indirectCommandsLayout, {}); |
| m_allocator = VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange(rhs.m_allocator, {}); |
| m_dispatcher = VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange(rhs.m_dispatcher, nullptr); |
| } |
| return *this; |
| } |
| |
| VULKAN_HPP_NAMESPACE::IndirectCommandsLayoutNV const &operator*() const VULKAN_HPP_NOEXCEPT |
| { |
| return m_indirectCommandsLayout; |
| } |
| |
| void clear() VULKAN_HPP_NOEXCEPT |
| { |
| if(m_indirectCommandsLayout) |
| { |
| getDispatcher()->vkDestroyIndirectCommandsLayoutNV(static_cast<VkDevice>(m_device), |
| static_cast<VkIndirectCommandsLayoutNV>(m_indirectCommandsLayout), |
| reinterpret_cast<const VkAllocationCallbacks *>(m_allocator)); |
| } |
| m_device = nullptr; |
| m_indirectCommandsLayout = nullptr; |
| m_allocator = nullptr; |
| m_dispatcher = nullptr; |
| } |
| |
| VULKAN_HPP_NAMESPACE::Device getDevice() const |
| { |
| return m_device; |
| } |
| |
| VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::DeviceDispatcher const *getDispatcher() const |
| { |
| VULKAN_HPP_ASSERT(m_dispatcher->getVkHeaderVersion() == VK_HEADER_VERSION); |
| return m_dispatcher; |
| } |
| |
| void swap(VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::IndirectCommandsLayoutNV &rhs) VULKAN_HPP_NOEXCEPT |
| { |
| std::swap(m_device, rhs.m_device); |
| std::swap(m_indirectCommandsLayout, rhs.m_indirectCommandsLayout); |
| std::swap(m_allocator, rhs.m_allocator); |
| std::swap(m_dispatcher, rhs.m_dispatcher); |
| } |
| |
| private: |
| VULKAN_HPP_NAMESPACE::Device m_device = {}; |
| VULKAN_HPP_NAMESPACE::IndirectCommandsLayoutNV m_indirectCommandsLayout = {}; |
| const VULKAN_HPP_NAMESPACE::AllocationCallbacks *m_allocator = {}; |
| VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::DeviceDispatcher const *m_dispatcher = nullptr; |
| }; |
| |
| class PerformanceConfigurationINTEL |
| { |
| public: |
| using CType = VkPerformanceConfigurationINTEL; |
| |
| static VULKAN_HPP_CONST_OR_CONSTEXPR VULKAN_HPP_NAMESPACE::ObjectType objectType = VULKAN_HPP_NAMESPACE::ObjectType::ePerformanceConfigurationINTEL; |
| static VULKAN_HPP_CONST_OR_CONSTEXPR VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT debugReportObjectType = |
| VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT::eUnknown; |
| |
| public: |
| PerformanceConfigurationINTEL(VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::Device const &device, |
| VULKAN_HPP_NAMESPACE::PerformanceConfigurationAcquireInfoINTEL const &acquireInfo) |
| : m_device(*device) |
| , m_dispatcher(device.getDispatcher()) |
| { |
| VULKAN_HPP_NAMESPACE::Result result = static_cast<VULKAN_HPP_NAMESPACE::Result>( |
| device.getDispatcher()->vkAcquirePerformanceConfigurationINTEL(static_cast<VkDevice>(*device), |
| reinterpret_cast<const VkPerformanceConfigurationAcquireInfoINTEL *>(&acquireInfo), |
| reinterpret_cast<VkPerformanceConfigurationINTEL *>(&m_configuration))); |
| if(result != VULKAN_HPP_NAMESPACE::Result::eSuccess) |
| { |
| throwResultException(result, "vkAcquirePerformanceConfigurationINTEL"); |
| } |
| } |
| |
| PerformanceConfigurationINTEL(VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::Device const &device, VkPerformanceConfigurationINTEL configuration) |
| : m_device(*device) |
| , m_configuration(configuration) |
| , m_dispatcher(device.getDispatcher()) |
| { |
| } |
| |
| PerformanceConfigurationINTEL(std::nullptr_t) {} |
| |
| ~PerformanceConfigurationINTEL() |
| { |
| clear(); |
| } |
| |
| PerformanceConfigurationINTEL() = delete; |
| PerformanceConfigurationINTEL(PerformanceConfigurationINTEL const &) = delete; |
| PerformanceConfigurationINTEL(PerformanceConfigurationINTEL &&rhs) VULKAN_HPP_NOEXCEPT |
| : m_device(VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange(rhs.m_device, {})), |
| m_configuration(VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange(rhs.m_configuration, {})), |
| m_dispatcher(VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange(rhs.m_dispatcher, nullptr)) |
| { |
| } |
| PerformanceConfigurationINTEL &operator=(PerformanceConfigurationINTEL const &) = delete; |
| PerformanceConfigurationINTEL &operator=(PerformanceConfigurationINTEL &&rhs) VULKAN_HPP_NOEXCEPT |
| { |
| if(this != &rhs) |
| { |
| clear(); |
| m_device = VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange(rhs.m_device, {}); |
| m_configuration = VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange(rhs.m_configuration, {}); |
| m_dispatcher = VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange(rhs.m_dispatcher, nullptr); |
| } |
| return *this; |
| } |
| |
| VULKAN_HPP_NAMESPACE::PerformanceConfigurationINTEL const &operator*() const VULKAN_HPP_NOEXCEPT |
| { |
| return m_configuration; |
| } |
| |
| void clear() VULKAN_HPP_NOEXCEPT |
| { |
| if(m_configuration) |
| { |
| getDispatcher()->vkReleasePerformanceConfigurationINTEL(static_cast<VkDevice>(m_device), |
| static_cast<VkPerformanceConfigurationINTEL>(m_configuration)); |
| } |
| m_device = nullptr; |
| m_configuration = nullptr; |
| m_dispatcher = nullptr; |
| } |
| |
| VULKAN_HPP_NAMESPACE::Device getDevice() const |
| { |
| return m_device; |
| } |
| |
| VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::DeviceDispatcher const *getDispatcher() const |
| { |
| VULKAN_HPP_ASSERT(m_dispatcher->getVkHeaderVersion() == VK_HEADER_VERSION); |
| return m_dispatcher; |
| } |
| |
| void swap(VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::PerformanceConfigurationINTEL &rhs) VULKAN_HPP_NOEXCEPT |
| { |
| std::swap(m_device, rhs.m_device); |
| std::swap(m_configuration, rhs.m_configuration); |
| std::swap(m_dispatcher, rhs.m_dispatcher); |
| } |
| |
| private: |
| VULKAN_HPP_NAMESPACE::Device m_device = {}; |
| VULKAN_HPP_NAMESPACE::PerformanceConfigurationINTEL m_configuration = {}; |
| VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::DeviceDispatcher const *m_dispatcher = nullptr; |
| }; |
| |
| class PipelineCache |
| { |
| public: |
| using CType = VkPipelineCache; |
| |
| static VULKAN_HPP_CONST_OR_CONSTEXPR VULKAN_HPP_NAMESPACE::ObjectType objectType = VULKAN_HPP_NAMESPACE::ObjectType::ePipelineCache; |
| static VULKAN_HPP_CONST_OR_CONSTEXPR VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT debugReportObjectType = |
| VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT::ePipelineCache; |
| |
| public: |
| PipelineCache(VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::Device const &device, |
| VULKAN_HPP_NAMESPACE::PipelineCacheCreateInfo const &createInfo, |
| VULKAN_HPP_NAMESPACE::Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator = nullptr) |
| : m_device(*device) |
| , m_allocator(static_cast<const VULKAN_HPP_NAMESPACE::AllocationCallbacks *>(allocator)) |
| , m_dispatcher(device.getDispatcher()) |
| { |
| VULKAN_HPP_NAMESPACE::Result result = static_cast<VULKAN_HPP_NAMESPACE::Result>( |
| device.getDispatcher()->vkCreatePipelineCache(static_cast<VkDevice>(*device), |
| reinterpret_cast<const VkPipelineCacheCreateInfo *>(&createInfo), |
| reinterpret_cast<const VkAllocationCallbacks *>(m_allocator), |
| reinterpret_cast<VkPipelineCache *>(&m_pipelineCache))); |
| if(result != VULKAN_HPP_NAMESPACE::Result::eSuccess) |
| { |
| throwResultException(result, "vkCreatePipelineCache"); |
| } |
| } |
| |
| PipelineCache(VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::Device const &device, |
| VkPipelineCache pipelineCache, |
| VULKAN_HPP_NAMESPACE::Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator = nullptr) |
| : m_device(*device) |
| , m_pipelineCache(pipelineCache) |
| , m_allocator(static_cast<const VULKAN_HPP_NAMESPACE::AllocationCallbacks *>(allocator)) |
| , m_dispatcher(device.getDispatcher()) |
| { |
| } |
| |
| PipelineCache(std::nullptr_t) {} |
| |
| ~PipelineCache() |
| { |
| clear(); |
| } |
| |
| PipelineCache() = delete; |
| PipelineCache(PipelineCache const &) = delete; |
| PipelineCache(PipelineCache &&rhs) VULKAN_HPP_NOEXCEPT |
| : m_device(VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange(rhs.m_device, {})), |
| m_pipelineCache(VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange(rhs.m_pipelineCache, {})), |
| m_allocator(VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange(rhs.m_allocator, {})), |
| m_dispatcher(VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange(rhs.m_dispatcher, nullptr)) |
| { |
| } |
| PipelineCache &operator=(PipelineCache const &) = delete; |
| PipelineCache &operator=(PipelineCache &&rhs) VULKAN_HPP_NOEXCEPT |
| { |
| if(this != &rhs) |
| { |
| clear(); |
| m_device = VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange(rhs.m_device, {}); |
| m_pipelineCache = VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange(rhs.m_pipelineCache, {}); |
| m_allocator = VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange(rhs.m_allocator, {}); |
| m_dispatcher = VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange(rhs.m_dispatcher, nullptr); |
| } |
| return *this; |
| } |
| |
| VULKAN_HPP_NAMESPACE::PipelineCache const &operator*() const VULKAN_HPP_NOEXCEPT |
| { |
| return m_pipelineCache; |
| } |
| |
| void clear() VULKAN_HPP_NOEXCEPT |
| { |
| if(m_pipelineCache) |
| { |
| getDispatcher()->vkDestroyPipelineCache(static_cast<VkDevice>(m_device), |
| static_cast<VkPipelineCache>(m_pipelineCache), |
| reinterpret_cast<const VkAllocationCallbacks *>(m_allocator)); |
| } |
| m_device = nullptr; |
| m_pipelineCache = nullptr; |
| m_allocator = nullptr; |
| m_dispatcher = nullptr; |
| } |
| |
| VULKAN_HPP_NAMESPACE::Device getDevice() const |
| { |
| return m_device; |
| } |
| |
| VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::DeviceDispatcher const *getDispatcher() const |
| { |
| VULKAN_HPP_ASSERT(m_dispatcher->getVkHeaderVersion() == VK_HEADER_VERSION); |
| return m_dispatcher; |
| } |
| |
| void swap(VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::PipelineCache &rhs) VULKAN_HPP_NOEXCEPT |
| { |
| std::swap(m_device, rhs.m_device); |
| std::swap(m_pipelineCache, rhs.m_pipelineCache); |
| std::swap(m_allocator, rhs.m_allocator); |
| std::swap(m_dispatcher, rhs.m_dispatcher); |
| } |
| |
| //=== VK_VERSION_1_0 === |
| |
| VULKAN_HPP_NODISCARD std::vector<uint8_t> getData() const; |
| |
| void merge(ArrayProxy<const VULKAN_HPP_NAMESPACE::PipelineCache> const &srcCaches) const; |
| |
| private: |
| VULKAN_HPP_NAMESPACE::Device m_device = {}; |
| VULKAN_HPP_NAMESPACE::PipelineCache m_pipelineCache = {}; |
| const VULKAN_HPP_NAMESPACE::AllocationCallbacks *m_allocator = {}; |
| VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::DeviceDispatcher const *m_dispatcher = nullptr; |
| }; |
| |
| class Pipeline |
| { |
| public: |
| using CType = VkPipeline; |
| |
| static VULKAN_HPP_CONST_OR_CONSTEXPR VULKAN_HPP_NAMESPACE::ObjectType objectType = VULKAN_HPP_NAMESPACE::ObjectType::ePipeline; |
| static VULKAN_HPP_CONST_OR_CONSTEXPR VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT debugReportObjectType = |
| VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT::ePipeline; |
| |
| public: |
| Pipeline(VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::Device const &device, |
| VULKAN_HPP_NAMESPACE::Optional<const VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::PipelineCache> const &pipelineCache, |
| VULKAN_HPP_NAMESPACE::ComputePipelineCreateInfo const &createInfo, |
| VULKAN_HPP_NAMESPACE::Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator = nullptr) |
| : m_device(*device) |
| , m_allocator(static_cast<const VULKAN_HPP_NAMESPACE::AllocationCallbacks *>(allocator)) |
| , m_dispatcher(device.getDispatcher()) |
| { |
| m_constructorSuccessCode = static_cast<VULKAN_HPP_NAMESPACE::Result>( |
| getDispatcher()->vkCreateComputePipelines(static_cast<VkDevice>(*device), |
| pipelineCache ? static_cast<VkPipelineCache>(**pipelineCache) : 0, |
| 1, |
| reinterpret_cast<const VkComputePipelineCreateInfo *>(&createInfo), |
| reinterpret_cast<const VkAllocationCallbacks *>(m_allocator), |
| reinterpret_cast<VkPipeline *>(&m_pipeline))); |
| if((m_constructorSuccessCode != VULKAN_HPP_NAMESPACE::Result::eSuccess) && |
| (m_constructorSuccessCode != VULKAN_HPP_NAMESPACE::Result::ePipelineCompileRequiredEXT)) |
| { |
| throwResultException(m_constructorSuccessCode, "vkCreateComputePipelines"); |
| } |
| } |
| |
| Pipeline(VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::Device const &device, |
| VULKAN_HPP_NAMESPACE::Optional<const VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::PipelineCache> const &pipelineCache, |
| VULKAN_HPP_NAMESPACE::GraphicsPipelineCreateInfo const &createInfo, |
| VULKAN_HPP_NAMESPACE::Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator = nullptr) |
| : m_device(*device) |
| , m_allocator(static_cast<const VULKAN_HPP_NAMESPACE::AllocationCallbacks *>(allocator)) |
| , m_dispatcher(device.getDispatcher()) |
| { |
| m_constructorSuccessCode = static_cast<VULKAN_HPP_NAMESPACE::Result>( |
| getDispatcher()->vkCreateGraphicsPipelines(static_cast<VkDevice>(*device), |
| pipelineCache ? static_cast<VkPipelineCache>(**pipelineCache) : 0, |
| 1, |
| reinterpret_cast<const VkGraphicsPipelineCreateInfo *>(&createInfo), |
| reinterpret_cast<const VkAllocationCallbacks *>(m_allocator), |
| reinterpret_cast<VkPipeline *>(&m_pipeline))); |
| if((m_constructorSuccessCode != VULKAN_HPP_NAMESPACE::Result::eSuccess) && |
| (m_constructorSuccessCode != VULKAN_HPP_NAMESPACE::Result::ePipelineCompileRequiredEXT)) |
| { |
| throwResultException(m_constructorSuccessCode, "vkCreateGraphicsPipelines"); |
| } |
| } |
| |
| Pipeline(VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::Device const &device, |
| VULKAN_HPP_NAMESPACE::Optional<const VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::DeferredOperationKHR> const &deferredOperation, |
| VULKAN_HPP_NAMESPACE::Optional<const VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::PipelineCache> const &pipelineCache, |
| VULKAN_HPP_NAMESPACE::RayTracingPipelineCreateInfoKHR const &createInfo, |
| VULKAN_HPP_NAMESPACE::Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator = nullptr) |
| : m_device(*device) |
| , m_allocator(static_cast<const VULKAN_HPP_NAMESPACE::AllocationCallbacks *>(allocator)) |
| , m_dispatcher(device.getDispatcher()) |
| { |
| m_constructorSuccessCode = static_cast<VULKAN_HPP_NAMESPACE::Result>( |
| getDispatcher()->vkCreateRayTracingPipelinesKHR(static_cast<VkDevice>(*device), |
| deferredOperation ? static_cast<VkDeferredOperationKHR>(**deferredOperation) : 0, |
| pipelineCache ? static_cast<VkPipelineCache>(**pipelineCache) : 0, |
| 1, |
| reinterpret_cast<const VkRayTracingPipelineCreateInfoKHR *>(&createInfo), |
| reinterpret_cast<const VkAllocationCallbacks *>(m_allocator), |
| reinterpret_cast<VkPipeline *>(&m_pipeline))); |
| if((m_constructorSuccessCode != VULKAN_HPP_NAMESPACE::Result::eSuccess) && |
| (m_constructorSuccessCode != VULKAN_HPP_NAMESPACE::Result::eOperationDeferredKHR) && |
| (m_constructorSuccessCode != VULKAN_HPP_NAMESPACE::Result::eOperationNotDeferredKHR) && |
| (m_constructorSuccessCode != VULKAN_HPP_NAMESPACE::Result::ePipelineCompileRequiredEXT)) |
| { |
| throwResultException(m_constructorSuccessCode, "vkCreateRayTracingPipelinesKHR"); |
| } |
| } |
| |
| Pipeline(VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::Device const &device, |
| VULKAN_HPP_NAMESPACE::Optional<const VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::PipelineCache> const &pipelineCache, |
| VULKAN_HPP_NAMESPACE::RayTracingPipelineCreateInfoNV const &createInfo, |
| VULKAN_HPP_NAMESPACE::Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator = nullptr) |
| : m_device(*device) |
| , m_allocator(static_cast<const VULKAN_HPP_NAMESPACE::AllocationCallbacks *>(allocator)) |
| , m_dispatcher(device.getDispatcher()) |
| { |
| m_constructorSuccessCode = static_cast<VULKAN_HPP_NAMESPACE::Result>( |
| getDispatcher()->vkCreateRayTracingPipelinesNV(static_cast<VkDevice>(*device), |
| pipelineCache ? static_cast<VkPipelineCache>(**pipelineCache) : 0, |
| 1, |
| reinterpret_cast<const VkRayTracingPipelineCreateInfoNV *>(&createInfo), |
| reinterpret_cast<const VkAllocationCallbacks *>(m_allocator), |
| reinterpret_cast<VkPipeline *>(&m_pipeline))); |
| if((m_constructorSuccessCode != VULKAN_HPP_NAMESPACE::Result::eSuccess) && |
| (m_constructorSuccessCode != VULKAN_HPP_NAMESPACE::Result::ePipelineCompileRequiredEXT)) |
| { |
| throwResultException(m_constructorSuccessCode, "vkCreateRayTracingPipelinesNV"); |
| } |
| } |
| |
| Pipeline(VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::Device const &device, |
| VkPipeline pipeline, |
| VULKAN_HPP_NAMESPACE::Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator = nullptr, |
| VULKAN_HPP_NAMESPACE::Result successCode = VULKAN_HPP_NAMESPACE::Result::eSuccess) |
| : m_device(*device) |
| , m_pipeline(pipeline) |
| , m_allocator(static_cast<const VULKAN_HPP_NAMESPACE::AllocationCallbacks *>(allocator)) |
| , m_constructorSuccessCode(successCode) |
| , m_dispatcher(device.getDispatcher()) |
| { |
| } |
| |
| Pipeline(std::nullptr_t) {} |
| |
| ~Pipeline() |
| { |
| clear(); |
| } |
| |
| Pipeline() = delete; |
| Pipeline(Pipeline const &) = delete; |
| Pipeline(Pipeline &&rhs) VULKAN_HPP_NOEXCEPT |
| : m_device(VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange(rhs.m_device, {})), |
| m_pipeline(VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange(rhs.m_pipeline, {})), |
| m_allocator(VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange(rhs.m_allocator, {})), |
| m_dispatcher(VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange(rhs.m_dispatcher, nullptr)) |
| { |
| } |
| Pipeline &operator=(Pipeline const &) = delete; |
| Pipeline &operator=(Pipeline &&rhs) VULKAN_HPP_NOEXCEPT |
| { |
| if(this != &rhs) |
| { |
| clear(); |
| m_device = VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange(rhs.m_device, {}); |
| m_pipeline = VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange(rhs.m_pipeline, {}); |
| m_allocator = VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange(rhs.m_allocator, {}); |
| m_dispatcher = VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange(rhs.m_dispatcher, nullptr); |
| } |
| return *this; |
| } |
| |
| VULKAN_HPP_NAMESPACE::Pipeline const &operator*() const VULKAN_HPP_NOEXCEPT |
| { |
| return m_pipeline; |
| } |
| |
| void clear() VULKAN_HPP_NOEXCEPT |
| { |
| if(m_pipeline) |
| { |
| getDispatcher()->vkDestroyPipeline( |
| static_cast<VkDevice>(m_device), static_cast<VkPipeline>(m_pipeline), reinterpret_cast<const VkAllocationCallbacks *>(m_allocator)); |
| } |
| m_device = nullptr; |
| m_pipeline = nullptr; |
| m_allocator = nullptr; |
| m_constructorSuccessCode = VULKAN_HPP_NAMESPACE::Result::eErrorUnknown; |
| m_dispatcher = nullptr; |
| } |
| |
| VULKAN_HPP_NAMESPACE::Result getConstructorSuccessCode() const |
| { |
| return m_constructorSuccessCode; |
| } |
| |
| VULKAN_HPP_NAMESPACE::Device getDevice() const |
| { |
| return m_device; |
| } |
| |
| VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::DeviceDispatcher const *getDispatcher() const |
| { |
| VULKAN_HPP_ASSERT(m_dispatcher->getVkHeaderVersion() == VK_HEADER_VERSION); |
| return m_dispatcher; |
| } |
| |
| void swap(VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::Pipeline &rhs) VULKAN_HPP_NOEXCEPT |
| { |
| std::swap(m_device, rhs.m_device); |
| std::swap(m_pipeline, rhs.m_pipeline); |
| std::swap(m_allocator, rhs.m_allocator); |
| std::swap(m_constructorSuccessCode, rhs.m_constructorSuccessCode); |
| std::swap(m_dispatcher, rhs.m_dispatcher); |
| } |
| |
| //=== VK_AMD_shader_info === |
| |
| VULKAN_HPP_NODISCARD std::vector<uint8_t> getShaderInfoAMD(VULKAN_HPP_NAMESPACE::ShaderStageFlagBits shaderStage, |
| VULKAN_HPP_NAMESPACE::ShaderInfoTypeAMD infoType) const; |
| |
| //=== VK_NV_ray_tracing === |
| |
| template<typename DataType> |
| VULKAN_HPP_NODISCARD std::vector<DataType> getRayTracingShaderGroupHandlesNV(uint32_t firstGroup, uint32_t groupCount, size_t dataSize) const; |
| |
| template<typename DataType> |
| VULKAN_HPP_NODISCARD DataType getRayTracingShaderGroupHandleNV(uint32_t firstGroup, uint32_t groupCount) const; |
| |
| void compileDeferredNV(uint32_t shader) const; |
| |
| //=== VK_KHR_ray_tracing_pipeline === |
| |
| template<typename DataType> |
| VULKAN_HPP_NODISCARD std::vector<DataType> getRayTracingShaderGroupHandlesKHR(uint32_t firstGroup, uint32_t groupCount, size_t dataSize) const; |
| |
| template<typename DataType> |
| VULKAN_HPP_NODISCARD DataType getRayTracingShaderGroupHandleKHR(uint32_t firstGroup, uint32_t groupCount) const; |
| |
| template<typename DataType> |
| VULKAN_HPP_NODISCARD std::vector<DataType> |
| getRayTracingCaptureReplayShaderGroupHandlesKHR(uint32_t firstGroup, uint32_t groupCount, size_t dataSize) const; |
| |
| template<typename DataType> |
| VULKAN_HPP_NODISCARD DataType getRayTracingCaptureReplayShaderGroupHandleKHR(uint32_t firstGroup, uint32_t groupCount) const; |
| |
| VULKAN_HPP_NODISCARD VULKAN_HPP_NAMESPACE::DeviceSize |
| getRayTracingShaderGroupStackSizeKHR(uint32_t group, VULKAN_HPP_NAMESPACE::ShaderGroupShaderKHR groupShader) const VULKAN_HPP_NOEXCEPT; |
| |
| private: |
| VULKAN_HPP_NAMESPACE::Device m_device = {}; |
| VULKAN_HPP_NAMESPACE::Pipeline m_pipeline = {}; |
| const VULKAN_HPP_NAMESPACE::AllocationCallbacks *m_allocator = {}; |
| VULKAN_HPP_NAMESPACE::Result m_constructorSuccessCode = VULKAN_HPP_NAMESPACE::Result::eErrorUnknown; |
| VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::DeviceDispatcher const *m_dispatcher = nullptr; |
| }; |
| |
| class Pipelines : public std::vector<VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::Pipeline> |
| { |
| public: |
| Pipelines(VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::Device const &device, |
| VULKAN_HPP_NAMESPACE::Optional<const VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::PipelineCache> const &pipelineCache, |
| VULKAN_HPP_NAMESPACE::ArrayProxy<VULKAN_HPP_NAMESPACE::ComputePipelineCreateInfo> const &createInfos, |
| VULKAN_HPP_NAMESPACE::Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator = nullptr) |
| { |
| VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::DeviceDispatcher const *dispatcher = device.getDispatcher(); |
| std::vector<VkPipeline> pipelines(createInfos.size()); |
| VULKAN_HPP_NAMESPACE::Result result = static_cast<VULKAN_HPP_NAMESPACE::Result>(dispatcher->vkCreateComputePipelines( |
| static_cast<VkDevice>(*device), |
| pipelineCache ? static_cast<VkPipelineCache>(**pipelineCache) : 0, |
| createInfos.size(), |
| reinterpret_cast<const VkComputePipelineCreateInfo *>(createInfos.data()), |
| reinterpret_cast<const VkAllocationCallbacks *>(static_cast<const VULKAN_HPP_NAMESPACE::AllocationCallbacks *>(allocator)), |
| pipelines.data())); |
| if((result == VULKAN_HPP_NAMESPACE::Result::eSuccess) || (result == VULKAN_HPP_NAMESPACE::Result::ePipelineCompileRequiredEXT)) |
| { |
| this->reserve(createInfos.size()); |
| for(auto const &pipeline : pipelines) |
| { |
| this->emplace_back(device, pipeline, allocator, result); |
| } |
| } |
| else |
| { |
| throwResultException(result, "vkCreateComputePipelines"); |
| } |
| } |
| |
| Pipelines(VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::Device const &device, |
| VULKAN_HPP_NAMESPACE::Optional<const VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::PipelineCache> const &pipelineCache, |
| VULKAN_HPP_NAMESPACE::ArrayProxy<VULKAN_HPP_NAMESPACE::GraphicsPipelineCreateInfo> const &createInfos, |
| VULKAN_HPP_NAMESPACE::Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator = nullptr) |
| { |
| VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::DeviceDispatcher const *dispatcher = device.getDispatcher(); |
| std::vector<VkPipeline> pipelines(createInfos.size()); |
| VULKAN_HPP_NAMESPACE::Result result = static_cast<VULKAN_HPP_NAMESPACE::Result>(dispatcher->vkCreateGraphicsPipelines( |
| static_cast<VkDevice>(*device), |
| pipelineCache ? static_cast<VkPipelineCache>(**pipelineCache) : 0, |
| createInfos.size(), |
| reinterpret_cast<const VkGraphicsPipelineCreateInfo *>(createInfos.data()), |
| reinterpret_cast<const VkAllocationCallbacks *>(static_cast<const VULKAN_HPP_NAMESPACE::AllocationCallbacks *>(allocator)), |
| pipelines.data())); |
| if((result == VULKAN_HPP_NAMESPACE::Result::eSuccess) || (result == VULKAN_HPP_NAMESPACE::Result::ePipelineCompileRequiredEXT)) |
| { |
| this->reserve(createInfos.size()); |
| for(auto const &pipeline : pipelines) |
| { |
| this->emplace_back(device, pipeline, allocator, result); |
| } |
| } |
| else |
| { |
| throwResultException(result, "vkCreateGraphicsPipelines"); |
| } |
| } |
| |
| Pipelines(VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::Device const &device, |
| VULKAN_HPP_NAMESPACE::Optional<const VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::DeferredOperationKHR> const &deferredOperation, |
| VULKAN_HPP_NAMESPACE::Optional<const VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::PipelineCache> const &pipelineCache, |
| VULKAN_HPP_NAMESPACE::ArrayProxy<VULKAN_HPP_NAMESPACE::RayTracingPipelineCreateInfoKHR> const &createInfos, |
| VULKAN_HPP_NAMESPACE::Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator = nullptr) |
| { |
| VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::DeviceDispatcher const *dispatcher = device.getDispatcher(); |
| std::vector<VkPipeline> pipelines(createInfos.size()); |
| VULKAN_HPP_NAMESPACE::Result result = static_cast<VULKAN_HPP_NAMESPACE::Result>(dispatcher->vkCreateRayTracingPipelinesKHR( |
| static_cast<VkDevice>(*device), |
| deferredOperation ? static_cast<VkDeferredOperationKHR>(**deferredOperation) : 0, |
| pipelineCache ? static_cast<VkPipelineCache>(**pipelineCache) : 0, |
| createInfos.size(), |
| reinterpret_cast<const VkRayTracingPipelineCreateInfoKHR *>(createInfos.data()), |
| reinterpret_cast<const VkAllocationCallbacks *>(static_cast<const VULKAN_HPP_NAMESPACE::AllocationCallbacks *>(allocator)), |
| pipelines.data())); |
| if((result == VULKAN_HPP_NAMESPACE::Result::eSuccess) || (result == VULKAN_HPP_NAMESPACE::Result::eOperationDeferredKHR) || |
| (result == VULKAN_HPP_NAMESPACE::Result::eOperationNotDeferredKHR) || (result == VULKAN_HPP_NAMESPACE::Result::ePipelineCompileRequiredEXT)) |
| { |
| this->reserve(createInfos.size()); |
| for(auto const &pipeline : pipelines) |
| { |
| this->emplace_back(device, pipeline, allocator, result); |
| } |
| } |
| else |
| { |
| throwResultException(result, "vkCreateRayTracingPipelinesKHR"); |
| } |
| } |
| |
| Pipelines(VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::Device const &device, |
| VULKAN_HPP_NAMESPACE::Optional<const VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::PipelineCache> const &pipelineCache, |
| VULKAN_HPP_NAMESPACE::ArrayProxy<VULKAN_HPP_NAMESPACE::RayTracingPipelineCreateInfoNV> const &createInfos, |
| VULKAN_HPP_NAMESPACE::Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator = nullptr) |
| { |
| VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::DeviceDispatcher const *dispatcher = device.getDispatcher(); |
| std::vector<VkPipeline> pipelines(createInfos.size()); |
| VULKAN_HPP_NAMESPACE::Result result = static_cast<VULKAN_HPP_NAMESPACE::Result>(dispatcher->vkCreateRayTracingPipelinesNV( |
| static_cast<VkDevice>(*device), |
| pipelineCache ? static_cast<VkPipelineCache>(**pipelineCache) : 0, |
| createInfos.size(), |
| reinterpret_cast<const VkRayTracingPipelineCreateInfoNV *>(createInfos.data()), |
| reinterpret_cast<const VkAllocationCallbacks *>(static_cast<const VULKAN_HPP_NAMESPACE::AllocationCallbacks *>(allocator)), |
| pipelines.data())); |
| if((result == VULKAN_HPP_NAMESPACE::Result::eSuccess) || (result == VULKAN_HPP_NAMESPACE::Result::ePipelineCompileRequiredEXT)) |
| { |
| this->reserve(createInfos.size()); |
| for(auto const &pipeline : pipelines) |
| { |
| this->emplace_back(device, pipeline, allocator, result); |
| } |
| } |
| else |
| { |
| throwResultException(result, "vkCreateRayTracingPipelinesNV"); |
| } |
| } |
| |
| Pipelines(std::nullptr_t) {} |
| |
| Pipelines() = delete; |
| Pipelines(Pipelines const &) = delete; |
| Pipelines(Pipelines &&rhs) = default; |
| Pipelines &operator=(Pipelines const &) = delete; |
| Pipelines &operator=(Pipelines &&rhs) = default; |
| }; |
| |
| class PipelineLayout |
| { |
| public: |
| using CType = VkPipelineLayout; |
| |
| static VULKAN_HPP_CONST_OR_CONSTEXPR VULKAN_HPP_NAMESPACE::ObjectType objectType = VULKAN_HPP_NAMESPACE::ObjectType::ePipelineLayout; |
| static VULKAN_HPP_CONST_OR_CONSTEXPR VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT debugReportObjectType = |
| VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT::ePipelineLayout; |
| |
| public: |
| PipelineLayout(VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::Device const &device, |
| VULKAN_HPP_NAMESPACE::PipelineLayoutCreateInfo const &createInfo, |
| VULKAN_HPP_NAMESPACE::Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator = nullptr) |
| : m_device(*device) |
| , m_allocator(static_cast<const VULKAN_HPP_NAMESPACE::AllocationCallbacks *>(allocator)) |
| , m_dispatcher(device.getDispatcher()) |
| { |
| VULKAN_HPP_NAMESPACE::Result result = static_cast<VULKAN_HPP_NAMESPACE::Result>( |
| device.getDispatcher()->vkCreatePipelineLayout(static_cast<VkDevice>(*device), |
| reinterpret_cast<const VkPipelineLayoutCreateInfo *>(&createInfo), |
| reinterpret_cast<const VkAllocationCallbacks *>(m_allocator), |
| reinterpret_cast<VkPipelineLayout *>(&m_pipelineLayout))); |
| if(result != VULKAN_HPP_NAMESPACE::Result::eSuccess) |
| { |
| throwResultException(result, "vkCreatePipelineLayout"); |
| } |
| } |
| |
| PipelineLayout(VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::Device const &device, |
| VkPipelineLayout pipelineLayout, |
| VULKAN_HPP_NAMESPACE::Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator = nullptr) |
| : m_device(*device) |
| , m_pipelineLayout(pipelineLayout) |
| , m_allocator(static_cast<const VULKAN_HPP_NAMESPACE::AllocationCallbacks *>(allocator)) |
| , m_dispatcher(device.getDispatcher()) |
| { |
| } |
| |
| PipelineLayout(std::nullptr_t) {} |
| |
| ~PipelineLayout() |
| { |
| clear(); |
| } |
| |
| PipelineLayout() = delete; |
| PipelineLayout(PipelineLayout const &) = delete; |
| PipelineLayout(PipelineLayout &&rhs) VULKAN_HPP_NOEXCEPT |
| : m_device(VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange(rhs.m_device, {})), |
| m_pipelineLayout(VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange(rhs.m_pipelineLayout, {})), |
| m_allocator(VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange(rhs.m_allocator, {})), |
| m_dispatcher(VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange(rhs.m_dispatcher, nullptr)) |
| { |
| } |
| PipelineLayout &operator=(PipelineLayout const &) = delete; |
| PipelineLayout &operator=(PipelineLayout &&rhs) VULKAN_HPP_NOEXCEPT |
| { |
| if(this != &rhs) |
| { |
| clear(); |
| m_device = VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange(rhs.m_device, {}); |
| m_pipelineLayout = VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange(rhs.m_pipelineLayout, {}); |
| m_allocator = VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange(rhs.m_allocator, {}); |
| m_dispatcher = VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange(rhs.m_dispatcher, nullptr); |
| } |
| return *this; |
| } |
| |
| VULKAN_HPP_NAMESPACE::PipelineLayout const &operator*() const VULKAN_HPP_NOEXCEPT |
| { |
| return m_pipelineLayout; |
| } |
| |
| void clear() VULKAN_HPP_NOEXCEPT |
| { |
| if(m_pipelineLayout) |
| { |
| getDispatcher()->vkDestroyPipelineLayout(static_cast<VkDevice>(m_device), |
| static_cast<VkPipelineLayout>(m_pipelineLayout), |
| reinterpret_cast<const VkAllocationCallbacks *>(m_allocator)); |
| } |
| m_device = nullptr; |
| m_pipelineLayout = nullptr; |
| m_allocator = nullptr; |
| m_dispatcher = nullptr; |
| } |
| |
| VULKAN_HPP_NAMESPACE::Device getDevice() const |
| { |
| return m_device; |
| } |
| |
| VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::DeviceDispatcher const *getDispatcher() const |
| { |
| VULKAN_HPP_ASSERT(m_dispatcher->getVkHeaderVersion() == VK_HEADER_VERSION); |
| return m_dispatcher; |
| } |
| |
| void swap(VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::PipelineLayout &rhs) VULKAN_HPP_NOEXCEPT |
| { |
| std::swap(m_device, rhs.m_device); |
| std::swap(m_pipelineLayout, rhs.m_pipelineLayout); |
| std::swap(m_allocator, rhs.m_allocator); |
| std::swap(m_dispatcher, rhs.m_dispatcher); |
| } |
| |
| private: |
| VULKAN_HPP_NAMESPACE::Device m_device = {}; |
| VULKAN_HPP_NAMESPACE::PipelineLayout m_pipelineLayout = {}; |
| const VULKAN_HPP_NAMESPACE::AllocationCallbacks *m_allocator = {}; |
| VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::DeviceDispatcher const *m_dispatcher = nullptr; |
| }; |
| |
| class PrivateDataSlot |
| { |
| public: |
| using CType = VkPrivateDataSlot; |
| |
| static VULKAN_HPP_CONST_OR_CONSTEXPR VULKAN_HPP_NAMESPACE::ObjectType objectType = VULKAN_HPP_NAMESPACE::ObjectType::ePrivateDataSlot; |
| static VULKAN_HPP_CONST_OR_CONSTEXPR VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT debugReportObjectType = |
| VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT::eUnknown; |
| |
| public: |
| PrivateDataSlot(VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::Device const &device, |
| VULKAN_HPP_NAMESPACE::PrivateDataSlotCreateInfo const &createInfo, |
| VULKAN_HPP_NAMESPACE::Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator = nullptr) |
| : m_device(*device) |
| , m_allocator(static_cast<const VULKAN_HPP_NAMESPACE::AllocationCallbacks *>(allocator)) |
| , m_dispatcher(device.getDispatcher()) |
| { |
| VULKAN_HPP_NAMESPACE::Result result = static_cast<VULKAN_HPP_NAMESPACE::Result>( |
| device.getDispatcher()->vkCreatePrivateDataSlot(static_cast<VkDevice>(*device), |
| reinterpret_cast<const VkPrivateDataSlotCreateInfo *>(&createInfo), |
| reinterpret_cast<const VkAllocationCallbacks *>(m_allocator), |
| reinterpret_cast<VkPrivateDataSlot *>(&m_privateDataSlot))); |
| if(result != VULKAN_HPP_NAMESPACE::Result::eSuccess) |
| { |
| throwResultException(result, "vkCreatePrivateDataSlot"); |
| } |
| } |
| |
| PrivateDataSlot(VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::Device const &device, |
| VkPrivateDataSlot privateDataSlot, |
| VULKAN_HPP_NAMESPACE::Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator = nullptr) |
| : m_device(*device) |
| , m_privateDataSlot(privateDataSlot) |
| , m_allocator(static_cast<const VULKAN_HPP_NAMESPACE::AllocationCallbacks *>(allocator)) |
| , m_dispatcher(device.getDispatcher()) |
| { |
| } |
| |
| PrivateDataSlot(std::nullptr_t) {} |
| |
| ~PrivateDataSlot() |
| { |
| clear(); |
| } |
| |
| PrivateDataSlot() = delete; |
| PrivateDataSlot(PrivateDataSlot const &) = delete; |
| PrivateDataSlot(PrivateDataSlot &&rhs) VULKAN_HPP_NOEXCEPT |
| : m_device(VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange(rhs.m_device, {})), |
| m_privateDataSlot(VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange(rhs.m_privateDataSlot, {})), |
| m_allocator(VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange(rhs.m_allocator, {})), |
| m_dispatcher(VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange(rhs.m_dispatcher, nullptr)) |
| { |
| } |
| PrivateDataSlot &operator=(PrivateDataSlot const &) = delete; |
| PrivateDataSlot &operator=(PrivateDataSlot &&rhs) VULKAN_HPP_NOEXCEPT |
| { |
| if(this != &rhs) |
| { |
| clear(); |
| m_device = VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange(rhs.m_device, {}); |
| m_privateDataSlot = VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange(rhs.m_privateDataSlot, {}); |
| m_allocator = VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange(rhs.m_allocator, {}); |
| m_dispatcher = VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange(rhs.m_dispatcher, nullptr); |
| } |
| return *this; |
| } |
| |
| VULKAN_HPP_NAMESPACE::PrivateDataSlot const &operator*() const VULKAN_HPP_NOEXCEPT |
| { |
| return m_privateDataSlot; |
| } |
| |
| void clear() VULKAN_HPP_NOEXCEPT |
| { |
| if(m_privateDataSlot) |
| { |
| getDispatcher()->vkDestroyPrivateDataSlot(static_cast<VkDevice>(m_device), |
| static_cast<VkPrivateDataSlot>(m_privateDataSlot), |
| reinterpret_cast<const VkAllocationCallbacks *>(m_allocator)); |
| } |
| m_device = nullptr; |
| m_privateDataSlot = nullptr; |
| m_allocator = nullptr; |
| m_dispatcher = nullptr; |
| } |
| |
| VULKAN_HPP_NAMESPACE::Device getDevice() const |
| { |
| return m_device; |
| } |
| |
| VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::DeviceDispatcher const *getDispatcher() const |
| { |
| VULKAN_HPP_ASSERT(m_dispatcher->getVkHeaderVersion() == VK_HEADER_VERSION); |
| return m_dispatcher; |
| } |
| |
| void swap(VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::PrivateDataSlot &rhs) VULKAN_HPP_NOEXCEPT |
| { |
| std::swap(m_device, rhs.m_device); |
| std::swap(m_privateDataSlot, rhs.m_privateDataSlot); |
| std::swap(m_allocator, rhs.m_allocator); |
| std::swap(m_dispatcher, rhs.m_dispatcher); |
| } |
| |
| private: |
| VULKAN_HPP_NAMESPACE::Device m_device = {}; |
| VULKAN_HPP_NAMESPACE::PrivateDataSlot m_privateDataSlot = {}; |
| const VULKAN_HPP_NAMESPACE::AllocationCallbacks *m_allocator = {}; |
| VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::DeviceDispatcher const *m_dispatcher = nullptr; |
| }; |
| |
| class QueryPool |
| { |
| public: |
| using CType = VkQueryPool; |
| |
| static VULKAN_HPP_CONST_OR_CONSTEXPR VULKAN_HPP_NAMESPACE::ObjectType objectType = VULKAN_HPP_NAMESPACE::ObjectType::eQueryPool; |
| static VULKAN_HPP_CONST_OR_CONSTEXPR VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT debugReportObjectType = |
| VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT::eQueryPool; |
| |
| public: |
| QueryPool(VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::Device const &device, |
| VULKAN_HPP_NAMESPACE::QueryPoolCreateInfo const &createInfo, |
| VULKAN_HPP_NAMESPACE::Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator = nullptr) |
| : m_device(*device) |
| , m_allocator(static_cast<const VULKAN_HPP_NAMESPACE::AllocationCallbacks *>(allocator)) |
| , m_dispatcher(device.getDispatcher()) |
| { |
| VULKAN_HPP_NAMESPACE::Result result = |
| static_cast<VULKAN_HPP_NAMESPACE::Result>(device.getDispatcher()->vkCreateQueryPool(static_cast<VkDevice>(*device), |
| reinterpret_cast<const VkQueryPoolCreateInfo *>(&createInfo), |
| reinterpret_cast<const VkAllocationCallbacks *>(m_allocator), |
| reinterpret_cast<VkQueryPool *>(&m_queryPool))); |
| if(result != VULKAN_HPP_NAMESPACE::Result::eSuccess) |
| { |
| throwResultException(result, "vkCreateQueryPool"); |
| } |
| } |
| |
| QueryPool(VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::Device const &device, |
| VkQueryPool queryPool, |
| VULKAN_HPP_NAMESPACE::Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator = nullptr) |
| : m_device(*device) |
| , m_queryPool(queryPool) |
| , m_allocator(static_cast<const VULKAN_HPP_NAMESPACE::AllocationCallbacks *>(allocator)) |
| , m_dispatcher(device.getDispatcher()) |
| { |
| } |
| |
| QueryPool(std::nullptr_t) {} |
| |
| ~QueryPool() |
| { |
| clear(); |
| } |
| |
| QueryPool() = delete; |
| QueryPool(QueryPool const &) = delete; |
| QueryPool(QueryPool &&rhs) VULKAN_HPP_NOEXCEPT |
| : m_device(VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange(rhs.m_device, {})), |
| m_queryPool(VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange(rhs.m_queryPool, {})), |
| m_allocator(VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange(rhs.m_allocator, {})), |
| m_dispatcher(VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange(rhs.m_dispatcher, nullptr)) |
| { |
| } |
| QueryPool &operator=(QueryPool const &) = delete; |
| QueryPool &operator=(QueryPool &&rhs) VULKAN_HPP_NOEXCEPT |
| { |
| if(this != &rhs) |
| { |
| clear(); |
| m_device = VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange(rhs.m_device, {}); |
| m_queryPool = VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange(rhs.m_queryPool, {}); |
| m_allocator = VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange(rhs.m_allocator, {}); |
| m_dispatcher = VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange(rhs.m_dispatcher, nullptr); |
| } |
| return *this; |
| } |
| |
| VULKAN_HPP_NAMESPACE::QueryPool const &operator*() const VULKAN_HPP_NOEXCEPT |
| { |
| return m_queryPool; |
| } |
| |
| void clear() VULKAN_HPP_NOEXCEPT |
| { |
| if(m_queryPool) |
| { |
| getDispatcher()->vkDestroyQueryPool( |
| static_cast<VkDevice>(m_device), static_cast<VkQueryPool>(m_queryPool), reinterpret_cast<const VkAllocationCallbacks *>(m_allocator)); |
| } |
| m_device = nullptr; |
| m_queryPool = nullptr; |
| m_allocator = nullptr; |
| m_dispatcher = nullptr; |
| } |
| |
| VULKAN_HPP_NAMESPACE::Device getDevice() const |
| { |
| return m_device; |
| } |
| |
| VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::DeviceDispatcher const *getDispatcher() const |
| { |
| VULKAN_HPP_ASSERT(m_dispatcher->getVkHeaderVersion() == VK_HEADER_VERSION); |
| return m_dispatcher; |
| } |
| |
| void swap(VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::QueryPool &rhs) VULKAN_HPP_NOEXCEPT |
| { |
| std::swap(m_device, rhs.m_device); |
| std::swap(m_queryPool, rhs.m_queryPool); |
| std::swap(m_allocator, rhs.m_allocator); |
| std::swap(m_dispatcher, rhs.m_dispatcher); |
| } |
| |
| //=== VK_VERSION_1_0 === |
| |
| template<typename DataType> |
| VULKAN_HPP_NODISCARD std::pair<VULKAN_HPP_NAMESPACE::Result, std::vector<DataType>> |
| getResults(uint32_t firstQuery, |
| uint32_t queryCount, |
| size_t dataSize, |
| VULKAN_HPP_NAMESPACE::DeviceSize stride, |
| VULKAN_HPP_NAMESPACE::QueryResultFlags flags VULKAN_HPP_DEFAULT_ARGUMENT_ASSIGNMENT) const; |
| |
| template<typename DataType> |
| VULKAN_HPP_NODISCARD std::pair<VULKAN_HPP_NAMESPACE::Result, DataType> |
| getResult(uint32_t firstQuery, |
| uint32_t queryCount, |
| VULKAN_HPP_NAMESPACE::DeviceSize stride, |
| VULKAN_HPP_NAMESPACE::QueryResultFlags flags VULKAN_HPP_DEFAULT_ARGUMENT_ASSIGNMENT) const; |
| |
| //=== VK_VERSION_1_2 === |
| |
| void reset(uint32_t firstQuery, uint32_t queryCount) const VULKAN_HPP_NOEXCEPT; |
| |
| //=== VK_EXT_host_query_reset === |
| |
| void resetEXT(uint32_t firstQuery, uint32_t queryCount) const VULKAN_HPP_NOEXCEPT; |
| |
| private: |
| VULKAN_HPP_NAMESPACE::Device m_device = {}; |
| VULKAN_HPP_NAMESPACE::QueryPool m_queryPool = {}; |
| const VULKAN_HPP_NAMESPACE::AllocationCallbacks *m_allocator = {}; |
| VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::DeviceDispatcher const *m_dispatcher = nullptr; |
| }; |
| |
| class Queue |
| { |
| public: |
| using CType = VkQueue; |
| |
| static VULKAN_HPP_CONST_OR_CONSTEXPR VULKAN_HPP_NAMESPACE::ObjectType objectType = VULKAN_HPP_NAMESPACE::ObjectType::eQueue; |
| static VULKAN_HPP_CONST_OR_CONSTEXPR VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT debugReportObjectType = |
| VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT::eQueue; |
| |
| public: |
| Queue(VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::Device const &device, uint32_t queueFamilyIndex, uint32_t queueIndex) |
| : m_dispatcher(device.getDispatcher()) |
| { |
| getDispatcher()->vkGetDeviceQueue(static_cast<VkDevice>(*device), queueFamilyIndex, queueIndex, reinterpret_cast<VkQueue *>(&m_queue)); |
| } |
| |
| Queue(VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::Device const &device, VULKAN_HPP_NAMESPACE::DeviceQueueInfo2 const &queueInfo) |
| : m_dispatcher(device.getDispatcher()) |
| { |
| getDispatcher()->vkGetDeviceQueue2( |
| static_cast<VkDevice>(*device), reinterpret_cast<const VkDeviceQueueInfo2 *>(&queueInfo), reinterpret_cast<VkQueue *>(&m_queue)); |
| } |
| |
| Queue(VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::Device const &device, VkQueue queue) |
| : m_queue(queue) |
| , m_dispatcher(device.getDispatcher()) |
| { |
| } |
| |
| Queue(std::nullptr_t) {} |
| |
| ~Queue() |
| { |
| clear(); |
| } |
| |
| Queue() = delete; |
| Queue(Queue const &rhs) |
| : m_queue(rhs.m_queue) |
| , m_dispatcher(rhs.m_dispatcher) |
| {} |
| Queue(Queue &&rhs) VULKAN_HPP_NOEXCEPT |
| : m_queue(VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange(rhs.m_queue, {})), |
| m_dispatcher(VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange(rhs.m_dispatcher, nullptr)) |
| { |
| } |
| Queue &operator=(Queue const &rhs) |
| { |
| m_queue = rhs.m_queue; |
| m_dispatcher = rhs.m_dispatcher; |
| return *this; |
| } |
| Queue &operator=(Queue &&rhs) VULKAN_HPP_NOEXCEPT |
| { |
| if(this != &rhs) |
| { |
| m_queue = VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange(rhs.m_queue, {}); |
| m_dispatcher = VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange(rhs.m_dispatcher, nullptr); |
| } |
| return *this; |
| } |
| |
| VULKAN_HPP_NAMESPACE::Queue const &operator*() const VULKAN_HPP_NOEXCEPT |
| { |
| return m_queue; |
| } |
| |
| void clear() VULKAN_HPP_NOEXCEPT |
| { |
| m_queue = nullptr; |
| m_dispatcher = nullptr; |
| } |
| |
| VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::DeviceDispatcher const *getDispatcher() const |
| { |
| VULKAN_HPP_ASSERT(m_dispatcher->getVkHeaderVersion() == VK_HEADER_VERSION); |
| return m_dispatcher; |
| } |
| |
| void swap(VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::Queue &rhs) VULKAN_HPP_NOEXCEPT |
| { |
| std::swap(m_queue, rhs.m_queue); |
| std::swap(m_dispatcher, rhs.m_dispatcher); |
| } |
| |
| //=== VK_VERSION_1_0 === |
| |
| void submit(ArrayProxy<const VULKAN_HPP_NAMESPACE::SubmitInfo> const &submits, |
| VULKAN_HPP_NAMESPACE::Fence fence VULKAN_HPP_DEFAULT_ARGUMENT_ASSIGNMENT) const; |
| |
| void waitIdle() const; |
| |
| void bindSparse(ArrayProxy<const VULKAN_HPP_NAMESPACE::BindSparseInfo> const &bindInfo, |
| VULKAN_HPP_NAMESPACE::Fence fence VULKAN_HPP_DEFAULT_ARGUMENT_ASSIGNMENT) const; |
| |
| //=== VK_VERSION_1_3 === |
| |
| void submit2(ArrayProxy<const VULKAN_HPP_NAMESPACE::SubmitInfo2> const &submits, |
| VULKAN_HPP_NAMESPACE::Fence fence VULKAN_HPP_DEFAULT_ARGUMENT_ASSIGNMENT) const; |
| |
| //=== VK_KHR_swapchain === |
| |
| VULKAN_HPP_NODISCARD VULKAN_HPP_NAMESPACE::Result presentKHR(const VULKAN_HPP_NAMESPACE::PresentInfoKHR &presentInfo) const; |
| |
| //=== VK_EXT_debug_utils === |
| |
| void beginDebugUtilsLabelEXT(const VULKAN_HPP_NAMESPACE::DebugUtilsLabelEXT &labelInfo) const VULKAN_HPP_NOEXCEPT; |
| |
| void endDebugUtilsLabelEXT() const VULKAN_HPP_NOEXCEPT; |
| |
| void insertDebugUtilsLabelEXT(const VULKAN_HPP_NAMESPACE::DebugUtilsLabelEXT &labelInfo) const VULKAN_HPP_NOEXCEPT; |
| |
| //=== VK_NV_device_diagnostic_checkpoints === |
| |
| VULKAN_HPP_NODISCARD std::vector<VULKAN_HPP_NAMESPACE::CheckpointDataNV> getCheckpointDataNV() const VULKAN_HPP_NOEXCEPT; |
| |
| //=== VK_INTEL_performance_query === |
| |
| void setPerformanceConfigurationINTEL(VULKAN_HPP_NAMESPACE::PerformanceConfigurationINTEL configuration) const; |
| |
| //=== VK_KHR_synchronization2 === |
| |
| void submit2KHR(ArrayProxy<const VULKAN_HPP_NAMESPACE::SubmitInfo2> const &submits, |
| VULKAN_HPP_NAMESPACE::Fence fence VULKAN_HPP_DEFAULT_ARGUMENT_ASSIGNMENT) const; |
| |
| VULKAN_HPP_NODISCARD std::vector<VULKAN_HPP_NAMESPACE::CheckpointData2NV> getCheckpointData2NV() const VULKAN_HPP_NOEXCEPT; |
| |
| private: |
| VULKAN_HPP_NAMESPACE::Queue m_queue = {}; |
| VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::DeviceDispatcher const *m_dispatcher = nullptr; |
| }; |
| |
| class RenderPass |
| { |
| public: |
| using CType = VkRenderPass; |
| |
| static VULKAN_HPP_CONST_OR_CONSTEXPR VULKAN_HPP_NAMESPACE::ObjectType objectType = VULKAN_HPP_NAMESPACE::ObjectType::eRenderPass; |
| static VULKAN_HPP_CONST_OR_CONSTEXPR VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT debugReportObjectType = |
| VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT::eRenderPass; |
| |
| public: |
| RenderPass(VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::Device const &device, |
| VULKAN_HPP_NAMESPACE::RenderPassCreateInfo const &createInfo, |
| VULKAN_HPP_NAMESPACE::Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator = nullptr) |
| : m_device(*device) |
| , m_allocator(static_cast<const VULKAN_HPP_NAMESPACE::AllocationCallbacks *>(allocator)) |
| , m_dispatcher(device.getDispatcher()) |
| { |
| VULKAN_HPP_NAMESPACE::Result result = static_cast<VULKAN_HPP_NAMESPACE::Result>( |
| device.getDispatcher()->vkCreateRenderPass(static_cast<VkDevice>(*device), |
| reinterpret_cast<const VkRenderPassCreateInfo *>(&createInfo), |
| reinterpret_cast<const VkAllocationCallbacks *>(m_allocator), |
| reinterpret_cast<VkRenderPass *>(&m_renderPass))); |
| if(result != VULKAN_HPP_NAMESPACE::Result::eSuccess) |
| { |
| throwResultException(result, "vkCreateRenderPass"); |
| } |
| } |
| |
| RenderPass(VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::Device const &device, |
| VULKAN_HPP_NAMESPACE::RenderPassCreateInfo2 const &createInfo, |
| VULKAN_HPP_NAMESPACE::Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator = nullptr) |
| : m_device(*device) |
| , m_allocator(static_cast<const VULKAN_HPP_NAMESPACE::AllocationCallbacks *>(allocator)) |
| , m_dispatcher(device.getDispatcher()) |
| { |
| VULKAN_HPP_NAMESPACE::Result result = static_cast<VULKAN_HPP_NAMESPACE::Result>( |
| device.getDispatcher()->vkCreateRenderPass2(static_cast<VkDevice>(*device), |
| reinterpret_cast<const VkRenderPassCreateInfo2 *>(&createInfo), |
| reinterpret_cast<const VkAllocationCallbacks *>(m_allocator), |
| reinterpret_cast<VkRenderPass *>(&m_renderPass))); |
| if(result != VULKAN_HPP_NAMESPACE::Result::eSuccess) |
| { |
| throwResultException(result, "vkCreateRenderPass2"); |
| } |
| } |
| |
| RenderPass(VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::Device const &device, |
| VkRenderPass renderPass, |
| VULKAN_HPP_NAMESPACE::Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator = nullptr) |
| : m_device(*device) |
| , m_renderPass(renderPass) |
| , m_allocator(static_cast<const VULKAN_HPP_NAMESPACE::AllocationCallbacks *>(allocator)) |
| , m_dispatcher(device.getDispatcher()) |
| { |
| } |
| |
| RenderPass(std::nullptr_t) {} |
| |
| ~RenderPass() |
| { |
| clear(); |
| } |
| |
| RenderPass() = delete; |
| RenderPass(RenderPass const &) = delete; |
| RenderPass(RenderPass &&rhs) VULKAN_HPP_NOEXCEPT |
| : m_device(VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange(rhs.m_device, {})), |
| m_renderPass(VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange(rhs.m_renderPass, {})), |
| m_allocator(VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange(rhs.m_allocator, {})), |
| m_dispatcher(VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange(rhs.m_dispatcher, nullptr)) |
| { |
| } |
| RenderPass &operator=(RenderPass const &) = delete; |
| RenderPass &operator=(RenderPass &&rhs) VULKAN_HPP_NOEXCEPT |
| { |
| if(this != &rhs) |
| { |
| clear(); |
| m_device = VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange(rhs.m_device, {}); |
| m_renderPass = VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange(rhs.m_renderPass, {}); |
| m_allocator = VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange(rhs.m_allocator, {}); |
| m_dispatcher = VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange(rhs.m_dispatcher, nullptr); |
| } |
| return *this; |
| } |
| |
| VULKAN_HPP_NAMESPACE::RenderPass const &operator*() const VULKAN_HPP_NOEXCEPT |
| { |
| return m_renderPass; |
| } |
| |
| void clear() VULKAN_HPP_NOEXCEPT |
| { |
| if(m_renderPass) |
| { |
| getDispatcher()->vkDestroyRenderPass( |
| static_cast<VkDevice>(m_device), static_cast<VkRenderPass>(m_renderPass), reinterpret_cast<const VkAllocationCallbacks *>(m_allocator)); |
| } |
| m_device = nullptr; |
| m_renderPass = nullptr; |
| m_allocator = nullptr; |
| m_dispatcher = nullptr; |
| } |
| |
| VULKAN_HPP_NAMESPACE::Device getDevice() const |
| { |
| return m_device; |
| } |
| |
| VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::DeviceDispatcher const *getDispatcher() const |
| { |
| VULKAN_HPP_ASSERT(m_dispatcher->getVkHeaderVersion() == VK_HEADER_VERSION); |
| return m_dispatcher; |
| } |
| |
| void swap(VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::RenderPass &rhs) VULKAN_HPP_NOEXCEPT |
| { |
| std::swap(m_device, rhs.m_device); |
| std::swap(m_renderPass, rhs.m_renderPass); |
| std::swap(m_allocator, rhs.m_allocator); |
| std::swap(m_dispatcher, rhs.m_dispatcher); |
| } |
| |
| //=== VK_VERSION_1_0 === |
| |
| VULKAN_HPP_NODISCARD VULKAN_HPP_NAMESPACE::Extent2D getRenderAreaGranularity() const VULKAN_HPP_NOEXCEPT; |
| |
| //=== VK_HUAWEI_subpass_shading === |
| |
| VULKAN_HPP_NODISCARD std::pair<VULKAN_HPP_NAMESPACE::Result, VULKAN_HPP_NAMESPACE::Extent2D> getSubpassShadingMaxWorkgroupSizeHUAWEI() const; |
| |
| private: |
| VULKAN_HPP_NAMESPACE::Device m_device = {}; |
| VULKAN_HPP_NAMESPACE::RenderPass m_renderPass = {}; |
| const VULKAN_HPP_NAMESPACE::AllocationCallbacks *m_allocator = {}; |
| VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::DeviceDispatcher const *m_dispatcher = nullptr; |
| }; |
| |
| class Sampler |
| { |
| public: |
| using CType = VkSampler; |
| |
| static VULKAN_HPP_CONST_OR_CONSTEXPR VULKAN_HPP_NAMESPACE::ObjectType objectType = VULKAN_HPP_NAMESPACE::ObjectType::eSampler; |
| static VULKAN_HPP_CONST_OR_CONSTEXPR VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT debugReportObjectType = |
| VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT::eSampler; |
| |
| public: |
| Sampler(VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::Device const &device, |
| VULKAN_HPP_NAMESPACE::SamplerCreateInfo const &createInfo, |
| VULKAN_HPP_NAMESPACE::Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator = nullptr) |
| : m_device(*device) |
| , m_allocator(static_cast<const VULKAN_HPP_NAMESPACE::AllocationCallbacks *>(allocator)) |
| , m_dispatcher(device.getDispatcher()) |
| { |
| VULKAN_HPP_NAMESPACE::Result result = |
| static_cast<VULKAN_HPP_NAMESPACE::Result>(device.getDispatcher()->vkCreateSampler(static_cast<VkDevice>(*device), |
| reinterpret_cast<const VkSamplerCreateInfo *>(&createInfo), |
| reinterpret_cast<const VkAllocationCallbacks *>(m_allocator), |
| reinterpret_cast<VkSampler *>(&m_sampler))); |
| if(result != VULKAN_HPP_NAMESPACE::Result::eSuccess) |
| { |
| throwResultException(result, "vkCreateSampler"); |
| } |
| } |
| |
| Sampler(VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::Device const &device, |
| VkSampler sampler, |
| VULKAN_HPP_NAMESPACE::Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator = nullptr) |
| : m_device(*device) |
| , m_sampler(sampler) |
| , m_allocator(static_cast<const VULKAN_HPP_NAMESPACE::AllocationCallbacks *>(allocator)) |
| , m_dispatcher(device.getDispatcher()) |
| { |
| } |
| |
| Sampler(std::nullptr_t) {} |
| |
| ~Sampler() |
| { |
| clear(); |
| } |
| |
| Sampler() = delete; |
| Sampler(Sampler const &) = delete; |
| Sampler(Sampler &&rhs) VULKAN_HPP_NOEXCEPT |
| : m_device(VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange(rhs.m_device, {})), |
| m_sampler(VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange(rhs.m_sampler, {})), |
| m_allocator(VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange(rhs.m_allocator, {})), |
| m_dispatcher(VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange(rhs.m_dispatcher, nullptr)) |
| { |
| } |
| Sampler &operator=(Sampler const &) = delete; |
| Sampler &operator=(Sampler &&rhs) VULKAN_HPP_NOEXCEPT |
| { |
| if(this != &rhs) |
| { |
| clear(); |
| m_device = VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange(rhs.m_device, {}); |
| m_sampler = VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange(rhs.m_sampler, {}); |
| m_allocator = VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange(rhs.m_allocator, {}); |
| m_dispatcher = VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange(rhs.m_dispatcher, nullptr); |
| } |
| return *this; |
| } |
| |
| VULKAN_HPP_NAMESPACE::Sampler const &operator*() const VULKAN_HPP_NOEXCEPT |
| { |
| return m_sampler; |
| } |
| |
| void clear() VULKAN_HPP_NOEXCEPT |
| { |
| if(m_sampler) |
| { |
| getDispatcher()->vkDestroySampler( |
| static_cast<VkDevice>(m_device), static_cast<VkSampler>(m_sampler), reinterpret_cast<const VkAllocationCallbacks *>(m_allocator)); |
| } |
| m_device = nullptr; |
| m_sampler = nullptr; |
| m_allocator = nullptr; |
| m_dispatcher = nullptr; |
| } |
| |
| VULKAN_HPP_NAMESPACE::Device getDevice() const |
| { |
| return m_device; |
| } |
| |
| VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::DeviceDispatcher const *getDispatcher() const |
| { |
| VULKAN_HPP_ASSERT(m_dispatcher->getVkHeaderVersion() == VK_HEADER_VERSION); |
| return m_dispatcher; |
| } |
| |
| void swap(VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::Sampler &rhs) VULKAN_HPP_NOEXCEPT |
| { |
| std::swap(m_device, rhs.m_device); |
| std::swap(m_sampler, rhs.m_sampler); |
| std::swap(m_allocator, rhs.m_allocator); |
| std::swap(m_dispatcher, rhs.m_dispatcher); |
| } |
| |
| private: |
| VULKAN_HPP_NAMESPACE::Device m_device = {}; |
| VULKAN_HPP_NAMESPACE::Sampler m_sampler = {}; |
| const VULKAN_HPP_NAMESPACE::AllocationCallbacks *m_allocator = {}; |
| VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::DeviceDispatcher const *m_dispatcher = nullptr; |
| }; |
| |
| class SamplerYcbcrConversion |
| { |
| public: |
| using CType = VkSamplerYcbcrConversion; |
| |
| static VULKAN_HPP_CONST_OR_CONSTEXPR VULKAN_HPP_NAMESPACE::ObjectType objectType = VULKAN_HPP_NAMESPACE::ObjectType::eSamplerYcbcrConversion; |
| static VULKAN_HPP_CONST_OR_CONSTEXPR VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT debugReportObjectType = |
| VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT::eSamplerYcbcrConversion; |
| |
| public: |
| SamplerYcbcrConversion(VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::Device const &device, |
| VULKAN_HPP_NAMESPACE::SamplerYcbcrConversionCreateInfo const &createInfo, |
| VULKAN_HPP_NAMESPACE::Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator = nullptr) |
| : m_device(*device) |
| , m_allocator(static_cast<const VULKAN_HPP_NAMESPACE::AllocationCallbacks *>(allocator)) |
| , m_dispatcher(device.getDispatcher()) |
| { |
| VULKAN_HPP_NAMESPACE::Result result = static_cast<VULKAN_HPP_NAMESPACE::Result>( |
| device.getDispatcher()->vkCreateSamplerYcbcrConversion(static_cast<VkDevice>(*device), |
| reinterpret_cast<const VkSamplerYcbcrConversionCreateInfo *>(&createInfo), |
| reinterpret_cast<const VkAllocationCallbacks *>(m_allocator), |
| reinterpret_cast<VkSamplerYcbcrConversion *>(&m_ycbcrConversion))); |
| if(result != VULKAN_HPP_NAMESPACE::Result::eSuccess) |
| { |
| throwResultException(result, "vkCreateSamplerYcbcrConversion"); |
| } |
| } |
| |
| SamplerYcbcrConversion(VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::Device const &device, |
| VkSamplerYcbcrConversion ycbcrConversion, |
| VULKAN_HPP_NAMESPACE::Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator = nullptr) |
| : m_device(*device) |
| , m_ycbcrConversion(ycbcrConversion) |
| , m_allocator(static_cast<const VULKAN_HPP_NAMESPACE::AllocationCallbacks *>(allocator)) |
| , m_dispatcher(device.getDispatcher()) |
| { |
| } |
| |
| SamplerYcbcrConversion(std::nullptr_t) {} |
| |
| ~SamplerYcbcrConversion() |
| { |
| clear(); |
| } |
| |
| SamplerYcbcrConversion() = delete; |
| SamplerYcbcrConversion(SamplerYcbcrConversion const &) = delete; |
| SamplerYcbcrConversion(SamplerYcbcrConversion &&rhs) VULKAN_HPP_NOEXCEPT |
| : m_device(VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange(rhs.m_device, {})), |
| m_ycbcrConversion(VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange(rhs.m_ycbcrConversion, {})), |
| m_allocator(VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange(rhs.m_allocator, {})), |
| m_dispatcher(VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange(rhs.m_dispatcher, nullptr)) |
| { |
| } |
| SamplerYcbcrConversion &operator=(SamplerYcbcrConversion const &) = delete; |
| SamplerYcbcrConversion &operator=(SamplerYcbcrConversion &&rhs) VULKAN_HPP_NOEXCEPT |
| { |
| if(this != &rhs) |
| { |
| clear(); |
| m_device = VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange(rhs.m_device, {}); |
| m_ycbcrConversion = VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange(rhs.m_ycbcrConversion, {}); |
| m_allocator = VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange(rhs.m_allocator, {}); |
| m_dispatcher = VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange(rhs.m_dispatcher, nullptr); |
| } |
| return *this; |
| } |
| |
| VULKAN_HPP_NAMESPACE::SamplerYcbcrConversion const &operator*() const VULKAN_HPP_NOEXCEPT |
| { |
| return m_ycbcrConversion; |
| } |
| |
| void clear() VULKAN_HPP_NOEXCEPT |
| { |
| if(m_ycbcrConversion) |
| { |
| getDispatcher()->vkDestroySamplerYcbcrConversion(static_cast<VkDevice>(m_device), |
| static_cast<VkSamplerYcbcrConversion>(m_ycbcrConversion), |
| reinterpret_cast<const VkAllocationCallbacks *>(m_allocator)); |
| } |
| m_device = nullptr; |
| m_ycbcrConversion = nullptr; |
| m_allocator = nullptr; |
| m_dispatcher = nullptr; |
| } |
| |
| VULKAN_HPP_NAMESPACE::Device getDevice() const |
| { |
| return m_device; |
| } |
| |
| VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::DeviceDispatcher const *getDispatcher() const |
| { |
| VULKAN_HPP_ASSERT(m_dispatcher->getVkHeaderVersion() == VK_HEADER_VERSION); |
| return m_dispatcher; |
| } |
| |
| void swap(VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::SamplerYcbcrConversion &rhs) VULKAN_HPP_NOEXCEPT |
| { |
| std::swap(m_device, rhs.m_device); |
| std::swap(m_ycbcrConversion, rhs.m_ycbcrConversion); |
| std::swap(m_allocator, rhs.m_allocator); |
| std::swap(m_dispatcher, rhs.m_dispatcher); |
| } |
| |
| private: |
| VULKAN_HPP_NAMESPACE::Device m_device = {}; |
| VULKAN_HPP_NAMESPACE::SamplerYcbcrConversion m_ycbcrConversion = {}; |
| const VULKAN_HPP_NAMESPACE::AllocationCallbacks *m_allocator = {}; |
| VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::DeviceDispatcher const *m_dispatcher = nullptr; |
| }; |
| |
| class Semaphore |
| { |
| public: |
| using CType = VkSemaphore; |
| |
| static VULKAN_HPP_CONST_OR_CONSTEXPR VULKAN_HPP_NAMESPACE::ObjectType objectType = VULKAN_HPP_NAMESPACE::ObjectType::eSemaphore; |
| static VULKAN_HPP_CONST_OR_CONSTEXPR VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT debugReportObjectType = |
| VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT::eSemaphore; |
| |
| public: |
| Semaphore(VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::Device const &device, |
| VULKAN_HPP_NAMESPACE::SemaphoreCreateInfo const &createInfo, |
| VULKAN_HPP_NAMESPACE::Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator = nullptr) |
| : m_device(*device) |
| , m_allocator(static_cast<const VULKAN_HPP_NAMESPACE::AllocationCallbacks *>(allocator)) |
| , m_dispatcher(device.getDispatcher()) |
| { |
| VULKAN_HPP_NAMESPACE::Result result = |
| static_cast<VULKAN_HPP_NAMESPACE::Result>(device.getDispatcher()->vkCreateSemaphore(static_cast<VkDevice>(*device), |
| reinterpret_cast<const VkSemaphoreCreateInfo *>(&createInfo), |
| reinterpret_cast<const VkAllocationCallbacks *>(m_allocator), |
| reinterpret_cast<VkSemaphore *>(&m_semaphore))); |
| if(result != VULKAN_HPP_NAMESPACE::Result::eSuccess) |
| { |
| throwResultException(result, "vkCreateSemaphore"); |
| } |
| } |
| |
| Semaphore(VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::Device const &device, |
| VkSemaphore semaphore, |
| VULKAN_HPP_NAMESPACE::Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator = nullptr) |
| : m_device(*device) |
| , m_semaphore(semaphore) |
| , m_allocator(static_cast<const VULKAN_HPP_NAMESPACE::AllocationCallbacks *>(allocator)) |
| , m_dispatcher(device.getDispatcher()) |
| { |
| } |
| |
| Semaphore(std::nullptr_t) {} |
| |
| ~Semaphore() |
| { |
| clear(); |
| } |
| |
| Semaphore() = delete; |
| Semaphore(Semaphore const &) = delete; |
| Semaphore(Semaphore &&rhs) VULKAN_HPP_NOEXCEPT |
| : m_device(VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange(rhs.m_device, {})), |
| m_semaphore(VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange(rhs.m_semaphore, {})), |
| m_allocator(VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange(rhs.m_allocator, {})), |
| m_dispatcher(VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange(rhs.m_dispatcher, nullptr)) |
| { |
| } |
| Semaphore &operator=(Semaphore const &) = delete; |
| Semaphore &operator=(Semaphore &&rhs) VULKAN_HPP_NOEXCEPT |
| { |
| if(this != &rhs) |
| { |
| clear(); |
| m_device = VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange(rhs.m_device, {}); |
| m_semaphore = VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange(rhs.m_semaphore, {}); |
| m_allocator = VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange(rhs.m_allocator, {}); |
| m_dispatcher = VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange(rhs.m_dispatcher, nullptr); |
| } |
| return *this; |
| } |
| |
| VULKAN_HPP_NAMESPACE::Semaphore const &operator*() const VULKAN_HPP_NOEXCEPT |
| { |
| return m_semaphore; |
| } |
| |
| void clear() VULKAN_HPP_NOEXCEPT |
| { |
| if(m_semaphore) |
| { |
| getDispatcher()->vkDestroySemaphore( |
| static_cast<VkDevice>(m_device), static_cast<VkSemaphore>(m_semaphore), reinterpret_cast<const VkAllocationCallbacks *>(m_allocator)); |
| } |
| m_device = nullptr; |
| m_semaphore = nullptr; |
| m_allocator = nullptr; |
| m_dispatcher = nullptr; |
| } |
| |
| VULKAN_HPP_NAMESPACE::Device getDevice() const |
| { |
| return m_device; |
| } |
| |
| VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::DeviceDispatcher const *getDispatcher() const |
| { |
| VULKAN_HPP_ASSERT(m_dispatcher->getVkHeaderVersion() == VK_HEADER_VERSION); |
| return m_dispatcher; |
| } |
| |
| void swap(VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::Semaphore &rhs) VULKAN_HPP_NOEXCEPT |
| { |
| std::swap(m_device, rhs.m_device); |
| std::swap(m_semaphore, rhs.m_semaphore); |
| std::swap(m_allocator, rhs.m_allocator); |
| std::swap(m_dispatcher, rhs.m_dispatcher); |
| } |
| |
| //=== VK_VERSION_1_2 === |
| |
| VULKAN_HPP_NODISCARD uint64_t getCounterValue() const; |
| |
| //=== VK_KHR_timeline_semaphore === |
| |
| VULKAN_HPP_NODISCARD uint64_t getCounterValueKHR() const; |
| |
| private: |
| VULKAN_HPP_NAMESPACE::Device m_device = {}; |
| VULKAN_HPP_NAMESPACE::Semaphore m_semaphore = {}; |
| const VULKAN_HPP_NAMESPACE::AllocationCallbacks *m_allocator = {}; |
| VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::DeviceDispatcher const *m_dispatcher = nullptr; |
| }; |
| |
| class ShaderModule |
| { |
| public: |
| using CType = VkShaderModule; |
| |
| static VULKAN_HPP_CONST_OR_CONSTEXPR VULKAN_HPP_NAMESPACE::ObjectType objectType = VULKAN_HPP_NAMESPACE::ObjectType::eShaderModule; |
| static VULKAN_HPP_CONST_OR_CONSTEXPR VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT debugReportObjectType = |
| VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT::eShaderModule; |
| |
| public: |
| ShaderModule(VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::Device const &device, |
| VULKAN_HPP_NAMESPACE::ShaderModuleCreateInfo const &createInfo, |
| VULKAN_HPP_NAMESPACE::Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator = nullptr) |
| : m_device(*device) |
| , m_allocator(static_cast<const VULKAN_HPP_NAMESPACE::AllocationCallbacks *>(allocator)) |
| , m_dispatcher(device.getDispatcher()) |
| { |
| VULKAN_HPP_NAMESPACE::Result result = static_cast<VULKAN_HPP_NAMESPACE::Result>( |
| device.getDispatcher()->vkCreateShaderModule(static_cast<VkDevice>(*device), |
| reinterpret_cast<const VkShaderModuleCreateInfo *>(&createInfo), |
| reinterpret_cast<const VkAllocationCallbacks *>(m_allocator), |
| reinterpret_cast<VkShaderModule *>(&m_shaderModule))); |
| if(result != VULKAN_HPP_NAMESPACE::Result::eSuccess) |
| { |
| throwResultException(result, "vkCreateShaderModule"); |
| } |
| } |
| |
| ShaderModule(VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::Device const &device, |
| VkShaderModule shaderModule, |
| VULKAN_HPP_NAMESPACE::Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator = nullptr) |
| : m_device(*device) |
| , m_shaderModule(shaderModule) |
| , m_allocator(static_cast<const VULKAN_HPP_NAMESPACE::AllocationCallbacks *>(allocator)) |
| , m_dispatcher(device.getDispatcher()) |
| { |
| } |
| |
| ShaderModule(std::nullptr_t) {} |
| |
| ~ShaderModule() |
| { |
| clear(); |
| } |
| |
| ShaderModule() = delete; |
| ShaderModule(ShaderModule const &) = delete; |
| ShaderModule(ShaderModule &&rhs) VULKAN_HPP_NOEXCEPT |
| : m_device(VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange(rhs.m_device, {})), |
| m_shaderModule(VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange(rhs.m_shaderModule, {})), |
| m_allocator(VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange(rhs.m_allocator, {})), |
| m_dispatcher(VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange(rhs.m_dispatcher, nullptr)) |
| { |
| } |
| ShaderModule &operator=(ShaderModule const &) = delete; |
| ShaderModule &operator=(ShaderModule &&rhs) VULKAN_HPP_NOEXCEPT |
| { |
| if(this != &rhs) |
| { |
| clear(); |
| m_device = VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange(rhs.m_device, {}); |
| m_shaderModule = VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange(rhs.m_shaderModule, {}); |
| m_allocator = VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange(rhs.m_allocator, {}); |
| m_dispatcher = VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange(rhs.m_dispatcher, nullptr); |
| } |
| return *this; |
| } |
| |
| VULKAN_HPP_NAMESPACE::ShaderModule const &operator*() const VULKAN_HPP_NOEXCEPT |
| { |
| return m_shaderModule; |
| } |
| |
| void clear() VULKAN_HPP_NOEXCEPT |
| { |
| if(m_shaderModule) |
| { |
| getDispatcher()->vkDestroyShaderModule( |
| static_cast<VkDevice>(m_device), static_cast<VkShaderModule>(m_shaderModule), reinterpret_cast<const VkAllocationCallbacks *>(m_allocator)); |
| } |
| m_device = nullptr; |
| m_shaderModule = nullptr; |
| m_allocator = nullptr; |
| m_dispatcher = nullptr; |
| } |
| |
| VULKAN_HPP_NAMESPACE::Device getDevice() const |
| { |
| return m_device; |
| } |
| |
| VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::DeviceDispatcher const *getDispatcher() const |
| { |
| VULKAN_HPP_ASSERT(m_dispatcher->getVkHeaderVersion() == VK_HEADER_VERSION); |
| return m_dispatcher; |
| } |
| |
| void swap(VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::ShaderModule &rhs) VULKAN_HPP_NOEXCEPT |
| { |
| std::swap(m_device, rhs.m_device); |
| std::swap(m_shaderModule, rhs.m_shaderModule); |
| std::swap(m_allocator, rhs.m_allocator); |
| std::swap(m_dispatcher, rhs.m_dispatcher); |
| } |
| |
| private: |
| VULKAN_HPP_NAMESPACE::Device m_device = {}; |
| VULKAN_HPP_NAMESPACE::ShaderModule m_shaderModule = {}; |
| const VULKAN_HPP_NAMESPACE::AllocationCallbacks *m_allocator = {}; |
| VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::DeviceDispatcher const *m_dispatcher = nullptr; |
| }; |
| |
| class SurfaceKHR |
| { |
| public: |
| using CType = VkSurfaceKHR; |
| |
| static VULKAN_HPP_CONST_OR_CONSTEXPR VULKAN_HPP_NAMESPACE::ObjectType objectType = VULKAN_HPP_NAMESPACE::ObjectType::eSurfaceKHR; |
| static VULKAN_HPP_CONST_OR_CONSTEXPR VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT debugReportObjectType = |
| VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT::eSurfaceKHR; |
| |
| public: |
| # if defined(VK_USE_PLATFORM_ANDROID_KHR) |
| SurfaceKHR(VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::Instance const &instance, |
| VULKAN_HPP_NAMESPACE::AndroidSurfaceCreateInfoKHR const &createInfo, |
| VULKAN_HPP_NAMESPACE::Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator = nullptr) |
| : m_instance(*instance) |
| , m_allocator(static_cast<const VULKAN_HPP_NAMESPACE::AllocationCallbacks *>(allocator)) |
| , m_dispatcher(instance.getDispatcher()) |
| { |
| VULKAN_HPP_NAMESPACE::Result result = static_cast<VULKAN_HPP_NAMESPACE::Result>( |
| instance.getDispatcher()->vkCreateAndroidSurfaceKHR(static_cast<VkInstance>(*instance), |
| reinterpret_cast<const VkAndroidSurfaceCreateInfoKHR *>(&createInfo), |
| reinterpret_cast<const VkAllocationCallbacks *>(m_allocator), |
| reinterpret_cast<VkSurfaceKHR *>(&m_surface))); |
| if(result != VULKAN_HPP_NAMESPACE::Result::eSuccess) |
| { |
| throwResultException(result, "vkCreateAndroidSurfaceKHR"); |
| } |
| } |
| # endif /*VK_USE_PLATFORM_ANDROID_KHR*/ |
| |
| # if defined(VK_USE_PLATFORM_DIRECTFB_EXT) |
| SurfaceKHR(VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::Instance const &instance, |
| VULKAN_HPP_NAMESPACE::DirectFBSurfaceCreateInfoEXT const &createInfo, |
| VULKAN_HPP_NAMESPACE::Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator = nullptr) |
| : m_instance(*instance) |
| , m_allocator(static_cast<const VULKAN_HPP_NAMESPACE::AllocationCallbacks *>(allocator)) |
| , m_dispatcher(instance.getDispatcher()) |
| { |
| VULKAN_HPP_NAMESPACE::Result result = static_cast<VULKAN_HPP_NAMESPACE::Result>( |
| instance.getDispatcher()->vkCreateDirectFBSurfaceEXT(static_cast<VkInstance>(*instance), |
| reinterpret_cast<const VkDirectFBSurfaceCreateInfoEXT *>(&createInfo), |
| reinterpret_cast<const VkAllocationCallbacks *>(m_allocator), |
| reinterpret_cast<VkSurfaceKHR *>(&m_surface))); |
| if(result != VULKAN_HPP_NAMESPACE::Result::eSuccess) |
| { |
| throwResultException(result, "vkCreateDirectFBSurfaceEXT"); |
| } |
| } |
| # endif /*VK_USE_PLATFORM_DIRECTFB_EXT*/ |
| |
| SurfaceKHR(VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::Instance const &instance, |
| VULKAN_HPP_NAMESPACE::DisplaySurfaceCreateInfoKHR const &createInfo, |
| VULKAN_HPP_NAMESPACE::Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator = nullptr) |
| : m_instance(*instance) |
| , m_allocator(static_cast<const VULKAN_HPP_NAMESPACE::AllocationCallbacks *>(allocator)) |
| , m_dispatcher(instance.getDispatcher()) |
| { |
| VULKAN_HPP_NAMESPACE::Result result = static_cast<VULKAN_HPP_NAMESPACE::Result>( |
| instance.getDispatcher()->vkCreateDisplayPlaneSurfaceKHR(static_cast<VkInstance>(*instance), |
| reinterpret_cast<const VkDisplaySurfaceCreateInfoKHR *>(&createInfo), |
| reinterpret_cast<const VkAllocationCallbacks *>(m_allocator), |
| reinterpret_cast<VkSurfaceKHR *>(&m_surface))); |
| if(result != VULKAN_HPP_NAMESPACE::Result::eSuccess) |
| { |
| throwResultException(result, "vkCreateDisplayPlaneSurfaceKHR"); |
| } |
| } |
| |
| SurfaceKHR(VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::Instance const &instance, |
| VULKAN_HPP_NAMESPACE::HeadlessSurfaceCreateInfoEXT const &createInfo, |
| VULKAN_HPP_NAMESPACE::Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator = nullptr) |
| : m_instance(*instance) |
| , m_allocator(static_cast<const VULKAN_HPP_NAMESPACE::AllocationCallbacks *>(allocator)) |
| , m_dispatcher(instance.getDispatcher()) |
| { |
| VULKAN_HPP_NAMESPACE::Result result = static_cast<VULKAN_HPP_NAMESPACE::Result>( |
| instance.getDispatcher()->vkCreateHeadlessSurfaceEXT(static_cast<VkInstance>(*instance), |
| reinterpret_cast<const VkHeadlessSurfaceCreateInfoEXT *>(&createInfo), |
| reinterpret_cast<const VkAllocationCallbacks *>(m_allocator), |
| reinterpret_cast<VkSurfaceKHR *>(&m_surface))); |
| if(result != VULKAN_HPP_NAMESPACE::Result::eSuccess) |
| { |
| throwResultException(result, "vkCreateHeadlessSurfaceEXT"); |
| } |
| } |
| |
| # if defined(VK_USE_PLATFORM_IOS_MVK) |
| SurfaceKHR(VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::Instance const &instance, |
| VULKAN_HPP_NAMESPACE::IOSSurfaceCreateInfoMVK const &createInfo, |
| VULKAN_HPP_NAMESPACE::Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator = nullptr) |
| : m_instance(*instance) |
| , m_allocator(static_cast<const VULKAN_HPP_NAMESPACE::AllocationCallbacks *>(allocator)) |
| , m_dispatcher(instance.getDispatcher()) |
| { |
| VULKAN_HPP_NAMESPACE::Result result = static_cast<VULKAN_HPP_NAMESPACE::Result>( |
| instance.getDispatcher()->vkCreateIOSSurfaceMVK(static_cast<VkInstance>(*instance), |
| reinterpret_cast<const VkIOSSurfaceCreateInfoMVK *>(&createInfo), |
| reinterpret_cast<const VkAllocationCallbacks *>(m_allocator), |
| reinterpret_cast<VkSurfaceKHR *>(&m_surface))); |
| if(result != VULKAN_HPP_NAMESPACE::Result::eSuccess) |
| { |
| throwResultException(result, "vkCreateIOSSurfaceMVK"); |
| } |
| } |
| # endif /*VK_USE_PLATFORM_IOS_MVK*/ |
| |
| # if defined(VK_USE_PLATFORM_FUCHSIA) |
| SurfaceKHR(VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::Instance const &instance, |
| VULKAN_HPP_NAMESPACE::ImagePipeSurfaceCreateInfoFUCHSIA const &createInfo, |
| VULKAN_HPP_NAMESPACE::Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator = nullptr) |
| : m_instance(*instance) |
| , m_allocator(static_cast<const VULKAN_HPP_NAMESPACE::AllocationCallbacks *>(allocator)) |
| , m_dispatcher(instance.getDispatcher()) |
| { |
| VULKAN_HPP_NAMESPACE::Result result = static_cast<VULKAN_HPP_NAMESPACE::Result>( |
| instance.getDispatcher()->vkCreateImagePipeSurfaceFUCHSIA(static_cast<VkInstance>(*instance), |
| reinterpret_cast<const VkImagePipeSurfaceCreateInfoFUCHSIA *>(&createInfo), |
| reinterpret_cast<const VkAllocationCallbacks *>(m_allocator), |
| reinterpret_cast<VkSurfaceKHR *>(&m_surface))); |
| if(result != VULKAN_HPP_NAMESPACE::Result::eSuccess) |
| { |
| throwResultException(result, "vkCreateImagePipeSurfaceFUCHSIA"); |
| } |
| } |
| # endif /*VK_USE_PLATFORM_FUCHSIA*/ |
| |
| # if defined(VK_USE_PLATFORM_MACOS_MVK) |
| SurfaceKHR(VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::Instance const &instance, |
| VULKAN_HPP_NAMESPACE::MacOSSurfaceCreateInfoMVK const &createInfo, |
| VULKAN_HPP_NAMESPACE::Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator = nullptr) |
| : m_instance(*instance) |
| , m_allocator(static_cast<const VULKAN_HPP_NAMESPACE::AllocationCallbacks *>(allocator)) |
| , m_dispatcher(instance.getDispatcher()) |
| { |
| VULKAN_HPP_NAMESPACE::Result result = static_cast<VULKAN_HPP_NAMESPACE::Result>( |
| instance.getDispatcher()->vkCreateMacOSSurfaceMVK(static_cast<VkInstance>(*instance), |
| reinterpret_cast<const VkMacOSSurfaceCreateInfoMVK *>(&createInfo), |
| reinterpret_cast<const VkAllocationCallbacks *>(m_allocator), |
| reinterpret_cast<VkSurfaceKHR *>(&m_surface))); |
| if(result != VULKAN_HPP_NAMESPACE::Result::eSuccess) |
| { |
| throwResultException(result, "vkCreateMacOSSurfaceMVK"); |
| } |
| } |
| # endif /*VK_USE_PLATFORM_MACOS_MVK*/ |
| |
| # if defined(VK_USE_PLATFORM_METAL_EXT) |
| SurfaceKHR(VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::Instance const &instance, |
| VULKAN_HPP_NAMESPACE::MetalSurfaceCreateInfoEXT const &createInfo, |
| VULKAN_HPP_NAMESPACE::Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator = nullptr) |
| : m_instance(*instance) |
| , m_allocator(static_cast<const VULKAN_HPP_NAMESPACE::AllocationCallbacks *>(allocator)) |
| , m_dispatcher(instance.getDispatcher()) |
| { |
| VULKAN_HPP_NAMESPACE::Result result = static_cast<VULKAN_HPP_NAMESPACE::Result>( |
| instance.getDispatcher()->vkCreateMetalSurfaceEXT(static_cast<VkInstance>(*instance), |
| reinterpret_cast<const VkMetalSurfaceCreateInfoEXT *>(&createInfo), |
| reinterpret_cast<const VkAllocationCallbacks *>(m_allocator), |
| reinterpret_cast<VkSurfaceKHR *>(&m_surface))); |
| if(result != VULKAN_HPP_NAMESPACE::Result::eSuccess) |
| { |
| throwResultException(result, "vkCreateMetalSurfaceEXT"); |
| } |
| } |
| # endif /*VK_USE_PLATFORM_METAL_EXT*/ |
| |
| # if defined(VK_USE_PLATFORM_SCREEN_QNX) |
| SurfaceKHR(VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::Instance const &instance, |
| VULKAN_HPP_NAMESPACE::ScreenSurfaceCreateInfoQNX const &createInfo, |
| VULKAN_HPP_NAMESPACE::Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator = nullptr) |
| : m_instance(*instance) |
| , m_allocator(static_cast<const VULKAN_HPP_NAMESPACE::AllocationCallbacks *>(allocator)) |
| , m_dispatcher(instance.getDispatcher()) |
| { |
| VULKAN_HPP_NAMESPACE::Result result = static_cast<VULKAN_HPP_NAMESPACE::Result>( |
| instance.getDispatcher()->vkCreateScreenSurfaceQNX(static_cast<VkInstance>(*instance), |
| reinterpret_cast<const VkScreenSurfaceCreateInfoQNX *>(&createInfo), |
| reinterpret_cast<const VkAllocationCallbacks *>(m_allocator), |
| reinterpret_cast<VkSurfaceKHR *>(&m_surface))); |
| if(result != VULKAN_HPP_NAMESPACE::Result::eSuccess) |
| { |
| throwResultException(result, "vkCreateScreenSurfaceQNX"); |
| } |
| } |
| # endif /*VK_USE_PLATFORM_SCREEN_QNX*/ |
| |
| # if defined(VK_USE_PLATFORM_GGP) |
| SurfaceKHR(VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::Instance const &instance, |
| VULKAN_HPP_NAMESPACE::StreamDescriptorSurfaceCreateInfoGGP const &createInfo, |
| VULKAN_HPP_NAMESPACE::Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator = nullptr) |
| : m_instance(*instance) |
| , m_allocator(static_cast<const VULKAN_HPP_NAMESPACE::AllocationCallbacks *>(allocator)) |
| , m_dispatcher(instance.getDispatcher()) |
| { |
| VULKAN_HPP_NAMESPACE::Result result = static_cast<VULKAN_HPP_NAMESPACE::Result>( |
| instance.getDispatcher()->vkCreateStreamDescriptorSurfaceGGP(static_cast<VkInstance>(*instance), |
| reinterpret_cast<const VkStreamDescriptorSurfaceCreateInfoGGP *>(&createInfo), |
| reinterpret_cast<const VkAllocationCallbacks *>(m_allocator), |
| reinterpret_cast<VkSurfaceKHR *>(&m_surface))); |
| if(result != VULKAN_HPP_NAMESPACE::Result::eSuccess) |
| { |
| throwResultException(result, "vkCreateStreamDescriptorSurfaceGGP"); |
| } |
| } |
| # endif /*VK_USE_PLATFORM_GGP*/ |
| |
| # if defined(VK_USE_PLATFORM_VI_NN) |
| SurfaceKHR(VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::Instance const &instance, |
| VULKAN_HPP_NAMESPACE::ViSurfaceCreateInfoNN const &createInfo, |
| VULKAN_HPP_NAMESPACE::Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator = nullptr) |
| : m_instance(*instance) |
| , m_allocator(static_cast<const VULKAN_HPP_NAMESPACE::AllocationCallbacks *>(allocator)) |
| , m_dispatcher(instance.getDispatcher()) |
| { |
| VULKAN_HPP_NAMESPACE::Result result = static_cast<VULKAN_HPP_NAMESPACE::Result>( |
| instance.getDispatcher()->vkCreateViSurfaceNN(static_cast<VkInstance>(*instance), |
| reinterpret_cast<const VkViSurfaceCreateInfoNN *>(&createInfo), |
| reinterpret_cast<const VkAllocationCallbacks *>(m_allocator), |
| reinterpret_cast<VkSurfaceKHR *>(&m_surface))); |
| if(result != VULKAN_HPP_NAMESPACE::Result::eSuccess) |
| { |
| throwResultException(result, "vkCreateViSurfaceNN"); |
| } |
| } |
| # endif /*VK_USE_PLATFORM_VI_NN*/ |
| |
| # if defined(VK_USE_PLATFORM_WAYLAND_KHR) |
| SurfaceKHR(VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::Instance const &instance, |
| VULKAN_HPP_NAMESPACE::WaylandSurfaceCreateInfoKHR const &createInfo, |
| VULKAN_HPP_NAMESPACE::Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator = nullptr) |
| : m_instance(*instance) |
| , m_allocator(static_cast<const VULKAN_HPP_NAMESPACE::AllocationCallbacks *>(allocator)) |
| , m_dispatcher(instance.getDispatcher()) |
| { |
| VULKAN_HPP_NAMESPACE::Result result = static_cast<VULKAN_HPP_NAMESPACE::Result>( |
| instance.getDispatcher()->vkCreateWaylandSurfaceKHR(static_cast<VkInstance>(*instance), |
| reinterpret_cast<const VkWaylandSurfaceCreateInfoKHR *>(&createInfo), |
| reinterpret_cast<const VkAllocationCallbacks *>(m_allocator), |
| reinterpret_cast<VkSurfaceKHR *>(&m_surface))); |
| if(result != VULKAN_HPP_NAMESPACE::Result::eSuccess) |
| { |
| throwResultException(result, "vkCreateWaylandSurfaceKHR"); |
| } |
| } |
| # endif /*VK_USE_PLATFORM_WAYLAND_KHR*/ |
| |
| # if defined(VK_USE_PLATFORM_WIN32_KHR) |
| SurfaceKHR(VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::Instance const &instance, |
| VULKAN_HPP_NAMESPACE::Win32SurfaceCreateInfoKHR const &createInfo, |
| VULKAN_HPP_NAMESPACE::Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator = nullptr) |
| : m_instance(*instance) |
| , m_allocator(static_cast<const VULKAN_HPP_NAMESPACE::AllocationCallbacks *>(allocator)) |
| , m_dispatcher(instance.getDispatcher()) |
| { |
| VULKAN_HPP_NAMESPACE::Result result = static_cast<VULKAN_HPP_NAMESPACE::Result>( |
| instance.getDispatcher()->vkCreateWin32SurfaceKHR(static_cast<VkInstance>(*instance), |
| reinterpret_cast<const VkWin32SurfaceCreateInfoKHR *>(&createInfo), |
| reinterpret_cast<const VkAllocationCallbacks *>(m_allocator), |
| reinterpret_cast<VkSurfaceKHR *>(&m_surface))); |
| if(result != VULKAN_HPP_NAMESPACE::Result::eSuccess) |
| { |
| throwResultException(result, "vkCreateWin32SurfaceKHR"); |
| } |
| } |
| # endif /*VK_USE_PLATFORM_WIN32_KHR*/ |
| |
| # if defined(VK_USE_PLATFORM_XCB_KHR) |
| SurfaceKHR(VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::Instance const &instance, |
| VULKAN_HPP_NAMESPACE::XcbSurfaceCreateInfoKHR const &createInfo, |
| VULKAN_HPP_NAMESPACE::Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator = nullptr) |
| : m_instance(*instance) |
| , m_allocator(static_cast<const VULKAN_HPP_NAMESPACE::AllocationCallbacks *>(allocator)) |
| , m_dispatcher(instance.getDispatcher()) |
| { |
| VULKAN_HPP_NAMESPACE::Result result = static_cast<VULKAN_HPP_NAMESPACE::Result>( |
| instance.getDispatcher()->vkCreateXcbSurfaceKHR(static_cast<VkInstance>(*instance), |
| reinterpret_cast<const VkXcbSurfaceCreateInfoKHR *>(&createInfo), |
| reinterpret_cast<const VkAllocationCallbacks *>(m_allocator), |
| reinterpret_cast<VkSurfaceKHR *>(&m_surface))); |
| if(result != VULKAN_HPP_NAMESPACE::Result::eSuccess) |
| { |
| throwResultException(result, "vkCreateXcbSurfaceKHR"); |
| } |
| } |
| # endif /*VK_USE_PLATFORM_XCB_KHR*/ |
| |
| # if defined(VK_USE_PLATFORM_XLIB_KHR) |
| SurfaceKHR(VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::Instance const &instance, |
| VULKAN_HPP_NAMESPACE::XlibSurfaceCreateInfoKHR const &createInfo, |
| VULKAN_HPP_NAMESPACE::Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator = nullptr) |
| : m_instance(*instance) |
| , m_allocator(static_cast<const VULKAN_HPP_NAMESPACE::AllocationCallbacks *>(allocator)) |
| , m_dispatcher(instance.getDispatcher()) |
| { |
| VULKAN_HPP_NAMESPACE::Result result = static_cast<VULKAN_HPP_NAMESPACE::Result>( |
| instance.getDispatcher()->vkCreateXlibSurfaceKHR(static_cast<VkInstance>(*instance), |
| reinterpret_cast<const VkXlibSurfaceCreateInfoKHR *>(&createInfo), |
| reinterpret_cast<const VkAllocationCallbacks *>(m_allocator), |
| reinterpret_cast<VkSurfaceKHR *>(&m_surface))); |
| if(result != VULKAN_HPP_NAMESPACE::Result::eSuccess) |
| { |
| throwResultException(result, "vkCreateXlibSurfaceKHR"); |
| } |
| } |
| # endif /*VK_USE_PLATFORM_XLIB_KHR*/ |
| |
| SurfaceKHR(VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::Instance const &instance, |
| VkSurfaceKHR surface, |
| VULKAN_HPP_NAMESPACE::Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator = nullptr) |
| : m_instance(*instance) |
| , m_surface(surface) |
| , m_allocator(static_cast<const VULKAN_HPP_NAMESPACE::AllocationCallbacks *>(allocator)) |
| , m_dispatcher(instance.getDispatcher()) |
| { |
| } |
| |
| SurfaceKHR(std::nullptr_t) {} |
| |
| ~SurfaceKHR() |
| { |
| clear(); |
| } |
| |
| SurfaceKHR() = delete; |
| SurfaceKHR(SurfaceKHR const &) = delete; |
| SurfaceKHR(SurfaceKHR &&rhs) VULKAN_HPP_NOEXCEPT |
| : m_instance(VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange(rhs.m_instance, {})), |
| m_surface(VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange(rhs.m_surface, {})), |
| m_allocator(VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange(rhs.m_allocator, {})), |
| m_dispatcher(VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange(rhs.m_dispatcher, nullptr)) |
| { |
| } |
| SurfaceKHR &operator=(SurfaceKHR const &) = delete; |
| SurfaceKHR &operator=(SurfaceKHR &&rhs) VULKAN_HPP_NOEXCEPT |
| { |
| if(this != &rhs) |
| { |
| clear(); |
| m_instance = VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange(rhs.m_instance, {}); |
| m_surface = VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange(rhs.m_surface, {}); |
| m_allocator = VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange(rhs.m_allocator, {}); |
| m_dispatcher = VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange(rhs.m_dispatcher, nullptr); |
| } |
| return *this; |
| } |
| |
| VULKAN_HPP_NAMESPACE::SurfaceKHR const &operator*() const VULKAN_HPP_NOEXCEPT |
| { |
| return m_surface; |
| } |
| |
| void clear() VULKAN_HPP_NOEXCEPT |
| { |
| if(m_surface) |
| { |
| getDispatcher()->vkDestroySurfaceKHR( |
| static_cast<VkInstance>(m_instance), static_cast<VkSurfaceKHR>(m_surface), reinterpret_cast<const VkAllocationCallbacks *>(m_allocator)); |
| } |
| m_instance = nullptr; |
| m_surface = nullptr; |
| m_allocator = nullptr; |
| m_dispatcher = nullptr; |
| } |
| |
| VULKAN_HPP_NAMESPACE::Instance getInstance() const |
| { |
| return m_instance; |
| } |
| |
| VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::InstanceDispatcher const *getDispatcher() const |
| { |
| VULKAN_HPP_ASSERT(m_dispatcher->getVkHeaderVersion() == VK_HEADER_VERSION); |
| return m_dispatcher; |
| } |
| |
| void swap(VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::SurfaceKHR &rhs) VULKAN_HPP_NOEXCEPT |
| { |
| std::swap(m_instance, rhs.m_instance); |
| std::swap(m_surface, rhs.m_surface); |
| std::swap(m_allocator, rhs.m_allocator); |
| std::swap(m_dispatcher, rhs.m_dispatcher); |
| } |
| |
| private: |
| VULKAN_HPP_NAMESPACE::Instance m_instance = {}; |
| VULKAN_HPP_NAMESPACE::SurfaceKHR m_surface = {}; |
| const VULKAN_HPP_NAMESPACE::AllocationCallbacks *m_allocator = {}; |
| VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::InstanceDispatcher const *m_dispatcher = nullptr; |
| }; |
| |
| class SwapchainKHR |
| { |
| public: |
| using CType = VkSwapchainKHR; |
| |
| static VULKAN_HPP_CONST_OR_CONSTEXPR VULKAN_HPP_NAMESPACE::ObjectType objectType = VULKAN_HPP_NAMESPACE::ObjectType::eSwapchainKHR; |
| static VULKAN_HPP_CONST_OR_CONSTEXPR VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT debugReportObjectType = |
| VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT::eSwapchainKHR; |
| |
| public: |
| SwapchainKHR(VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::Device const &device, |
| VULKAN_HPP_NAMESPACE::SwapchainCreateInfoKHR const &createInfo, |
| VULKAN_HPP_NAMESPACE::Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator = nullptr) |
| : m_device(*device) |
| , m_allocator(static_cast<const VULKAN_HPP_NAMESPACE::AllocationCallbacks *>(allocator)) |
| , m_dispatcher(device.getDispatcher()) |
| { |
| VULKAN_HPP_NAMESPACE::Result result = static_cast<VULKAN_HPP_NAMESPACE::Result>( |
| device.getDispatcher()->vkCreateSwapchainKHR(static_cast<VkDevice>(*device), |
| reinterpret_cast<const VkSwapchainCreateInfoKHR *>(&createInfo), |
| reinterpret_cast<const VkAllocationCallbacks *>(m_allocator), |
| reinterpret_cast<VkSwapchainKHR *>(&m_swapchain))); |
| if(result != VULKAN_HPP_NAMESPACE::Result::eSuccess) |
| { |
| throwResultException(result, "vkCreateSwapchainKHR"); |
| } |
| } |
| |
| SwapchainKHR(VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::Device const &device, |
| VkSwapchainKHR swapchain, |
| VULKAN_HPP_NAMESPACE::Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator = nullptr) |
| : m_device(*device) |
| , m_swapchain(swapchain) |
| , m_allocator(static_cast<const VULKAN_HPP_NAMESPACE::AllocationCallbacks *>(allocator)) |
| , m_dispatcher(device.getDispatcher()) |
| { |
| } |
| |
| SwapchainKHR(std::nullptr_t) {} |
| |
| ~SwapchainKHR() |
| { |
| clear(); |
| } |
| |
| SwapchainKHR() = delete; |
| SwapchainKHR(SwapchainKHR const &) = delete; |
| SwapchainKHR(SwapchainKHR &&rhs) VULKAN_HPP_NOEXCEPT |
| : m_device(VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange(rhs.m_device, {})), |
| m_swapchain(VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange(rhs.m_swapchain, {})), |
| m_allocator(VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange(rhs.m_allocator, {})), |
| m_dispatcher(VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange(rhs.m_dispatcher, nullptr)) |
| { |
| } |
| SwapchainKHR &operator=(SwapchainKHR const &) = delete; |
| SwapchainKHR &operator=(SwapchainKHR &&rhs) VULKAN_HPP_NOEXCEPT |
| { |
| if(this != &rhs) |
| { |
| clear(); |
| m_device = VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange(rhs.m_device, {}); |
| m_swapchain = VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange(rhs.m_swapchain, {}); |
| m_allocator = VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange(rhs.m_allocator, {}); |
| m_dispatcher = VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange(rhs.m_dispatcher, nullptr); |
| } |
| return *this; |
| } |
| |
| VULKAN_HPP_NAMESPACE::SwapchainKHR const &operator*() const VULKAN_HPP_NOEXCEPT |
| { |
| return m_swapchain; |
| } |
| |
| void clear() VULKAN_HPP_NOEXCEPT |
| { |
| if(m_swapchain) |
| { |
| getDispatcher()->vkDestroySwapchainKHR( |
| static_cast<VkDevice>(m_device), static_cast<VkSwapchainKHR>(m_swapchain), reinterpret_cast<const VkAllocationCallbacks *>(m_allocator)); |
| } |
| m_device = nullptr; |
| m_swapchain = nullptr; |
| m_allocator = nullptr; |
| m_dispatcher = nullptr; |
| } |
| |
| VULKAN_HPP_NAMESPACE::Device getDevice() const |
| { |
| return m_device; |
| } |
| |
| VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::DeviceDispatcher const *getDispatcher() const |
| { |
| VULKAN_HPP_ASSERT(m_dispatcher->getVkHeaderVersion() == VK_HEADER_VERSION); |
| return m_dispatcher; |
| } |
| |
| void swap(VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::SwapchainKHR &rhs) VULKAN_HPP_NOEXCEPT |
| { |
| std::swap(m_device, rhs.m_device); |
| std::swap(m_swapchain, rhs.m_swapchain); |
| std::swap(m_allocator, rhs.m_allocator); |
| std::swap(m_dispatcher, rhs.m_dispatcher); |
| } |
| |
| //=== VK_KHR_swapchain === |
| |
| VULKAN_HPP_NODISCARD std::vector<VkImage> getImages() const; |
| |
| VULKAN_HPP_NODISCARD std::pair<VULKAN_HPP_NAMESPACE::Result, uint32_t> |
| acquireNextImage(uint64_t timeout, |
| VULKAN_HPP_NAMESPACE::Semaphore semaphore VULKAN_HPP_DEFAULT_ARGUMENT_ASSIGNMENT, |
| VULKAN_HPP_NAMESPACE::Fence fence VULKAN_HPP_DEFAULT_ARGUMENT_ASSIGNMENT) const; |
| |
| //=== VK_EXT_display_control === |
| |
| VULKAN_HPP_NODISCARD uint64_t getCounterEXT(VULKAN_HPP_NAMESPACE::SurfaceCounterFlagBitsEXT counter) const; |
| |
| //=== VK_GOOGLE_display_timing === |
| |
| VULKAN_HPP_NODISCARD VULKAN_HPP_NAMESPACE::RefreshCycleDurationGOOGLE getRefreshCycleDurationGOOGLE() const; |
| |
| VULKAN_HPP_NODISCARD std::vector<VULKAN_HPP_NAMESPACE::PastPresentationTimingGOOGLE> getPastPresentationTimingGOOGLE() const; |
| |
| //=== VK_KHR_shared_presentable_image === |
| |
| VULKAN_HPP_NODISCARD VULKAN_HPP_NAMESPACE::Result getStatus() const; |
| |
| //=== VK_AMD_display_native_hdr === |
| |
| void setLocalDimmingAMD(VULKAN_HPP_NAMESPACE::Bool32 localDimmingEnable) const VULKAN_HPP_NOEXCEPT; |
| |
| //=== VK_KHR_present_wait === |
| |
| VULKAN_HPP_NODISCARD VULKAN_HPP_NAMESPACE::Result waitForPresent(uint64_t presentId, uint64_t timeout) const; |
| |
| # if defined(VK_USE_PLATFORM_WIN32_KHR) |
| //=== VK_EXT_full_screen_exclusive === |
| |
| void acquireFullScreenExclusiveModeEXT() const; |
| |
| void releaseFullScreenExclusiveModeEXT() const; |
| # endif /*VK_USE_PLATFORM_WIN32_KHR*/ |
| |
| private: |
| VULKAN_HPP_NAMESPACE::Device m_device = {}; |
| VULKAN_HPP_NAMESPACE::SwapchainKHR m_swapchain = {}; |
| const VULKAN_HPP_NAMESPACE::AllocationCallbacks *m_allocator = {}; |
| VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::DeviceDispatcher const *m_dispatcher = nullptr; |
| }; |
| |
| class SwapchainKHRs : public std::vector<VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::SwapchainKHR> |
| { |
| public: |
| SwapchainKHRs(VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::Device const &device, |
| VULKAN_HPP_NAMESPACE::ArrayProxy<VULKAN_HPP_NAMESPACE::SwapchainCreateInfoKHR> const &createInfos, |
| VULKAN_HPP_NAMESPACE::Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator = nullptr) |
| { |
| VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::DeviceDispatcher const *dispatcher = device.getDispatcher(); |
| std::vector<VkSwapchainKHR> swapchains(createInfos.size()); |
| VULKAN_HPP_NAMESPACE::Result result = static_cast<VULKAN_HPP_NAMESPACE::Result>(dispatcher->vkCreateSharedSwapchainsKHR( |
| static_cast<VkDevice>(*device), |
| createInfos.size(), |
| reinterpret_cast<const VkSwapchainCreateInfoKHR *>(createInfos.data()), |
| reinterpret_cast<const VkAllocationCallbacks *>(static_cast<const VULKAN_HPP_NAMESPACE::AllocationCallbacks *>(allocator)), |
| swapchains.data())); |
| if(result == VULKAN_HPP_NAMESPACE::Result::eSuccess) |
| { |
| this->reserve(createInfos.size()); |
| for(auto const &swapchainKHR : swapchains) |
| { |
| this->emplace_back(device, swapchainKHR, allocator); |
| } |
| } |
| else |
| { |
| throwResultException(result, "vkCreateSharedSwapchainsKHR"); |
| } |
| } |
| |
| SwapchainKHRs(std::nullptr_t) {} |
| |
| SwapchainKHRs() = delete; |
| SwapchainKHRs(SwapchainKHRs const &) = delete; |
| SwapchainKHRs(SwapchainKHRs &&rhs) = default; |
| SwapchainKHRs &operator=(SwapchainKHRs const &) = delete; |
| SwapchainKHRs &operator=(SwapchainKHRs &&rhs) = default; |
| }; |
| |
| class ValidationCacheEXT |
| { |
| public: |
| using CType = VkValidationCacheEXT; |
| |
| static VULKAN_HPP_CONST_OR_CONSTEXPR VULKAN_HPP_NAMESPACE::ObjectType objectType = VULKAN_HPP_NAMESPACE::ObjectType::eValidationCacheEXT; |
| static VULKAN_HPP_CONST_OR_CONSTEXPR VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT debugReportObjectType = |
| VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT::eValidationCacheEXT; |
| |
| public: |
| ValidationCacheEXT(VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::Device const &device, |
| VULKAN_HPP_NAMESPACE::ValidationCacheCreateInfoEXT const &createInfo, |
| VULKAN_HPP_NAMESPACE::Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator = nullptr) |
| : m_device(*device) |
| , m_allocator(static_cast<const VULKAN_HPP_NAMESPACE::AllocationCallbacks *>(allocator)) |
| , m_dispatcher(device.getDispatcher()) |
| { |
| VULKAN_HPP_NAMESPACE::Result result = static_cast<VULKAN_HPP_NAMESPACE::Result>( |
| device.getDispatcher()->vkCreateValidationCacheEXT(static_cast<VkDevice>(*device), |
| reinterpret_cast<const VkValidationCacheCreateInfoEXT *>(&createInfo), |
| reinterpret_cast<const VkAllocationCallbacks *>(m_allocator), |
| reinterpret_cast<VkValidationCacheEXT *>(&m_validationCache))); |
| if(result != VULKAN_HPP_NAMESPACE::Result::eSuccess) |
| { |
| throwResultException(result, "vkCreateValidationCacheEXT"); |
| } |
| } |
| |
| ValidationCacheEXT(VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::Device const &device, |
| VkValidationCacheEXT validationCache, |
| VULKAN_HPP_NAMESPACE::Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator = nullptr) |
| : m_device(*device) |
| , m_validationCache(validationCache) |
| , m_allocator(static_cast<const VULKAN_HPP_NAMESPACE::AllocationCallbacks *>(allocator)) |
| , m_dispatcher(device.getDispatcher()) |
| { |
| } |
| |
| ValidationCacheEXT(std::nullptr_t) {} |
| |
| ~ValidationCacheEXT() |
| { |
| clear(); |
| } |
| |
| ValidationCacheEXT() = delete; |
| ValidationCacheEXT(ValidationCacheEXT const &) = delete; |
| ValidationCacheEXT(ValidationCacheEXT &&rhs) VULKAN_HPP_NOEXCEPT |
| : m_device(VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange(rhs.m_device, {})), |
| m_validationCache(VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange(rhs.m_validationCache, {})), |
| m_allocator(VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange(rhs.m_allocator, {})), |
| m_dispatcher(VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange(rhs.m_dispatcher, nullptr)) |
| { |
| } |
| ValidationCacheEXT &operator=(ValidationCacheEXT const &) = delete; |
| ValidationCacheEXT &operator=(ValidationCacheEXT &&rhs) VULKAN_HPP_NOEXCEPT |
| { |
| if(this != &rhs) |
| { |
| clear(); |
| m_device = VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange(rhs.m_device, {}); |
| m_validationCache = VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange(rhs.m_validationCache, {}); |
| m_allocator = VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange(rhs.m_allocator, {}); |
| m_dispatcher = VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange(rhs.m_dispatcher, nullptr); |
| } |
| return *this; |
| } |
| |
| VULKAN_HPP_NAMESPACE::ValidationCacheEXT const &operator*() const VULKAN_HPP_NOEXCEPT |
| { |
| return m_validationCache; |
| } |
| |
| void clear() VULKAN_HPP_NOEXCEPT |
| { |
| if(m_validationCache) |
| { |
| getDispatcher()->vkDestroyValidationCacheEXT(static_cast<VkDevice>(m_device), |
| static_cast<VkValidationCacheEXT>(m_validationCache), |
| reinterpret_cast<const VkAllocationCallbacks *>(m_allocator)); |
| } |
| m_device = nullptr; |
| m_validationCache = nullptr; |
| m_allocator = nullptr; |
| m_dispatcher = nullptr; |
| } |
| |
| VULKAN_HPP_NAMESPACE::Device getDevice() const |
| { |
| return m_device; |
| } |
| |
| VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::DeviceDispatcher const *getDispatcher() const |
| { |
| VULKAN_HPP_ASSERT(m_dispatcher->getVkHeaderVersion() == VK_HEADER_VERSION); |
| return m_dispatcher; |
| } |
| |
| void swap(VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::ValidationCacheEXT &rhs) VULKAN_HPP_NOEXCEPT |
| { |
| std::swap(m_device, rhs.m_device); |
| std::swap(m_validationCache, rhs.m_validationCache); |
| std::swap(m_allocator, rhs.m_allocator); |
| std::swap(m_dispatcher, rhs.m_dispatcher); |
| } |
| |
| //=== VK_EXT_validation_cache === |
| |
| void merge(ArrayProxy<const VULKAN_HPP_NAMESPACE::ValidationCacheEXT> const &srcCaches) const; |
| |
| VULKAN_HPP_NODISCARD std::vector<uint8_t> getData() const; |
| |
| private: |
| VULKAN_HPP_NAMESPACE::Device m_device = {}; |
| VULKAN_HPP_NAMESPACE::ValidationCacheEXT m_validationCache = {}; |
| const VULKAN_HPP_NAMESPACE::AllocationCallbacks *m_allocator = {}; |
| VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::DeviceDispatcher const *m_dispatcher = nullptr; |
| }; |
| |
| # if defined(VK_ENABLE_BETA_EXTENSIONS) |
| class VideoSessionKHR |
| { |
| public: |
| using CType = VkVideoSessionKHR; |
| |
| static VULKAN_HPP_CONST_OR_CONSTEXPR VULKAN_HPP_NAMESPACE::ObjectType objectType = VULKAN_HPP_NAMESPACE::ObjectType::eVideoSessionKHR; |
| static VULKAN_HPP_CONST_OR_CONSTEXPR VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT debugReportObjectType = |
| VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT::eUnknown; |
| |
| public: |
| VideoSessionKHR(VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::Device const &device, |
| VULKAN_HPP_NAMESPACE::VideoSessionCreateInfoKHR const &createInfo, |
| VULKAN_HPP_NAMESPACE::Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator = nullptr) |
| : m_device(*device) |
| , m_allocator(static_cast<const VULKAN_HPP_NAMESPACE::AllocationCallbacks *>(allocator)) |
| , m_dispatcher(device.getDispatcher()) |
| { |
| VULKAN_HPP_NAMESPACE::Result result = static_cast<VULKAN_HPP_NAMESPACE::Result>( |
| device.getDispatcher()->vkCreateVideoSessionKHR(static_cast<VkDevice>(*device), |
| reinterpret_cast<const VkVideoSessionCreateInfoKHR *>(&createInfo), |
| reinterpret_cast<const VkAllocationCallbacks *>(m_allocator), |
| reinterpret_cast<VkVideoSessionKHR *>(&m_videoSession))); |
| if(result != VULKAN_HPP_NAMESPACE::Result::eSuccess) |
| { |
| throwResultException(result, "vkCreateVideoSessionKHR"); |
| } |
| } |
| |
| VideoSessionKHR(VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::Device const &device, |
| VkVideoSessionKHR videoSession, |
| VULKAN_HPP_NAMESPACE::Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator = nullptr) |
| : m_device(*device) |
| , m_videoSession(videoSession) |
| , m_allocator(static_cast<const VULKAN_HPP_NAMESPACE::AllocationCallbacks *>(allocator)) |
| , m_dispatcher(device.getDispatcher()) |
| { |
| } |
| |
| VideoSessionKHR(std::nullptr_t) {} |
| |
| ~VideoSessionKHR() |
| { |
| clear(); |
| } |
| |
| VideoSessionKHR() = delete; |
| VideoSessionKHR(VideoSessionKHR const &) = delete; |
| VideoSessionKHR(VideoSessionKHR &&rhs) VULKAN_HPP_NOEXCEPT |
| : m_device(VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange(rhs.m_device, {})), |
| m_videoSession(VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange(rhs.m_videoSession, {})), |
| m_allocator(VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange(rhs.m_allocator, {})), |
| m_dispatcher(VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange(rhs.m_dispatcher, nullptr)) |
| { |
| } |
| VideoSessionKHR &operator=(VideoSessionKHR const &) = delete; |
| VideoSessionKHR &operator=(VideoSessionKHR &&rhs) VULKAN_HPP_NOEXCEPT |
| { |
| if(this != &rhs) |
| { |
| clear(); |
| m_device = VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange(rhs.m_device, {}); |
| m_videoSession = VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange(rhs.m_videoSession, {}); |
| m_allocator = VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange(rhs.m_allocator, {}); |
| m_dispatcher = VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange(rhs.m_dispatcher, nullptr); |
| } |
| return *this; |
| } |
| |
| VULKAN_HPP_NAMESPACE::VideoSessionKHR const &operator*() const VULKAN_HPP_NOEXCEPT |
| { |
| return m_videoSession; |
| } |
| |
| void clear() VULKAN_HPP_NOEXCEPT |
| { |
| if(m_videoSession) |
| { |
| getDispatcher()->vkDestroyVideoSessionKHR(static_cast<VkDevice>(m_device), |
| static_cast<VkVideoSessionKHR>(m_videoSession), |
| reinterpret_cast<const VkAllocationCallbacks *>(m_allocator)); |
| } |
| m_device = nullptr; |
| m_videoSession = nullptr; |
| m_allocator = nullptr; |
| m_dispatcher = nullptr; |
| } |
| |
| VULKAN_HPP_NAMESPACE::Device getDevice() const |
| { |
| return m_device; |
| } |
| |
| VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::DeviceDispatcher const *getDispatcher() const |
| { |
| VULKAN_HPP_ASSERT(m_dispatcher->getVkHeaderVersion() == VK_HEADER_VERSION); |
| return m_dispatcher; |
| } |
| |
| void swap(VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::VideoSessionKHR &rhs) VULKAN_HPP_NOEXCEPT |
| { |
| std::swap(m_device, rhs.m_device); |
| std::swap(m_videoSession, rhs.m_videoSession); |
| std::swap(m_allocator, rhs.m_allocator); |
| std::swap(m_dispatcher, rhs.m_dispatcher); |
| } |
| |
| //=== VK_KHR_video_queue === |
| |
| VULKAN_HPP_NODISCARD std::vector<VULKAN_HPP_NAMESPACE::VideoGetMemoryPropertiesKHR> getMemoryRequirements() const; |
| |
| void bindMemory(ArrayProxy<const VULKAN_HPP_NAMESPACE::VideoBindMemoryKHR> const &videoSessionBindMemories) const; |
| |
| private: |
| VULKAN_HPP_NAMESPACE::Device m_device = {}; |
| VULKAN_HPP_NAMESPACE::VideoSessionKHR m_videoSession = {}; |
| const VULKAN_HPP_NAMESPACE::AllocationCallbacks *m_allocator = {}; |
| VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::DeviceDispatcher const *m_dispatcher = nullptr; |
| }; |
| # endif /*VK_ENABLE_BETA_EXTENSIONS*/ |
| |
| # if defined(VK_ENABLE_BETA_EXTENSIONS) |
| class VideoSessionParametersKHR |
| { |
| public: |
| using CType = VkVideoSessionParametersKHR; |
| |
| static VULKAN_HPP_CONST_OR_CONSTEXPR VULKAN_HPP_NAMESPACE::ObjectType objectType = VULKAN_HPP_NAMESPACE::ObjectType::eVideoSessionParametersKHR; |
| static VULKAN_HPP_CONST_OR_CONSTEXPR VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT debugReportObjectType = |
| VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT::eUnknown; |
| |
| public: |
| VideoSessionParametersKHR(VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::Device const &device, |
| VULKAN_HPP_NAMESPACE::VideoSessionParametersCreateInfoKHR const &createInfo, |
| VULKAN_HPP_NAMESPACE::Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator = nullptr) |
| : m_device(*device) |
| , m_allocator(static_cast<const VULKAN_HPP_NAMESPACE::AllocationCallbacks *>(allocator)) |
| , m_dispatcher(device.getDispatcher()) |
| { |
| VULKAN_HPP_NAMESPACE::Result result = static_cast<VULKAN_HPP_NAMESPACE::Result>( |
| device.getDispatcher()->vkCreateVideoSessionParametersKHR(static_cast<VkDevice>(*device), |
| reinterpret_cast<const VkVideoSessionParametersCreateInfoKHR *>(&createInfo), |
| reinterpret_cast<const VkAllocationCallbacks *>(m_allocator), |
| reinterpret_cast<VkVideoSessionParametersKHR *>(&m_videoSessionParameters))); |
| if(result != VULKAN_HPP_NAMESPACE::Result::eSuccess) |
| { |
| throwResultException(result, "vkCreateVideoSessionParametersKHR"); |
| } |
| } |
| |
| VideoSessionParametersKHR(VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::Device const &device, |
| VkVideoSessionParametersKHR videoSessionParameters, |
| VULKAN_HPP_NAMESPACE::Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator = nullptr) |
| : m_device(*device) |
| , m_videoSessionParameters(videoSessionParameters) |
| , m_allocator(static_cast<const VULKAN_HPP_NAMESPACE::AllocationCallbacks *>(allocator)) |
| , m_dispatcher(device.getDispatcher()) |
| { |
| } |
| |
| VideoSessionParametersKHR(std::nullptr_t) {} |
| |
| ~VideoSessionParametersKHR() |
| { |
| clear(); |
| } |
| |
| VideoSessionParametersKHR() = delete; |
| VideoSessionParametersKHR(VideoSessionParametersKHR const &) = delete; |
| VideoSessionParametersKHR(VideoSessionParametersKHR &&rhs) VULKAN_HPP_NOEXCEPT |
| : m_device(VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange(rhs.m_device, {})), |
| m_videoSessionParameters(VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange(rhs.m_videoSessionParameters, {})), |
| m_allocator(VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange(rhs.m_allocator, {})), |
| m_dispatcher(VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange(rhs.m_dispatcher, nullptr)) |
| { |
| } |
| VideoSessionParametersKHR &operator=(VideoSessionParametersKHR const &) = delete; |
| VideoSessionParametersKHR &operator=(VideoSessionParametersKHR &&rhs) VULKAN_HPP_NOEXCEPT |
| { |
| if(this != &rhs) |
| { |
| clear(); |
| m_device = VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange(rhs.m_device, {}); |
| m_videoSessionParameters = VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange(rhs.m_videoSessionParameters, {}); |
| m_allocator = VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange(rhs.m_allocator, {}); |
| m_dispatcher = VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange(rhs.m_dispatcher, nullptr); |
| } |
| return *this; |
| } |
| |
| VULKAN_HPP_NAMESPACE::VideoSessionParametersKHR const &operator*() const VULKAN_HPP_NOEXCEPT |
| { |
| return m_videoSessionParameters; |
| } |
| |
| void clear() VULKAN_HPP_NOEXCEPT |
| { |
| if(m_videoSessionParameters) |
| { |
| getDispatcher()->vkDestroyVideoSessionParametersKHR(static_cast<VkDevice>(m_device), |
| static_cast<VkVideoSessionParametersKHR>(m_videoSessionParameters), |
| reinterpret_cast<const VkAllocationCallbacks *>(m_allocator)); |
| } |
| m_device = nullptr; |
| m_videoSessionParameters = nullptr; |
| m_allocator = nullptr; |
| m_dispatcher = nullptr; |
| } |
| |
| VULKAN_HPP_NAMESPACE::Device getDevice() const |
| { |
| return m_device; |
| } |
| |
| VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::DeviceDispatcher const *getDispatcher() const |
| { |
| VULKAN_HPP_ASSERT(m_dispatcher->getVkHeaderVersion() == VK_HEADER_VERSION); |
| return m_dispatcher; |
| } |
| |
| void swap(VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::VideoSessionParametersKHR &rhs) VULKAN_HPP_NOEXCEPT |
| { |
| std::swap(m_device, rhs.m_device); |
| std::swap(m_videoSessionParameters, rhs.m_videoSessionParameters); |
| std::swap(m_allocator, rhs.m_allocator); |
| std::swap(m_dispatcher, rhs.m_dispatcher); |
| } |
| |
| //=== VK_KHR_video_queue === |
| |
| void update(const VULKAN_HPP_NAMESPACE::VideoSessionParametersUpdateInfoKHR &updateInfo) const; |
| |
| private: |
| VULKAN_HPP_NAMESPACE::Device m_device = {}; |
| VULKAN_HPP_NAMESPACE::VideoSessionParametersKHR m_videoSessionParameters = {}; |
| const VULKAN_HPP_NAMESPACE::AllocationCallbacks *m_allocator = {}; |
| VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::DeviceDispatcher const *m_dispatcher = nullptr; |
| }; |
| # endif /*VK_ENABLE_BETA_EXTENSIONS*/ |
| |
| //=========================== |
| //=== COMMAND Definitions === |
| //=========================== |
| |
| //=== VK_VERSION_1_0 === |
| |
| VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE VULKAN_HPP_RAII_NAMESPACE::Instance |
| Context::createInstance(VULKAN_HPP_NAMESPACE::InstanceCreateInfo const &createInfo, |
| VULKAN_HPP_NAMESPACE::Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator) const |
| { |
| return VULKAN_HPP_RAII_NAMESPACE::Instance(*this, createInfo, allocator); |
| } |
| |
| VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE std::vector<VULKAN_HPP_RAII_NAMESPACE::PhysicalDevice> Instance::enumeratePhysicalDevices() const |
| { |
| return VULKAN_HPP_RAII_NAMESPACE::PhysicalDevices(*this); |
| } |
| |
| VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE VULKAN_HPP_NAMESPACE::PhysicalDeviceFeatures PhysicalDevice::getFeatures() const VULKAN_HPP_NOEXCEPT |
| { |
| VULKAN_HPP_NAMESPACE::PhysicalDeviceFeatures features; |
| getDispatcher()->vkGetPhysicalDeviceFeatures(static_cast<VkPhysicalDevice>(m_physicalDevice), |
| reinterpret_cast<VkPhysicalDeviceFeatures *>(&features)); |
| return features; |
| } |
| |
| VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE VULKAN_HPP_NAMESPACE::FormatProperties |
| PhysicalDevice::getFormatProperties(VULKAN_HPP_NAMESPACE::Format format) const VULKAN_HPP_NOEXCEPT |
| { |
| VULKAN_HPP_NAMESPACE::FormatProperties formatProperties; |
| getDispatcher()->vkGetPhysicalDeviceFormatProperties( |
| static_cast<VkPhysicalDevice>(m_physicalDevice), static_cast<VkFormat>(format), reinterpret_cast<VkFormatProperties *>(&formatProperties)); |
| return formatProperties; |
| } |
| |
| VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE VULKAN_HPP_NAMESPACE::ImageFormatProperties |
| PhysicalDevice::getImageFormatProperties(VULKAN_HPP_NAMESPACE::Format format, |
| VULKAN_HPP_NAMESPACE::ImageType type, |
| VULKAN_HPP_NAMESPACE::ImageTiling tiling, |
| VULKAN_HPP_NAMESPACE::ImageUsageFlags usage, |
| VULKAN_HPP_NAMESPACE::ImageCreateFlags flags) const |
| { |
| VULKAN_HPP_NAMESPACE::ImageFormatProperties imageFormatProperties; |
| VULKAN_HPP_NAMESPACE::Result result = static_cast<VULKAN_HPP_NAMESPACE::Result>( |
| getDispatcher()->vkGetPhysicalDeviceImageFormatProperties(static_cast<VkPhysicalDevice>(m_physicalDevice), |
| static_cast<VkFormat>(format), |
| static_cast<VkImageType>(type), |
| static_cast<VkImageTiling>(tiling), |
| static_cast<VkImageUsageFlags>(usage), |
| static_cast<VkImageCreateFlags>(flags), |
| reinterpret_cast<VkImageFormatProperties *>(&imageFormatProperties))); |
| if(result != VULKAN_HPP_NAMESPACE::Result::eSuccess) |
| { |
| throwResultException(result, VULKAN_HPP_NAMESPACE_STRING "::PhysicalDevice::getImageFormatProperties"); |
| } |
| return imageFormatProperties; |
| } |
| |
| VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE VULKAN_HPP_NAMESPACE::PhysicalDeviceProperties PhysicalDevice::getProperties() const VULKAN_HPP_NOEXCEPT |
| { |
| VULKAN_HPP_NAMESPACE::PhysicalDeviceProperties properties; |
| getDispatcher()->vkGetPhysicalDeviceProperties(static_cast<VkPhysicalDevice>(m_physicalDevice), |
| reinterpret_cast<VkPhysicalDeviceProperties *>(&properties)); |
| return properties; |
| } |
| |
| VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE std::vector<VULKAN_HPP_NAMESPACE::QueueFamilyProperties> |
| PhysicalDevice::getQueueFamilyProperties() const VULKAN_HPP_NOEXCEPT |
| { |
| uint32_t queueFamilyPropertyCount; |
| getDispatcher()->vkGetPhysicalDeviceQueueFamilyProperties(static_cast<VkPhysicalDevice>(m_physicalDevice), &queueFamilyPropertyCount, nullptr); |
| std::vector<VULKAN_HPP_NAMESPACE::QueueFamilyProperties> queueFamilyProperties(queueFamilyPropertyCount); |
| getDispatcher()->vkGetPhysicalDeviceQueueFamilyProperties(static_cast<VkPhysicalDevice>(m_physicalDevice), |
| &queueFamilyPropertyCount, |
| reinterpret_cast<VkQueueFamilyProperties *>(queueFamilyProperties.data())); |
| VULKAN_HPP_ASSERT(queueFamilyPropertyCount == queueFamilyProperties.size()); |
| return queueFamilyProperties; |
| } |
| |
| VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE VULKAN_HPP_NAMESPACE::PhysicalDeviceMemoryProperties PhysicalDevice::getMemoryProperties() const VULKAN_HPP_NOEXCEPT |
| { |
| VULKAN_HPP_NAMESPACE::PhysicalDeviceMemoryProperties memoryProperties; |
| getDispatcher()->vkGetPhysicalDeviceMemoryProperties(static_cast<VkPhysicalDevice>(m_physicalDevice), |
| reinterpret_cast<VkPhysicalDeviceMemoryProperties *>(&memoryProperties)); |
| return memoryProperties; |
| } |
| |
| VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE PFN_vkVoidFunction Instance::getProcAddr(const std::string &name) const VULKAN_HPP_NOEXCEPT |
| { |
| return getDispatcher()->vkGetInstanceProcAddr(static_cast<VkInstance>(m_instance), name.c_str()); |
| } |
| |
| VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE PFN_vkVoidFunction Device::getProcAddr(const std::string &name) const VULKAN_HPP_NOEXCEPT |
| { |
| return getDispatcher()->vkGetDeviceProcAddr(static_cast<VkDevice>(m_device), name.c_str()); |
| } |
| |
| VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE VULKAN_HPP_RAII_NAMESPACE::Device |
| PhysicalDevice::createDevice(VULKAN_HPP_NAMESPACE::DeviceCreateInfo const &createInfo, |
| VULKAN_HPP_NAMESPACE::Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator) const |
| { |
| return VULKAN_HPP_RAII_NAMESPACE::Device(*this, createInfo, allocator); |
| } |
| |
| VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE std::vector<VULKAN_HPP_NAMESPACE::ExtensionProperties> |
| Context::enumerateInstanceExtensionProperties(Optional<const std::string> layerName) const |
| { |
| std::vector<VULKAN_HPP_NAMESPACE::ExtensionProperties> properties; |
| uint32_t propertyCount; |
| VULKAN_HPP_NAMESPACE::Result result; |
| do |
| { |
| result = static_cast<VULKAN_HPP_NAMESPACE::Result>( |
| getDispatcher()->vkEnumerateInstanceExtensionProperties(layerName ? layerName->c_str() : nullptr, &propertyCount, nullptr)); |
| if((result == VULKAN_HPP_NAMESPACE::Result::eSuccess) && propertyCount) |
| { |
| properties.resize(propertyCount); |
| result = static_cast<VULKAN_HPP_NAMESPACE::Result>(getDispatcher()->vkEnumerateInstanceExtensionProperties( |
| layerName ? layerName->c_str() : nullptr, &propertyCount, reinterpret_cast<VkExtensionProperties *>(properties.data()))); |
| } |
| } while(result == VULKAN_HPP_NAMESPACE::Result::eIncomplete); |
| if(result != VULKAN_HPP_NAMESPACE::Result::eSuccess) |
| { |
| throwResultException(result, VULKAN_HPP_NAMESPACE_STRING "::Context::enumerateInstanceExtensionProperties"); |
| } |
| if(result == VULKAN_HPP_NAMESPACE::Result::eSuccess) |
| { |
| VULKAN_HPP_ASSERT(propertyCount <= properties.size()); |
| if(propertyCount < properties.size()) |
| { |
| properties.resize(propertyCount); |
| } |
| } |
| return properties; |
| } |
| |
| VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE std::vector<VULKAN_HPP_NAMESPACE::ExtensionProperties> |
| PhysicalDevice::enumerateDeviceExtensionProperties(Optional<const std::string> layerName) const |
| { |
| std::vector<VULKAN_HPP_NAMESPACE::ExtensionProperties> properties; |
| uint32_t propertyCount; |
| VULKAN_HPP_NAMESPACE::Result result; |
| do |
| { |
| result = static_cast<VULKAN_HPP_NAMESPACE::Result>(getDispatcher()->vkEnumerateDeviceExtensionProperties( |
| static_cast<VkPhysicalDevice>(m_physicalDevice), layerName ? layerName->c_str() : nullptr, &propertyCount, nullptr)); |
| if((result == VULKAN_HPP_NAMESPACE::Result::eSuccess) && propertyCount) |
| { |
| properties.resize(propertyCount); |
| result = static_cast<VULKAN_HPP_NAMESPACE::Result>( |
| getDispatcher()->vkEnumerateDeviceExtensionProperties(static_cast<VkPhysicalDevice>(m_physicalDevice), |
| layerName ? layerName->c_str() : nullptr, |
| &propertyCount, |
| reinterpret_cast<VkExtensionProperties *>(properties.data()))); |
| } |
| } while(result == VULKAN_HPP_NAMESPACE::Result::eIncomplete); |
| if(result != VULKAN_HPP_NAMESPACE::Result::eSuccess) |
| { |
| throwResultException(result, VULKAN_HPP_NAMESPACE_STRING "::PhysicalDevice::enumerateDeviceExtensionProperties"); |
| } |
| if(result == VULKAN_HPP_NAMESPACE::Result::eSuccess) |
| { |
| VULKAN_HPP_ASSERT(propertyCount <= properties.size()); |
| if(propertyCount < properties.size()) |
| { |
| properties.resize(propertyCount); |
| } |
| } |
| return properties; |
| } |
| |
| VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE std::vector<VULKAN_HPP_NAMESPACE::LayerProperties> Context::enumerateInstanceLayerProperties() const |
| { |
| std::vector<VULKAN_HPP_NAMESPACE::LayerProperties> properties; |
| uint32_t propertyCount; |
| VULKAN_HPP_NAMESPACE::Result result; |
| do |
| { |
| result = static_cast<VULKAN_HPP_NAMESPACE::Result>(getDispatcher()->vkEnumerateInstanceLayerProperties(&propertyCount, nullptr)); |
| if((result == VULKAN_HPP_NAMESPACE::Result::eSuccess) && propertyCount) |
| { |
| properties.resize(propertyCount); |
| result = static_cast<VULKAN_HPP_NAMESPACE::Result>( |
| getDispatcher()->vkEnumerateInstanceLayerProperties(&propertyCount, reinterpret_cast<VkLayerProperties *>(properties.data()))); |
| } |
| } while(result == VULKAN_HPP_NAMESPACE::Result::eIncomplete); |
| if(result != VULKAN_HPP_NAMESPACE::Result::eSuccess) |
| { |
| throwResultException(result, VULKAN_HPP_NAMESPACE_STRING "::Context::enumerateInstanceLayerProperties"); |
| } |
| if(result == VULKAN_HPP_NAMESPACE::Result::eSuccess) |
| { |
| VULKAN_HPP_ASSERT(propertyCount <= properties.size()); |
| if(propertyCount < properties.size()) |
| { |
| properties.resize(propertyCount); |
| } |
| } |
| return properties; |
| } |
| |
| VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE std::vector<VULKAN_HPP_NAMESPACE::LayerProperties> PhysicalDevice::enumerateDeviceLayerProperties() const |
| { |
| std::vector<VULKAN_HPP_NAMESPACE::LayerProperties> properties; |
| uint32_t propertyCount; |
| VULKAN_HPP_NAMESPACE::Result result; |
| do |
| { |
| result = static_cast<VULKAN_HPP_NAMESPACE::Result>( |
| getDispatcher()->vkEnumerateDeviceLayerProperties(static_cast<VkPhysicalDevice>(m_physicalDevice), &propertyCount, nullptr)); |
| if((result == VULKAN_HPP_NAMESPACE::Result::eSuccess) && propertyCount) |
| { |
| properties.resize(propertyCount); |
| result = static_cast<VULKAN_HPP_NAMESPACE::Result>(getDispatcher()->vkEnumerateDeviceLayerProperties( |
| static_cast<VkPhysicalDevice>(m_physicalDevice), &propertyCount, reinterpret_cast<VkLayerProperties *>(properties.data()))); |
| } |
| } while(result == VULKAN_HPP_NAMESPACE::Result::eIncomplete); |
| if(result != VULKAN_HPP_NAMESPACE::Result::eSuccess) |
| { |
| throwResultException(result, VULKAN_HPP_NAMESPACE_STRING "::PhysicalDevice::enumerateDeviceLayerProperties"); |
| } |
| if(result == VULKAN_HPP_NAMESPACE::Result::eSuccess) |
| { |
| VULKAN_HPP_ASSERT(propertyCount <= properties.size()); |
| if(propertyCount < properties.size()) |
| { |
| properties.resize(propertyCount); |
| } |
| } |
| return properties; |
| } |
| |
| VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE VULKAN_HPP_RAII_NAMESPACE::Queue Device::getQueue(uint32_t queueFamilyIndex, uint32_t queueIndex) const |
| { |
| return VULKAN_HPP_RAII_NAMESPACE::Queue(*this, queueFamilyIndex, queueIndex); |
| } |
| |
| VULKAN_HPP_INLINE void Queue::submit(ArrayProxy<const VULKAN_HPP_NAMESPACE::SubmitInfo> const &submits, VULKAN_HPP_NAMESPACE::Fence fence) const |
| { |
| VULKAN_HPP_NAMESPACE::Result result = static_cast<VULKAN_HPP_NAMESPACE::Result>(getDispatcher()->vkQueueSubmit( |
| static_cast<VkQueue>(m_queue), submits.size(), reinterpret_cast<const VkSubmitInfo *>(submits.data()), static_cast<VkFence>(fence))); |
| if(result != VULKAN_HPP_NAMESPACE::Result::eSuccess) |
| { |
| throwResultException(result, VULKAN_HPP_NAMESPACE_STRING "::Queue::submit"); |
| } |
| } |
| |
| VULKAN_HPP_INLINE void Queue::waitIdle() const |
| { |
| VULKAN_HPP_NAMESPACE::Result result = static_cast<VULKAN_HPP_NAMESPACE::Result>(getDispatcher()->vkQueueWaitIdle(static_cast<VkQueue>(m_queue))); |
| if(result != VULKAN_HPP_NAMESPACE::Result::eSuccess) |
| { |
| throwResultException(result, VULKAN_HPP_NAMESPACE_STRING "::Queue::waitIdle"); |
| } |
| } |
| |
| VULKAN_HPP_INLINE void Device::waitIdle() const |
| { |
| VULKAN_HPP_NAMESPACE::Result result = static_cast<VULKAN_HPP_NAMESPACE::Result>(getDispatcher()->vkDeviceWaitIdle(static_cast<VkDevice>(m_device))); |
| if(result != VULKAN_HPP_NAMESPACE::Result::eSuccess) |
| { |
| throwResultException(result, VULKAN_HPP_NAMESPACE_STRING "::Device::waitIdle"); |
| } |
| } |
| |
| VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE VULKAN_HPP_RAII_NAMESPACE::DeviceMemory |
| Device::allocateMemory(VULKAN_HPP_NAMESPACE::MemoryAllocateInfo const &allocateInfo, |
| VULKAN_HPP_NAMESPACE::Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator) const |
| { |
| return VULKAN_HPP_RAII_NAMESPACE::DeviceMemory(*this, allocateInfo, allocator); |
| } |
| |
| VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE void *DeviceMemory::mapMemory(VULKAN_HPP_NAMESPACE::DeviceSize offset, |
| VULKAN_HPP_NAMESPACE::DeviceSize size, |
| VULKAN_HPP_NAMESPACE::MemoryMapFlags flags) const |
| { |
| void *pData; |
| VULKAN_HPP_NAMESPACE::Result result = static_cast<VULKAN_HPP_NAMESPACE::Result>(getDispatcher()->vkMapMemory(static_cast<VkDevice>(m_device), |
| static_cast<VkDeviceMemory>(m_memory), |
| static_cast<VkDeviceSize>(offset), |
| static_cast<VkDeviceSize>(size), |
| static_cast<VkMemoryMapFlags>(flags), |
| &pData)); |
| if(result != VULKAN_HPP_NAMESPACE::Result::eSuccess) |
| { |
| throwResultException(result, VULKAN_HPP_NAMESPACE_STRING "::DeviceMemory::mapMemory"); |
| } |
| return pData; |
| } |
| |
| VULKAN_HPP_INLINE void DeviceMemory::unmapMemory() const VULKAN_HPP_NOEXCEPT |
| { |
| getDispatcher()->vkUnmapMemory(static_cast<VkDevice>(m_device), static_cast<VkDeviceMemory>(m_memory)); |
| } |
| |
| VULKAN_HPP_INLINE void Device::flushMappedMemoryRanges(ArrayProxy<const VULKAN_HPP_NAMESPACE::MappedMemoryRange> const &memoryRanges) const |
| { |
| VULKAN_HPP_NAMESPACE::Result result = static_cast<VULKAN_HPP_NAMESPACE::Result>(getDispatcher()->vkFlushMappedMemoryRanges( |
| static_cast<VkDevice>(m_device), memoryRanges.size(), reinterpret_cast<const VkMappedMemoryRange *>(memoryRanges.data()))); |
| if(result != VULKAN_HPP_NAMESPACE::Result::eSuccess) |
| { |
| throwResultException(result, VULKAN_HPP_NAMESPACE_STRING "::Device::flushMappedMemoryRanges"); |
| } |
| } |
| |
| VULKAN_HPP_INLINE void Device::invalidateMappedMemoryRanges(ArrayProxy<const VULKAN_HPP_NAMESPACE::MappedMemoryRange> const &memoryRanges) const |
| { |
| VULKAN_HPP_NAMESPACE::Result result = static_cast<VULKAN_HPP_NAMESPACE::Result>(getDispatcher()->vkInvalidateMappedMemoryRanges( |
| static_cast<VkDevice>(m_device), memoryRanges.size(), reinterpret_cast<const VkMappedMemoryRange *>(memoryRanges.data()))); |
| if(result != VULKAN_HPP_NAMESPACE::Result::eSuccess) |
| { |
| throwResultException(result, VULKAN_HPP_NAMESPACE_STRING "::Device::invalidateMappedMemoryRanges"); |
| } |
| } |
| |
| VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE VULKAN_HPP_NAMESPACE::DeviceSize DeviceMemory::getCommitment() const VULKAN_HPP_NOEXCEPT |
| { |
| VULKAN_HPP_NAMESPACE::DeviceSize committedMemoryInBytes; |
| getDispatcher()->vkGetDeviceMemoryCommitment( |
| static_cast<VkDevice>(m_device), static_cast<VkDeviceMemory>(m_memory), reinterpret_cast<VkDeviceSize *>(&committedMemoryInBytes)); |
| return committedMemoryInBytes; |
| } |
| |
| VULKAN_HPP_INLINE void Buffer::bindMemory(VULKAN_HPP_NAMESPACE::DeviceMemory memory, VULKAN_HPP_NAMESPACE::DeviceSize memoryOffset) const |
| { |
| VULKAN_HPP_NAMESPACE::Result result = |
| static_cast<VULKAN_HPP_NAMESPACE::Result>(getDispatcher()->vkBindBufferMemory(static_cast<VkDevice>(m_device), |
| static_cast<VkBuffer>(m_buffer), |
| static_cast<VkDeviceMemory>(memory), |
| static_cast<VkDeviceSize>(memoryOffset))); |
| if(result != VULKAN_HPP_NAMESPACE::Result::eSuccess) |
| { |
| throwResultException(result, VULKAN_HPP_NAMESPACE_STRING "::Buffer::bindMemory"); |
| } |
| } |
| |
| VULKAN_HPP_INLINE void Image::bindMemory(VULKAN_HPP_NAMESPACE::DeviceMemory memory, VULKAN_HPP_NAMESPACE::DeviceSize memoryOffset) const |
| { |
| VULKAN_HPP_NAMESPACE::Result result = |
| static_cast<VULKAN_HPP_NAMESPACE::Result>(getDispatcher()->vkBindImageMemory(static_cast<VkDevice>(m_device), |
| static_cast<VkImage>(m_image), |
| static_cast<VkDeviceMemory>(memory), |
| static_cast<VkDeviceSize>(memoryOffset))); |
| if(result != VULKAN_HPP_NAMESPACE::Result::eSuccess) |
| { |
| throwResultException(result, VULKAN_HPP_NAMESPACE_STRING "::Image::bindMemory"); |
| } |
| } |
| |
| VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE VULKAN_HPP_NAMESPACE::MemoryRequirements Buffer::getMemoryRequirements() const VULKAN_HPP_NOEXCEPT |
| { |
| VULKAN_HPP_NAMESPACE::MemoryRequirements memoryRequirements; |
| getDispatcher()->vkGetBufferMemoryRequirements( |
| static_cast<VkDevice>(m_device), static_cast<VkBuffer>(m_buffer), reinterpret_cast<VkMemoryRequirements *>(&memoryRequirements)); |
| return memoryRequirements; |
| } |
| |
| VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE VULKAN_HPP_NAMESPACE::MemoryRequirements Image::getMemoryRequirements() const VULKAN_HPP_NOEXCEPT |
| { |
| VULKAN_HPP_NAMESPACE::MemoryRequirements memoryRequirements; |
| getDispatcher()->vkGetImageMemoryRequirements( |
| static_cast<VkDevice>(m_device), static_cast<VkImage>(m_image), reinterpret_cast<VkMemoryRequirements *>(&memoryRequirements)); |
| return memoryRequirements; |
| } |
| |
| VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE std::vector<VULKAN_HPP_NAMESPACE::SparseImageMemoryRequirements> |
| Image::getSparseMemoryRequirements() const VULKAN_HPP_NOEXCEPT |
| { |
| uint32_t sparseMemoryRequirementCount; |
| getDispatcher()->vkGetImageSparseMemoryRequirements( |
| static_cast<VkDevice>(m_device), static_cast<VkImage>(m_image), &sparseMemoryRequirementCount, nullptr); |
| std::vector<VULKAN_HPP_NAMESPACE::SparseImageMemoryRequirements> sparseMemoryRequirements(sparseMemoryRequirementCount); |
| getDispatcher()->vkGetImageSparseMemoryRequirements(static_cast<VkDevice>(m_device), |
| static_cast<VkImage>(m_image), |
| &sparseMemoryRequirementCount, |
| reinterpret_cast<VkSparseImageMemoryRequirements *>(sparseMemoryRequirements.data())); |
| VULKAN_HPP_ASSERT(sparseMemoryRequirementCount == sparseMemoryRequirements.size()); |
| return sparseMemoryRequirements; |
| } |
| |
| VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE std::vector<VULKAN_HPP_NAMESPACE::SparseImageFormatProperties> |
| PhysicalDevice::getSparseImageFormatProperties(VULKAN_HPP_NAMESPACE::Format format, |
| VULKAN_HPP_NAMESPACE::ImageType type, |
| VULKAN_HPP_NAMESPACE::SampleCountFlagBits samples, |
| VULKAN_HPP_NAMESPACE::ImageUsageFlags usage, |
| VULKAN_HPP_NAMESPACE::ImageTiling tiling) const VULKAN_HPP_NOEXCEPT |
| { |
| uint32_t propertyCount; |
| getDispatcher()->vkGetPhysicalDeviceSparseImageFormatProperties(static_cast<VkPhysicalDevice>(m_physicalDevice), |
| static_cast<VkFormat>(format), |
| static_cast<VkImageType>(type), |
| static_cast<VkSampleCountFlagBits>(samples), |
| static_cast<VkImageUsageFlags>(usage), |
| static_cast<VkImageTiling>(tiling), |
| &propertyCount, |
| nullptr); |
| std::vector<VULKAN_HPP_NAMESPACE::SparseImageFormatProperties> properties(propertyCount); |
| getDispatcher()->vkGetPhysicalDeviceSparseImageFormatProperties(static_cast<VkPhysicalDevice>(m_physicalDevice), |
| static_cast<VkFormat>(format), |
| static_cast<VkImageType>(type), |
| static_cast<VkSampleCountFlagBits>(samples), |
| static_cast<VkImageUsageFlags>(usage), |
| static_cast<VkImageTiling>(tiling), |
| &propertyCount, |
| reinterpret_cast<VkSparseImageFormatProperties *>(properties.data())); |
| VULKAN_HPP_ASSERT(propertyCount == properties.size()); |
| return properties; |
| } |
| |
| VULKAN_HPP_INLINE void Queue::bindSparse(ArrayProxy<const VULKAN_HPP_NAMESPACE::BindSparseInfo> const &bindInfo, VULKAN_HPP_NAMESPACE::Fence fence) const |
| { |
| VULKAN_HPP_NAMESPACE::Result result = static_cast<VULKAN_HPP_NAMESPACE::Result>(getDispatcher()->vkQueueBindSparse( |
| static_cast<VkQueue>(m_queue), bindInfo.size(), reinterpret_cast<const VkBindSparseInfo *>(bindInfo.data()), static_cast<VkFence>(fence))); |
| if(result != VULKAN_HPP_NAMESPACE::Result::eSuccess) |
| { |
| throwResultException(result, VULKAN_HPP_NAMESPACE_STRING "::Queue::bindSparse"); |
| } |
| } |
| |
| VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE VULKAN_HPP_RAII_NAMESPACE::Fence |
| Device::createFence(VULKAN_HPP_NAMESPACE::FenceCreateInfo const &createInfo, |
| VULKAN_HPP_NAMESPACE::Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator) const |
| { |
| return VULKAN_HPP_RAII_NAMESPACE::Fence(*this, createInfo, allocator); |
| } |
| |
| VULKAN_HPP_INLINE void Device::resetFences(ArrayProxy<const VULKAN_HPP_NAMESPACE::Fence> const &fences) const |
| { |
| VULKAN_HPP_NAMESPACE::Result result = static_cast<VULKAN_HPP_NAMESPACE::Result>( |
| getDispatcher()->vkResetFences(static_cast<VkDevice>(m_device), fences.size(), reinterpret_cast<const VkFence *>(fences.data()))); |
| if(result != VULKAN_HPP_NAMESPACE::Result::eSuccess) |
| { |
| throwResultException(result, VULKAN_HPP_NAMESPACE_STRING "::Device::resetFences"); |
| } |
| } |
| |
| VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE VULKAN_HPP_NAMESPACE::Result Fence::getStatus() const |
| { |
| VULKAN_HPP_NAMESPACE::Result result = |
| static_cast<VULKAN_HPP_NAMESPACE::Result>(getDispatcher()->vkGetFenceStatus(static_cast<VkDevice>(m_device), static_cast<VkFence>(m_fence))); |
| if((result != VULKAN_HPP_NAMESPACE::Result::eSuccess) && (result != VULKAN_HPP_NAMESPACE::Result::eNotReady)) |
| { |
| throwResultException(result, VULKAN_HPP_NAMESPACE_STRING "::Fence::getStatus"); |
| } |
| return result; |
| } |
| |
| VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE VULKAN_HPP_NAMESPACE::Result |
| Device::waitForFences(ArrayProxy<const VULKAN_HPP_NAMESPACE::Fence> const &fences, VULKAN_HPP_NAMESPACE::Bool32 waitAll, uint64_t timeout) const |
| { |
| VULKAN_HPP_NAMESPACE::Result result = static_cast<VULKAN_HPP_NAMESPACE::Result>(getDispatcher()->vkWaitForFences( |
| static_cast<VkDevice>(m_device), fences.size(), reinterpret_cast<const VkFence *>(fences.data()), static_cast<VkBool32>(waitAll), timeout)); |
| if((result != VULKAN_HPP_NAMESPACE::Result::eSuccess) && (result != VULKAN_HPP_NAMESPACE::Result::eTimeout)) |
| { |
| throwResultException(result, VULKAN_HPP_NAMESPACE_STRING "::Device::waitForFences"); |
| } |
| return result; |
| } |
| |
| VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE VULKAN_HPP_RAII_NAMESPACE::Semaphore |
| Device::createSemaphore(VULKAN_HPP_NAMESPACE::SemaphoreCreateInfo const &createInfo, |
| VULKAN_HPP_NAMESPACE::Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator) const |
| { |
| return VULKAN_HPP_RAII_NAMESPACE::Semaphore(*this, createInfo, allocator); |
| } |
| |
| VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE VULKAN_HPP_RAII_NAMESPACE::Event |
| Device::createEvent(VULKAN_HPP_NAMESPACE::EventCreateInfo const &createInfo, |
| VULKAN_HPP_NAMESPACE::Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator) const |
| { |
| return VULKAN_HPP_RAII_NAMESPACE::Event(*this, createInfo, allocator); |
| } |
| |
| VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE VULKAN_HPP_NAMESPACE::Result Event::getStatus() const |
| { |
| VULKAN_HPP_NAMESPACE::Result result = |
| static_cast<VULKAN_HPP_NAMESPACE::Result>(getDispatcher()->vkGetEventStatus(static_cast<VkDevice>(m_device), static_cast<VkEvent>(m_event))); |
| if((result != VULKAN_HPP_NAMESPACE::Result::eEventSet) && (result != VULKAN_HPP_NAMESPACE::Result::eEventReset)) |
| { |
| throwResultException(result, VULKAN_HPP_NAMESPACE_STRING "::Event::getStatus"); |
| } |
| return result; |
| } |
| |
| VULKAN_HPP_INLINE void Event::set() const |
| { |
| VULKAN_HPP_NAMESPACE::Result result = |
| static_cast<VULKAN_HPP_NAMESPACE::Result>(getDispatcher()->vkSetEvent(static_cast<VkDevice>(m_device), static_cast<VkEvent>(m_event))); |
| if(result != VULKAN_HPP_NAMESPACE::Result::eSuccess) |
| { |
| throwResultException(result, VULKAN_HPP_NAMESPACE_STRING "::Event::set"); |
| } |
| } |
| |
| VULKAN_HPP_INLINE void Event::reset() const |
| { |
| VULKAN_HPP_NAMESPACE::Result result = |
| static_cast<VULKAN_HPP_NAMESPACE::Result>(getDispatcher()->vkResetEvent(static_cast<VkDevice>(m_device), static_cast<VkEvent>(m_event))); |
| if(result != VULKAN_HPP_NAMESPACE::Result::eSuccess) |
| { |
| throwResultException(result, VULKAN_HPP_NAMESPACE_STRING "::Event::reset"); |
| } |
| } |
| |
| VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE VULKAN_HPP_RAII_NAMESPACE::QueryPool |
| Device::createQueryPool(VULKAN_HPP_NAMESPACE::QueryPoolCreateInfo const &createInfo, |
| VULKAN_HPP_NAMESPACE::Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator) const |
| { |
| return VULKAN_HPP_RAII_NAMESPACE::QueryPool(*this, createInfo, allocator); |
| } |
| |
| template<typename DataType> |
| VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE std::pair<VULKAN_HPP_NAMESPACE::Result, std::vector<DataType>> QueryPool::getResults( |
| uint32_t firstQuery, uint32_t queryCount, size_t dataSize, VULKAN_HPP_NAMESPACE::DeviceSize stride, VULKAN_HPP_NAMESPACE::QueryResultFlags flags) const |
| { |
| VULKAN_HPP_ASSERT(dataSize % sizeof(DataType) == 0); |
| std::vector<DataType> data(dataSize / sizeof(DataType)); |
| Result result = static_cast<Result>(getDispatcher()->vkGetQueryPoolResults(static_cast<VkDevice>(m_device), |
| static_cast<VkQueryPool>(m_queryPool), |
| firstQuery, |
| queryCount, |
| data.size() * sizeof(DataType), |
| reinterpret_cast<void *>(data.data()), |
| static_cast<VkDeviceSize>(stride), |
| static_cast<VkQueryResultFlags>(flags))); |
| if((result != VULKAN_HPP_NAMESPACE::Result::eSuccess) && (result != VULKAN_HPP_NAMESPACE::Result::eNotReady)) |
| { |
| throwResultException(result, VULKAN_HPP_NAMESPACE_STRING "::QueryPool::getResults"); |
| } |
| return std::make_pair(result, data); |
| } |
| |
| template<typename DataType> |
| VULKAN_HPP_NODISCARD std::pair<VULKAN_HPP_NAMESPACE::Result, DataType> QueryPool::getResult(uint32_t firstQuery, |
| uint32_t queryCount, |
| VULKAN_HPP_NAMESPACE::DeviceSize stride, |
| VULKAN_HPP_NAMESPACE::QueryResultFlags flags) const |
| { |
| DataType data; |
| Result result = static_cast<Result>(getDispatcher()->vkGetQueryPoolResults(static_cast<VkDevice>(m_device), |
| static_cast<VkQueryPool>(m_queryPool), |
| firstQuery, |
| queryCount, |
| sizeof(DataType), |
| reinterpret_cast<void *>(&data), |
| static_cast<VkDeviceSize>(stride), |
| static_cast<VkQueryResultFlags>(flags))); |
| if((result != VULKAN_HPP_NAMESPACE::Result::eSuccess) && (result != VULKAN_HPP_NAMESPACE::Result::eNotReady)) |
| { |
| throwResultException(result, VULKAN_HPP_NAMESPACE_STRING "::QueryPool::getResult"); |
| } |
| return std::make_pair(result, data); |
| } |
| |
| VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE VULKAN_HPP_RAII_NAMESPACE::Buffer |
| Device::createBuffer(VULKAN_HPP_NAMESPACE::BufferCreateInfo const &createInfo, |
| VULKAN_HPP_NAMESPACE::Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator) const |
| { |
| return VULKAN_HPP_RAII_NAMESPACE::Buffer(*this, createInfo, allocator); |
| } |
| |
| VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE VULKAN_HPP_RAII_NAMESPACE::BufferView |
| Device::createBufferView(VULKAN_HPP_NAMESPACE::BufferViewCreateInfo const &createInfo, |
| VULKAN_HPP_NAMESPACE::Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator) const |
| { |
| return VULKAN_HPP_RAII_NAMESPACE::BufferView(*this, createInfo, allocator); |
| } |
| |
| VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE VULKAN_HPP_RAII_NAMESPACE::Image |
| Device::createImage(VULKAN_HPP_NAMESPACE::ImageCreateInfo const &createInfo, |
| VULKAN_HPP_NAMESPACE::Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator) const |
| { |
| return VULKAN_HPP_RAII_NAMESPACE::Image(*this, createInfo, allocator); |
| } |
| |
| VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE VULKAN_HPP_NAMESPACE::SubresourceLayout |
| Image::getSubresourceLayout(const VULKAN_HPP_NAMESPACE::ImageSubresource &subresource) const VULKAN_HPP_NOEXCEPT |
| { |
| VULKAN_HPP_NAMESPACE::SubresourceLayout layout; |
| getDispatcher()->vkGetImageSubresourceLayout(static_cast<VkDevice>(m_device), |
| static_cast<VkImage>(m_image), |
| reinterpret_cast<const VkImageSubresource *>(&subresource), |
| reinterpret_cast<VkSubresourceLayout *>(&layout)); |
| return layout; |
| } |
| |
| VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE VULKAN_HPP_RAII_NAMESPACE::ImageView |
| Device::createImageView(VULKAN_HPP_NAMESPACE::ImageViewCreateInfo const &createInfo, |
| VULKAN_HPP_NAMESPACE::Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator) const |
| { |
| return VULKAN_HPP_RAII_NAMESPACE::ImageView(*this, createInfo, allocator); |
| } |
| |
| VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE VULKAN_HPP_RAII_NAMESPACE::ShaderModule |
| Device::createShaderModule(VULKAN_HPP_NAMESPACE::ShaderModuleCreateInfo const &createInfo, |
| VULKAN_HPP_NAMESPACE::Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator) const |
| { |
| return VULKAN_HPP_RAII_NAMESPACE::ShaderModule(*this, createInfo, allocator); |
| } |
| |
| VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE VULKAN_HPP_RAII_NAMESPACE::PipelineCache |
| Device::createPipelineCache(VULKAN_HPP_NAMESPACE::PipelineCacheCreateInfo const &createInfo, |
| VULKAN_HPP_NAMESPACE::Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator) const |
| { |
| return VULKAN_HPP_RAII_NAMESPACE::PipelineCache(*this, createInfo, allocator); |
| } |
| |
| VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE std::vector<uint8_t> PipelineCache::getData() const |
| { |
| std::vector<uint8_t> data; |
| size_t dataSize; |
| VULKAN_HPP_NAMESPACE::Result result; |
| do |
| { |
| result = static_cast<VULKAN_HPP_NAMESPACE::Result>( |
| getDispatcher()->vkGetPipelineCacheData(static_cast<VkDevice>(m_device), static_cast<VkPipelineCache>(m_pipelineCache), &dataSize, nullptr)); |
| if((result == VULKAN_HPP_NAMESPACE::Result::eSuccess) && dataSize) |
| { |
| data.resize(dataSize); |
| result = static_cast<VULKAN_HPP_NAMESPACE::Result>(getDispatcher()->vkGetPipelineCacheData( |
| static_cast<VkDevice>(m_device), static_cast<VkPipelineCache>(m_pipelineCache), &dataSize, reinterpret_cast<void *>(data.data()))); |
| } |
| } while(result == VULKAN_HPP_NAMESPACE::Result::eIncomplete); |
| if(result != VULKAN_HPP_NAMESPACE::Result::eSuccess) |
| { |
| throwResultException(result, VULKAN_HPP_NAMESPACE_STRING "::PipelineCache::getData"); |
| } |
| if(result == VULKAN_HPP_NAMESPACE::Result::eSuccess) |
| { |
| VULKAN_HPP_ASSERT(dataSize <= data.size()); |
| if(dataSize < data.size()) |
| { |
| data.resize(dataSize); |
| } |
| } |
| return data; |
| } |
| |
| VULKAN_HPP_INLINE void PipelineCache::merge(ArrayProxy<const VULKAN_HPP_NAMESPACE::PipelineCache> const &srcCaches) const |
| { |
| VULKAN_HPP_NAMESPACE::Result result = |
| static_cast<VULKAN_HPP_NAMESPACE::Result>(getDispatcher()->vkMergePipelineCaches(static_cast<VkDevice>(m_device), |
| static_cast<VkPipelineCache>(m_pipelineCache), |
| srcCaches.size(), |
| reinterpret_cast<const VkPipelineCache *>(srcCaches.data()))); |
| if(result != VULKAN_HPP_NAMESPACE::Result::eSuccess) |
| { |
| throwResultException(result, VULKAN_HPP_NAMESPACE_STRING "::PipelineCache::merge"); |
| } |
| } |
| |
| VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE std::vector<VULKAN_HPP_RAII_NAMESPACE::Pipeline> Device::createGraphicsPipelines( |
| VULKAN_HPP_NAMESPACE::Optional<const VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::PipelineCache> const &pipelineCache, |
| VULKAN_HPP_NAMESPACE::ArrayProxy<VULKAN_HPP_NAMESPACE::GraphicsPipelineCreateInfo> const &createInfos, |
| VULKAN_HPP_NAMESPACE::Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator) const |
| { |
| return VULKAN_HPP_RAII_NAMESPACE::Pipelines(*this, pipelineCache, createInfos, allocator); |
| } |
| |
| VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE VULKAN_HPP_RAII_NAMESPACE::Pipeline Device::createGraphicsPipeline( |
| VULKAN_HPP_NAMESPACE::Optional<const VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::PipelineCache> const &pipelineCache, |
| VULKAN_HPP_NAMESPACE::GraphicsPipelineCreateInfo const &createInfo, |
| VULKAN_HPP_NAMESPACE::Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator) const |
| { |
| return VULKAN_HPP_RAII_NAMESPACE::Pipeline(*this, pipelineCache, createInfo, allocator); |
| } |
| |
| VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE std::vector<VULKAN_HPP_RAII_NAMESPACE::Pipeline> Device::createComputePipelines( |
| VULKAN_HPP_NAMESPACE::Optional<const VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::PipelineCache> const &pipelineCache, |
| VULKAN_HPP_NAMESPACE::ArrayProxy<VULKAN_HPP_NAMESPACE::ComputePipelineCreateInfo> const &createInfos, |
| VULKAN_HPP_NAMESPACE::Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator) const |
| { |
| return VULKAN_HPP_RAII_NAMESPACE::Pipelines(*this, pipelineCache, createInfos, allocator); |
| } |
| |
| VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE VULKAN_HPP_RAII_NAMESPACE::Pipeline |
| Device::createComputePipeline(VULKAN_HPP_NAMESPACE::Optional<const VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::PipelineCache> const &pipelineCache, |
| VULKAN_HPP_NAMESPACE::ComputePipelineCreateInfo const &createInfo, |
| VULKAN_HPP_NAMESPACE::Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator) const |
| { |
| return VULKAN_HPP_RAII_NAMESPACE::Pipeline(*this, pipelineCache, createInfo, allocator); |
| } |
| |
| VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE VULKAN_HPP_RAII_NAMESPACE::PipelineLayout |
| Device::createPipelineLayout(VULKAN_HPP_NAMESPACE::PipelineLayoutCreateInfo const &createInfo, |
| VULKAN_HPP_NAMESPACE::Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator) const |
| { |
| return VULKAN_HPP_RAII_NAMESPACE::PipelineLayout(*this, createInfo, allocator); |
| } |
| |
| VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE VULKAN_HPP_RAII_NAMESPACE::Sampler |
| Device::createSampler(VULKAN_HPP_NAMESPACE::SamplerCreateInfo const &createInfo, |
| VULKAN_HPP_NAMESPACE::Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator) const |
| { |
| return VULKAN_HPP_RAII_NAMESPACE::Sampler(*this, createInfo, allocator); |
| } |
| |
| VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE VULKAN_HPP_RAII_NAMESPACE::DescriptorSetLayout |
| Device::createDescriptorSetLayout(VULKAN_HPP_NAMESPACE::DescriptorSetLayoutCreateInfo const &createInfo, |
| VULKAN_HPP_NAMESPACE::Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator) const |
| { |
| return VULKAN_HPP_RAII_NAMESPACE::DescriptorSetLayout(*this, createInfo, allocator); |
| } |
| |
| VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE VULKAN_HPP_RAII_NAMESPACE::DescriptorPool |
| Device::createDescriptorPool(VULKAN_HPP_NAMESPACE::DescriptorPoolCreateInfo const &createInfo, |
| VULKAN_HPP_NAMESPACE::Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator) const |
| { |
| return VULKAN_HPP_RAII_NAMESPACE::DescriptorPool(*this, createInfo, allocator); |
| } |
| |
| VULKAN_HPP_INLINE void DescriptorPool::reset(VULKAN_HPP_NAMESPACE::DescriptorPoolResetFlags flags) const VULKAN_HPP_NOEXCEPT |
| { |
| getDispatcher()->vkResetDescriptorPool( |
| static_cast<VkDevice>(m_device), static_cast<VkDescriptorPool>(m_descriptorPool), static_cast<VkDescriptorPoolResetFlags>(flags)); |
| } |
| |
| VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE std::vector<VULKAN_HPP_RAII_NAMESPACE::DescriptorSet> |
| Device::allocateDescriptorSets(VULKAN_HPP_NAMESPACE::DescriptorSetAllocateInfo const &allocateInfo) const |
| { |
| return VULKAN_HPP_RAII_NAMESPACE::DescriptorSets(*this, allocateInfo); |
| } |
| |
| VULKAN_HPP_INLINE void |
| Device::updateDescriptorSets(ArrayProxy<const VULKAN_HPP_NAMESPACE::WriteDescriptorSet> const &descriptorWrites, |
| ArrayProxy<const VULKAN_HPP_NAMESPACE::CopyDescriptorSet> const &descriptorCopies) const VULKAN_HPP_NOEXCEPT |
| { |
| getDispatcher()->vkUpdateDescriptorSets(static_cast<VkDevice>(m_device), |
| descriptorWrites.size(), |
| reinterpret_cast<const VkWriteDescriptorSet *>(descriptorWrites.data()), |
| descriptorCopies.size(), |
| reinterpret_cast<const VkCopyDescriptorSet *>(descriptorCopies.data())); |
| } |
| |
| VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE VULKAN_HPP_RAII_NAMESPACE::Framebuffer |
| Device::createFramebuffer(VULKAN_HPP_NAMESPACE::FramebufferCreateInfo const &createInfo, |
| VULKAN_HPP_NAMESPACE::Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator) const |
| { |
| return VULKAN_HPP_RAII_NAMESPACE::Framebuffer(*this, createInfo, allocator); |
| } |
| |
| VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE VULKAN_HPP_RAII_NAMESPACE::RenderPass |
| Device::createRenderPass(VULKAN_HPP_NAMESPACE::RenderPassCreateInfo const &createInfo, |
| VULKAN_HPP_NAMESPACE::Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator) const |
| { |
| return VULKAN_HPP_RAII_NAMESPACE::RenderPass(*this, createInfo, allocator); |
| } |
| |
| VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE VULKAN_HPP_NAMESPACE::Extent2D RenderPass::getRenderAreaGranularity() const VULKAN_HPP_NOEXCEPT |
| { |
| VULKAN_HPP_NAMESPACE::Extent2D granularity; |
| getDispatcher()->vkGetRenderAreaGranularity( |
| static_cast<VkDevice>(m_device), static_cast<VkRenderPass>(m_renderPass), reinterpret_cast<VkExtent2D *>(&granularity)); |
| return granularity; |
| } |
| |
| VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE VULKAN_HPP_RAII_NAMESPACE::CommandPool |
| Device::createCommandPool(VULKAN_HPP_NAMESPACE::CommandPoolCreateInfo const &createInfo, |
| VULKAN_HPP_NAMESPACE::Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator) const |
| { |
| return VULKAN_HPP_RAII_NAMESPACE::CommandPool(*this, createInfo, allocator); |
| } |
| |
| VULKAN_HPP_INLINE void CommandPool::reset(VULKAN_HPP_NAMESPACE::CommandPoolResetFlags flags) const |
| { |
| VULKAN_HPP_NAMESPACE::Result result = static_cast<VULKAN_HPP_NAMESPACE::Result>(getDispatcher()->vkResetCommandPool( |
| static_cast<VkDevice>(m_device), static_cast<VkCommandPool>(m_commandPool), static_cast<VkCommandPoolResetFlags>(flags))); |
| if(result != VULKAN_HPP_NAMESPACE::Result::eSuccess) |
| { |
| throwResultException(result, VULKAN_HPP_NAMESPACE_STRING "::CommandPool::reset"); |
| } |
| } |
| |
| VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE std::vector<VULKAN_HPP_RAII_NAMESPACE::CommandBuffer> |
| Device::allocateCommandBuffers(VULKAN_HPP_NAMESPACE::CommandBufferAllocateInfo const &allocateInfo) const |
| { |
| return VULKAN_HPP_RAII_NAMESPACE::CommandBuffers(*this, allocateInfo); |
| } |
| |
| VULKAN_HPP_INLINE void CommandBuffer::begin(const VULKAN_HPP_NAMESPACE::CommandBufferBeginInfo &beginInfo) const |
| { |
| VULKAN_HPP_NAMESPACE::Result result = static_cast<VULKAN_HPP_NAMESPACE::Result>(getDispatcher()->vkBeginCommandBuffer( |
| static_cast<VkCommandBuffer>(m_commandBuffer), reinterpret_cast<const VkCommandBufferBeginInfo *>(&beginInfo))); |
| if(result != VULKAN_HPP_NAMESPACE::Result::eSuccess) |
| { |
| throwResultException(result, VULKAN_HPP_NAMESPACE_STRING "::CommandBuffer::begin"); |
| } |
| } |
| |
| VULKAN_HPP_INLINE void CommandBuffer::end() const |
| { |
| VULKAN_HPP_NAMESPACE::Result result = |
| static_cast<VULKAN_HPP_NAMESPACE::Result>(getDispatcher()->vkEndCommandBuffer(static_cast<VkCommandBuffer>(m_commandBuffer))); |
| if(result != VULKAN_HPP_NAMESPACE::Result::eSuccess) |
| { |
| throwResultException(result, VULKAN_HPP_NAMESPACE_STRING "::CommandBuffer::end"); |
| } |
| } |
| |
| VULKAN_HPP_INLINE void CommandBuffer::reset(VULKAN_HPP_NAMESPACE::CommandBufferResetFlags flags) const |
| { |
| VULKAN_HPP_NAMESPACE::Result result = static_cast<VULKAN_HPP_NAMESPACE::Result>( |
| getDispatcher()->vkResetCommandBuffer(static_cast<VkCommandBuffer>(m_commandBuffer), static_cast<VkCommandBufferResetFlags>(flags))); |
| if(result != VULKAN_HPP_NAMESPACE::Result::eSuccess) |
| { |
| throwResultException(result, VULKAN_HPP_NAMESPACE_STRING "::CommandBuffer::reset"); |
| } |
| } |
| |
| VULKAN_HPP_INLINE void CommandBuffer::bindPipeline(VULKAN_HPP_NAMESPACE::PipelineBindPoint pipelineBindPoint, |
| VULKAN_HPP_NAMESPACE::Pipeline pipeline) const VULKAN_HPP_NOEXCEPT |
| { |
| getDispatcher()->vkCmdBindPipeline( |
| static_cast<VkCommandBuffer>(m_commandBuffer), static_cast<VkPipelineBindPoint>(pipelineBindPoint), static_cast<VkPipeline>(pipeline)); |
| } |
| |
| VULKAN_HPP_INLINE void CommandBuffer::setViewport(uint32_t firstViewport, |
| ArrayProxy<const VULKAN_HPP_NAMESPACE::Viewport> const &viewports) const VULKAN_HPP_NOEXCEPT |
| { |
| getDispatcher()->vkCmdSetViewport( |
| static_cast<VkCommandBuffer>(m_commandBuffer), firstViewport, viewports.size(), reinterpret_cast<const VkViewport *>(viewports.data())); |
| } |
| |
| VULKAN_HPP_INLINE void CommandBuffer::setScissor(uint32_t firstScissor, |
| ArrayProxy<const VULKAN_HPP_NAMESPACE::Rect2D> const &scissors) const VULKAN_HPP_NOEXCEPT |
| { |
| getDispatcher()->vkCmdSetScissor( |
| static_cast<VkCommandBuffer>(m_commandBuffer), firstScissor, scissors.size(), reinterpret_cast<const VkRect2D *>(scissors.data())); |
| } |
| |
| VULKAN_HPP_INLINE void CommandBuffer::setLineWidth(float lineWidth) const VULKAN_HPP_NOEXCEPT |
| { |
| getDispatcher()->vkCmdSetLineWidth(static_cast<VkCommandBuffer>(m_commandBuffer), lineWidth); |
| } |
| |
| VULKAN_HPP_INLINE void |
| CommandBuffer::setDepthBias(float depthBiasConstantFactor, float depthBiasClamp, float depthBiasSlopeFactor) const VULKAN_HPP_NOEXCEPT |
| { |
| getDispatcher()->vkCmdSetDepthBias(static_cast<VkCommandBuffer>(m_commandBuffer), depthBiasConstantFactor, depthBiasClamp, depthBiasSlopeFactor); |
| } |
| |
| VULKAN_HPP_INLINE void CommandBuffer::setBlendConstants(const float blendConstants[4]) const VULKAN_HPP_NOEXCEPT |
| { |
| getDispatcher()->vkCmdSetBlendConstants(static_cast<VkCommandBuffer>(m_commandBuffer), blendConstants); |
| } |
| |
| VULKAN_HPP_INLINE void CommandBuffer::setDepthBounds(float minDepthBounds, float maxDepthBounds) const VULKAN_HPP_NOEXCEPT |
| { |
| getDispatcher()->vkCmdSetDepthBounds(static_cast<VkCommandBuffer>(m_commandBuffer), minDepthBounds, maxDepthBounds); |
| } |
| |
| VULKAN_HPP_INLINE void CommandBuffer::setStencilCompareMask(VULKAN_HPP_NAMESPACE::StencilFaceFlags faceMask, |
| uint32_t compareMask) const VULKAN_HPP_NOEXCEPT |
| { |
| getDispatcher()->vkCmdSetStencilCompareMask(static_cast<VkCommandBuffer>(m_commandBuffer), static_cast<VkStencilFaceFlags>(faceMask), compareMask); |
| } |
| |
| VULKAN_HPP_INLINE void CommandBuffer::setStencilWriteMask(VULKAN_HPP_NAMESPACE::StencilFaceFlags faceMask, uint32_t writeMask) const VULKAN_HPP_NOEXCEPT |
| { |
| getDispatcher()->vkCmdSetStencilWriteMask(static_cast<VkCommandBuffer>(m_commandBuffer), static_cast<VkStencilFaceFlags>(faceMask), writeMask); |
| } |
| |
| VULKAN_HPP_INLINE void CommandBuffer::setStencilReference(VULKAN_HPP_NAMESPACE::StencilFaceFlags faceMask, uint32_t reference) const VULKAN_HPP_NOEXCEPT |
| { |
| getDispatcher()->vkCmdSetStencilReference(static_cast<VkCommandBuffer>(m_commandBuffer), static_cast<VkStencilFaceFlags>(faceMask), reference); |
| } |
| |
| VULKAN_HPP_INLINE void CommandBuffer::bindDescriptorSets(VULKAN_HPP_NAMESPACE::PipelineBindPoint pipelineBindPoint, |
| VULKAN_HPP_NAMESPACE::PipelineLayout layout, |
| uint32_t firstSet, |
| ArrayProxy<const VULKAN_HPP_NAMESPACE::DescriptorSet> const &descriptorSets, |
| ArrayProxy<const uint32_t> const &dynamicOffsets) const VULKAN_HPP_NOEXCEPT |
| { |
| getDispatcher()->vkCmdBindDescriptorSets(static_cast<VkCommandBuffer>(m_commandBuffer), |
| static_cast<VkPipelineBindPoint>(pipelineBindPoint), |
| static_cast<VkPipelineLayout>(layout), |
| firstSet, |
| descriptorSets.size(), |
| reinterpret_cast<const VkDescriptorSet *>(descriptorSets.data()), |
| dynamicOffsets.size(), |
| dynamicOffsets.data()); |
| } |
| |
| VULKAN_HPP_INLINE void CommandBuffer::bindIndexBuffer(VULKAN_HPP_NAMESPACE::Buffer buffer, |
| VULKAN_HPP_NAMESPACE::DeviceSize offset, |
| VULKAN_HPP_NAMESPACE::IndexType indexType) const VULKAN_HPP_NOEXCEPT |
| { |
| getDispatcher()->vkCmdBindIndexBuffer(static_cast<VkCommandBuffer>(m_commandBuffer), |
| static_cast<VkBuffer>(buffer), |
| static_cast<VkDeviceSize>(offset), |
| static_cast<VkIndexType>(indexType)); |
| } |
| |
| VULKAN_HPP_INLINE void CommandBuffer::bindVertexBuffers(uint32_t firstBinding, |
| ArrayProxy<const VULKAN_HPP_NAMESPACE::Buffer> const &buffers, |
| ArrayProxy<const VULKAN_HPP_NAMESPACE::DeviceSize> const &offsets) const |
| { |
| if(buffers.size() != offsets.size()) |
| { |
| throw LogicError(VULKAN_HPP_NAMESPACE_STRING "::CommandBuffer::bindVertexBuffers: buffers.size() != offsets.size()"); |
| } |
| getDispatcher()->vkCmdBindVertexBuffers(static_cast<VkCommandBuffer>(m_commandBuffer), |
| firstBinding, |
| buffers.size(), |
| reinterpret_cast<const VkBuffer *>(buffers.data()), |
| reinterpret_cast<const VkDeviceSize *>(offsets.data())); |
| } |
| |
| VULKAN_HPP_INLINE void |
| CommandBuffer::draw(uint32_t vertexCount, uint32_t instanceCount, uint32_t firstVertex, uint32_t firstInstance) const VULKAN_HPP_NOEXCEPT |
| { |
| getDispatcher()->vkCmdDraw(static_cast<VkCommandBuffer>(m_commandBuffer), vertexCount, instanceCount, firstVertex, firstInstance); |
| } |
| |
| VULKAN_HPP_INLINE void CommandBuffer::drawIndexed( |
| uint32_t indexCount, uint32_t instanceCount, uint32_t firstIndex, int32_t vertexOffset, uint32_t firstInstance) const VULKAN_HPP_NOEXCEPT |
| { |
| getDispatcher()->vkCmdDrawIndexed(static_cast<VkCommandBuffer>(m_commandBuffer), indexCount, instanceCount, firstIndex, vertexOffset, firstInstance); |
| } |
| |
| VULKAN_HPP_INLINE void CommandBuffer::drawIndirect(VULKAN_HPP_NAMESPACE::Buffer buffer, |
| VULKAN_HPP_NAMESPACE::DeviceSize offset, |
| uint32_t drawCount, |
| uint32_t stride) const VULKAN_HPP_NOEXCEPT |
| { |
| getDispatcher()->vkCmdDrawIndirect( |
| static_cast<VkCommandBuffer>(m_commandBuffer), static_cast<VkBuffer>(buffer), static_cast<VkDeviceSize>(offset), drawCount, stride); |
| } |
| |
| VULKAN_HPP_INLINE void CommandBuffer::drawIndexedIndirect(VULKAN_HPP_NAMESPACE::Buffer buffer, |
| VULKAN_HPP_NAMESPACE::DeviceSize offset, |
| uint32_t drawCount, |
| uint32_t stride) const VULKAN_HPP_NOEXCEPT |
| { |
| getDispatcher()->vkCmdDrawIndexedIndirect( |
| static_cast<VkCommandBuffer>(m_commandBuffer), static_cast<VkBuffer>(buffer), static_cast<VkDeviceSize>(offset), drawCount, stride); |
| } |
| |
| VULKAN_HPP_INLINE void CommandBuffer::dispatch(uint32_t groupCountX, uint32_t groupCountY, uint32_t groupCountZ) const VULKAN_HPP_NOEXCEPT |
| { |
| getDispatcher()->vkCmdDispatch(static_cast<VkCommandBuffer>(m_commandBuffer), groupCountX, groupCountY, groupCountZ); |
| } |
| |
| VULKAN_HPP_INLINE void CommandBuffer::dispatchIndirect(VULKAN_HPP_NAMESPACE::Buffer buffer, |
| VULKAN_HPP_NAMESPACE::DeviceSize offset) const VULKAN_HPP_NOEXCEPT |
| { |
| getDispatcher()->vkCmdDispatchIndirect( |
| static_cast<VkCommandBuffer>(m_commandBuffer), static_cast<VkBuffer>(buffer), static_cast<VkDeviceSize>(offset)); |
| } |
| |
| VULKAN_HPP_INLINE void CommandBuffer::copyBuffer(VULKAN_HPP_NAMESPACE::Buffer srcBuffer, |
| VULKAN_HPP_NAMESPACE::Buffer dstBuffer, |
| ArrayProxy<const VULKAN_HPP_NAMESPACE::BufferCopy> const ®ions) const VULKAN_HPP_NOEXCEPT |
| { |
| getDispatcher()->vkCmdCopyBuffer(static_cast<VkCommandBuffer>(m_commandBuffer), |
| static_cast<VkBuffer>(srcBuffer), |
| static_cast<VkBuffer>(dstBuffer), |
| regions.size(), |
| reinterpret_cast<const VkBufferCopy *>(regions.data())); |
| } |
| |
| VULKAN_HPP_INLINE void CommandBuffer::copyImage(VULKAN_HPP_NAMESPACE::Image srcImage, |
| VULKAN_HPP_NAMESPACE::ImageLayout srcImageLayout, |
| VULKAN_HPP_NAMESPACE::Image dstImage, |
| VULKAN_HPP_NAMESPACE::ImageLayout dstImageLayout, |
| ArrayProxy<const VULKAN_HPP_NAMESPACE::ImageCopy> const ®ions) const VULKAN_HPP_NOEXCEPT |
| { |
| getDispatcher()->vkCmdCopyImage(static_cast<VkCommandBuffer>(m_commandBuffer), |
| static_cast<VkImage>(srcImage), |
| static_cast<VkImageLayout>(srcImageLayout), |
| static_cast<VkImage>(dstImage), |
| static_cast<VkImageLayout>(dstImageLayout), |
| regions.size(), |
| reinterpret_cast<const VkImageCopy *>(regions.data())); |
| } |
| |
| VULKAN_HPP_INLINE void CommandBuffer::blitImage(VULKAN_HPP_NAMESPACE::Image srcImage, |
| VULKAN_HPP_NAMESPACE::ImageLayout srcImageLayout, |
| VULKAN_HPP_NAMESPACE::Image dstImage, |
| VULKAN_HPP_NAMESPACE::ImageLayout dstImageLayout, |
| ArrayProxy<const VULKAN_HPP_NAMESPACE::ImageBlit> const ®ions, |
| VULKAN_HPP_NAMESPACE::Filter filter) const VULKAN_HPP_NOEXCEPT |
| { |
| getDispatcher()->vkCmdBlitImage(static_cast<VkCommandBuffer>(m_commandBuffer), |
| static_cast<VkImage>(srcImage), |
| static_cast<VkImageLayout>(srcImageLayout), |
| static_cast<VkImage>(dstImage), |
| static_cast<VkImageLayout>(dstImageLayout), |
| regions.size(), |
| reinterpret_cast<const VkImageBlit *>(regions.data()), |
| static_cast<VkFilter>(filter)); |
| } |
| |
| VULKAN_HPP_INLINE void CommandBuffer::copyBufferToImage(VULKAN_HPP_NAMESPACE::Buffer srcBuffer, |
| VULKAN_HPP_NAMESPACE::Image dstImage, |
| VULKAN_HPP_NAMESPACE::ImageLayout dstImageLayout, |
| ArrayProxy<const VULKAN_HPP_NAMESPACE::BufferImageCopy> const ®ions) const VULKAN_HPP_NOEXCEPT |
| { |
| getDispatcher()->vkCmdCopyBufferToImage(static_cast<VkCommandBuffer>(m_commandBuffer), |
| static_cast<VkBuffer>(srcBuffer), |
| static_cast<VkImage>(dstImage), |
| static_cast<VkImageLayout>(dstImageLayout), |
| regions.size(), |
| reinterpret_cast<const VkBufferImageCopy *>(regions.data())); |
| } |
| |
| VULKAN_HPP_INLINE void CommandBuffer::copyImageToBuffer(VULKAN_HPP_NAMESPACE::Image srcImage, |
| VULKAN_HPP_NAMESPACE::ImageLayout srcImageLayout, |
| VULKAN_HPP_NAMESPACE::Buffer dstBuffer, |
| ArrayProxy<const VULKAN_HPP_NAMESPACE::BufferImageCopy> const ®ions) const VULKAN_HPP_NOEXCEPT |
| { |
| getDispatcher()->vkCmdCopyImageToBuffer(static_cast<VkCommandBuffer>(m_commandBuffer), |
| static_cast<VkImage>(srcImage), |
| static_cast<VkImageLayout>(srcImageLayout), |
| static_cast<VkBuffer>(dstBuffer), |
| regions.size(), |
| reinterpret_cast<const VkBufferImageCopy *>(regions.data())); |
| } |
| |
| template<typename DataType> |
| VULKAN_HPP_INLINE void CommandBuffer::updateBuffer(VULKAN_HPP_NAMESPACE::Buffer dstBuffer, |
| VULKAN_HPP_NAMESPACE::DeviceSize dstOffset, |
| ArrayProxy<const DataType> const &data) const VULKAN_HPP_NOEXCEPT |
| { |
| getDispatcher()->vkCmdUpdateBuffer(static_cast<VkCommandBuffer>(m_commandBuffer), |
| static_cast<VkBuffer>(dstBuffer), |
| static_cast<VkDeviceSize>(dstOffset), |
| data.size() * sizeof(DataType), |
| reinterpret_cast<const void *>(data.data())); |
| } |
| |
| VULKAN_HPP_INLINE void CommandBuffer::fillBuffer(VULKAN_HPP_NAMESPACE::Buffer dstBuffer, |
| VULKAN_HPP_NAMESPACE::DeviceSize dstOffset, |
| VULKAN_HPP_NAMESPACE::DeviceSize size, |
| uint32_t data) const VULKAN_HPP_NOEXCEPT |
| { |
| getDispatcher()->vkCmdFillBuffer(static_cast<VkCommandBuffer>(m_commandBuffer), |
| static_cast<VkBuffer>(dstBuffer), |
| static_cast<VkDeviceSize>(dstOffset), |
| static_cast<VkDeviceSize>(size), |
| data); |
| } |
| |
| VULKAN_HPP_INLINE void |
| CommandBuffer::clearColorImage(VULKAN_HPP_NAMESPACE::Image image, |
| VULKAN_HPP_NAMESPACE::ImageLayout imageLayout, |
| const VULKAN_HPP_NAMESPACE::ClearColorValue &color, |
| ArrayProxy<const VULKAN_HPP_NAMESPACE::ImageSubresourceRange> const &ranges) const VULKAN_HPP_NOEXCEPT |
| { |
| getDispatcher()->vkCmdClearColorImage(static_cast<VkCommandBuffer>(m_commandBuffer), |
| static_cast<VkImage>(image), |
| static_cast<VkImageLayout>(imageLayout), |
| reinterpret_cast<const VkClearColorValue *>(&color), |
| ranges.size(), |
| reinterpret_cast<const VkImageSubresourceRange *>(ranges.data())); |
| } |
| |
| VULKAN_HPP_INLINE void |
| CommandBuffer::clearDepthStencilImage(VULKAN_HPP_NAMESPACE::Image image, |
| VULKAN_HPP_NAMESPACE::ImageLayout imageLayout, |
| const VULKAN_HPP_NAMESPACE::ClearDepthStencilValue &depthStencil, |
| ArrayProxy<const VULKAN_HPP_NAMESPACE::ImageSubresourceRange> const &ranges) const VULKAN_HPP_NOEXCEPT |
| { |
| getDispatcher()->vkCmdClearDepthStencilImage(static_cast<VkCommandBuffer>(m_commandBuffer), |
| static_cast<VkImage>(image), |
| static_cast<VkImageLayout>(imageLayout), |
| reinterpret_cast<const VkClearDepthStencilValue *>(&depthStencil), |
| ranges.size(), |
| reinterpret_cast<const VkImageSubresourceRange *>(ranges.data())); |
| } |
| |
| VULKAN_HPP_INLINE void CommandBuffer::clearAttachments(ArrayProxy<const VULKAN_HPP_NAMESPACE::ClearAttachment> const &attachments, |
| ArrayProxy<const VULKAN_HPP_NAMESPACE::ClearRect> const &rects) const VULKAN_HPP_NOEXCEPT |
| { |
| getDispatcher()->vkCmdClearAttachments(static_cast<VkCommandBuffer>(m_commandBuffer), |
| attachments.size(), |
| reinterpret_cast<const VkClearAttachment *>(attachments.data()), |
| rects.size(), |
| reinterpret_cast<const VkClearRect *>(rects.data())); |
| } |
| |
| VULKAN_HPP_INLINE void CommandBuffer::resolveImage(VULKAN_HPP_NAMESPACE::Image srcImage, |
| VULKAN_HPP_NAMESPACE::ImageLayout srcImageLayout, |
| VULKAN_HPP_NAMESPACE::Image dstImage, |
| VULKAN_HPP_NAMESPACE::ImageLayout dstImageLayout, |
| ArrayProxy<const VULKAN_HPP_NAMESPACE::ImageResolve> const ®ions) const VULKAN_HPP_NOEXCEPT |
| { |
| getDispatcher()->vkCmdResolveImage(static_cast<VkCommandBuffer>(m_commandBuffer), |
| static_cast<VkImage>(srcImage), |
| static_cast<VkImageLayout>(srcImageLayout), |
| static_cast<VkImage>(dstImage), |
| static_cast<VkImageLayout>(dstImageLayout), |
| regions.size(), |
| reinterpret_cast<const VkImageResolve *>(regions.data())); |
| } |
| |
| VULKAN_HPP_INLINE void CommandBuffer::setEvent(VULKAN_HPP_NAMESPACE::Event event, |
| VULKAN_HPP_NAMESPACE::PipelineStageFlags stageMask) const VULKAN_HPP_NOEXCEPT |
| { |
| getDispatcher()->vkCmdSetEvent( |
| static_cast<VkCommandBuffer>(m_commandBuffer), static_cast<VkEvent>(event), static_cast<VkPipelineStageFlags>(stageMask)); |
| } |
| |
| VULKAN_HPP_INLINE void CommandBuffer::resetEvent(VULKAN_HPP_NAMESPACE::Event event, |
| VULKAN_HPP_NAMESPACE::PipelineStageFlags stageMask) const VULKAN_HPP_NOEXCEPT |
| { |
| getDispatcher()->vkCmdResetEvent( |
| static_cast<VkCommandBuffer>(m_commandBuffer), static_cast<VkEvent>(event), static_cast<VkPipelineStageFlags>(stageMask)); |
| } |
| |
| VULKAN_HPP_INLINE void |
| CommandBuffer::waitEvents(ArrayProxy<const VULKAN_HPP_NAMESPACE::Event> const &events, |
| VULKAN_HPP_NAMESPACE::PipelineStageFlags srcStageMask, |
| VULKAN_HPP_NAMESPACE::PipelineStageFlags dstStageMask, |
| ArrayProxy<const VULKAN_HPP_NAMESPACE::MemoryBarrier> const &memoryBarriers, |
| ArrayProxy<const VULKAN_HPP_NAMESPACE::BufferMemoryBarrier> const &bufferMemoryBarriers, |
| ArrayProxy<const VULKAN_HPP_NAMESPACE::ImageMemoryBarrier> const &imageMemoryBarriers) const VULKAN_HPP_NOEXCEPT |
| { |
| getDispatcher()->vkCmdWaitEvents(static_cast<VkCommandBuffer>(m_commandBuffer), |
| events.size(), |
| reinterpret_cast<const VkEvent *>(events.data()), |
| static_cast<VkPipelineStageFlags>(srcStageMask), |
| static_cast<VkPipelineStageFlags>(dstStageMask), |
| memoryBarriers.size(), |
| reinterpret_cast<const VkMemoryBarrier *>(memoryBarriers.data()), |
| bufferMemoryBarriers.size(), |
| reinterpret_cast<const VkBufferMemoryBarrier *>(bufferMemoryBarriers.data()), |
| imageMemoryBarriers.size(), |
| reinterpret_cast<const VkImageMemoryBarrier *>(imageMemoryBarriers.data())); |
| } |
| |
| VULKAN_HPP_INLINE void |
| CommandBuffer::pipelineBarrier(VULKAN_HPP_NAMESPACE::PipelineStageFlags srcStageMask, |
| VULKAN_HPP_NAMESPACE::PipelineStageFlags dstStageMask, |
| VULKAN_HPP_NAMESPACE::DependencyFlags dependencyFlags, |
| ArrayProxy<const VULKAN_HPP_NAMESPACE::MemoryBarrier> const &memoryBarriers, |
| ArrayProxy<const VULKAN_HPP_NAMESPACE::BufferMemoryBarrier> const &bufferMemoryBarriers, |
| ArrayProxy<const VULKAN_HPP_NAMESPACE::ImageMemoryBarrier> const &imageMemoryBarriers) const VULKAN_HPP_NOEXCEPT |
| { |
| getDispatcher()->vkCmdPipelineBarrier(static_cast<VkCommandBuffer>(m_commandBuffer), |
| static_cast<VkPipelineStageFlags>(srcStageMask), |
| static_cast<VkPipelineStageFlags>(dstStageMask), |
| static_cast<VkDependencyFlags>(dependencyFlags), |
| memoryBarriers.size(), |
| reinterpret_cast<const VkMemoryBarrier *>(memoryBarriers.data()), |
| bufferMemoryBarriers.size(), |
| reinterpret_cast<const VkBufferMemoryBarrier *>(bufferMemoryBarriers.data()), |
| imageMemoryBarriers.size(), |
| reinterpret_cast<const VkImageMemoryBarrier *>(imageMemoryBarriers.data())); |
| } |
| |
| VULKAN_HPP_INLINE void CommandBuffer::beginQuery(VULKAN_HPP_NAMESPACE::QueryPool queryPool, |
| uint32_t query, |
| VULKAN_HPP_NAMESPACE::QueryControlFlags flags) const VULKAN_HPP_NOEXCEPT |
| { |
| getDispatcher()->vkCmdBeginQuery( |
| static_cast<VkCommandBuffer>(m_commandBuffer), static_cast<VkQueryPool>(queryPool), query, static_cast<VkQueryControlFlags>(flags)); |
| } |
| |
| VULKAN_HPP_INLINE void CommandBuffer::endQuery(VULKAN_HPP_NAMESPACE::QueryPool queryPool, uint32_t query) const VULKAN_HPP_NOEXCEPT |
| { |
| getDispatcher()->vkCmdEndQuery(static_cast<VkCommandBuffer>(m_commandBuffer), static_cast<VkQueryPool>(queryPool), query); |
| } |
| |
| VULKAN_HPP_INLINE void |
| CommandBuffer::resetQueryPool(VULKAN_HPP_NAMESPACE::QueryPool queryPool, uint32_t firstQuery, uint32_t queryCount) const VULKAN_HPP_NOEXCEPT |
| { |
| getDispatcher()->vkCmdResetQueryPool(static_cast<VkCommandBuffer>(m_commandBuffer), static_cast<VkQueryPool>(queryPool), firstQuery, queryCount); |
| } |
| |
| VULKAN_HPP_INLINE void CommandBuffer::writeTimestamp(VULKAN_HPP_NAMESPACE::PipelineStageFlagBits pipelineStage, |
| VULKAN_HPP_NAMESPACE::QueryPool queryPool, |
| uint32_t query) const VULKAN_HPP_NOEXCEPT |
| { |
| getDispatcher()->vkCmdWriteTimestamp( |
| static_cast<VkCommandBuffer>(m_commandBuffer), static_cast<VkPipelineStageFlagBits>(pipelineStage), static_cast<VkQueryPool>(queryPool), query); |
| } |
| |
| VULKAN_HPP_INLINE void CommandBuffer::copyQueryPoolResults(VULKAN_HPP_NAMESPACE::QueryPool queryPool, |
| uint32_t firstQuery, |
| uint32_t queryCount, |
| VULKAN_HPP_NAMESPACE::Buffer dstBuffer, |
| VULKAN_HPP_NAMESPACE::DeviceSize dstOffset, |
| VULKAN_HPP_NAMESPACE::DeviceSize stride, |
| VULKAN_HPP_NAMESPACE::QueryResultFlags flags) const VULKAN_HPP_NOEXCEPT |
| { |
| getDispatcher()->vkCmdCopyQueryPoolResults(static_cast<VkCommandBuffer>(m_commandBuffer), |
| static_cast<VkQueryPool>(queryPool), |
| firstQuery, |
| queryCount, |
| static_cast<VkBuffer>(dstBuffer), |
| static_cast<VkDeviceSize>(dstOffset), |
| static_cast<VkDeviceSize>(stride), |
| static_cast<VkQueryResultFlags>(flags)); |
| } |
| |
| template<typename ValuesType> |
| VULKAN_HPP_INLINE void CommandBuffer::pushConstants(VULKAN_HPP_NAMESPACE::PipelineLayout layout, |
| VULKAN_HPP_NAMESPACE::ShaderStageFlags stageFlags, |
| uint32_t offset, |
| ArrayProxy<const ValuesType> const &values) const VULKAN_HPP_NOEXCEPT |
| { |
| getDispatcher()->vkCmdPushConstants(static_cast<VkCommandBuffer>(m_commandBuffer), |
| static_cast<VkPipelineLayout>(layout), |
| static_cast<VkShaderStageFlags>(stageFlags), |
| offset, |
| values.size() * sizeof(ValuesType), |
| reinterpret_cast<const void *>(values.data())); |
| } |
| |
| VULKAN_HPP_INLINE void CommandBuffer::beginRenderPass(const VULKAN_HPP_NAMESPACE::RenderPassBeginInfo &renderPassBegin, |
| VULKAN_HPP_NAMESPACE::SubpassContents contents) const VULKAN_HPP_NOEXCEPT |
| { |
| getDispatcher()->vkCmdBeginRenderPass(static_cast<VkCommandBuffer>(m_commandBuffer), |
| reinterpret_cast<const VkRenderPassBeginInfo *>(&renderPassBegin), |
| static_cast<VkSubpassContents>(contents)); |
| } |
| |
| VULKAN_HPP_INLINE void CommandBuffer::nextSubpass(VULKAN_HPP_NAMESPACE::SubpassContents contents) const VULKAN_HPP_NOEXCEPT |
| { |
| getDispatcher()->vkCmdNextSubpass(static_cast<VkCommandBuffer>(m_commandBuffer), static_cast<VkSubpassContents>(contents)); |
| } |
| |
| VULKAN_HPP_INLINE void CommandBuffer::endRenderPass() const VULKAN_HPP_NOEXCEPT |
| { |
| getDispatcher()->vkCmdEndRenderPass(static_cast<VkCommandBuffer>(m_commandBuffer)); |
| } |
| |
| VULKAN_HPP_INLINE void |
| CommandBuffer::executeCommands(ArrayProxy<const VULKAN_HPP_NAMESPACE::CommandBuffer> const &commandBuffers) const VULKAN_HPP_NOEXCEPT |
| { |
| getDispatcher()->vkCmdExecuteCommands( |
| static_cast<VkCommandBuffer>(m_commandBuffer), commandBuffers.size(), reinterpret_cast<const VkCommandBuffer *>(commandBuffers.data())); |
| } |
| |
| //=== VK_VERSION_1_1 === |
| |
| VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE uint32_t Context::enumerateInstanceVersion() const |
| { |
| uint32_t apiVersion; |
| VULKAN_HPP_NAMESPACE::Result result = static_cast<VULKAN_HPP_NAMESPACE::Result>(getDispatcher()->vkEnumerateInstanceVersion(&apiVersion)); |
| if(result != VULKAN_HPP_NAMESPACE::Result::eSuccess) |
| { |
| throwResultException(result, VULKAN_HPP_NAMESPACE_STRING "::Context::enumerateInstanceVersion"); |
| } |
| return apiVersion; |
| } |
| |
| VULKAN_HPP_INLINE void Device::bindBufferMemory2(ArrayProxy<const VULKAN_HPP_NAMESPACE::BindBufferMemoryInfo> const &bindInfos) const |
| { |
| VULKAN_HPP_NAMESPACE::Result result = static_cast<VULKAN_HPP_NAMESPACE::Result>(getDispatcher()->vkBindBufferMemory2( |
| static_cast<VkDevice>(m_device), bindInfos.size(), reinterpret_cast<const VkBindBufferMemoryInfo *>(bindInfos.data()))); |
| if(result != VULKAN_HPP_NAMESPACE::Result::eSuccess) |
| { |
| throwResultException(result, VULKAN_HPP_NAMESPACE_STRING "::Device::bindBufferMemory2"); |
| } |
| } |
| |
| VULKAN_HPP_INLINE void Device::bindImageMemory2(ArrayProxy<const VULKAN_HPP_NAMESPACE::BindImageMemoryInfo> const &bindInfos) const |
| { |
| VULKAN_HPP_NAMESPACE::Result result = static_cast<VULKAN_HPP_NAMESPACE::Result>(getDispatcher()->vkBindImageMemory2( |
| static_cast<VkDevice>(m_device), bindInfos.size(), reinterpret_cast<const VkBindImageMemoryInfo *>(bindInfos.data()))); |
| if(result != VULKAN_HPP_NAMESPACE::Result::eSuccess) |
| { |
| throwResultException(result, VULKAN_HPP_NAMESPACE_STRING "::Device::bindImageMemory2"); |
| } |
| } |
| |
| VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE VULKAN_HPP_NAMESPACE::PeerMemoryFeatureFlags |
| Device::getGroupPeerMemoryFeatures(uint32_t heapIndex, uint32_t localDeviceIndex, uint32_t remoteDeviceIndex) const VULKAN_HPP_NOEXCEPT |
| { |
| VULKAN_HPP_NAMESPACE::PeerMemoryFeatureFlags peerMemoryFeatures; |
| getDispatcher()->vkGetDeviceGroupPeerMemoryFeatures(static_cast<VkDevice>(m_device), |
| heapIndex, |
| localDeviceIndex, |
| remoteDeviceIndex, |
| reinterpret_cast<VkPeerMemoryFeatureFlags *>(&peerMemoryFeatures)); |
| return peerMemoryFeatures; |
| } |
| |
| VULKAN_HPP_INLINE void CommandBuffer::setDeviceMask(uint32_t deviceMask) const VULKAN_HPP_NOEXCEPT |
| { |
| getDispatcher()->vkCmdSetDeviceMask(static_cast<VkCommandBuffer>(m_commandBuffer), deviceMask); |
| } |
| |
| VULKAN_HPP_INLINE void CommandBuffer::dispatchBase(uint32_t baseGroupX, |
| uint32_t baseGroupY, |
| uint32_t baseGroupZ, |
| uint32_t groupCountX, |
| uint32_t groupCountY, |
| uint32_t groupCountZ) const VULKAN_HPP_NOEXCEPT |
| { |
| getDispatcher()->vkCmdDispatchBase( |
| static_cast<VkCommandBuffer>(m_commandBuffer), baseGroupX, baseGroupY, baseGroupZ, groupCountX, groupCountY, groupCountZ); |
| } |
| |
| VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE std::vector<VULKAN_HPP_NAMESPACE::PhysicalDeviceGroupProperties> Instance::enumeratePhysicalDeviceGroups() const |
| { |
| std::vector<VULKAN_HPP_NAMESPACE::PhysicalDeviceGroupProperties> physicalDeviceGroupProperties; |
| uint32_t physicalDeviceGroupCount; |
| VULKAN_HPP_NAMESPACE::Result result; |
| do |
| { |
| result = static_cast<VULKAN_HPP_NAMESPACE::Result>( |
| getDispatcher()->vkEnumeratePhysicalDeviceGroups(static_cast<VkInstance>(m_instance), &physicalDeviceGroupCount, nullptr)); |
| if((result == VULKAN_HPP_NAMESPACE::Result::eSuccess) && physicalDeviceGroupCount) |
| { |
| physicalDeviceGroupProperties.resize(physicalDeviceGroupCount); |
| result = static_cast<VULKAN_HPP_NAMESPACE::Result>( |
| getDispatcher()->vkEnumeratePhysicalDeviceGroups(static_cast<VkInstance>(m_instance), |
| &physicalDeviceGroupCount, |
| reinterpret_cast<VkPhysicalDeviceGroupProperties *>(physicalDeviceGroupProperties.data()))); |
| } |
| } while(result == VULKAN_HPP_NAMESPACE::Result::eIncomplete); |
| if(result != VULKAN_HPP_NAMESPACE::Result::eSuccess) |
| { |
| throwResultException(result, VULKAN_HPP_NAMESPACE_STRING "::Instance::enumeratePhysicalDeviceGroups"); |
| } |
| if(result == VULKAN_HPP_NAMESPACE::Result::eSuccess) |
| { |
| VULKAN_HPP_ASSERT(physicalDeviceGroupCount <= physicalDeviceGroupProperties.size()); |
| if(physicalDeviceGroupCount < physicalDeviceGroupProperties.size()) |
| { |
| physicalDeviceGroupProperties.resize(physicalDeviceGroupCount); |
| } |
| } |
| return physicalDeviceGroupProperties; |
| } |
| |
| VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE VULKAN_HPP_NAMESPACE::MemoryRequirements2 |
| Device::getImageMemoryRequirements2(const VULKAN_HPP_NAMESPACE::ImageMemoryRequirementsInfo2 &info) const VULKAN_HPP_NOEXCEPT |
| { |
| VULKAN_HPP_NAMESPACE::MemoryRequirements2 memoryRequirements; |
| getDispatcher()->vkGetImageMemoryRequirements2(static_cast<VkDevice>(m_device), |
| reinterpret_cast<const VkImageMemoryRequirementsInfo2 *>(&info), |
| reinterpret_cast<VkMemoryRequirements2 *>(&memoryRequirements)); |
| return memoryRequirements; |
| } |
| |
| template<typename X, typename Y, typename... Z> |
| VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE StructureChain<X, Y, Z...> |
| Device::getImageMemoryRequirements2(const VULKAN_HPP_NAMESPACE::ImageMemoryRequirementsInfo2 &info) const VULKAN_HPP_NOEXCEPT |
| { |
| StructureChain<X, Y, Z...> structureChain; |
| VULKAN_HPP_NAMESPACE::MemoryRequirements2 &memoryRequirements = structureChain.template get<VULKAN_HPP_NAMESPACE::MemoryRequirements2>(); |
| getDispatcher()->vkGetImageMemoryRequirements2(static_cast<VkDevice>(m_device), |
| reinterpret_cast<const VkImageMemoryRequirementsInfo2 *>(&info), |
| reinterpret_cast<VkMemoryRequirements2 *>(&memoryRequirements)); |
| return structureChain; |
| } |
| |
| VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE VULKAN_HPP_NAMESPACE::MemoryRequirements2 |
| Device::getBufferMemoryRequirements2(const VULKAN_HPP_NAMESPACE::BufferMemoryRequirementsInfo2 &info) const VULKAN_HPP_NOEXCEPT |
| { |
| VULKAN_HPP_NAMESPACE::MemoryRequirements2 memoryRequirements; |
| getDispatcher()->vkGetBufferMemoryRequirements2(static_cast<VkDevice>(m_device), |
| reinterpret_cast<const VkBufferMemoryRequirementsInfo2 *>(&info), |
| reinterpret_cast<VkMemoryRequirements2 *>(&memoryRequirements)); |
| return memoryRequirements; |
| } |
| |
| template<typename X, typename Y, typename... Z> |
| VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE StructureChain<X, Y, Z...> |
| Device::getBufferMemoryRequirements2(const VULKAN_HPP_NAMESPACE::BufferMemoryRequirementsInfo2 &info) const VULKAN_HPP_NOEXCEPT |
| { |
| StructureChain<X, Y, Z...> structureChain; |
| VULKAN_HPP_NAMESPACE::MemoryRequirements2 &memoryRequirements = structureChain.template get<VULKAN_HPP_NAMESPACE::MemoryRequirements2>(); |
| getDispatcher()->vkGetBufferMemoryRequirements2(static_cast<VkDevice>(m_device), |
| reinterpret_cast<const VkBufferMemoryRequirementsInfo2 *>(&info), |
| reinterpret_cast<VkMemoryRequirements2 *>(&memoryRequirements)); |
| return structureChain; |
| } |
| |
| VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE std::vector<VULKAN_HPP_NAMESPACE::SparseImageMemoryRequirements2> |
| Device::getImageSparseMemoryRequirements2(const VULKAN_HPP_NAMESPACE::ImageSparseMemoryRequirementsInfo2 &info) const VULKAN_HPP_NOEXCEPT |
| { |
| uint32_t sparseMemoryRequirementCount; |
| getDispatcher()->vkGetImageSparseMemoryRequirements2( |
| static_cast<VkDevice>(m_device), reinterpret_cast<const VkImageSparseMemoryRequirementsInfo2 *>(&info), &sparseMemoryRequirementCount, nullptr); |
| std::vector<VULKAN_HPP_NAMESPACE::SparseImageMemoryRequirements2> sparseMemoryRequirements(sparseMemoryRequirementCount); |
| getDispatcher()->vkGetImageSparseMemoryRequirements2(static_cast<VkDevice>(m_device), |
| reinterpret_cast<const VkImageSparseMemoryRequirementsInfo2 *>(&info), |
| &sparseMemoryRequirementCount, |
| reinterpret_cast<VkSparseImageMemoryRequirements2 *>(sparseMemoryRequirements.data())); |
| VULKAN_HPP_ASSERT(sparseMemoryRequirementCount == sparseMemoryRequirements.size()); |
| return sparseMemoryRequirements; |
| } |
| |
| VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE VULKAN_HPP_NAMESPACE::PhysicalDeviceFeatures2 PhysicalDevice::getFeatures2() const VULKAN_HPP_NOEXCEPT |
| { |
| VULKAN_HPP_NAMESPACE::PhysicalDeviceFeatures2 features; |
| getDispatcher()->vkGetPhysicalDeviceFeatures2(static_cast<VkPhysicalDevice>(m_physicalDevice), |
| reinterpret_cast<VkPhysicalDeviceFeatures2 *>(&features)); |
| return features; |
| } |
| |
| template<typename X, typename Y, typename... Z> |
| VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE StructureChain<X, Y, Z...> PhysicalDevice::getFeatures2() const VULKAN_HPP_NOEXCEPT |
| { |
| StructureChain<X, Y, Z...> structureChain; |
| VULKAN_HPP_NAMESPACE::PhysicalDeviceFeatures2 &features = structureChain.template get<VULKAN_HPP_NAMESPACE::PhysicalDeviceFeatures2>(); |
| getDispatcher()->vkGetPhysicalDeviceFeatures2(static_cast<VkPhysicalDevice>(m_physicalDevice), |
| reinterpret_cast<VkPhysicalDeviceFeatures2 *>(&features)); |
| return structureChain; |
| } |
| |
| VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE VULKAN_HPP_NAMESPACE::PhysicalDeviceProperties2 PhysicalDevice::getProperties2() const VULKAN_HPP_NOEXCEPT |
| { |
| VULKAN_HPP_NAMESPACE::PhysicalDeviceProperties2 properties; |
| getDispatcher()->vkGetPhysicalDeviceProperties2(static_cast<VkPhysicalDevice>(m_physicalDevice), |
| reinterpret_cast<VkPhysicalDeviceProperties2 *>(&properties)); |
| return properties; |
| } |
| |
| template<typename X, typename Y, typename... Z> |
| VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE StructureChain<X, Y, Z...> PhysicalDevice::getProperties2() const VULKAN_HPP_NOEXCEPT |
| { |
| StructureChain<X, Y, Z...> structureChain; |
| VULKAN_HPP_NAMESPACE::PhysicalDeviceProperties2 &properties = structureChain.template get<VULKAN_HPP_NAMESPACE::PhysicalDeviceProperties2>(); |
| getDispatcher()->vkGetPhysicalDeviceProperties2(static_cast<VkPhysicalDevice>(m_physicalDevice), |
| reinterpret_cast<VkPhysicalDeviceProperties2 *>(&properties)); |
| return structureChain; |
| } |
| |
| VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE VULKAN_HPP_NAMESPACE::FormatProperties2 |
| PhysicalDevice::getFormatProperties2(VULKAN_HPP_NAMESPACE::Format format) const VULKAN_HPP_NOEXCEPT |
| { |
| VULKAN_HPP_NAMESPACE::FormatProperties2 formatProperties; |
| getDispatcher()->vkGetPhysicalDeviceFormatProperties2( |
| static_cast<VkPhysicalDevice>(m_physicalDevice), static_cast<VkFormat>(format), reinterpret_cast<VkFormatProperties2 *>(&formatProperties)); |
| return formatProperties; |
| } |
| |
| template<typename X, typename Y, typename... Z> |
| VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE StructureChain<X, Y, Z...> |
| PhysicalDevice::getFormatProperties2(VULKAN_HPP_NAMESPACE::Format format) const VULKAN_HPP_NOEXCEPT |
| { |
| StructureChain<X, Y, Z...> structureChain; |
| VULKAN_HPP_NAMESPACE::FormatProperties2 &formatProperties = structureChain.template get<VULKAN_HPP_NAMESPACE::FormatProperties2>(); |
| getDispatcher()->vkGetPhysicalDeviceFormatProperties2( |
| static_cast<VkPhysicalDevice>(m_physicalDevice), static_cast<VkFormat>(format), reinterpret_cast<VkFormatProperties2 *>(&formatProperties)); |
| return structureChain; |
| } |
| |
| VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE VULKAN_HPP_NAMESPACE::ImageFormatProperties2 |
| PhysicalDevice::getImageFormatProperties2(const VULKAN_HPP_NAMESPACE::PhysicalDeviceImageFormatInfo2 &imageFormatInfo) const |
| { |
| VULKAN_HPP_NAMESPACE::ImageFormatProperties2 imageFormatProperties; |
| VULKAN_HPP_NAMESPACE::Result result = static_cast<VULKAN_HPP_NAMESPACE::Result>( |
| getDispatcher()->vkGetPhysicalDeviceImageFormatProperties2(static_cast<VkPhysicalDevice>(m_physicalDevice), |
| reinterpret_cast<const VkPhysicalDeviceImageFormatInfo2 *>(&imageFormatInfo), |
| reinterpret_cast<VkImageFormatProperties2 *>(&imageFormatProperties))); |
| if(result != VULKAN_HPP_NAMESPACE::Result::eSuccess) |
| { |
| throwResultException(result, VULKAN_HPP_NAMESPACE_STRING "::PhysicalDevice::getImageFormatProperties2"); |
| } |
| return imageFormatProperties; |
| } |
| |
| template<typename X, typename Y, typename... Z> |
| VULKAN_HPP_NODISCARD StructureChain<X, Y, Z...> |
| PhysicalDevice::getImageFormatProperties2(const VULKAN_HPP_NAMESPACE::PhysicalDeviceImageFormatInfo2 &imageFormatInfo) const |
| { |
| StructureChain<X, Y, Z...> structureChain; |
| VULKAN_HPP_NAMESPACE::ImageFormatProperties2 &imageFormatProperties = structureChain.template get<VULKAN_HPP_NAMESPACE::ImageFormatProperties2>(); |
| VULKAN_HPP_NAMESPACE::Result result = static_cast<VULKAN_HPP_NAMESPACE::Result>( |
| getDispatcher()->vkGetPhysicalDeviceImageFormatProperties2(static_cast<VkPhysicalDevice>(m_physicalDevice), |
| reinterpret_cast<const VkPhysicalDeviceImageFormatInfo2 *>(&imageFormatInfo), |
| reinterpret_cast<VkImageFormatProperties2 *>(&imageFormatProperties))); |
| if(result != VULKAN_HPP_NAMESPACE::Result::eSuccess) |
| { |
| throwResultException(result, VULKAN_HPP_NAMESPACE_STRING "::PhysicalDevice::getImageFormatProperties2"); |
| } |
| return structureChain; |
| } |
| |
| VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE std::vector<VULKAN_HPP_NAMESPACE::QueueFamilyProperties2> |
| PhysicalDevice::getQueueFamilyProperties2() const VULKAN_HPP_NOEXCEPT |
| { |
| uint32_t queueFamilyPropertyCount; |
| getDispatcher()->vkGetPhysicalDeviceQueueFamilyProperties2(static_cast<VkPhysicalDevice>(m_physicalDevice), &queueFamilyPropertyCount, nullptr); |
| std::vector<VULKAN_HPP_NAMESPACE::QueueFamilyProperties2> queueFamilyProperties(queueFamilyPropertyCount); |
| getDispatcher()->vkGetPhysicalDeviceQueueFamilyProperties2(static_cast<VkPhysicalDevice>(m_physicalDevice), |
| &queueFamilyPropertyCount, |
| reinterpret_cast<VkQueueFamilyProperties2 *>(queueFamilyProperties.data())); |
| VULKAN_HPP_ASSERT(queueFamilyPropertyCount == queueFamilyProperties.size()); |
| return queueFamilyProperties; |
| } |
| |
| template<typename StructureChain> |
| VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE std::vector<StructureChain> PhysicalDevice::getQueueFamilyProperties2() const |
| { |
| uint32_t queueFamilyPropertyCount; |
| getDispatcher()->vkGetPhysicalDeviceQueueFamilyProperties2(static_cast<VkPhysicalDevice>(m_physicalDevice), &queueFamilyPropertyCount, nullptr); |
| std::vector<StructureChain> returnVector(queueFamilyPropertyCount); |
| std::vector<VULKAN_HPP_NAMESPACE::QueueFamilyProperties2> queueFamilyProperties(queueFamilyPropertyCount); |
| for(uint32_t i = 0; i < queueFamilyPropertyCount; i++) |
| { |
| queueFamilyProperties[i].pNext = returnVector[i].template get<VULKAN_HPP_NAMESPACE::QueueFamilyProperties2>().pNext; |
| } |
| getDispatcher()->vkGetPhysicalDeviceQueueFamilyProperties2(static_cast<VkPhysicalDevice>(m_physicalDevice), |
| &queueFamilyPropertyCount, |
| reinterpret_cast<VkQueueFamilyProperties2 *>(queueFamilyProperties.data())); |
| VULKAN_HPP_ASSERT(queueFamilyPropertyCount <= queueFamilyProperties.size()); |
| for(uint32_t i = 0; i < queueFamilyPropertyCount; i++) |
| { |
| returnVector[i].template get<VULKAN_HPP_NAMESPACE::QueueFamilyProperties2>() = queueFamilyProperties[i]; |
| } |
| return returnVector; |
| } |
| |
| VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE VULKAN_HPP_NAMESPACE::PhysicalDeviceMemoryProperties2 |
| PhysicalDevice::getMemoryProperties2() const VULKAN_HPP_NOEXCEPT |
| { |
| VULKAN_HPP_NAMESPACE::PhysicalDeviceMemoryProperties2 memoryProperties; |
| getDispatcher()->vkGetPhysicalDeviceMemoryProperties2(static_cast<VkPhysicalDevice>(m_physicalDevice), |
| reinterpret_cast<VkPhysicalDeviceMemoryProperties2 *>(&memoryProperties)); |
| return memoryProperties; |
| } |
| |
| template<typename X, typename Y, typename... Z> |
| VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE StructureChain<X, Y, Z...> PhysicalDevice::getMemoryProperties2() const VULKAN_HPP_NOEXCEPT |
| { |
| StructureChain<X, Y, Z...> structureChain; |
| VULKAN_HPP_NAMESPACE::PhysicalDeviceMemoryProperties2 &memoryProperties = |
| structureChain.template get<VULKAN_HPP_NAMESPACE::PhysicalDeviceMemoryProperties2>(); |
| getDispatcher()->vkGetPhysicalDeviceMemoryProperties2(static_cast<VkPhysicalDevice>(m_physicalDevice), |
| reinterpret_cast<VkPhysicalDeviceMemoryProperties2 *>(&memoryProperties)); |
| return structureChain; |
| } |
| |
| VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE std::vector<VULKAN_HPP_NAMESPACE::SparseImageFormatProperties2> |
| PhysicalDevice::getSparseImageFormatProperties2(const VULKAN_HPP_NAMESPACE::PhysicalDeviceSparseImageFormatInfo2 &formatInfo) const VULKAN_HPP_NOEXCEPT |
| { |
| uint32_t propertyCount; |
| getDispatcher()->vkGetPhysicalDeviceSparseImageFormatProperties2(static_cast<VkPhysicalDevice>(m_physicalDevice), |
| reinterpret_cast<const VkPhysicalDeviceSparseImageFormatInfo2 *>(&formatInfo), |
| &propertyCount, |
| nullptr); |
| std::vector<VULKAN_HPP_NAMESPACE::SparseImageFormatProperties2> properties(propertyCount); |
| getDispatcher()->vkGetPhysicalDeviceSparseImageFormatProperties2(static_cast<VkPhysicalDevice>(m_physicalDevice), |
| reinterpret_cast<const VkPhysicalDeviceSparseImageFormatInfo2 *>(&formatInfo), |
| &propertyCount, |
| reinterpret_cast<VkSparseImageFormatProperties2 *>(properties.data())); |
| VULKAN_HPP_ASSERT(propertyCount == properties.size()); |
| return properties; |
| } |
| |
| VULKAN_HPP_INLINE void CommandPool::trim(VULKAN_HPP_NAMESPACE::CommandPoolTrimFlags flags) const VULKAN_HPP_NOEXCEPT |
| { |
| getDispatcher()->vkTrimCommandPool( |
| static_cast<VkDevice>(m_device), static_cast<VkCommandPool>(m_commandPool), static_cast<VkCommandPoolTrimFlags>(flags)); |
| } |
| |
| VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE VULKAN_HPP_RAII_NAMESPACE::Queue Device::getQueue2(VULKAN_HPP_NAMESPACE::DeviceQueueInfo2 const &queueInfo) const |
| { |
| return VULKAN_HPP_RAII_NAMESPACE::Queue(*this, queueInfo); |
| } |
| |
| VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE VULKAN_HPP_RAII_NAMESPACE::SamplerYcbcrConversion |
| Device::createSamplerYcbcrConversion(VULKAN_HPP_NAMESPACE::SamplerYcbcrConversionCreateInfo const &createInfo, |
| VULKAN_HPP_NAMESPACE::Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator) const |
| { |
| return VULKAN_HPP_RAII_NAMESPACE::SamplerYcbcrConversion(*this, createInfo, allocator); |
| } |
| |
| VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE VULKAN_HPP_RAII_NAMESPACE::DescriptorUpdateTemplate |
| Device::createDescriptorUpdateTemplate(VULKAN_HPP_NAMESPACE::DescriptorUpdateTemplateCreateInfo const &createInfo, |
| VULKAN_HPP_NAMESPACE::Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator) const |
| { |
| return VULKAN_HPP_RAII_NAMESPACE::DescriptorUpdateTemplate(*this, createInfo, allocator); |
| } |
| |
| template<typename DataType> |
| VULKAN_HPP_INLINE void DescriptorSet::updateWithTemplate(VULKAN_HPP_NAMESPACE::DescriptorUpdateTemplate descriptorUpdateTemplate, |
| DataType const &data) const VULKAN_HPP_NOEXCEPT |
| { |
| getDispatcher()->vkUpdateDescriptorSetWithTemplate(static_cast<VkDevice>(m_device), |
| static_cast<VkDescriptorSet>(m_descriptorSet), |
| static_cast<VkDescriptorUpdateTemplate>(descriptorUpdateTemplate), |
| reinterpret_cast<const void *>(&data)); |
| } |
| |
| VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE VULKAN_HPP_NAMESPACE::ExternalBufferProperties |
| PhysicalDevice::getExternalBufferProperties(const VULKAN_HPP_NAMESPACE::PhysicalDeviceExternalBufferInfo &externalBufferInfo) const VULKAN_HPP_NOEXCEPT |
| { |
| VULKAN_HPP_NAMESPACE::ExternalBufferProperties externalBufferProperties; |
| getDispatcher()->vkGetPhysicalDeviceExternalBufferProperties(static_cast<VkPhysicalDevice>(m_physicalDevice), |
| reinterpret_cast<const VkPhysicalDeviceExternalBufferInfo *>(&externalBufferInfo), |
| reinterpret_cast<VkExternalBufferProperties *>(&externalBufferProperties)); |
| return externalBufferProperties; |
| } |
| |
| VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE VULKAN_HPP_NAMESPACE::ExternalFenceProperties |
| PhysicalDevice::getExternalFenceProperties(const VULKAN_HPP_NAMESPACE::PhysicalDeviceExternalFenceInfo &externalFenceInfo) const VULKAN_HPP_NOEXCEPT |
| { |
| VULKAN_HPP_NAMESPACE::ExternalFenceProperties externalFenceProperties; |
| getDispatcher()->vkGetPhysicalDeviceExternalFenceProperties(static_cast<VkPhysicalDevice>(m_physicalDevice), |
| reinterpret_cast<const VkPhysicalDeviceExternalFenceInfo *>(&externalFenceInfo), |
| reinterpret_cast<VkExternalFenceProperties *>(&externalFenceProperties)); |
| return externalFenceProperties; |
| } |
| |
| VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE VULKAN_HPP_NAMESPACE::ExternalSemaphoreProperties PhysicalDevice::getExternalSemaphoreProperties( |
| const VULKAN_HPP_NAMESPACE::PhysicalDeviceExternalSemaphoreInfo &externalSemaphoreInfo) const VULKAN_HPP_NOEXCEPT |
| { |
| VULKAN_HPP_NAMESPACE::ExternalSemaphoreProperties externalSemaphoreProperties; |
| getDispatcher()->vkGetPhysicalDeviceExternalSemaphoreProperties( |
| static_cast<VkPhysicalDevice>(m_physicalDevice), |
| reinterpret_cast<const VkPhysicalDeviceExternalSemaphoreInfo *>(&externalSemaphoreInfo), |
| reinterpret_cast<VkExternalSemaphoreProperties *>(&externalSemaphoreProperties)); |
| return externalSemaphoreProperties; |
| } |
| |
| VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE VULKAN_HPP_NAMESPACE::DescriptorSetLayoutSupport |
| Device::getDescriptorSetLayoutSupport(const VULKAN_HPP_NAMESPACE::DescriptorSetLayoutCreateInfo &createInfo) const VULKAN_HPP_NOEXCEPT |
| { |
| VULKAN_HPP_NAMESPACE::DescriptorSetLayoutSupport support; |
| getDispatcher()->vkGetDescriptorSetLayoutSupport(static_cast<VkDevice>(m_device), |
| reinterpret_cast<const VkDescriptorSetLayoutCreateInfo *>(&createInfo), |
| reinterpret_cast<VkDescriptorSetLayoutSupport *>(&support)); |
| return support; |
| } |
| |
| template<typename X, typename Y, typename... Z> |
| VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE StructureChain<X, Y, Z...> |
| Device::getDescriptorSetLayoutSupport(const VULKAN_HPP_NAMESPACE::DescriptorSetLayoutCreateInfo &createInfo) const VULKAN_HPP_NOEXCEPT |
| { |
| StructureChain<X, Y, Z...> structureChain; |
| VULKAN_HPP_NAMESPACE::DescriptorSetLayoutSupport &support = structureChain.template get<VULKAN_HPP_NAMESPACE::DescriptorSetLayoutSupport>(); |
| getDispatcher()->vkGetDescriptorSetLayoutSupport(static_cast<VkDevice>(m_device), |
| reinterpret_cast<const VkDescriptorSetLayoutCreateInfo *>(&createInfo), |
| reinterpret_cast<VkDescriptorSetLayoutSupport *>(&support)); |
| return structureChain; |
| } |
| |
| //=== VK_VERSION_1_2 === |
| |
| VULKAN_HPP_INLINE void CommandBuffer::drawIndirectCount(VULKAN_HPP_NAMESPACE::Buffer buffer, |
| VULKAN_HPP_NAMESPACE::DeviceSize offset, |
| VULKAN_HPP_NAMESPACE::Buffer countBuffer, |
| VULKAN_HPP_NAMESPACE::DeviceSize countBufferOffset, |
| uint32_t maxDrawCount, |
| uint32_t stride) const VULKAN_HPP_NOEXCEPT |
| { |
| getDispatcher()->vkCmdDrawIndirectCount(static_cast<VkCommandBuffer>(m_commandBuffer), |
| static_cast<VkBuffer>(buffer), |
| static_cast<VkDeviceSize>(offset), |
| static_cast<VkBuffer>(countBuffer), |
| static_cast<VkDeviceSize>(countBufferOffset), |
| maxDrawCount, |
| stride); |
| } |
| |
| VULKAN_HPP_INLINE void CommandBuffer::drawIndexedIndirectCount(VULKAN_HPP_NAMESPACE::Buffer buffer, |
| VULKAN_HPP_NAMESPACE::DeviceSize offset, |
| VULKAN_HPP_NAMESPACE::Buffer countBuffer, |
| VULKAN_HPP_NAMESPACE::DeviceSize countBufferOffset, |
| uint32_t maxDrawCount, |
| uint32_t stride) const VULKAN_HPP_NOEXCEPT |
| { |
| getDispatcher()->vkCmdDrawIndexedIndirectCount(static_cast<VkCommandBuffer>(m_commandBuffer), |
| static_cast<VkBuffer>(buffer), |
| static_cast<VkDeviceSize>(offset), |
| static_cast<VkBuffer>(countBuffer), |
| static_cast<VkDeviceSize>(countBufferOffset), |
| maxDrawCount, |
| stride); |
| } |
| |
| VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE VULKAN_HPP_RAII_NAMESPACE::RenderPass |
| Device::createRenderPass2(VULKAN_HPP_NAMESPACE::RenderPassCreateInfo2 const &createInfo, |
| VULKAN_HPP_NAMESPACE::Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator) const |
| { |
| return VULKAN_HPP_RAII_NAMESPACE::RenderPass(*this, createInfo, allocator); |
| } |
| |
| VULKAN_HPP_INLINE void CommandBuffer::beginRenderPass2(const VULKAN_HPP_NAMESPACE::RenderPassBeginInfo &renderPassBegin, |
| const VULKAN_HPP_NAMESPACE::SubpassBeginInfo &subpassBeginInfo) const VULKAN_HPP_NOEXCEPT |
| { |
| getDispatcher()->vkCmdBeginRenderPass2(static_cast<VkCommandBuffer>(m_commandBuffer), |
| reinterpret_cast<const VkRenderPassBeginInfo *>(&renderPassBegin), |
| reinterpret_cast<const VkSubpassBeginInfo *>(&subpassBeginInfo)); |
| } |
| |
| VULKAN_HPP_INLINE void CommandBuffer::nextSubpass2(const VULKAN_HPP_NAMESPACE::SubpassBeginInfo &subpassBeginInfo, |
| const VULKAN_HPP_NAMESPACE::SubpassEndInfo &subpassEndInfo) const VULKAN_HPP_NOEXCEPT |
| { |
| getDispatcher()->vkCmdNextSubpass2(static_cast<VkCommandBuffer>(m_commandBuffer), |
| reinterpret_cast<const VkSubpassBeginInfo *>(&subpassBeginInfo), |
| reinterpret_cast<const VkSubpassEndInfo *>(&subpassEndInfo)); |
| } |
| |
| VULKAN_HPP_INLINE void CommandBuffer::endRenderPass2(const VULKAN_HPP_NAMESPACE::SubpassEndInfo &subpassEndInfo) const VULKAN_HPP_NOEXCEPT |
| { |
| getDispatcher()->vkCmdEndRenderPass2(static_cast<VkCommandBuffer>(m_commandBuffer), reinterpret_cast<const VkSubpassEndInfo *>(&subpassEndInfo)); |
| } |
| |
| VULKAN_HPP_INLINE void QueryPool::reset(uint32_t firstQuery, uint32_t queryCount) const VULKAN_HPP_NOEXCEPT |
| { |
| getDispatcher()->vkResetQueryPool(static_cast<VkDevice>(m_device), static_cast<VkQueryPool>(m_queryPool), firstQuery, queryCount); |
| } |
| |
| VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE uint64_t Semaphore::getCounterValue() const |
| { |
| uint64_t value; |
| VULKAN_HPP_NAMESPACE::Result result = static_cast<VULKAN_HPP_NAMESPACE::Result>( |
| getDispatcher()->vkGetSemaphoreCounterValue(static_cast<VkDevice>(m_device), static_cast<VkSemaphore>(m_semaphore), &value)); |
| if(result != VULKAN_HPP_NAMESPACE::Result::eSuccess) |
| { |
| throwResultException(result, VULKAN_HPP_NAMESPACE_STRING "::Semaphore::getCounterValue"); |
| } |
| return value; |
| } |
| |
| VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE VULKAN_HPP_NAMESPACE::Result Device::waitSemaphores(const VULKAN_HPP_NAMESPACE::SemaphoreWaitInfo &waitInfo, |
| uint64_t timeout) const |
| { |
| VULKAN_HPP_NAMESPACE::Result result = static_cast<VULKAN_HPP_NAMESPACE::Result>( |
| getDispatcher()->vkWaitSemaphores(static_cast<VkDevice>(m_device), reinterpret_cast<const VkSemaphoreWaitInfo *>(&waitInfo), timeout)); |
| if((result != VULKAN_HPP_NAMESPACE::Result::eSuccess) && (result != VULKAN_HPP_NAMESPACE::Result::eTimeout)) |
| { |
| throwResultException(result, VULKAN_HPP_NAMESPACE_STRING "::Device::waitSemaphores"); |
| } |
| return result; |
| } |
| |
| VULKAN_HPP_INLINE void Device::signalSemaphore(const VULKAN_HPP_NAMESPACE::SemaphoreSignalInfo &signalInfo) const |
| { |
| VULKAN_HPP_NAMESPACE::Result result = static_cast<VULKAN_HPP_NAMESPACE::Result>( |
| getDispatcher()->vkSignalSemaphore(static_cast<VkDevice>(m_device), reinterpret_cast<const VkSemaphoreSignalInfo *>(&signalInfo))); |
| if(result != VULKAN_HPP_NAMESPACE::Result::eSuccess) |
| { |
| throwResultException(result, VULKAN_HPP_NAMESPACE_STRING "::Device::signalSemaphore"); |
| } |
| } |
| |
| VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE VULKAN_HPP_NAMESPACE::DeviceAddress |
| Device::getBufferAddress(const VULKAN_HPP_NAMESPACE::BufferDeviceAddressInfo &info) const VULKAN_HPP_NOEXCEPT |
| { |
| return static_cast<VULKAN_HPP_NAMESPACE::DeviceAddress>( |
| getDispatcher()->vkGetBufferDeviceAddress(static_cast<VkDevice>(m_device), reinterpret_cast<const VkBufferDeviceAddressInfo *>(&info))); |
| } |
| |
| VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE uint64_t |
| Device::getBufferOpaqueCaptureAddress(const VULKAN_HPP_NAMESPACE::BufferDeviceAddressInfo &info) const VULKAN_HPP_NOEXCEPT |
| { |
| return getDispatcher()->vkGetBufferOpaqueCaptureAddress(static_cast<VkDevice>(m_device), |
| reinterpret_cast<const VkBufferDeviceAddressInfo *>(&info)); |
| } |
| |
| VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE uint64_t |
| Device::getMemoryOpaqueCaptureAddress(const VULKAN_HPP_NAMESPACE::DeviceMemoryOpaqueCaptureAddressInfo &info) const VULKAN_HPP_NOEXCEPT |
| { |
| return getDispatcher()->vkGetDeviceMemoryOpaqueCaptureAddress(static_cast<VkDevice>(m_device), |
| reinterpret_cast<const VkDeviceMemoryOpaqueCaptureAddressInfo *>(&info)); |
| } |
| |
| //=== VK_VERSION_1_3 === |
| |
| VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE std::vector<VULKAN_HPP_NAMESPACE::PhysicalDeviceToolProperties> PhysicalDevice::getToolProperties() const |
| { |
| std::vector<VULKAN_HPP_NAMESPACE::PhysicalDeviceToolProperties> toolProperties; |
| uint32_t toolCount; |
| VULKAN_HPP_NAMESPACE::Result result; |
| do |
| { |
| result = static_cast<VULKAN_HPP_NAMESPACE::Result>( |
| getDispatcher()->vkGetPhysicalDeviceToolProperties(static_cast<VkPhysicalDevice>(m_physicalDevice), &toolCount, nullptr)); |
| if((result == VULKAN_HPP_NAMESPACE::Result::eSuccess) && toolCount) |
| { |
| toolProperties.resize(toolCount); |
| result = static_cast<VULKAN_HPP_NAMESPACE::Result>(getDispatcher()->vkGetPhysicalDeviceToolProperties( |
| static_cast<VkPhysicalDevice>(m_physicalDevice), &toolCount, reinterpret_cast<VkPhysicalDeviceToolProperties *>(toolProperties.data()))); |
| } |
| } while(result == VULKAN_HPP_NAMESPACE::Result::eIncomplete); |
| if(result != VULKAN_HPP_NAMESPACE::Result::eSuccess) |
| { |
| throwResultException(result, VULKAN_HPP_NAMESPACE_STRING "::PhysicalDevice::getToolProperties"); |
| } |
| if(result == VULKAN_HPP_NAMESPACE::Result::eSuccess) |
| { |
| VULKAN_HPP_ASSERT(toolCount <= toolProperties.size()); |
| if(toolCount < toolProperties.size()) |
| { |
| toolProperties.resize(toolCount); |
| } |
| } |
| return toolProperties; |
| } |
| |
| VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE VULKAN_HPP_RAII_NAMESPACE::PrivateDataSlot |
| Device::createPrivateDataSlot(VULKAN_HPP_NAMESPACE::PrivateDataSlotCreateInfo const &createInfo, |
| VULKAN_HPP_NAMESPACE::Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator) const |
| { |
| return VULKAN_HPP_RAII_NAMESPACE::PrivateDataSlot(*this, createInfo, allocator); |
| } |
| |
| VULKAN_HPP_INLINE void Device::setPrivateData(VULKAN_HPP_NAMESPACE::ObjectType objectType_, |
| uint64_t objectHandle, |
| VULKAN_HPP_NAMESPACE::PrivateDataSlot privateDataSlot, |
| uint64_t data) const |
| { |
| VULKAN_HPP_NAMESPACE::Result result = static_cast<VULKAN_HPP_NAMESPACE::Result>(getDispatcher()->vkSetPrivateData( |
| static_cast<VkDevice>(m_device), static_cast<VkObjectType>(objectType_), objectHandle, static_cast<VkPrivateDataSlot>(privateDataSlot), data)); |
| if(result != VULKAN_HPP_NAMESPACE::Result::eSuccess) |
| { |
| throwResultException(result, VULKAN_HPP_NAMESPACE_STRING "::Device::setPrivateData"); |
| } |
| } |
| |
| VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE uint64_t Device::getPrivateData(VULKAN_HPP_NAMESPACE::ObjectType objectType_, |
| uint64_t objectHandle, |
| VULKAN_HPP_NAMESPACE::PrivateDataSlot privateDataSlot) const VULKAN_HPP_NOEXCEPT |
| { |
| uint64_t data; |
| getDispatcher()->vkGetPrivateData( |
| static_cast<VkDevice>(m_device), static_cast<VkObjectType>(objectType_), objectHandle, static_cast<VkPrivateDataSlot>(privateDataSlot), &data); |
| return data; |
| } |
| |
| VULKAN_HPP_INLINE void CommandBuffer::setEvent2(VULKAN_HPP_NAMESPACE::Event event, |
| const VULKAN_HPP_NAMESPACE::DependencyInfo &dependencyInfo) const VULKAN_HPP_NOEXCEPT |
| { |
| getDispatcher()->vkCmdSetEvent2( |
| static_cast<VkCommandBuffer>(m_commandBuffer), static_cast<VkEvent>(event), reinterpret_cast<const VkDependencyInfo *>(&dependencyInfo)); |
| } |
| |
| VULKAN_HPP_INLINE void CommandBuffer::resetEvent2(VULKAN_HPP_NAMESPACE::Event event, |
| VULKAN_HPP_NAMESPACE::PipelineStageFlags2 stageMask) const VULKAN_HPP_NOEXCEPT |
| { |
| getDispatcher()->vkCmdResetEvent2( |
| static_cast<VkCommandBuffer>(m_commandBuffer), static_cast<VkEvent>(event), static_cast<VkPipelineStageFlags2>(stageMask)); |
| } |
| |
| VULKAN_HPP_INLINE void CommandBuffer::waitEvents2(ArrayProxy<const VULKAN_HPP_NAMESPACE::Event> const &events, |
| ArrayProxy<const VULKAN_HPP_NAMESPACE::DependencyInfo> const &dependencyInfos) const |
| { |
| if(events.size() != dependencyInfos.size()) |
| { |
| throw LogicError(VULKAN_HPP_NAMESPACE_STRING "::CommandBuffer::waitEvents2: events.size() != dependencyInfos.size()"); |
| } |
| getDispatcher()->vkCmdWaitEvents2(static_cast<VkCommandBuffer>(m_commandBuffer), |
| events.size(), |
| reinterpret_cast<const VkEvent *>(events.data()), |
| reinterpret_cast<const VkDependencyInfo *>(dependencyInfos.data())); |
| } |
| |
| VULKAN_HPP_INLINE void CommandBuffer::pipelineBarrier2(const VULKAN_HPP_NAMESPACE::DependencyInfo &dependencyInfo) const VULKAN_HPP_NOEXCEPT |
| { |
| getDispatcher()->vkCmdPipelineBarrier2(static_cast<VkCommandBuffer>(m_commandBuffer), reinterpret_cast<const VkDependencyInfo *>(&dependencyInfo)); |
| } |
| |
| VULKAN_HPP_INLINE void CommandBuffer::writeTimestamp2(VULKAN_HPP_NAMESPACE::PipelineStageFlags2 stage, |
| VULKAN_HPP_NAMESPACE::QueryPool queryPool, |
| uint32_t query) const VULKAN_HPP_NOEXCEPT |
| { |
| getDispatcher()->vkCmdWriteTimestamp2( |
| static_cast<VkCommandBuffer>(m_commandBuffer), static_cast<VkPipelineStageFlags2>(stage), static_cast<VkQueryPool>(queryPool), query); |
| } |
| |
| VULKAN_HPP_INLINE void Queue::submit2(ArrayProxy<const VULKAN_HPP_NAMESPACE::SubmitInfo2> const &submits, VULKAN_HPP_NAMESPACE::Fence fence) const |
| { |
| VULKAN_HPP_NAMESPACE::Result result = static_cast<VULKAN_HPP_NAMESPACE::Result>(getDispatcher()->vkQueueSubmit2( |
| static_cast<VkQueue>(m_queue), submits.size(), reinterpret_cast<const VkSubmitInfo2 *>(submits.data()), static_cast<VkFence>(fence))); |
| if(result != VULKAN_HPP_NAMESPACE::Result::eSuccess) |
| { |
| throwResultException(result, VULKAN_HPP_NAMESPACE_STRING "::Queue::submit2"); |
| } |
| } |
| |
| VULKAN_HPP_INLINE void CommandBuffer::copyBuffer2(const VULKAN_HPP_NAMESPACE::CopyBufferInfo2 ©BufferInfo) const VULKAN_HPP_NOEXCEPT |
| { |
| getDispatcher()->vkCmdCopyBuffer2(static_cast<VkCommandBuffer>(m_commandBuffer), reinterpret_cast<const VkCopyBufferInfo2 *>(©BufferInfo)); |
| } |
| |
| VULKAN_HPP_INLINE void CommandBuffer::copyImage2(const VULKAN_HPP_NAMESPACE::CopyImageInfo2 ©ImageInfo) const VULKAN_HPP_NOEXCEPT |
| { |
| getDispatcher()->vkCmdCopyImage2(static_cast<VkCommandBuffer>(m_commandBuffer), reinterpret_cast<const VkCopyImageInfo2 *>(©ImageInfo)); |
| } |
| |
| VULKAN_HPP_INLINE void |
| CommandBuffer::copyBufferToImage2(const VULKAN_HPP_NAMESPACE::CopyBufferToImageInfo2 ©BufferToImageInfo) const VULKAN_HPP_NOEXCEPT |
| { |
| getDispatcher()->vkCmdCopyBufferToImage2(static_cast<VkCommandBuffer>(m_commandBuffer), |
| reinterpret_cast<const VkCopyBufferToImageInfo2 *>(©BufferToImageInfo)); |
| } |
| |
| VULKAN_HPP_INLINE void |
| CommandBuffer::copyImageToBuffer2(const VULKAN_HPP_NAMESPACE::CopyImageToBufferInfo2 ©ImageToBufferInfo) const VULKAN_HPP_NOEXCEPT |
| { |
| getDispatcher()->vkCmdCopyImageToBuffer2(static_cast<VkCommandBuffer>(m_commandBuffer), |
| reinterpret_cast<const VkCopyImageToBufferInfo2 *>(©ImageToBufferInfo)); |
| } |
| |
| VULKAN_HPP_INLINE void CommandBuffer::blitImage2(const VULKAN_HPP_NAMESPACE::BlitImageInfo2 &blitImageInfo) const VULKAN_HPP_NOEXCEPT |
| { |
| getDispatcher()->vkCmdBlitImage2(static_cast<VkCommandBuffer>(m_commandBuffer), reinterpret_cast<const VkBlitImageInfo2 *>(&blitImageInfo)); |
| } |
| |
| VULKAN_HPP_INLINE void CommandBuffer::resolveImage2(const VULKAN_HPP_NAMESPACE::ResolveImageInfo2 &resolveImageInfo) const VULKAN_HPP_NOEXCEPT |
| { |
| getDispatcher()->vkCmdResolveImage2(static_cast<VkCommandBuffer>(m_commandBuffer), |
| reinterpret_cast<const VkResolveImageInfo2 *>(&resolveImageInfo)); |
| } |
| |
| VULKAN_HPP_INLINE void CommandBuffer::beginRendering(const VULKAN_HPP_NAMESPACE::RenderingInfo &renderingInfo) const VULKAN_HPP_NOEXCEPT |
| { |
| getDispatcher()->vkCmdBeginRendering(static_cast<VkCommandBuffer>(m_commandBuffer), reinterpret_cast<const VkRenderingInfo *>(&renderingInfo)); |
| } |
| |
| VULKAN_HPP_INLINE void CommandBuffer::endRendering() const VULKAN_HPP_NOEXCEPT |
| { |
| getDispatcher()->vkCmdEndRendering(static_cast<VkCommandBuffer>(m_commandBuffer)); |
| } |
| |
| VULKAN_HPP_INLINE void CommandBuffer::setCullMode(VULKAN_HPP_NAMESPACE::CullModeFlags cullMode) const VULKAN_HPP_NOEXCEPT |
| { |
| getDispatcher()->vkCmdSetCullMode(static_cast<VkCommandBuffer>(m_commandBuffer), static_cast<VkCullModeFlags>(cullMode)); |
| } |
| |
| VULKAN_HPP_INLINE void CommandBuffer::setFrontFace(VULKAN_HPP_NAMESPACE::FrontFace frontFace) const VULKAN_HPP_NOEXCEPT |
| { |
| getDispatcher()->vkCmdSetFrontFace(static_cast<VkCommandBuffer>(m_commandBuffer), static_cast<VkFrontFace>(frontFace)); |
| } |
| |
| VULKAN_HPP_INLINE void CommandBuffer::setPrimitiveTopology(VULKAN_HPP_NAMESPACE::PrimitiveTopology primitiveTopology) const VULKAN_HPP_NOEXCEPT |
| { |
| getDispatcher()->vkCmdSetPrimitiveTopology(static_cast<VkCommandBuffer>(m_commandBuffer), static_cast<VkPrimitiveTopology>(primitiveTopology)); |
| } |
| |
| VULKAN_HPP_INLINE void CommandBuffer::setViewportWithCount(ArrayProxy<const VULKAN_HPP_NAMESPACE::Viewport> const &viewports) const VULKAN_HPP_NOEXCEPT |
| { |
| getDispatcher()->vkCmdSetViewportWithCount( |
| static_cast<VkCommandBuffer>(m_commandBuffer), viewports.size(), reinterpret_cast<const VkViewport *>(viewports.data())); |
| } |
| |
| VULKAN_HPP_INLINE void CommandBuffer::setScissorWithCount(ArrayProxy<const VULKAN_HPP_NAMESPACE::Rect2D> const &scissors) const VULKAN_HPP_NOEXCEPT |
| { |
| getDispatcher()->vkCmdSetScissorWithCount( |
| static_cast<VkCommandBuffer>(m_commandBuffer), scissors.size(), reinterpret_cast<const VkRect2D *>(scissors.data())); |
| } |
| |
| VULKAN_HPP_INLINE void CommandBuffer::bindVertexBuffers2(uint32_t firstBinding, |
| ArrayProxy<const VULKAN_HPP_NAMESPACE::Buffer> const &buffers, |
| ArrayProxy<const VULKAN_HPP_NAMESPACE::DeviceSize> const &offsets, |
| ArrayProxy<const VULKAN_HPP_NAMESPACE::DeviceSize> const &sizes, |
| ArrayProxy<const VULKAN_HPP_NAMESPACE::DeviceSize> const &strides) const |
| { |
| if(buffers.size() != offsets.size()) |
| { |
| throw LogicError(VULKAN_HPP_NAMESPACE_STRING "::CommandBuffer::bindVertexBuffers2: buffers.size() != offsets.size()"); |
| } |
| if(!sizes.empty() && buffers.size() != sizes.size()) |
| { |
| throw LogicError(VULKAN_HPP_NAMESPACE_STRING "::CommandBuffer::bindVertexBuffers2: buffers.size() != sizes.size()"); |
| } |
| if(!strides.empty() && buffers.size() != strides.size()) |
| { |
| throw LogicError(VULKAN_HPP_NAMESPACE_STRING "::CommandBuffer::bindVertexBuffers2: buffers.size() != strides.size()"); |
| } |
| getDispatcher()->vkCmdBindVertexBuffers2(static_cast<VkCommandBuffer>(m_commandBuffer), |
| firstBinding, |
| buffers.size(), |
| reinterpret_cast<const VkBuffer *>(buffers.data()), |
| reinterpret_cast<const VkDeviceSize *>(offsets.data()), |
| reinterpret_cast<const VkDeviceSize *>(sizes.data()), |
| reinterpret_cast<const VkDeviceSize *>(strides.data())); |
| } |
| |
| VULKAN_HPP_INLINE void CommandBuffer::setDepthTestEnable(VULKAN_HPP_NAMESPACE::Bool32 depthTestEnable) const VULKAN_HPP_NOEXCEPT |
| { |
| getDispatcher()->vkCmdSetDepthTestEnable(static_cast<VkCommandBuffer>(m_commandBuffer), static_cast<VkBool32>(depthTestEnable)); |
| } |
| |
| VULKAN_HPP_INLINE void CommandBuffer::setDepthWriteEnable(VULKAN_HPP_NAMESPACE::Bool32 depthWriteEnable) const VULKAN_HPP_NOEXCEPT |
| { |
| getDispatcher()->vkCmdSetDepthWriteEnable(static_cast<VkCommandBuffer>(m_commandBuffer), static_cast<VkBool32>(depthWriteEnable)); |
| } |
| |
| VULKAN_HPP_INLINE void CommandBuffer::setDepthCompareOp(VULKAN_HPP_NAMESPACE::CompareOp depthCompareOp) const VULKAN_HPP_NOEXCEPT |
| { |
| getDispatcher()->vkCmdSetDepthCompareOp(static_cast<VkCommandBuffer>(m_commandBuffer), static_cast<VkCompareOp>(depthCompareOp)); |
| } |
| |
| VULKAN_HPP_INLINE void CommandBuffer::setDepthBoundsTestEnable(VULKAN_HPP_NAMESPACE::Bool32 depthBoundsTestEnable) const VULKAN_HPP_NOEXCEPT |
| { |
| getDispatcher()->vkCmdSetDepthBoundsTestEnable(static_cast<VkCommandBuffer>(m_commandBuffer), static_cast<VkBool32>(depthBoundsTestEnable)); |
| } |
| |
| VULKAN_HPP_INLINE void CommandBuffer::setStencilTestEnable(VULKAN_HPP_NAMESPACE::Bool32 stencilTestEnable) const VULKAN_HPP_NOEXCEPT |
| { |
| getDispatcher()->vkCmdSetStencilTestEnable(static_cast<VkCommandBuffer>(m_commandBuffer), static_cast<VkBool32>(stencilTestEnable)); |
| } |
| |
| VULKAN_HPP_INLINE void CommandBuffer::setStencilOp(VULKAN_HPP_NAMESPACE::StencilFaceFlags faceMask, |
| VULKAN_HPP_NAMESPACE::StencilOp failOp, |
| VULKAN_HPP_NAMESPACE::StencilOp passOp, |
| VULKAN_HPP_NAMESPACE::StencilOp depthFailOp, |
| VULKAN_HPP_NAMESPACE::CompareOp compareOp) const VULKAN_HPP_NOEXCEPT |
| { |
| getDispatcher()->vkCmdSetStencilOp(static_cast<VkCommandBuffer>(m_commandBuffer), |
| static_cast<VkStencilFaceFlags>(faceMask), |
| static_cast<VkStencilOp>(failOp), |
| static_cast<VkStencilOp>(passOp), |
| static_cast<VkStencilOp>(depthFailOp), |
| static_cast<VkCompareOp>(compareOp)); |
| } |
| |
| VULKAN_HPP_INLINE void CommandBuffer::setRasterizerDiscardEnable(VULKAN_HPP_NAMESPACE::Bool32 rasterizerDiscardEnable) const VULKAN_HPP_NOEXCEPT |
| { |
| getDispatcher()->vkCmdSetRasterizerDiscardEnable(static_cast<VkCommandBuffer>(m_commandBuffer), static_cast<VkBool32>(rasterizerDiscardEnable)); |
| } |
| |
| VULKAN_HPP_INLINE void CommandBuffer::setDepthBiasEnable(VULKAN_HPP_NAMESPACE::Bool32 depthBiasEnable) const VULKAN_HPP_NOEXCEPT |
| { |
| getDispatcher()->vkCmdSetDepthBiasEnable(static_cast<VkCommandBuffer>(m_commandBuffer), static_cast<VkBool32>(depthBiasEnable)); |
| } |
| |
| VULKAN_HPP_INLINE void CommandBuffer::setPrimitiveRestartEnable(VULKAN_HPP_NAMESPACE::Bool32 primitiveRestartEnable) const VULKAN_HPP_NOEXCEPT |
| { |
| getDispatcher()->vkCmdSetPrimitiveRestartEnable(static_cast<VkCommandBuffer>(m_commandBuffer), static_cast<VkBool32>(primitiveRestartEnable)); |
| } |
| |
| VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE VULKAN_HPP_NAMESPACE::MemoryRequirements2 |
| Device::getBufferMemoryRequirements(const VULKAN_HPP_NAMESPACE::DeviceBufferMemoryRequirements &info) const VULKAN_HPP_NOEXCEPT |
| { |
| VULKAN_HPP_NAMESPACE::MemoryRequirements2 memoryRequirements; |
| getDispatcher()->vkGetDeviceBufferMemoryRequirements(static_cast<VkDevice>(m_device), |
| reinterpret_cast<const VkDeviceBufferMemoryRequirements *>(&info), |
| reinterpret_cast<VkMemoryRequirements2 *>(&memoryRequirements)); |
| return memoryRequirements; |
| } |
| |
| template<typename X, typename Y, typename... Z> |
| VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE StructureChain<X, Y, Z...> |
| Device::getBufferMemoryRequirements(const VULKAN_HPP_NAMESPACE::DeviceBufferMemoryRequirements &info) const VULKAN_HPP_NOEXCEPT |
| { |
| StructureChain<X, Y, Z...> structureChain; |
| VULKAN_HPP_NAMESPACE::MemoryRequirements2 &memoryRequirements = structureChain.template get<VULKAN_HPP_NAMESPACE::MemoryRequirements2>(); |
| getDispatcher()->vkGetDeviceBufferMemoryRequirements(static_cast<VkDevice>(m_device), |
| reinterpret_cast<const VkDeviceBufferMemoryRequirements *>(&info), |
| reinterpret_cast<VkMemoryRequirements2 *>(&memoryRequirements)); |
| return structureChain; |
| } |
| |
| VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE VULKAN_HPP_NAMESPACE::MemoryRequirements2 |
| Device::getImageMemoryRequirements(const VULKAN_HPP_NAMESPACE::DeviceImageMemoryRequirements &info) const VULKAN_HPP_NOEXCEPT |
| { |
| VULKAN_HPP_NAMESPACE::MemoryRequirements2 memoryRequirements; |
| getDispatcher()->vkGetDeviceImageMemoryRequirements(static_cast<VkDevice>(m_device), |
| reinterpret_cast<const VkDeviceImageMemoryRequirements *>(&info), |
| reinterpret_cast<VkMemoryRequirements2 *>(&memoryRequirements)); |
| return memoryRequirements; |
| } |
| |
| template<typename X, typename Y, typename... Z> |
| VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE StructureChain<X, Y, Z...> |
| Device::getImageMemoryRequirements(const VULKAN_HPP_NAMESPACE::DeviceImageMemoryRequirements &info) const VULKAN_HPP_NOEXCEPT |
| { |
| StructureChain<X, Y, Z...> structureChain; |
| VULKAN_HPP_NAMESPACE::MemoryRequirements2 &memoryRequirements = structureChain.template get<VULKAN_HPP_NAMESPACE::MemoryRequirements2>(); |
| getDispatcher()->vkGetDeviceImageMemoryRequirements(static_cast<VkDevice>(m_device), |
| reinterpret_cast<const VkDeviceImageMemoryRequirements *>(&info), |
| reinterpret_cast<VkMemoryRequirements2 *>(&memoryRequirements)); |
| return structureChain; |
| } |
| |
| VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE std::vector<VULKAN_HPP_NAMESPACE::SparseImageMemoryRequirements2> |
| Device::getImageSparseMemoryRequirements(const VULKAN_HPP_NAMESPACE::DeviceImageMemoryRequirements &info) const VULKAN_HPP_NOEXCEPT |
| { |
| uint32_t sparseMemoryRequirementCount; |
| getDispatcher()->vkGetDeviceImageSparseMemoryRequirements( |
| static_cast<VkDevice>(m_device), reinterpret_cast<const VkDeviceImageMemoryRequirements *>(&info), &sparseMemoryRequirementCount, nullptr); |
| std::vector<VULKAN_HPP_NAMESPACE::SparseImageMemoryRequirements2> sparseMemoryRequirements(sparseMemoryRequirementCount); |
| getDispatcher()->vkGetDeviceImageSparseMemoryRequirements(static_cast<VkDevice>(m_device), |
| reinterpret_cast<const VkDeviceImageMemoryRequirements *>(&info), |
| &sparseMemoryRequirementCount, |
| reinterpret_cast<VkSparseImageMemoryRequirements2 *>(sparseMemoryRequirements.data())); |
| VULKAN_HPP_ASSERT(sparseMemoryRequirementCount == sparseMemoryRequirements.size()); |
| return sparseMemoryRequirements; |
| } |
| |
| //=== VK_KHR_surface === |
| |
| VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE VULKAN_HPP_NAMESPACE::Bool32 PhysicalDevice::getSurfaceSupportKHR(uint32_t queueFamilyIndex, |
| VULKAN_HPP_NAMESPACE::SurfaceKHR surface) const |
| { |
| VULKAN_HPP_ASSERT(getDispatcher()->vkGetPhysicalDeviceSurfaceSupportKHR && |
| "Function <vkGetPhysicalDeviceSurfaceSupportKHR> needs extension <VK_KHR_surface> enabled!"); |
| |
| VULKAN_HPP_NAMESPACE::Bool32 supported; |
| VULKAN_HPP_NAMESPACE::Result result = |
| static_cast<VULKAN_HPP_NAMESPACE::Result>(getDispatcher()->vkGetPhysicalDeviceSurfaceSupportKHR(static_cast<VkPhysicalDevice>(m_physicalDevice), |
| queueFamilyIndex, |
| static_cast<VkSurfaceKHR>(surface), |
| reinterpret_cast<VkBool32 *>(&supported))); |
| if(result != VULKAN_HPP_NAMESPACE::Result::eSuccess) |
| { |
| throwResultException(result, VULKAN_HPP_NAMESPACE_STRING "::PhysicalDevice::getSurfaceSupportKHR"); |
| } |
| return supported; |
| } |
| |
| VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE VULKAN_HPP_NAMESPACE::SurfaceCapabilitiesKHR |
| PhysicalDevice::getSurfaceCapabilitiesKHR(VULKAN_HPP_NAMESPACE::SurfaceKHR surface) const |
| { |
| VULKAN_HPP_ASSERT(getDispatcher()->vkGetPhysicalDeviceSurfaceCapabilitiesKHR && |
| "Function <vkGetPhysicalDeviceSurfaceCapabilitiesKHR> needs extension <VK_KHR_surface> enabled!"); |
| |
| VULKAN_HPP_NAMESPACE::SurfaceCapabilitiesKHR surfaceCapabilities; |
| VULKAN_HPP_NAMESPACE::Result result = static_cast<VULKAN_HPP_NAMESPACE::Result>( |
| getDispatcher()->vkGetPhysicalDeviceSurfaceCapabilitiesKHR(static_cast<VkPhysicalDevice>(m_physicalDevice), |
| static_cast<VkSurfaceKHR>(surface), |
| reinterpret_cast<VkSurfaceCapabilitiesKHR *>(&surfaceCapabilities))); |
| if(result != VULKAN_HPP_NAMESPACE::Result::eSuccess) |
| { |
| throwResultException(result, VULKAN_HPP_NAMESPACE_STRING "::PhysicalDevice::getSurfaceCapabilitiesKHR"); |
| } |
| return surfaceCapabilities; |
| } |
| |
| VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE std::vector<VULKAN_HPP_NAMESPACE::SurfaceFormatKHR> |
| PhysicalDevice::getSurfaceFormatsKHR(VULKAN_HPP_NAMESPACE::SurfaceKHR surface) const |
| { |
| VULKAN_HPP_ASSERT(getDispatcher()->vkGetPhysicalDeviceSurfaceFormatsKHR && |
| "Function <vkGetPhysicalDeviceSurfaceFormatsKHR> needs extension <VK_KHR_surface> enabled!"); |
| |
| std::vector<VULKAN_HPP_NAMESPACE::SurfaceFormatKHR> surfaceFormats; |
| uint32_t surfaceFormatCount; |
| VULKAN_HPP_NAMESPACE::Result result; |
| do |
| { |
| result = static_cast<VULKAN_HPP_NAMESPACE::Result>(getDispatcher()->vkGetPhysicalDeviceSurfaceFormatsKHR( |
| static_cast<VkPhysicalDevice>(m_physicalDevice), static_cast<VkSurfaceKHR>(surface), &surfaceFormatCount, nullptr)); |
| if((result == VULKAN_HPP_NAMESPACE::Result::eSuccess) && surfaceFormatCount) |
| { |
| surfaceFormats.resize(surfaceFormatCount); |
| result = static_cast<VULKAN_HPP_NAMESPACE::Result>( |
| getDispatcher()->vkGetPhysicalDeviceSurfaceFormatsKHR(static_cast<VkPhysicalDevice>(m_physicalDevice), |
| static_cast<VkSurfaceKHR>(surface), |
| &surfaceFormatCount, |
| reinterpret_cast<VkSurfaceFormatKHR *>(surfaceFormats.data()))); |
| } |
| } while(result == VULKAN_HPP_NAMESPACE::Result::eIncomplete); |
| if(result != VULKAN_HPP_NAMESPACE::Result::eSuccess) |
| { |
| throwResultException(result, VULKAN_HPP_NAMESPACE_STRING "::PhysicalDevice::getSurfaceFormatsKHR"); |
| } |
| if(result == VULKAN_HPP_NAMESPACE::Result::eSuccess) |
| { |
| VULKAN_HPP_ASSERT(surfaceFormatCount <= surfaceFormats.size()); |
| if(surfaceFormatCount < surfaceFormats.size()) |
| { |
| surfaceFormats.resize(surfaceFormatCount); |
| } |
| } |
| return surfaceFormats; |
| } |
| |
| VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE std::vector<VULKAN_HPP_NAMESPACE::PresentModeKHR> |
| PhysicalDevice::getSurfacePresentModesKHR(VULKAN_HPP_NAMESPACE::SurfaceKHR surface) const |
| { |
| VULKAN_HPP_ASSERT(getDispatcher()->vkGetPhysicalDeviceSurfacePresentModesKHR && |
| "Function <vkGetPhysicalDeviceSurfacePresentModesKHR> needs extension <VK_KHR_surface> enabled!"); |
| |
| std::vector<VULKAN_HPP_NAMESPACE::PresentModeKHR> presentModes; |
| uint32_t presentModeCount; |
| VULKAN_HPP_NAMESPACE::Result result; |
| do |
| { |
| result = static_cast<VULKAN_HPP_NAMESPACE::Result>(getDispatcher()->vkGetPhysicalDeviceSurfacePresentModesKHR( |
| static_cast<VkPhysicalDevice>(m_physicalDevice), static_cast<VkSurfaceKHR>(surface), &presentModeCount, nullptr)); |
| if((result == VULKAN_HPP_NAMESPACE::Result::eSuccess) && presentModeCount) |
| { |
| presentModes.resize(presentModeCount); |
| result = static_cast<VULKAN_HPP_NAMESPACE::Result>( |
| getDispatcher()->vkGetPhysicalDeviceSurfacePresentModesKHR(static_cast<VkPhysicalDevice>(m_physicalDevice), |
| static_cast<VkSurfaceKHR>(surface), |
| &presentModeCount, |
| reinterpret_cast<VkPresentModeKHR *>(presentModes.data()))); |
| } |
| } while(result == VULKAN_HPP_NAMESPACE::Result::eIncomplete); |
| if(result != VULKAN_HPP_NAMESPACE::Result::eSuccess) |
| { |
| throwResultException(result, VULKAN_HPP_NAMESPACE_STRING "::PhysicalDevice::getSurfacePresentModesKHR"); |
| } |
| if(result == VULKAN_HPP_NAMESPACE::Result::eSuccess) |
| { |
| VULKAN_HPP_ASSERT(presentModeCount <= presentModes.size()); |
| if(presentModeCount < presentModes.size()) |
| { |
| presentModes.resize(presentModeCount); |
| } |
| } |
| return presentModes; |
| } |
| |
| //=== VK_KHR_swapchain === |
| |
| VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE VULKAN_HPP_RAII_NAMESPACE::SwapchainKHR |
| Device::createSwapchainKHR(VULKAN_HPP_NAMESPACE::SwapchainCreateInfoKHR const &createInfo, |
| VULKAN_HPP_NAMESPACE::Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator) const |
| { |
| return VULKAN_HPP_RAII_NAMESPACE::SwapchainKHR(*this, createInfo, allocator); |
| } |
| |
| VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE std::vector<VkImage> SwapchainKHR::getImages() const |
| { |
| VULKAN_HPP_ASSERT(getDispatcher()->vkGetSwapchainImagesKHR && "Function <vkGetSwapchainImagesKHR> needs extension <VK_KHR_swapchain> enabled!"); |
| |
| std::vector<VkImage> swapchainImages; |
| uint32_t swapchainImageCount; |
| VULKAN_HPP_NAMESPACE::Result result; |
| do |
| { |
| result = static_cast<VULKAN_HPP_NAMESPACE::Result>(getDispatcher()->vkGetSwapchainImagesKHR( |
| static_cast<VkDevice>(m_device), static_cast<VkSwapchainKHR>(m_swapchain), &swapchainImageCount, nullptr)); |
| if((result == VULKAN_HPP_NAMESPACE::Result::eSuccess) && swapchainImageCount) |
| { |
| swapchainImages.resize(swapchainImageCount); |
| result = static_cast<VULKAN_HPP_NAMESPACE::Result>(getDispatcher()->vkGetSwapchainImagesKHR( |
| static_cast<VkDevice>(m_device), static_cast<VkSwapchainKHR>(m_swapchain), &swapchainImageCount, swapchainImages.data())); |
| } |
| } while(result == VULKAN_HPP_NAMESPACE::Result::eIncomplete); |
| if(result != VULKAN_HPP_NAMESPACE::Result::eSuccess) |
| { |
| throwResultException(result, VULKAN_HPP_NAMESPACE_STRING "::SwapchainKHR::getImages"); |
| } |
| if(result == VULKAN_HPP_NAMESPACE::Result::eSuccess) |
| { |
| VULKAN_HPP_ASSERT(swapchainImageCount <= swapchainImages.size()); |
| if(swapchainImageCount < swapchainImages.size()) |
| { |
| swapchainImages.resize(swapchainImageCount); |
| } |
| } |
| return swapchainImages; |
| } |
| |
| VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE std::pair<VULKAN_HPP_NAMESPACE::Result, uint32_t> |
| SwapchainKHR::acquireNextImage(uint64_t timeout, VULKAN_HPP_NAMESPACE::Semaphore semaphore, VULKAN_HPP_NAMESPACE::Fence fence) const |
| { |
| VULKAN_HPP_ASSERT(getDispatcher()->vkAcquireNextImageKHR && "Function <vkAcquireNextImageKHR> needs extension <VK_KHR_swapchain> enabled!"); |
| |
| uint32_t imageIndex; |
| VULKAN_HPP_NAMESPACE::Result result = |
| static_cast<VULKAN_HPP_NAMESPACE::Result>(getDispatcher()->vkAcquireNextImageKHR(static_cast<VkDevice>(m_device), |
| static_cast<VkSwapchainKHR>(m_swapchain), |
| timeout, |
| static_cast<VkSemaphore>(semaphore), |
| static_cast<VkFence>(fence), |
| &imageIndex)); |
| if((result != VULKAN_HPP_NAMESPACE::Result::eSuccess) && (result != VULKAN_HPP_NAMESPACE::Result::eTimeout) && |
| (result != VULKAN_HPP_NAMESPACE::Result::eNotReady) && (result != VULKAN_HPP_NAMESPACE::Result::eSuboptimalKHR)) |
| { |
| throwResultException(result, VULKAN_HPP_NAMESPACE_STRING "::SwapchainKHR::acquireNextImage"); |
| } |
| return std::make_pair(result, imageIndex); |
| } |
| |
| VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE VULKAN_HPP_NAMESPACE::Result Queue::presentKHR(const VULKAN_HPP_NAMESPACE::PresentInfoKHR &presentInfo) const |
| { |
| VULKAN_HPP_ASSERT(getDispatcher()->vkQueuePresentKHR && "Function <vkQueuePresentKHR> needs extension <VK_KHR_swapchain> enabled!"); |
| |
| VULKAN_HPP_NAMESPACE::Result result = static_cast<VULKAN_HPP_NAMESPACE::Result>( |
| getDispatcher()->vkQueuePresentKHR(static_cast<VkQueue>(m_queue), reinterpret_cast<const VkPresentInfoKHR *>(&presentInfo))); |
| if((result != VULKAN_HPP_NAMESPACE::Result::eSuccess) && (result != VULKAN_HPP_NAMESPACE::Result::eSuboptimalKHR)) |
| { |
| throwResultException(result, VULKAN_HPP_NAMESPACE_STRING "::Queue::presentKHR"); |
| } |
| return result; |
| } |
| |
| VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE VULKAN_HPP_NAMESPACE::DeviceGroupPresentCapabilitiesKHR Device::getGroupPresentCapabilitiesKHR() const |
| { |
| VULKAN_HPP_ASSERT(getDispatcher()->vkGetDeviceGroupPresentCapabilitiesKHR && |
| "Function <vkGetDeviceGroupPresentCapabilitiesKHR> needs extension <VK_KHR_swapchain> enabled!"); |
| |
| VULKAN_HPP_NAMESPACE::DeviceGroupPresentCapabilitiesKHR deviceGroupPresentCapabilities; |
| VULKAN_HPP_NAMESPACE::Result result = static_cast<VULKAN_HPP_NAMESPACE::Result>(getDispatcher()->vkGetDeviceGroupPresentCapabilitiesKHR( |
| static_cast<VkDevice>(m_device), reinterpret_cast<VkDeviceGroupPresentCapabilitiesKHR *>(&deviceGroupPresentCapabilities))); |
| if(result != VULKAN_HPP_NAMESPACE::Result::eSuccess) |
| { |
| throwResultException(result, VULKAN_HPP_NAMESPACE_STRING "::Device::getGroupPresentCapabilitiesKHR"); |
| } |
| return deviceGroupPresentCapabilities; |
| } |
| |
| VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE VULKAN_HPP_NAMESPACE::DeviceGroupPresentModeFlagsKHR |
| Device::getGroupSurfacePresentModesKHR(VULKAN_HPP_NAMESPACE::SurfaceKHR surface) const |
| { |
| VULKAN_HPP_ASSERT(getDispatcher()->vkGetDeviceGroupSurfacePresentModesKHR && |
| "Function <vkGetDeviceGroupSurfacePresentModesKHR> needs extension <VK_KHR_swapchain> enabled!"); |
| |
| VULKAN_HPP_NAMESPACE::DeviceGroupPresentModeFlagsKHR modes; |
| VULKAN_HPP_NAMESPACE::Result result = static_cast<VULKAN_HPP_NAMESPACE::Result>(getDispatcher()->vkGetDeviceGroupSurfacePresentModesKHR( |
| static_cast<VkDevice>(m_device), static_cast<VkSurfaceKHR>(surface), reinterpret_cast<VkDeviceGroupPresentModeFlagsKHR *>(&modes))); |
| if(result != VULKAN_HPP_NAMESPACE::Result::eSuccess) |
| { |
| throwResultException(result, VULKAN_HPP_NAMESPACE_STRING "::Device::getGroupSurfacePresentModesKHR"); |
| } |
| return modes; |
| } |
| |
| VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE std::vector<VULKAN_HPP_NAMESPACE::Rect2D> |
| PhysicalDevice::getPresentRectanglesKHR(VULKAN_HPP_NAMESPACE::SurfaceKHR surface) const |
| { |
| VULKAN_HPP_ASSERT(getDispatcher()->vkGetPhysicalDevicePresentRectanglesKHR && |
| "Function <vkGetPhysicalDevicePresentRectanglesKHR> needs extension <VK_KHR_swapchain> enabled!"); |
| |
| std::vector<VULKAN_HPP_NAMESPACE::Rect2D> rects; |
| uint32_t rectCount; |
| VULKAN_HPP_NAMESPACE::Result result; |
| do |
| { |
| result = static_cast<VULKAN_HPP_NAMESPACE::Result>(getDispatcher()->vkGetPhysicalDevicePresentRectanglesKHR( |
| static_cast<VkPhysicalDevice>(m_physicalDevice), static_cast<VkSurfaceKHR>(surface), &rectCount, nullptr)); |
| if((result == VULKAN_HPP_NAMESPACE::Result::eSuccess) && rectCount) |
| { |
| rects.resize(rectCount); |
| result = static_cast<VULKAN_HPP_NAMESPACE::Result>( |
| getDispatcher()->vkGetPhysicalDevicePresentRectanglesKHR(static_cast<VkPhysicalDevice>(m_physicalDevice), |
| static_cast<VkSurfaceKHR>(surface), |
| &rectCount, |
| reinterpret_cast<VkRect2D *>(rects.data()))); |
| } |
| } while(result == VULKAN_HPP_NAMESPACE::Result::eIncomplete); |
| if(result != VULKAN_HPP_NAMESPACE::Result::eSuccess) |
| { |
| throwResultException(result, VULKAN_HPP_NAMESPACE_STRING "::PhysicalDevice::getPresentRectanglesKHR"); |
| } |
| if(result == VULKAN_HPP_NAMESPACE::Result::eSuccess) |
| { |
| VULKAN_HPP_ASSERT(rectCount <= rects.size()); |
| if(rectCount < rects.size()) |
| { |
| rects.resize(rectCount); |
| } |
| } |
| return rects; |
| } |
| |
| VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE std::pair<VULKAN_HPP_NAMESPACE::Result, uint32_t> |
| Device::acquireNextImage2KHR(const VULKAN_HPP_NAMESPACE::AcquireNextImageInfoKHR &acquireInfo) const |
| { |
| VULKAN_HPP_ASSERT(getDispatcher()->vkAcquireNextImage2KHR && "Function <vkAcquireNextImage2KHR> needs extension <VK_KHR_swapchain> enabled!"); |
| |
| uint32_t imageIndex; |
| VULKAN_HPP_NAMESPACE::Result result = static_cast<VULKAN_HPP_NAMESPACE::Result>(getDispatcher()->vkAcquireNextImage2KHR( |
| static_cast<VkDevice>(m_device), reinterpret_cast<const VkAcquireNextImageInfoKHR *>(&acquireInfo), &imageIndex)); |
| if((result != VULKAN_HPP_NAMESPACE::Result::eSuccess) && (result != VULKAN_HPP_NAMESPACE::Result::eTimeout) && |
| (result != VULKAN_HPP_NAMESPACE::Result::eNotReady) && (result != VULKAN_HPP_NAMESPACE::Result::eSuboptimalKHR)) |
| { |
| throwResultException(result, VULKAN_HPP_NAMESPACE_STRING "::Device::acquireNextImage2KHR"); |
| } |
| return std::make_pair(result, imageIndex); |
| } |
| |
| //=== VK_KHR_display === |
| |
| VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE std::vector<VULKAN_HPP_NAMESPACE::DisplayPropertiesKHR> PhysicalDevice::getDisplayPropertiesKHR() const |
| { |
| VULKAN_HPP_ASSERT(getDispatcher()->vkGetPhysicalDeviceDisplayPropertiesKHR && |
| "Function <vkGetPhysicalDeviceDisplayPropertiesKHR> needs extension <VK_KHR_display> enabled!"); |
| |
| std::vector<VULKAN_HPP_NAMESPACE::DisplayPropertiesKHR> properties; |
| uint32_t propertyCount; |
| VULKAN_HPP_NAMESPACE::Result result; |
| do |
| { |
| result = static_cast<VULKAN_HPP_NAMESPACE::Result>( |
| getDispatcher()->vkGetPhysicalDeviceDisplayPropertiesKHR(static_cast<VkPhysicalDevice>(m_physicalDevice), &propertyCount, nullptr)); |
| if((result == VULKAN_HPP_NAMESPACE::Result::eSuccess) && propertyCount) |
| { |
| properties.resize(propertyCount); |
| result = static_cast<VULKAN_HPP_NAMESPACE::Result>(getDispatcher()->vkGetPhysicalDeviceDisplayPropertiesKHR( |
| static_cast<VkPhysicalDevice>(m_physicalDevice), &propertyCount, reinterpret_cast<VkDisplayPropertiesKHR *>(properties.data()))); |
| } |
| } while(result == VULKAN_HPP_NAMESPACE::Result::eIncomplete); |
| if(result != VULKAN_HPP_NAMESPACE::Result::eSuccess) |
| { |
| throwResultException(result, VULKAN_HPP_NAMESPACE_STRING "::PhysicalDevice::getDisplayPropertiesKHR"); |
| } |
| if(result == VULKAN_HPP_NAMESPACE::Result::eSuccess) |
| { |
| VULKAN_HPP_ASSERT(propertyCount <= properties.size()); |
| if(propertyCount < properties.size()) |
| { |
| properties.resize(propertyCount); |
| } |
| } |
| return properties; |
| } |
| |
| VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE std::vector<VULKAN_HPP_NAMESPACE::DisplayPlanePropertiesKHR> PhysicalDevice::getDisplayPlanePropertiesKHR() const |
| { |
| VULKAN_HPP_ASSERT(getDispatcher()->vkGetPhysicalDeviceDisplayPlanePropertiesKHR && |
| "Function <vkGetPhysicalDeviceDisplayPlanePropertiesKHR> needs extension <VK_KHR_display> enabled!"); |
| |
| std::vector<VULKAN_HPP_NAMESPACE::DisplayPlanePropertiesKHR> properties; |
| uint32_t propertyCount; |
| VULKAN_HPP_NAMESPACE::Result result; |
| do |
| { |
| result = static_cast<VULKAN_HPP_NAMESPACE::Result>( |
| getDispatcher()->vkGetPhysicalDeviceDisplayPlanePropertiesKHR(static_cast<VkPhysicalDevice>(m_physicalDevice), &propertyCount, nullptr)); |
| if((result == VULKAN_HPP_NAMESPACE::Result::eSuccess) && propertyCount) |
| { |
| properties.resize(propertyCount); |
| result = static_cast<VULKAN_HPP_NAMESPACE::Result>(getDispatcher()->vkGetPhysicalDeviceDisplayPlanePropertiesKHR( |
| static_cast<VkPhysicalDevice>(m_physicalDevice), &propertyCount, reinterpret_cast<VkDisplayPlanePropertiesKHR *>(properties.data()))); |
| } |
| } while(result == VULKAN_HPP_NAMESPACE::Result::eIncomplete); |
| if(result != VULKAN_HPP_NAMESPACE::Result::eSuccess) |
| { |
| throwResultException(result, VULKAN_HPP_NAMESPACE_STRING "::PhysicalDevice::getDisplayPlanePropertiesKHR"); |
| } |
| if(result == VULKAN_HPP_NAMESPACE::Result::eSuccess) |
| { |
| VULKAN_HPP_ASSERT(propertyCount <= properties.size()); |
| if(propertyCount < properties.size()) |
| { |
| properties.resize(propertyCount); |
| } |
| } |
| return properties; |
| } |
| |
| VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE std::vector<VULKAN_HPP_RAII_NAMESPACE::DisplayKHR> |
| PhysicalDevice::getDisplayPlaneSupportedDisplaysKHR(uint32_t planeIndex) const |
| { |
| return VULKAN_HPP_RAII_NAMESPACE::DisplayKHRs(*this, planeIndex); |
| } |
| |
| VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE std::vector<VULKAN_HPP_NAMESPACE::DisplayModePropertiesKHR> DisplayKHR::getModeProperties() const |
| { |
| VULKAN_HPP_ASSERT(getDispatcher()->vkGetDisplayModePropertiesKHR && |
| "Function <vkGetDisplayModePropertiesKHR> needs extension <VK_KHR_display> enabled!"); |
| |
| std::vector<VULKAN_HPP_NAMESPACE::DisplayModePropertiesKHR> properties; |
| uint32_t propertyCount; |
| VULKAN_HPP_NAMESPACE::Result result; |
| do |
| { |
| result = static_cast<VULKAN_HPP_NAMESPACE::Result>(getDispatcher()->vkGetDisplayModePropertiesKHR( |
| static_cast<VkPhysicalDevice>(m_physicalDevice), static_cast<VkDisplayKHR>(m_display), &propertyCount, nullptr)); |
| if((result == VULKAN_HPP_NAMESPACE::Result::eSuccess) && propertyCount) |
| { |
| properties.resize(propertyCount); |
| result = static_cast<VULKAN_HPP_NAMESPACE::Result>( |
| getDispatcher()->vkGetDisplayModePropertiesKHR(static_cast<VkPhysicalDevice>(m_physicalDevice), |
| static_cast<VkDisplayKHR>(m_display), |
| &propertyCount, |
| reinterpret_cast<VkDisplayModePropertiesKHR *>(properties.data()))); |
| } |
| } while(result == VULKAN_HPP_NAMESPACE::Result::eIncomplete); |
| if(result != VULKAN_HPP_NAMESPACE::Result::eSuccess) |
| { |
| throwResultException(result, VULKAN_HPP_NAMESPACE_STRING "::DisplayKHR::getModeProperties"); |
| } |
| if(result == VULKAN_HPP_NAMESPACE::Result::eSuccess) |
| { |
| VULKAN_HPP_ASSERT(propertyCount <= properties.size()); |
| if(propertyCount < properties.size()) |
| { |
| properties.resize(propertyCount); |
| } |
| } |
| return properties; |
| } |
| |
| VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE VULKAN_HPP_RAII_NAMESPACE::DisplayModeKHR |
| DisplayKHR::createMode(VULKAN_HPP_NAMESPACE::DisplayModeCreateInfoKHR const &createInfo, |
| VULKAN_HPP_NAMESPACE::Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator) const |
| { |
| return VULKAN_HPP_RAII_NAMESPACE::DisplayModeKHR(*this, createInfo, allocator); |
| } |
| |
| VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE VULKAN_HPP_NAMESPACE::DisplayPlaneCapabilitiesKHR |
| DisplayModeKHR::getDisplayPlaneCapabilities(uint32_t planeIndex) const |
| { |
| VULKAN_HPP_ASSERT(getDispatcher()->vkGetDisplayPlaneCapabilitiesKHR && |
| "Function <vkGetDisplayPlaneCapabilitiesKHR> needs extension <VK_KHR_display> enabled!"); |
| |
| VULKAN_HPP_NAMESPACE::DisplayPlaneCapabilitiesKHR capabilities; |
| VULKAN_HPP_NAMESPACE::Result result = static_cast<VULKAN_HPP_NAMESPACE::Result>( |
| getDispatcher()->vkGetDisplayPlaneCapabilitiesKHR(static_cast<VkPhysicalDevice>(m_physicalDevice), |
| static_cast<VkDisplayModeKHR>(m_displayModeKHR), |
| planeIndex, |
| reinterpret_cast<VkDisplayPlaneCapabilitiesKHR *>(&capabilities))); |
| if(result != VULKAN_HPP_NAMESPACE::Result::eSuccess) |
| { |
| throwResultException(result, VULKAN_HPP_NAMESPACE_STRING "::DisplayModeKHR::getDisplayPlaneCapabilities"); |
| } |
| return capabilities; |
| } |
| |
| VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE VULKAN_HPP_RAII_NAMESPACE::SurfaceKHR |
| Instance::createDisplayPlaneSurfaceKHR(VULKAN_HPP_NAMESPACE::DisplaySurfaceCreateInfoKHR const &createInfo, |
| VULKAN_HPP_NAMESPACE::Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator) const |
| { |
| return VULKAN_HPP_RAII_NAMESPACE::SurfaceKHR(*this, createInfo, allocator); |
| } |
| |
| //=== VK_KHR_display_swapchain === |
| |
| VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE std::vector<VULKAN_HPP_RAII_NAMESPACE::SwapchainKHR> |
| Device::createSharedSwapchainsKHR(VULKAN_HPP_NAMESPACE::ArrayProxy<VULKAN_HPP_NAMESPACE::SwapchainCreateInfoKHR> const &createInfos, |
| VULKAN_HPP_NAMESPACE::Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator) const |
| { |
| return VULKAN_HPP_RAII_NAMESPACE::SwapchainKHRs(*this, createInfos, allocator); |
| } |
| |
| VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE VULKAN_HPP_RAII_NAMESPACE::SwapchainKHR |
| Device::createSharedSwapchainKHR(VULKAN_HPP_NAMESPACE::SwapchainCreateInfoKHR const &createInfo, |
| VULKAN_HPP_NAMESPACE::Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator) const |
| { |
| return VULKAN_HPP_RAII_NAMESPACE::SwapchainKHR(*this, createInfo, allocator); |
| } |
| |
| # if defined(VK_USE_PLATFORM_XLIB_KHR) |
| //=== VK_KHR_xlib_surface === |
| |
| VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE VULKAN_HPP_RAII_NAMESPACE::SurfaceKHR |
| Instance::createXlibSurfaceKHR(VULKAN_HPP_NAMESPACE::XlibSurfaceCreateInfoKHR const &createInfo, |
| VULKAN_HPP_NAMESPACE::Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator) const |
| { |
| return VULKAN_HPP_RAII_NAMESPACE::SurfaceKHR(*this, createInfo, allocator); |
| } |
| |
| VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE VULKAN_HPP_NAMESPACE::Bool32 |
| PhysicalDevice::getXlibPresentationSupportKHR(uint32_t queueFamilyIndex, Display &dpy, VisualID visualID) const VULKAN_HPP_NOEXCEPT |
| { |
| VULKAN_HPP_ASSERT(getDispatcher()->vkGetPhysicalDeviceXlibPresentationSupportKHR && |
| "Function <vkGetPhysicalDeviceXlibPresentationSupportKHR> needs extension <VK_KHR_xlib_surface> enabled!"); |
| |
| return static_cast<VULKAN_HPP_NAMESPACE::Bool32>( |
| getDispatcher()->vkGetPhysicalDeviceXlibPresentationSupportKHR(static_cast<VkPhysicalDevice>(m_physicalDevice), queueFamilyIndex, &dpy, visualID)); |
| } |
| # endif /*VK_USE_PLATFORM_XLIB_KHR*/ |
| |
| # if defined(VK_USE_PLATFORM_XCB_KHR) |
| //=== VK_KHR_xcb_surface === |
| |
| VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE VULKAN_HPP_RAII_NAMESPACE::SurfaceKHR |
| Instance::createXcbSurfaceKHR(VULKAN_HPP_NAMESPACE::XcbSurfaceCreateInfoKHR const &createInfo, |
| VULKAN_HPP_NAMESPACE::Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator) const |
| { |
| return VULKAN_HPP_RAII_NAMESPACE::SurfaceKHR(*this, createInfo, allocator); |
| } |
| |
| VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE VULKAN_HPP_NAMESPACE::Bool32 PhysicalDevice::getXcbPresentationSupportKHR( |
| uint32_t queueFamilyIndex, xcb_connection_t &connection, xcb_visualid_t visual_id) const VULKAN_HPP_NOEXCEPT |
| { |
| VULKAN_HPP_ASSERT(getDispatcher()->vkGetPhysicalDeviceXcbPresentationSupportKHR && |
| "Function <vkGetPhysicalDeviceXcbPresentationSupportKHR> needs extension <VK_KHR_xcb_surface> enabled!"); |
| |
| return static_cast<VULKAN_HPP_NAMESPACE::Bool32>(getDispatcher()->vkGetPhysicalDeviceXcbPresentationSupportKHR( |
| static_cast<VkPhysicalDevice>(m_physicalDevice), queueFamilyIndex, &connection, visual_id)); |
| } |
| # endif /*VK_USE_PLATFORM_XCB_KHR*/ |
| |
| # if defined(VK_USE_PLATFORM_WAYLAND_KHR) |
| //=== VK_KHR_wayland_surface === |
| |
| VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE VULKAN_HPP_RAII_NAMESPACE::SurfaceKHR |
| Instance::createWaylandSurfaceKHR(VULKAN_HPP_NAMESPACE::WaylandSurfaceCreateInfoKHR const &createInfo, |
| VULKAN_HPP_NAMESPACE::Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator) const |
| { |
| return VULKAN_HPP_RAII_NAMESPACE::SurfaceKHR(*this, createInfo, allocator); |
| } |
| |
| VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE VULKAN_HPP_NAMESPACE::Bool32 |
| PhysicalDevice::getWaylandPresentationSupportKHR(uint32_t queueFamilyIndex, struct wl_display &display) const VULKAN_HPP_NOEXCEPT |
| { |
| VULKAN_HPP_ASSERT(getDispatcher()->vkGetPhysicalDeviceWaylandPresentationSupportKHR && |
| "Function <vkGetPhysicalDeviceWaylandPresentationSupportKHR> needs extension <VK_KHR_wayland_surface> enabled!"); |
| |
| return static_cast<VULKAN_HPP_NAMESPACE::Bool32>( |
| getDispatcher()->vkGetPhysicalDeviceWaylandPresentationSupportKHR(static_cast<VkPhysicalDevice>(m_physicalDevice), queueFamilyIndex, &display)); |
| } |
| # endif /*VK_USE_PLATFORM_WAYLAND_KHR*/ |
| |
| # if defined(VK_USE_PLATFORM_ANDROID_KHR) |
| //=== VK_KHR_android_surface === |
| |
| VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE VULKAN_HPP_RAII_NAMESPACE::SurfaceKHR |
| Instance::createAndroidSurfaceKHR(VULKAN_HPP_NAMESPACE::AndroidSurfaceCreateInfoKHR const &createInfo, |
| VULKAN_HPP_NAMESPACE::Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator) const |
| { |
| return VULKAN_HPP_RAII_NAMESPACE::SurfaceKHR(*this, createInfo, allocator); |
| } |
| # endif /*VK_USE_PLATFORM_ANDROID_KHR*/ |
| |
| # if defined(VK_USE_PLATFORM_WIN32_KHR) |
| //=== VK_KHR_win32_surface === |
| |
| VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE VULKAN_HPP_RAII_NAMESPACE::SurfaceKHR |
| Instance::createWin32SurfaceKHR(VULKAN_HPP_NAMESPACE::Win32SurfaceCreateInfoKHR const &createInfo, |
| VULKAN_HPP_NAMESPACE::Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator) const |
| { |
| return VULKAN_HPP_RAII_NAMESPACE::SurfaceKHR(*this, createInfo, allocator); |
| } |
| |
| VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE VULKAN_HPP_NAMESPACE::Bool32 |
| PhysicalDevice::getWin32PresentationSupportKHR(uint32_t queueFamilyIndex) const VULKAN_HPP_NOEXCEPT |
| { |
| VULKAN_HPP_ASSERT(getDispatcher()->vkGetPhysicalDeviceWin32PresentationSupportKHR && |
| "Function <vkGetPhysicalDeviceWin32PresentationSupportKHR> needs extension <VK_KHR_win32_surface> enabled!"); |
| |
| return static_cast<VULKAN_HPP_NAMESPACE::Bool32>( |
| getDispatcher()->vkGetPhysicalDeviceWin32PresentationSupportKHR(static_cast<VkPhysicalDevice>(m_physicalDevice), queueFamilyIndex)); |
| } |
| # endif /*VK_USE_PLATFORM_WIN32_KHR*/ |
| |
| //=== VK_EXT_debug_report === |
| |
| VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE VULKAN_HPP_RAII_NAMESPACE::DebugReportCallbackEXT |
| Instance::createDebugReportCallbackEXT(VULKAN_HPP_NAMESPACE::DebugReportCallbackCreateInfoEXT const &createInfo, |
| VULKAN_HPP_NAMESPACE::Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator) const |
| { |
| return VULKAN_HPP_RAII_NAMESPACE::DebugReportCallbackEXT(*this, createInfo, allocator); |
| } |
| |
| VULKAN_HPP_INLINE void Instance::debugReportMessageEXT(VULKAN_HPP_NAMESPACE::DebugReportFlagsEXT flags, |
| VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT objectType_, |
| uint64_t object, |
| size_t location, |
| int32_t messageCode, |
| const std::string &layerPrefix, |
| const std::string &message) const VULKAN_HPP_NOEXCEPT |
| { |
| VULKAN_HPP_ASSERT(getDispatcher()->vkDebugReportMessageEXT && "Function <vkDebugReportMessageEXT> needs extension <VK_EXT_debug_report> enabled!"); |
| |
| getDispatcher()->vkDebugReportMessageEXT(static_cast<VkInstance>(m_instance), |
| static_cast<VkDebugReportFlagsEXT>(flags), |
| static_cast<VkDebugReportObjectTypeEXT>(objectType_), |
| object, |
| location, |
| messageCode, |
| layerPrefix.c_str(), |
| message.c_str()); |
| } |
| |
| //=== VK_EXT_debug_marker === |
| |
| VULKAN_HPP_INLINE void Device::debugMarkerSetObjectTagEXT(const VULKAN_HPP_NAMESPACE::DebugMarkerObjectTagInfoEXT &tagInfo) const |
| { |
| VULKAN_HPP_ASSERT(getDispatcher()->vkDebugMarkerSetObjectTagEXT && |
| "Function <vkDebugMarkerSetObjectTagEXT> needs extension <VK_EXT_debug_marker> enabled!"); |
| |
| VULKAN_HPP_NAMESPACE::Result result = static_cast<VULKAN_HPP_NAMESPACE::Result>(getDispatcher()->vkDebugMarkerSetObjectTagEXT( |
| static_cast<VkDevice>(m_device), reinterpret_cast<const VkDebugMarkerObjectTagInfoEXT *>(&tagInfo))); |
| if(result != VULKAN_HPP_NAMESPACE::Result::eSuccess) |
| { |
| throwResultException(result, VULKAN_HPP_NAMESPACE_STRING "::Device::debugMarkerSetObjectTagEXT"); |
| } |
| } |
| |
| VULKAN_HPP_INLINE void Device::debugMarkerSetObjectNameEXT(const VULKAN_HPP_NAMESPACE::DebugMarkerObjectNameInfoEXT &nameInfo) const |
| { |
| VULKAN_HPP_ASSERT(getDispatcher()->vkDebugMarkerSetObjectNameEXT && |
| "Function <vkDebugMarkerSetObjectNameEXT> needs extension <VK_EXT_debug_marker> enabled!"); |
| |
| VULKAN_HPP_NAMESPACE::Result result = static_cast<VULKAN_HPP_NAMESPACE::Result>(getDispatcher()->vkDebugMarkerSetObjectNameEXT( |
| static_cast<VkDevice>(m_device), reinterpret_cast<const VkDebugMarkerObjectNameInfoEXT *>(&nameInfo))); |
| if(result != VULKAN_HPP_NAMESPACE::Result::eSuccess) |
| { |
| throwResultException(result, VULKAN_HPP_NAMESPACE_STRING "::Device::debugMarkerSetObjectNameEXT"); |
| } |
| } |
| |
| VULKAN_HPP_INLINE void CommandBuffer::debugMarkerBeginEXT(const VULKAN_HPP_NAMESPACE::DebugMarkerMarkerInfoEXT &markerInfo) const VULKAN_HPP_NOEXCEPT |
| { |
| VULKAN_HPP_ASSERT(getDispatcher()->vkCmdDebugMarkerBeginEXT && "Function <vkCmdDebugMarkerBeginEXT> needs extension <VK_EXT_debug_marker> enabled!"); |
| |
| getDispatcher()->vkCmdDebugMarkerBeginEXT(static_cast<VkCommandBuffer>(m_commandBuffer), |
| reinterpret_cast<const VkDebugMarkerMarkerInfoEXT *>(&markerInfo)); |
| } |
| |
| VULKAN_HPP_INLINE void CommandBuffer::debugMarkerEndEXT() const VULKAN_HPP_NOEXCEPT |
| { |
| VULKAN_HPP_ASSERT(getDispatcher()->vkCmdDebugMarkerEndEXT && "Function <vkCmdDebugMarkerEndEXT> needs extension <VK_EXT_debug_marker> enabled!"); |
| |
| getDispatcher()->vkCmdDebugMarkerEndEXT(static_cast<VkCommandBuffer>(m_commandBuffer)); |
| } |
| |
| VULKAN_HPP_INLINE void CommandBuffer::debugMarkerInsertEXT(const VULKAN_HPP_NAMESPACE::DebugMarkerMarkerInfoEXT &markerInfo) const VULKAN_HPP_NOEXCEPT |
| { |
| VULKAN_HPP_ASSERT(getDispatcher()->vkCmdDebugMarkerInsertEXT && "Function <vkCmdDebugMarkerInsertEXT> needs extension <VK_EXT_debug_marker> enabled!"); |
| |
| getDispatcher()->vkCmdDebugMarkerInsertEXT(static_cast<VkCommandBuffer>(m_commandBuffer), |
| reinterpret_cast<const VkDebugMarkerMarkerInfoEXT *>(&markerInfo)); |
| } |
| |
| # if defined(VK_ENABLE_BETA_EXTENSIONS) |
| //=== VK_KHR_video_queue === |
| |
| VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE VULKAN_HPP_NAMESPACE::VideoCapabilitiesKHR |
| PhysicalDevice::getVideoCapabilitiesKHR(const VULKAN_HPP_NAMESPACE::VideoProfileKHR &videoProfile) const |
| { |
| VULKAN_HPP_ASSERT(getDispatcher()->vkGetPhysicalDeviceVideoCapabilitiesKHR && |
| "Function <vkGetPhysicalDeviceVideoCapabilitiesKHR> needs extension <VK_KHR_video_queue> enabled!"); |
| |
| VULKAN_HPP_NAMESPACE::VideoCapabilitiesKHR capabilities; |
| VULKAN_HPP_NAMESPACE::Result result = static_cast<VULKAN_HPP_NAMESPACE::Result>( |
| getDispatcher()->vkGetPhysicalDeviceVideoCapabilitiesKHR(static_cast<VkPhysicalDevice>(m_physicalDevice), |
| reinterpret_cast<const VkVideoProfileKHR *>(&videoProfile), |
| reinterpret_cast<VkVideoCapabilitiesKHR *>(&capabilities))); |
| if(result != VULKAN_HPP_NAMESPACE::Result::eSuccess) |
| { |
| throwResultException(result, VULKAN_HPP_NAMESPACE_STRING "::PhysicalDevice::getVideoCapabilitiesKHR"); |
| } |
| return capabilities; |
| } |
| |
| template<typename X, typename Y, typename... Z> |
| VULKAN_HPP_NODISCARD StructureChain<X, Y, Z...> PhysicalDevice::getVideoCapabilitiesKHR(const VULKAN_HPP_NAMESPACE::VideoProfileKHR &videoProfile) const |
| { |
| StructureChain<X, Y, Z...> structureChain; |
| VULKAN_HPP_NAMESPACE::VideoCapabilitiesKHR &capabilities = structureChain.template get<VULKAN_HPP_NAMESPACE::VideoCapabilitiesKHR>(); |
| VULKAN_HPP_NAMESPACE::Result result = static_cast<VULKAN_HPP_NAMESPACE::Result>( |
| getDispatcher()->vkGetPhysicalDeviceVideoCapabilitiesKHR(static_cast<VkPhysicalDevice>(m_physicalDevice), |
| reinterpret_cast<const VkVideoProfileKHR *>(&videoProfile), |
| reinterpret_cast<VkVideoCapabilitiesKHR *>(&capabilities))); |
| if(result != VULKAN_HPP_NAMESPACE::Result::eSuccess) |
| { |
| throwResultException(result, VULKAN_HPP_NAMESPACE_STRING "::PhysicalDevice::getVideoCapabilitiesKHR"); |
| } |
| return structureChain; |
| } |
| |
| VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE std::vector<VULKAN_HPP_NAMESPACE::VideoFormatPropertiesKHR> |
| PhysicalDevice::getVideoFormatPropertiesKHR(const VULKAN_HPP_NAMESPACE::PhysicalDeviceVideoFormatInfoKHR &videoFormatInfo) const |
| { |
| VULKAN_HPP_ASSERT(getDispatcher()->vkGetPhysicalDeviceVideoFormatPropertiesKHR && |
| "Function <vkGetPhysicalDeviceVideoFormatPropertiesKHR> needs extension <VK_KHR_video_queue> enabled!"); |
| |
| std::vector<VULKAN_HPP_NAMESPACE::VideoFormatPropertiesKHR> videoFormatProperties; |
| uint32_t videoFormatPropertyCount; |
| VULKAN_HPP_NAMESPACE::Result result; |
| do |
| { |
| result = static_cast<VULKAN_HPP_NAMESPACE::Result>( |
| getDispatcher()->vkGetPhysicalDeviceVideoFormatPropertiesKHR(static_cast<VkPhysicalDevice>(m_physicalDevice), |
| reinterpret_cast<const VkPhysicalDeviceVideoFormatInfoKHR *>(&videoFormatInfo), |
| &videoFormatPropertyCount, |
| nullptr)); |
| if((result == VULKAN_HPP_NAMESPACE::Result::eSuccess) && videoFormatPropertyCount) |
| { |
| videoFormatProperties.resize(videoFormatPropertyCount); |
| result = static_cast<VULKAN_HPP_NAMESPACE::Result>( |
| getDispatcher()->vkGetPhysicalDeviceVideoFormatPropertiesKHR(static_cast<VkPhysicalDevice>(m_physicalDevice), |
| reinterpret_cast<const VkPhysicalDeviceVideoFormatInfoKHR *>(&videoFormatInfo), |
| &videoFormatPropertyCount, |
| reinterpret_cast<VkVideoFormatPropertiesKHR *>(videoFormatProperties.data()))); |
| } |
| } while(result == VULKAN_HPP_NAMESPACE::Result::eIncomplete); |
| if(result != VULKAN_HPP_NAMESPACE::Result::eSuccess) |
| { |
| throwResultException(result, VULKAN_HPP_NAMESPACE_STRING "::PhysicalDevice::getVideoFormatPropertiesKHR"); |
| } |
| if(result == VULKAN_HPP_NAMESPACE::Result::eSuccess) |
| { |
| VULKAN_HPP_ASSERT(videoFormatPropertyCount <= videoFormatProperties.size()); |
| if(videoFormatPropertyCount < videoFormatProperties.size()) |
| { |
| videoFormatProperties.resize(videoFormatPropertyCount); |
| } |
| } |
| return videoFormatProperties; |
| } |
| |
| VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE VULKAN_HPP_RAII_NAMESPACE::VideoSessionKHR |
| Device::createVideoSessionKHR(VULKAN_HPP_NAMESPACE::VideoSessionCreateInfoKHR const &createInfo, |
| VULKAN_HPP_NAMESPACE::Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator) const |
| { |
| return VULKAN_HPP_RAII_NAMESPACE::VideoSessionKHR(*this, createInfo, allocator); |
| } |
| |
| VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE std::vector<VULKAN_HPP_NAMESPACE::VideoGetMemoryPropertiesKHR> VideoSessionKHR::getMemoryRequirements() const |
| { |
| VULKAN_HPP_ASSERT(getDispatcher()->vkGetVideoSessionMemoryRequirementsKHR && |
| "Function <vkGetVideoSessionMemoryRequirementsKHR> needs extension <VK_KHR_video_queue> enabled!"); |
| |
| std::vector<VULKAN_HPP_NAMESPACE::VideoGetMemoryPropertiesKHR> videoSessionMemoryRequirements; |
| uint32_t videoSessionMemoryRequirementsCount; |
| VULKAN_HPP_NAMESPACE::Result result; |
| do |
| { |
| result = static_cast<VULKAN_HPP_NAMESPACE::Result>(getDispatcher()->vkGetVideoSessionMemoryRequirementsKHR( |
| static_cast<VkDevice>(m_device), static_cast<VkVideoSessionKHR>(m_videoSession), &videoSessionMemoryRequirementsCount, nullptr)); |
| if((result == VULKAN_HPP_NAMESPACE::Result::eSuccess) && videoSessionMemoryRequirementsCount) |
| { |
| videoSessionMemoryRequirements.resize(videoSessionMemoryRequirementsCount); |
| result = static_cast<VULKAN_HPP_NAMESPACE::Result>(getDispatcher()->vkGetVideoSessionMemoryRequirementsKHR( |
| static_cast<VkDevice>(m_device), |
| static_cast<VkVideoSessionKHR>(m_videoSession), |
| &videoSessionMemoryRequirementsCount, |
| reinterpret_cast<VkVideoGetMemoryPropertiesKHR *>(videoSessionMemoryRequirements.data()))); |
| } |
| } while(result == VULKAN_HPP_NAMESPACE::Result::eIncomplete); |
| if(result != VULKAN_HPP_NAMESPACE::Result::eSuccess) |
| { |
| throwResultException(result, VULKAN_HPP_NAMESPACE_STRING "::VideoSessionKHR::getMemoryRequirements"); |
| } |
| if(result == VULKAN_HPP_NAMESPACE::Result::eSuccess) |
| { |
| VULKAN_HPP_ASSERT(videoSessionMemoryRequirementsCount <= videoSessionMemoryRequirements.size()); |
| if(videoSessionMemoryRequirementsCount < videoSessionMemoryRequirements.size()) |
| { |
| videoSessionMemoryRequirements.resize(videoSessionMemoryRequirementsCount); |
| } |
| } |
| return videoSessionMemoryRequirements; |
| } |
| |
| VULKAN_HPP_INLINE void VideoSessionKHR::bindMemory(ArrayProxy<const VULKAN_HPP_NAMESPACE::VideoBindMemoryKHR> const &videoSessionBindMemories) const |
| { |
| VULKAN_HPP_ASSERT(getDispatcher()->vkBindVideoSessionMemoryKHR && |
| "Function <vkBindVideoSessionMemoryKHR> needs extension <VK_KHR_video_queue> enabled!"); |
| |
| VULKAN_HPP_NAMESPACE::Result result = static_cast<VULKAN_HPP_NAMESPACE::Result>( |
| getDispatcher()->vkBindVideoSessionMemoryKHR(static_cast<VkDevice>(m_device), |
| static_cast<VkVideoSessionKHR>(m_videoSession), |
| videoSessionBindMemories.size(), |
| reinterpret_cast<const VkVideoBindMemoryKHR *>(videoSessionBindMemories.data()))); |
| if(result != VULKAN_HPP_NAMESPACE::Result::eSuccess) |
| { |
| throwResultException(result, VULKAN_HPP_NAMESPACE_STRING "::VideoSessionKHR::bindMemory"); |
| } |
| } |
| |
| VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE VULKAN_HPP_RAII_NAMESPACE::VideoSessionParametersKHR |
| Device::createVideoSessionParametersKHR(VULKAN_HPP_NAMESPACE::VideoSessionParametersCreateInfoKHR const &createInfo, |
| VULKAN_HPP_NAMESPACE::Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator) const |
| { |
| return VULKAN_HPP_RAII_NAMESPACE::VideoSessionParametersKHR(*this, createInfo, allocator); |
| } |
| |
| VULKAN_HPP_INLINE void VideoSessionParametersKHR::update(const VULKAN_HPP_NAMESPACE::VideoSessionParametersUpdateInfoKHR &updateInfo) const |
| { |
| VULKAN_HPP_ASSERT(getDispatcher()->vkUpdateVideoSessionParametersKHR && |
| "Function <vkUpdateVideoSessionParametersKHR> needs extension <VK_KHR_video_queue> enabled!"); |
| |
| VULKAN_HPP_NAMESPACE::Result result = static_cast<VULKAN_HPP_NAMESPACE::Result>( |
| getDispatcher()->vkUpdateVideoSessionParametersKHR(static_cast<VkDevice>(m_device), |
| static_cast<VkVideoSessionParametersKHR>(m_videoSessionParameters), |
| reinterpret_cast<const VkVideoSessionParametersUpdateInfoKHR *>(&updateInfo))); |
| if(result != VULKAN_HPP_NAMESPACE::Result::eSuccess) |
| { |
| throwResultException(result, VULKAN_HPP_NAMESPACE_STRING "::VideoSessionParametersKHR::update"); |
| } |
| } |
| |
| VULKAN_HPP_INLINE void CommandBuffer::beginVideoCodingKHR(const VULKAN_HPP_NAMESPACE::VideoBeginCodingInfoKHR &beginInfo) const VULKAN_HPP_NOEXCEPT |
| { |
| VULKAN_HPP_ASSERT(getDispatcher()->vkCmdBeginVideoCodingKHR && "Function <vkCmdBeginVideoCodingKHR> needs extension <VK_KHR_video_queue> enabled!"); |
| |
| getDispatcher()->vkCmdBeginVideoCodingKHR(static_cast<VkCommandBuffer>(m_commandBuffer), |
| reinterpret_cast<const VkVideoBeginCodingInfoKHR *>(&beginInfo)); |
| } |
| |
| VULKAN_HPP_INLINE void CommandBuffer::endVideoCodingKHR(const VULKAN_HPP_NAMESPACE::VideoEndCodingInfoKHR &endCodingInfo) const VULKAN_HPP_NOEXCEPT |
| { |
| VULKAN_HPP_ASSERT(getDispatcher()->vkCmdEndVideoCodingKHR && "Function <vkCmdEndVideoCodingKHR> needs extension <VK_KHR_video_queue> enabled!"); |
| |
| getDispatcher()->vkCmdEndVideoCodingKHR(static_cast<VkCommandBuffer>(m_commandBuffer), |
| reinterpret_cast<const VkVideoEndCodingInfoKHR *>(&endCodingInfo)); |
| } |
| |
| VULKAN_HPP_INLINE void |
| CommandBuffer::controlVideoCodingKHR(const VULKAN_HPP_NAMESPACE::VideoCodingControlInfoKHR &codingControlInfo) const VULKAN_HPP_NOEXCEPT |
| { |
| VULKAN_HPP_ASSERT(getDispatcher()->vkCmdControlVideoCodingKHR && "Function <vkCmdControlVideoCodingKHR> needs extension <VK_KHR_video_queue> enabled!"); |
| |
| getDispatcher()->vkCmdControlVideoCodingKHR(static_cast<VkCommandBuffer>(m_commandBuffer), |
| reinterpret_cast<const VkVideoCodingControlInfoKHR *>(&codingControlInfo)); |
| } |
| # endif /*VK_ENABLE_BETA_EXTENSIONS*/ |
| |
| # if defined(VK_ENABLE_BETA_EXTENSIONS) |
| //=== VK_KHR_video_decode_queue === |
| |
| VULKAN_HPP_INLINE void CommandBuffer::decodeVideoKHR(const VULKAN_HPP_NAMESPACE::VideoDecodeInfoKHR &frameInfo) const VULKAN_HPP_NOEXCEPT |
| { |
| VULKAN_HPP_ASSERT(getDispatcher()->vkCmdDecodeVideoKHR && "Function <vkCmdDecodeVideoKHR> needs extension <VK_KHR_video_decode_queue> enabled!"); |
| |
| getDispatcher()->vkCmdDecodeVideoKHR(static_cast<VkCommandBuffer>(m_commandBuffer), reinterpret_cast<const VkVideoDecodeInfoKHR *>(&frameInfo)); |
| } |
| # endif /*VK_ENABLE_BETA_EXTENSIONS*/ |
| |
| //=== VK_EXT_transform_feedback === |
| |
| VULKAN_HPP_INLINE void CommandBuffer::bindTransformFeedbackBuffersEXT(uint32_t firstBinding, |
| ArrayProxy<const VULKAN_HPP_NAMESPACE::Buffer> const &buffers, |
| ArrayProxy<const VULKAN_HPP_NAMESPACE::DeviceSize> const &offsets, |
| ArrayProxy<const VULKAN_HPP_NAMESPACE::DeviceSize> const &sizes) const |
| { |
| VULKAN_HPP_ASSERT(getDispatcher()->vkCmdBindTransformFeedbackBuffersEXT && |
| "Function <vkCmdBindTransformFeedbackBuffersEXT> needs extension <VK_EXT_transform_feedback> enabled!"); |
| |
| if(buffers.size() != offsets.size()) |
| { |
| throw LogicError(VULKAN_HPP_NAMESPACE_STRING "::CommandBuffer::bindTransformFeedbackBuffersEXT: buffers.size() != offsets.size()"); |
| } |
| if(!sizes.empty() && buffers.size() != sizes.size()) |
| { |
| throw LogicError(VULKAN_HPP_NAMESPACE_STRING "::CommandBuffer::bindTransformFeedbackBuffersEXT: buffers.size() != sizes.size()"); |
| } |
| getDispatcher()->vkCmdBindTransformFeedbackBuffersEXT(static_cast<VkCommandBuffer>(m_commandBuffer), |
| firstBinding, |
| buffers.size(), |
| reinterpret_cast<const VkBuffer *>(buffers.data()), |
| reinterpret_cast<const VkDeviceSize *>(offsets.data()), |
| reinterpret_cast<const VkDeviceSize *>(sizes.data())); |
| } |
| |
| VULKAN_HPP_INLINE void CommandBuffer::beginTransformFeedbackEXT(uint32_t firstCounterBuffer, |
| ArrayProxy<const VULKAN_HPP_NAMESPACE::Buffer> const &counterBuffers, |
| ArrayProxy<const VULKAN_HPP_NAMESPACE::DeviceSize> const &counterBufferOffsets) const |
| { |
| VULKAN_HPP_ASSERT(getDispatcher()->vkCmdBeginTransformFeedbackEXT && |
| "Function <vkCmdBeginTransformFeedbackEXT> needs extension <VK_EXT_transform_feedback> enabled!"); |
| |
| if(!counterBufferOffsets.empty() && counterBuffers.size() != counterBufferOffsets.size()) |
| { |
| throw LogicError(VULKAN_HPP_NAMESPACE_STRING "::CommandBuffer::beginTransformFeedbackEXT: counterBuffers.size() != counterBufferOffsets.size()"); |
| } |
| getDispatcher()->vkCmdBeginTransformFeedbackEXT(static_cast<VkCommandBuffer>(m_commandBuffer), |
| firstCounterBuffer, |
| counterBuffers.size(), |
| reinterpret_cast<const VkBuffer *>(counterBuffers.data()), |
| reinterpret_cast<const VkDeviceSize *>(counterBufferOffsets.data())); |
| } |
| |
| VULKAN_HPP_INLINE void CommandBuffer::endTransformFeedbackEXT(uint32_t firstCounterBuffer, |
| ArrayProxy<const VULKAN_HPP_NAMESPACE::Buffer> const &counterBuffers, |
| ArrayProxy<const VULKAN_HPP_NAMESPACE::DeviceSize> const &counterBufferOffsets) const |
| { |
| VULKAN_HPP_ASSERT(getDispatcher()->vkCmdEndTransformFeedbackEXT && |
| "Function <vkCmdEndTransformFeedbackEXT> needs extension <VK_EXT_transform_feedback> enabled!"); |
| |
| if(!counterBufferOffsets.empty() && counterBuffers.size() != counterBufferOffsets.size()) |
| { |
| throw LogicError(VULKAN_HPP_NAMESPACE_STRING "::CommandBuffer::endTransformFeedbackEXT: counterBuffers.size() != counterBufferOffsets.size()"); |
| } |
| getDispatcher()->vkCmdEndTransformFeedbackEXT(static_cast<VkCommandBuffer>(m_commandBuffer), |
| firstCounterBuffer, |
| counterBuffers.size(), |
| reinterpret_cast<const VkBuffer *>(counterBuffers.data()), |
| reinterpret_cast<const VkDeviceSize *>(counterBufferOffsets.data())); |
| } |
| |
| VULKAN_HPP_INLINE void CommandBuffer::beginQueryIndexedEXT(VULKAN_HPP_NAMESPACE::QueryPool queryPool, |
| uint32_t query, |
| VULKAN_HPP_NAMESPACE::QueryControlFlags flags, |
| uint32_t index) const VULKAN_HPP_NOEXCEPT |
| { |
| VULKAN_HPP_ASSERT(getDispatcher()->vkCmdBeginQueryIndexedEXT && |
| "Function <vkCmdBeginQueryIndexedEXT> needs extension <VK_EXT_transform_feedback> enabled!"); |
| |
| getDispatcher()->vkCmdBeginQueryIndexedEXT( |
| static_cast<VkCommandBuffer>(m_commandBuffer), static_cast<VkQueryPool>(queryPool), query, static_cast<VkQueryControlFlags>(flags), index); |
| } |
| |
| VULKAN_HPP_INLINE void |
| CommandBuffer::endQueryIndexedEXT(VULKAN_HPP_NAMESPACE::QueryPool queryPool, uint32_t query, uint32_t index) const VULKAN_HPP_NOEXCEPT |
| { |
| VULKAN_HPP_ASSERT(getDispatcher()->vkCmdEndQueryIndexedEXT && |
| "Function <vkCmdEndQueryIndexedEXT> needs extension <VK_EXT_transform_feedback> enabled!"); |
| |
| getDispatcher()->vkCmdEndQueryIndexedEXT(static_cast<VkCommandBuffer>(m_commandBuffer), static_cast<VkQueryPool>(queryPool), query, index); |
| } |
| |
| VULKAN_HPP_INLINE void CommandBuffer::drawIndirectByteCountEXT(uint32_t instanceCount, |
| uint32_t firstInstance, |
| VULKAN_HPP_NAMESPACE::Buffer counterBuffer, |
| VULKAN_HPP_NAMESPACE::DeviceSize counterBufferOffset, |
| uint32_t counterOffset, |
| uint32_t vertexStride) const VULKAN_HPP_NOEXCEPT |
| { |
| VULKAN_HPP_ASSERT(getDispatcher()->vkCmdDrawIndirectByteCountEXT && |
| "Function <vkCmdDrawIndirectByteCountEXT> needs extension <VK_EXT_transform_feedback> enabled!"); |
| |
| getDispatcher()->vkCmdDrawIndirectByteCountEXT(static_cast<VkCommandBuffer>(m_commandBuffer), |
| instanceCount, |
| firstInstance, |
| static_cast<VkBuffer>(counterBuffer), |
| static_cast<VkDeviceSize>(counterBufferOffset), |
| counterOffset, |
| vertexStride); |
| } |
| |
| //=== VK_NVX_binary_import === |
| |
| VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE VULKAN_HPP_RAII_NAMESPACE::CuModuleNVX |
| Device::createCuModuleNVX(VULKAN_HPP_NAMESPACE::CuModuleCreateInfoNVX const &createInfo, |
| VULKAN_HPP_NAMESPACE::Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator) const |
| { |
| return VULKAN_HPP_RAII_NAMESPACE::CuModuleNVX(*this, createInfo, allocator); |
| } |
| |
| VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE VULKAN_HPP_RAII_NAMESPACE::CuFunctionNVX |
| Device::createCuFunctionNVX(VULKAN_HPP_NAMESPACE::CuFunctionCreateInfoNVX const &createInfo, |
| VULKAN_HPP_NAMESPACE::Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator) const |
| { |
| return VULKAN_HPP_RAII_NAMESPACE::CuFunctionNVX(*this, createInfo, allocator); |
| } |
| |
| VULKAN_HPP_INLINE void CommandBuffer::cuLaunchKernelNVX(const VULKAN_HPP_NAMESPACE::CuLaunchInfoNVX &launchInfo) const VULKAN_HPP_NOEXCEPT |
| { |
| VULKAN_HPP_ASSERT(getDispatcher()->vkCmdCuLaunchKernelNVX && "Function <vkCmdCuLaunchKernelNVX> needs extension <VK_NVX_binary_import> enabled!"); |
| |
| getDispatcher()->vkCmdCuLaunchKernelNVX(static_cast<VkCommandBuffer>(m_commandBuffer), reinterpret_cast<const VkCuLaunchInfoNVX *>(&launchInfo)); |
| } |
| |
| //=== VK_NVX_image_view_handle === |
| |
| VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE uint32_t |
| Device::getImageViewHandleNVX(const VULKAN_HPP_NAMESPACE::ImageViewHandleInfoNVX &info) const VULKAN_HPP_NOEXCEPT |
| { |
| VULKAN_HPP_ASSERT(getDispatcher()->vkGetImageViewHandleNVX && "Function <vkGetImageViewHandleNVX> needs extension <VK_NVX_image_view_handle> enabled!"); |
| |
| return getDispatcher()->vkGetImageViewHandleNVX(static_cast<VkDevice>(m_device), reinterpret_cast<const VkImageViewHandleInfoNVX *>(&info)); |
| } |
| |
| VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE VULKAN_HPP_NAMESPACE::ImageViewAddressPropertiesNVX ImageView::getAddressNVX() const |
| { |
| VULKAN_HPP_ASSERT(getDispatcher()->vkGetImageViewAddressNVX && |
| "Function <vkGetImageViewAddressNVX> needs extension <VK_NVX_image_view_handle> enabled!"); |
| |
| VULKAN_HPP_NAMESPACE::ImageViewAddressPropertiesNVX properties; |
| VULKAN_HPP_NAMESPACE::Result result = static_cast<VULKAN_HPP_NAMESPACE::Result>(getDispatcher()->vkGetImageViewAddressNVX( |
| static_cast<VkDevice>(m_device), static_cast<VkImageView>(m_imageView), reinterpret_cast<VkImageViewAddressPropertiesNVX *>(&properties))); |
| if(result != VULKAN_HPP_NAMESPACE::Result::eSuccess) |
| { |
| throwResultException(result, VULKAN_HPP_NAMESPACE_STRING "::ImageView::getAddressNVX"); |
| } |
| return properties; |
| } |
| |
| //=== VK_AMD_draw_indirect_count === |
| |
| VULKAN_HPP_INLINE void CommandBuffer::drawIndirectCountAMD(VULKAN_HPP_NAMESPACE::Buffer buffer, |
| VULKAN_HPP_NAMESPACE::DeviceSize offset, |
| VULKAN_HPP_NAMESPACE::Buffer countBuffer, |
| VULKAN_HPP_NAMESPACE::DeviceSize countBufferOffset, |
| uint32_t maxDrawCount, |
| uint32_t stride) const VULKAN_HPP_NOEXCEPT |
| { |
| VULKAN_HPP_ASSERT(getDispatcher()->vkCmdDrawIndirectCountAMD && |
| "Function <vkCmdDrawIndirectCountAMD> needs extension <VK_AMD_draw_indirect_count> enabled!"); |
| |
| getDispatcher()->vkCmdDrawIndirectCountAMD(static_cast<VkCommandBuffer>(m_commandBuffer), |
| static_cast<VkBuffer>(buffer), |
| static_cast<VkDeviceSize>(offset), |
| static_cast<VkBuffer>(countBuffer), |
| static_cast<VkDeviceSize>(countBufferOffset), |
| maxDrawCount, |
| stride); |
| } |
| |
| VULKAN_HPP_INLINE void CommandBuffer::drawIndexedIndirectCountAMD(VULKAN_HPP_NAMESPACE::Buffer buffer, |
| VULKAN_HPP_NAMESPACE::DeviceSize offset, |
| VULKAN_HPP_NAMESPACE::Buffer countBuffer, |
| VULKAN_HPP_NAMESPACE::DeviceSize countBufferOffset, |
| uint32_t maxDrawCount, |
| uint32_t stride) const VULKAN_HPP_NOEXCEPT |
| { |
| VULKAN_HPP_ASSERT(getDispatcher()->vkCmdDrawIndexedIndirectCountAMD && |
| "Function <vkCmdDrawIndexedIndirectCountAMD> needs extension <VK_AMD_draw_indirect_count> enabled!"); |
| |
| getDispatcher()->vkCmdDrawIndexedIndirectCountAMD(static_cast<VkCommandBuffer>(m_commandBuffer), |
| static_cast<VkBuffer>(buffer), |
| static_cast<VkDeviceSize>(offset), |
| static_cast<VkBuffer>(countBuffer), |
| static_cast<VkDeviceSize>(countBufferOffset), |
| maxDrawCount, |
| stride); |
| } |
| |
| //=== VK_AMD_shader_info === |
| |
| VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE std::vector<uint8_t> Pipeline::getShaderInfoAMD(VULKAN_HPP_NAMESPACE::ShaderStageFlagBits shaderStage, |
| VULKAN_HPP_NAMESPACE::ShaderInfoTypeAMD infoType) const |
| { |
| VULKAN_HPP_ASSERT(getDispatcher()->vkGetShaderInfoAMD && "Function <vkGetShaderInfoAMD> needs extension <VK_AMD_shader_info> enabled!"); |
| |
| std::vector<uint8_t> info; |
| size_t infoSize; |
| VULKAN_HPP_NAMESPACE::Result result; |
| do |
| { |
| result = static_cast<VULKAN_HPP_NAMESPACE::Result>(getDispatcher()->vkGetShaderInfoAMD(static_cast<VkDevice>(m_device), |
| static_cast<VkPipeline>(m_pipeline), |
| static_cast<VkShaderStageFlagBits>(shaderStage), |
| static_cast<VkShaderInfoTypeAMD>(infoType), |
| &infoSize, |
| nullptr)); |
| if((result == VULKAN_HPP_NAMESPACE::Result::eSuccess) && infoSize) |
| { |
| info.resize(infoSize); |
| result = static_cast<VULKAN_HPP_NAMESPACE::Result>(getDispatcher()->vkGetShaderInfoAMD(static_cast<VkDevice>(m_device), |
| static_cast<VkPipeline>(m_pipeline), |
| static_cast<VkShaderStageFlagBits>(shaderStage), |
| static_cast<VkShaderInfoTypeAMD>(infoType), |
| &infoSize, |
| reinterpret_cast<void *>(info.data()))); |
| } |
| } while(result == VULKAN_HPP_NAMESPACE::Result::eIncomplete); |
| if(result != VULKAN_HPP_NAMESPACE::Result::eSuccess) |
| { |
| throwResultException(result, VULKAN_HPP_NAMESPACE_STRING "::Pipeline::getShaderInfoAMD"); |
| } |
| if(result == VULKAN_HPP_NAMESPACE::Result::eSuccess) |
| { |
| VULKAN_HPP_ASSERT(infoSize <= info.size()); |
| if(infoSize < info.size()) |
| { |
| info.resize(infoSize); |
| } |
| } |
| return info; |
| } |
| |
| //=== VK_KHR_dynamic_rendering === |
| |
| VULKAN_HPP_INLINE void CommandBuffer::beginRenderingKHR(const VULKAN_HPP_NAMESPACE::RenderingInfo &renderingInfo) const VULKAN_HPP_NOEXCEPT |
| { |
| VULKAN_HPP_ASSERT(getDispatcher()->vkCmdBeginRenderingKHR && "Function <vkCmdBeginRenderingKHR> needs extension <VK_KHR_dynamic_rendering> enabled!"); |
| |
| getDispatcher()->vkCmdBeginRenderingKHR(static_cast<VkCommandBuffer>(m_commandBuffer), reinterpret_cast<const VkRenderingInfo *>(&renderingInfo)); |
| } |
| |
| VULKAN_HPP_INLINE void CommandBuffer::endRenderingKHR() const VULKAN_HPP_NOEXCEPT |
| { |
| VULKAN_HPP_ASSERT(getDispatcher()->vkCmdEndRenderingKHR && "Function <vkCmdEndRenderingKHR> needs extension <VK_KHR_dynamic_rendering> enabled!"); |
| |
| getDispatcher()->vkCmdEndRenderingKHR(static_cast<VkCommandBuffer>(m_commandBuffer)); |
| } |
| |
| # if defined(VK_USE_PLATFORM_GGP) |
| //=== VK_GGP_stream_descriptor_surface === |
| |
| VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE VULKAN_HPP_RAII_NAMESPACE::SurfaceKHR |
| Instance::createStreamDescriptorSurfaceGGP(VULKAN_HPP_NAMESPACE::StreamDescriptorSurfaceCreateInfoGGP const &createInfo, |
| VULKAN_HPP_NAMESPACE::Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator) const |
| { |
| return VULKAN_HPP_RAII_NAMESPACE::SurfaceKHR(*this, createInfo, allocator); |
| } |
| # endif /*VK_USE_PLATFORM_GGP*/ |
| |
| //=== VK_NV_external_memory_capabilities === |
| |
| VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE VULKAN_HPP_NAMESPACE::ExternalImageFormatPropertiesNV |
| PhysicalDevice::getExternalImageFormatPropertiesNV(VULKAN_HPP_NAMESPACE::Format format, |
| VULKAN_HPP_NAMESPACE::ImageType type, |
| VULKAN_HPP_NAMESPACE::ImageTiling tiling, |
| VULKAN_HPP_NAMESPACE::ImageUsageFlags usage, |
| VULKAN_HPP_NAMESPACE::ImageCreateFlags flags, |
| VULKAN_HPP_NAMESPACE::ExternalMemoryHandleTypeFlagsNV externalHandleType) const |
| { |
| VULKAN_HPP_ASSERT(getDispatcher()->vkGetPhysicalDeviceExternalImageFormatPropertiesNV && |
| "Function <vkGetPhysicalDeviceExternalImageFormatPropertiesNV> needs extension <VK_NV_external_memory_capabilities> enabled!"); |
| |
| VULKAN_HPP_NAMESPACE::ExternalImageFormatPropertiesNV externalImageFormatProperties; |
| VULKAN_HPP_NAMESPACE::Result result = static_cast<VULKAN_HPP_NAMESPACE::Result>(getDispatcher()->vkGetPhysicalDeviceExternalImageFormatPropertiesNV( |
| static_cast<VkPhysicalDevice>(m_physicalDevice), |
| static_cast<VkFormat>(format), |
| static_cast<VkImageType>(type), |
| static_cast<VkImageTiling>(tiling), |
| static_cast<VkImageUsageFlags>(usage), |
| static_cast<VkImageCreateFlags>(flags), |
| static_cast<VkExternalMemoryHandleTypeFlagsNV>(externalHandleType), |
| reinterpret_cast<VkExternalImageFormatPropertiesNV *>(&externalImageFormatProperties))); |
| if(result != VULKAN_HPP_NAMESPACE::Result::eSuccess) |
| { |
| throwResultException(result, VULKAN_HPP_NAMESPACE_STRING "::PhysicalDevice::getExternalImageFormatPropertiesNV"); |
| } |
| return externalImageFormatProperties; |
| } |
| |
| # if defined(VK_USE_PLATFORM_WIN32_KHR) |
| //=== VK_NV_external_memory_win32 === |
| |
| VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE HANDLE DeviceMemory::getMemoryWin32HandleNV(VULKAN_HPP_NAMESPACE::ExternalMemoryHandleTypeFlagsNV handleType) const |
| { |
| VULKAN_HPP_ASSERT(getDispatcher()->vkGetMemoryWin32HandleNV && |
| "Function <vkGetMemoryWin32HandleNV> needs extension <VK_NV_external_memory_win32> enabled!"); |
| |
| HANDLE handle; |
| VULKAN_HPP_NAMESPACE::Result result = static_cast<VULKAN_HPP_NAMESPACE::Result>(getDispatcher()->vkGetMemoryWin32HandleNV( |
| static_cast<VkDevice>(m_device), static_cast<VkDeviceMemory>(m_memory), static_cast<VkExternalMemoryHandleTypeFlagsNV>(handleType), &handle)); |
| if(result != VULKAN_HPP_NAMESPACE::Result::eSuccess) |
| { |
| throwResultException(result, VULKAN_HPP_NAMESPACE_STRING "::DeviceMemory::getMemoryWin32HandleNV"); |
| } |
| return handle; |
| } |
| # endif /*VK_USE_PLATFORM_WIN32_KHR*/ |
| |
| //=== VK_KHR_get_physical_device_properties2 === |
| |
| VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE VULKAN_HPP_NAMESPACE::PhysicalDeviceFeatures2 PhysicalDevice::getFeatures2KHR() const VULKAN_HPP_NOEXCEPT |
| { |
| VULKAN_HPP_ASSERT(getDispatcher()->vkGetPhysicalDeviceFeatures2KHR && |
| "Function <vkGetPhysicalDeviceFeatures2KHR> needs extension <VK_KHR_get_physical_device_properties2> enabled!"); |
| |
| VULKAN_HPP_NAMESPACE::PhysicalDeviceFeatures2 features; |
| getDispatcher()->vkGetPhysicalDeviceFeatures2KHR(static_cast<VkPhysicalDevice>(m_physicalDevice), |
| reinterpret_cast<VkPhysicalDeviceFeatures2 *>(&features)); |
| return features; |
| } |
| |
| template<typename X, typename Y, typename... Z> |
| VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE StructureChain<X, Y, Z...> PhysicalDevice::getFeatures2KHR() const VULKAN_HPP_NOEXCEPT |
| { |
| VULKAN_HPP_ASSERT(getDispatcher()->vkGetPhysicalDeviceFeatures2KHR && |
| "Function <vkGetPhysicalDeviceFeatures2KHR> needs extension <VK_KHR_get_physical_device_properties2> enabled!"); |
| |
| StructureChain<X, Y, Z...> structureChain; |
| VULKAN_HPP_NAMESPACE::PhysicalDeviceFeatures2 &features = structureChain.template get<VULKAN_HPP_NAMESPACE::PhysicalDeviceFeatures2>(); |
| getDispatcher()->vkGetPhysicalDeviceFeatures2KHR(static_cast<VkPhysicalDevice>(m_physicalDevice), |
| reinterpret_cast<VkPhysicalDeviceFeatures2 *>(&features)); |
| return structureChain; |
| } |
| |
| VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE VULKAN_HPP_NAMESPACE::PhysicalDeviceProperties2 PhysicalDevice::getProperties2KHR() const VULKAN_HPP_NOEXCEPT |
| { |
| VULKAN_HPP_ASSERT(getDispatcher()->vkGetPhysicalDeviceProperties2KHR && |
| "Function <vkGetPhysicalDeviceProperties2KHR> needs extension <VK_KHR_get_physical_device_properties2> enabled!"); |
| |
| VULKAN_HPP_NAMESPACE::PhysicalDeviceProperties2 properties; |
| getDispatcher()->vkGetPhysicalDeviceProperties2KHR(static_cast<VkPhysicalDevice>(m_physicalDevice), |
| reinterpret_cast<VkPhysicalDeviceProperties2 *>(&properties)); |
| return properties; |
| } |
| |
| template<typename X, typename Y, typename... Z> |
| VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE StructureChain<X, Y, Z...> PhysicalDevice::getProperties2KHR() const VULKAN_HPP_NOEXCEPT |
| { |
| VULKAN_HPP_ASSERT(getDispatcher()->vkGetPhysicalDeviceProperties2KHR && |
| "Function <vkGetPhysicalDeviceProperties2KHR> needs extension <VK_KHR_get_physical_device_properties2> enabled!"); |
| |
| StructureChain<X, Y, Z...> structureChain; |
| VULKAN_HPP_NAMESPACE::PhysicalDeviceProperties2 &properties = structureChain.template get<VULKAN_HPP_NAMESPACE::PhysicalDeviceProperties2>(); |
| getDispatcher()->vkGetPhysicalDeviceProperties2KHR(static_cast<VkPhysicalDevice>(m_physicalDevice), |
| reinterpret_cast<VkPhysicalDeviceProperties2 *>(&properties)); |
| return structureChain; |
| } |
| |
| VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE VULKAN_HPP_NAMESPACE::FormatProperties2 |
| PhysicalDevice::getFormatProperties2KHR(VULKAN_HPP_NAMESPACE::Format format) const VULKAN_HPP_NOEXCEPT |
| { |
| VULKAN_HPP_ASSERT(getDispatcher()->vkGetPhysicalDeviceFormatProperties2KHR && |
| "Function <vkGetPhysicalDeviceFormatProperties2KHR> needs extension <VK_KHR_get_physical_device_properties2> enabled!"); |
| |
| VULKAN_HPP_NAMESPACE::FormatProperties2 formatProperties; |
| getDispatcher()->vkGetPhysicalDeviceFormatProperties2KHR( |
| static_cast<VkPhysicalDevice>(m_physicalDevice), static_cast<VkFormat>(format), reinterpret_cast<VkFormatProperties2 *>(&formatProperties)); |
| return formatProperties; |
| } |
| |
| template<typename X, typename Y, typename... Z> |
| VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE StructureChain<X, Y, Z...> |
| PhysicalDevice::getFormatProperties2KHR(VULKAN_HPP_NAMESPACE::Format format) const VULKAN_HPP_NOEXCEPT |
| { |
| VULKAN_HPP_ASSERT(getDispatcher()->vkGetPhysicalDeviceFormatProperties2KHR && |
| "Function <vkGetPhysicalDeviceFormatProperties2KHR> needs extension <VK_KHR_get_physical_device_properties2> enabled!"); |
| |
| StructureChain<X, Y, Z...> structureChain; |
| VULKAN_HPP_NAMESPACE::FormatProperties2 &formatProperties = structureChain.template get<VULKAN_HPP_NAMESPACE::FormatProperties2>(); |
| getDispatcher()->vkGetPhysicalDeviceFormatProperties2KHR( |
| static_cast<VkPhysicalDevice>(m_physicalDevice), static_cast<VkFormat>(format), reinterpret_cast<VkFormatProperties2 *>(&formatProperties)); |
| return structureChain; |
| } |
| |
| VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE VULKAN_HPP_NAMESPACE::ImageFormatProperties2 |
| PhysicalDevice::getImageFormatProperties2KHR(const VULKAN_HPP_NAMESPACE::PhysicalDeviceImageFormatInfo2 &imageFormatInfo) const |
| { |
| VULKAN_HPP_ASSERT(getDispatcher()->vkGetPhysicalDeviceImageFormatProperties2KHR && |
| "Function <vkGetPhysicalDeviceImageFormatProperties2KHR> needs extension <VK_KHR_get_physical_device_properties2> enabled!"); |
| |
| VULKAN_HPP_NAMESPACE::ImageFormatProperties2 imageFormatProperties; |
| VULKAN_HPP_NAMESPACE::Result result = static_cast<VULKAN_HPP_NAMESPACE::Result>( |
| getDispatcher()->vkGetPhysicalDeviceImageFormatProperties2KHR(static_cast<VkPhysicalDevice>(m_physicalDevice), |
| reinterpret_cast<const VkPhysicalDeviceImageFormatInfo2 *>(&imageFormatInfo), |
| reinterpret_cast<VkImageFormatProperties2 *>(&imageFormatProperties))); |
| if(result != VULKAN_HPP_NAMESPACE::Result::eSuccess) |
| { |
| throwResultException(result, VULKAN_HPP_NAMESPACE_STRING "::PhysicalDevice::getImageFormatProperties2KHR"); |
| } |
| return imageFormatProperties; |
| } |
| |
| template<typename X, typename Y, typename... Z> |
| VULKAN_HPP_NODISCARD StructureChain<X, Y, Z...> |
| PhysicalDevice::getImageFormatProperties2KHR(const VULKAN_HPP_NAMESPACE::PhysicalDeviceImageFormatInfo2 &imageFormatInfo) const |
| { |
| StructureChain<X, Y, Z...> structureChain; |
| VULKAN_HPP_NAMESPACE::ImageFormatProperties2 &imageFormatProperties = structureChain.template get<VULKAN_HPP_NAMESPACE::ImageFormatProperties2>(); |
| VULKAN_HPP_NAMESPACE::Result result = static_cast<VULKAN_HPP_NAMESPACE::Result>( |
| getDispatcher()->vkGetPhysicalDeviceImageFormatProperties2KHR(static_cast<VkPhysicalDevice>(m_physicalDevice), |
| reinterpret_cast<const VkPhysicalDeviceImageFormatInfo2 *>(&imageFormatInfo), |
| reinterpret_cast<VkImageFormatProperties2 *>(&imageFormatProperties))); |
| if(result != VULKAN_HPP_NAMESPACE::Result::eSuccess) |
| { |
| throwResultException(result, VULKAN_HPP_NAMESPACE_STRING "::PhysicalDevice::getImageFormatProperties2KHR"); |
| } |
| return structureChain; |
| } |
| |
| VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE std::vector<VULKAN_HPP_NAMESPACE::QueueFamilyProperties2> |
| PhysicalDevice::getQueueFamilyProperties2KHR() const VULKAN_HPP_NOEXCEPT |
| { |
| VULKAN_HPP_ASSERT(getDispatcher()->vkGetPhysicalDeviceQueueFamilyProperties2KHR && |
| "Function <vkGetPhysicalDeviceQueueFamilyProperties2KHR> needs extension <VK_KHR_get_physical_device_properties2> enabled!"); |
| |
| uint32_t queueFamilyPropertyCount; |
| getDispatcher()->vkGetPhysicalDeviceQueueFamilyProperties2KHR(static_cast<VkPhysicalDevice>(m_physicalDevice), &queueFamilyPropertyCount, nullptr); |
| std::vector<VULKAN_HPP_NAMESPACE::QueueFamilyProperties2> queueFamilyProperties(queueFamilyPropertyCount); |
| getDispatcher()->vkGetPhysicalDeviceQueueFamilyProperties2KHR(static_cast<VkPhysicalDevice>(m_physicalDevice), |
| &queueFamilyPropertyCount, |
| reinterpret_cast<VkQueueFamilyProperties2 *>(queueFamilyProperties.data())); |
| VULKAN_HPP_ASSERT(queueFamilyPropertyCount == queueFamilyProperties.size()); |
| return queueFamilyProperties; |
| } |
| |
| template<typename StructureChain> |
| VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE std::vector<StructureChain> PhysicalDevice::getQueueFamilyProperties2KHR() const |
| { |
| VULKAN_HPP_ASSERT(getDispatcher()->vkGetPhysicalDeviceQueueFamilyProperties2KHR && |
| "Function <vkGetPhysicalDeviceQueueFamilyProperties2KHR> needs extension <VK_KHR_get_physical_device_properties2> enabled!"); |
| |
| uint32_t queueFamilyPropertyCount; |
| getDispatcher()->vkGetPhysicalDeviceQueueFamilyProperties2KHR(static_cast<VkPhysicalDevice>(m_physicalDevice), &queueFamilyPropertyCount, nullptr); |
| std::vector<StructureChain> returnVector(queueFamilyPropertyCount); |
| std::vector<VULKAN_HPP_NAMESPACE::QueueFamilyProperties2> queueFamilyProperties(queueFamilyPropertyCount); |
| for(uint32_t i = 0; i < queueFamilyPropertyCount; i++) |
| { |
| queueFamilyProperties[i].pNext = returnVector[i].template get<VULKAN_HPP_NAMESPACE::QueueFamilyProperties2>().pNext; |
| } |
| getDispatcher()->vkGetPhysicalDeviceQueueFamilyProperties2KHR(static_cast<VkPhysicalDevice>(m_physicalDevice), |
| &queueFamilyPropertyCount, |
| reinterpret_cast<VkQueueFamilyProperties2 *>(queueFamilyProperties.data())); |
| VULKAN_HPP_ASSERT(queueFamilyPropertyCount <= queueFamilyProperties.size()); |
| for(uint32_t i = 0; i < queueFamilyPropertyCount; i++) |
| { |
| returnVector[i].template get<VULKAN_HPP_NAMESPACE::QueueFamilyProperties2>() = queueFamilyProperties[i]; |
| } |
| return returnVector; |
| } |
| |
| VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE VULKAN_HPP_NAMESPACE::PhysicalDeviceMemoryProperties2 |
| PhysicalDevice::getMemoryProperties2KHR() const VULKAN_HPP_NOEXCEPT |
| { |
| VULKAN_HPP_ASSERT(getDispatcher()->vkGetPhysicalDeviceMemoryProperties2KHR && |
| "Function <vkGetPhysicalDeviceMemoryProperties2KHR> needs extension <VK_KHR_get_physical_device_properties2> enabled!"); |
| |
| VULKAN_HPP_NAMESPACE::PhysicalDeviceMemoryProperties2 memoryProperties; |
| getDispatcher()->vkGetPhysicalDeviceMemoryProperties2KHR(static_cast<VkPhysicalDevice>(m_physicalDevice), |
| reinterpret_cast<VkPhysicalDeviceMemoryProperties2 *>(&memoryProperties)); |
| return memoryProperties; |
| } |
| |
| template<typename X, typename Y, typename... Z> |
| VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE StructureChain<X, Y, Z...> PhysicalDevice::getMemoryProperties2KHR() const VULKAN_HPP_NOEXCEPT |
| { |
| VULKAN_HPP_ASSERT(getDispatcher()->vkGetPhysicalDeviceMemoryProperties2KHR && |
| "Function <vkGetPhysicalDeviceMemoryProperties2KHR> needs extension <VK_KHR_get_physical_device_properties2> enabled!"); |
| |
| StructureChain<X, Y, Z...> structureChain; |
| VULKAN_HPP_NAMESPACE::PhysicalDeviceMemoryProperties2 &memoryProperties = |
| structureChain.template get<VULKAN_HPP_NAMESPACE::PhysicalDeviceMemoryProperties2>(); |
| getDispatcher()->vkGetPhysicalDeviceMemoryProperties2KHR(static_cast<VkPhysicalDevice>(m_physicalDevice), |
| reinterpret_cast<VkPhysicalDeviceMemoryProperties2 *>(&memoryProperties)); |
| return structureChain; |
| } |
| |
| VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE std::vector<VULKAN_HPP_NAMESPACE::SparseImageFormatProperties2> PhysicalDevice::getSparseImageFormatProperties2KHR( |
| const VULKAN_HPP_NAMESPACE::PhysicalDeviceSparseImageFormatInfo2 &formatInfo) const VULKAN_HPP_NOEXCEPT |
| { |
| VULKAN_HPP_ASSERT(getDispatcher()->vkGetPhysicalDeviceSparseImageFormatProperties2KHR && |
| "Function <vkGetPhysicalDeviceSparseImageFormatProperties2KHR> needs extension <VK_KHR_get_physical_device_properties2> enabled!"); |
| |
| uint32_t propertyCount; |
| getDispatcher()->vkGetPhysicalDeviceSparseImageFormatProperties2KHR(static_cast<VkPhysicalDevice>(m_physicalDevice), |
| reinterpret_cast<const VkPhysicalDeviceSparseImageFormatInfo2 *>(&formatInfo), |
| &propertyCount, |
| nullptr); |
| std::vector<VULKAN_HPP_NAMESPACE::SparseImageFormatProperties2> properties(propertyCount); |
| getDispatcher()->vkGetPhysicalDeviceSparseImageFormatProperties2KHR(static_cast<VkPhysicalDevice>(m_physicalDevice), |
| reinterpret_cast<const VkPhysicalDeviceSparseImageFormatInfo2 *>(&formatInfo), |
| &propertyCount, |
| reinterpret_cast<VkSparseImageFormatProperties2 *>(properties.data())); |
| VULKAN_HPP_ASSERT(propertyCount == properties.size()); |
| return properties; |
| } |
| |
| //=== VK_KHR_device_group === |
| |
| VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE VULKAN_HPP_NAMESPACE::PeerMemoryFeatureFlags |
| Device::getGroupPeerMemoryFeaturesKHR(uint32_t heapIndex, uint32_t localDeviceIndex, uint32_t remoteDeviceIndex) const VULKAN_HPP_NOEXCEPT |
| { |
| VULKAN_HPP_ASSERT(getDispatcher()->vkGetDeviceGroupPeerMemoryFeaturesKHR && |
| "Function <vkGetDeviceGroupPeerMemoryFeaturesKHR> needs extension <VK_KHR_device_group> enabled!"); |
| |
| VULKAN_HPP_NAMESPACE::PeerMemoryFeatureFlags peerMemoryFeatures; |
| getDispatcher()->vkGetDeviceGroupPeerMemoryFeaturesKHR(static_cast<VkDevice>(m_device), |
| heapIndex, |
| localDeviceIndex, |
| remoteDeviceIndex, |
| reinterpret_cast<VkPeerMemoryFeatureFlags *>(&peerMemoryFeatures)); |
| return peerMemoryFeatures; |
| } |
| |
| VULKAN_HPP_INLINE void CommandBuffer::setDeviceMaskKHR(uint32_t deviceMask) const VULKAN_HPP_NOEXCEPT |
| { |
| VULKAN_HPP_ASSERT(getDispatcher()->vkCmdSetDeviceMaskKHR && "Function <vkCmdSetDeviceMaskKHR> needs extension <VK_KHR_device_group> enabled!"); |
| |
| getDispatcher()->vkCmdSetDeviceMaskKHR(static_cast<VkCommandBuffer>(m_commandBuffer), deviceMask); |
| } |
| |
| VULKAN_HPP_INLINE void CommandBuffer::dispatchBaseKHR(uint32_t baseGroupX, |
| uint32_t baseGroupY, |
| uint32_t baseGroupZ, |
| uint32_t groupCountX, |
| uint32_t groupCountY, |
| uint32_t groupCountZ) const VULKAN_HPP_NOEXCEPT |
| { |
| VULKAN_HPP_ASSERT(getDispatcher()->vkCmdDispatchBaseKHR && "Function <vkCmdDispatchBaseKHR> needs extension <VK_KHR_device_group> enabled!"); |
| |
| getDispatcher()->vkCmdDispatchBaseKHR( |
| static_cast<VkCommandBuffer>(m_commandBuffer), baseGroupX, baseGroupY, baseGroupZ, groupCountX, groupCountY, groupCountZ); |
| } |
| |
| # if defined(VK_USE_PLATFORM_VI_NN) |
| //=== VK_NN_vi_surface === |
| |
| VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE VULKAN_HPP_RAII_NAMESPACE::SurfaceKHR |
| Instance::createViSurfaceNN(VULKAN_HPP_NAMESPACE::ViSurfaceCreateInfoNN const &createInfo, |
| VULKAN_HPP_NAMESPACE::Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator) const |
| { |
| return VULKAN_HPP_RAII_NAMESPACE::SurfaceKHR(*this, createInfo, allocator); |
| } |
| # endif /*VK_USE_PLATFORM_VI_NN*/ |
| |
| //=== VK_KHR_maintenance1 === |
| |
| VULKAN_HPP_INLINE void CommandPool::trimKHR(VULKAN_HPP_NAMESPACE::CommandPoolTrimFlags flags) const VULKAN_HPP_NOEXCEPT |
| { |
| VULKAN_HPP_ASSERT(getDispatcher()->vkTrimCommandPoolKHR && "Function <vkTrimCommandPoolKHR> needs extension <VK_KHR_maintenance1> enabled!"); |
| |
| getDispatcher()->vkTrimCommandPoolKHR( |
| static_cast<VkDevice>(m_device), static_cast<VkCommandPool>(m_commandPool), static_cast<VkCommandPoolTrimFlags>(flags)); |
| } |
| |
| //=== VK_KHR_device_group_creation === |
| |
| VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE std::vector<VULKAN_HPP_NAMESPACE::PhysicalDeviceGroupProperties> Instance::enumeratePhysicalDeviceGroupsKHR() const |
| { |
| VULKAN_HPP_ASSERT(getDispatcher()->vkEnumeratePhysicalDeviceGroupsKHR && |
| "Function <vkEnumeratePhysicalDeviceGroupsKHR> needs extension <VK_KHR_device_group_creation> enabled!"); |
| |
| std::vector<VULKAN_HPP_NAMESPACE::PhysicalDeviceGroupProperties> physicalDeviceGroupProperties; |
| uint32_t physicalDeviceGroupCount; |
| VULKAN_HPP_NAMESPACE::Result result; |
| do |
| { |
| result = static_cast<VULKAN_HPP_NAMESPACE::Result>( |
| getDispatcher()->vkEnumeratePhysicalDeviceGroupsKHR(static_cast<VkInstance>(m_instance), &physicalDeviceGroupCount, nullptr)); |
| if((result == VULKAN_HPP_NAMESPACE::Result::eSuccess) && physicalDeviceGroupCount) |
| { |
| physicalDeviceGroupProperties.resize(physicalDeviceGroupCount); |
| result = static_cast<VULKAN_HPP_NAMESPACE::Result>(getDispatcher()->vkEnumeratePhysicalDeviceGroupsKHR( |
| static_cast<VkInstance>(m_instance), |
| &physicalDeviceGroupCount, |
| reinterpret_cast<VkPhysicalDeviceGroupProperties *>(physicalDeviceGroupProperties.data()))); |
| } |
| } while(result == VULKAN_HPP_NAMESPACE::Result::eIncomplete); |
| if(result != VULKAN_HPP_NAMESPACE::Result::eSuccess) |
| { |
| throwResultException(result, VULKAN_HPP_NAMESPACE_STRING "::Instance::enumeratePhysicalDeviceGroupsKHR"); |
| } |
| if(result == VULKAN_HPP_NAMESPACE::Result::eSuccess) |
| { |
| VULKAN_HPP_ASSERT(physicalDeviceGroupCount <= physicalDeviceGroupProperties.size()); |
| if(physicalDeviceGroupCount < physicalDeviceGroupProperties.size()) |
| { |
| physicalDeviceGroupProperties.resize(physicalDeviceGroupCount); |
| } |
| } |
| return physicalDeviceGroupProperties; |
| } |
| |
| //=== VK_KHR_external_memory_capabilities === |
| |
| VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE VULKAN_HPP_NAMESPACE::ExternalBufferProperties PhysicalDevice::getExternalBufferPropertiesKHR( |
| const VULKAN_HPP_NAMESPACE::PhysicalDeviceExternalBufferInfo &externalBufferInfo) const VULKAN_HPP_NOEXCEPT |
| { |
| VULKAN_HPP_ASSERT(getDispatcher()->vkGetPhysicalDeviceExternalBufferPropertiesKHR && |
| "Function <vkGetPhysicalDeviceExternalBufferPropertiesKHR> needs extension <VK_KHR_external_memory_capabilities> enabled!"); |
| |
| VULKAN_HPP_NAMESPACE::ExternalBufferProperties externalBufferProperties; |
| getDispatcher()->vkGetPhysicalDeviceExternalBufferPropertiesKHR(static_cast<VkPhysicalDevice>(m_physicalDevice), |
| reinterpret_cast<const VkPhysicalDeviceExternalBufferInfo *>(&externalBufferInfo), |
| reinterpret_cast<VkExternalBufferProperties *>(&externalBufferProperties)); |
| return externalBufferProperties; |
| } |
| |
| # if defined(VK_USE_PLATFORM_WIN32_KHR) |
| //=== VK_KHR_external_memory_win32 === |
| |
| VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE HANDLE |
| Device::getMemoryWin32HandleKHR(const VULKAN_HPP_NAMESPACE::MemoryGetWin32HandleInfoKHR &getWin32HandleInfo) const |
| { |
| VULKAN_HPP_ASSERT(getDispatcher()->vkGetMemoryWin32HandleKHR && |
| "Function <vkGetMemoryWin32HandleKHR> needs extension <VK_KHR_external_memory_win32> enabled!"); |
| |
| HANDLE handle; |
| VULKAN_HPP_NAMESPACE::Result result = static_cast<VULKAN_HPP_NAMESPACE::Result>(getDispatcher()->vkGetMemoryWin32HandleKHR( |
| static_cast<VkDevice>(m_device), reinterpret_cast<const VkMemoryGetWin32HandleInfoKHR *>(&getWin32HandleInfo), &handle)); |
| if(result != VULKAN_HPP_NAMESPACE::Result::eSuccess) |
| { |
| throwResultException(result, VULKAN_HPP_NAMESPACE_STRING "::Device::getMemoryWin32HandleKHR"); |
| } |
| return handle; |
| } |
| |
| VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE VULKAN_HPP_NAMESPACE::MemoryWin32HandlePropertiesKHR |
| Device::getMemoryWin32HandlePropertiesKHR(VULKAN_HPP_NAMESPACE::ExternalMemoryHandleTypeFlagBits handleType, HANDLE handle) const |
| { |
| VULKAN_HPP_ASSERT(getDispatcher()->vkGetMemoryWin32HandlePropertiesKHR && |
| "Function <vkGetMemoryWin32HandlePropertiesKHR> needs extension <VK_KHR_external_memory_win32> enabled!"); |
| |
| VULKAN_HPP_NAMESPACE::MemoryWin32HandlePropertiesKHR memoryWin32HandleProperties; |
| VULKAN_HPP_NAMESPACE::Result result = static_cast<VULKAN_HPP_NAMESPACE::Result>( |
| getDispatcher()->vkGetMemoryWin32HandlePropertiesKHR(static_cast<VkDevice>(m_device), |
| static_cast<VkExternalMemoryHandleTypeFlagBits>(handleType), |
| handle, |
| reinterpret_cast<VkMemoryWin32HandlePropertiesKHR *>(&memoryWin32HandleProperties))); |
| if(result != VULKAN_HPP_NAMESPACE::Result::eSuccess) |
| { |
| throwResultException(result, VULKAN_HPP_NAMESPACE_STRING "::Device::getMemoryWin32HandlePropertiesKHR"); |
| } |
| return memoryWin32HandleProperties; |
| } |
| # endif /*VK_USE_PLATFORM_WIN32_KHR*/ |
| |
| //=== VK_KHR_external_memory_fd === |
| |
| VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE int Device::getMemoryFdKHR(const VULKAN_HPP_NAMESPACE::MemoryGetFdInfoKHR &getFdInfo) const |
| { |
| VULKAN_HPP_ASSERT(getDispatcher()->vkGetMemoryFdKHR && "Function <vkGetMemoryFdKHR> needs extension <VK_KHR_external_memory_fd> enabled!"); |
| |
| int fd; |
| VULKAN_HPP_NAMESPACE::Result result = static_cast<VULKAN_HPP_NAMESPACE::Result>( |
| getDispatcher()->vkGetMemoryFdKHR(static_cast<VkDevice>(m_device), reinterpret_cast<const VkMemoryGetFdInfoKHR *>(&getFdInfo), &fd)); |
| if(result != VULKAN_HPP_NAMESPACE::Result::eSuccess) |
| { |
| throwResultException(result, VULKAN_HPP_NAMESPACE_STRING "::Device::getMemoryFdKHR"); |
| } |
| return fd; |
| } |
| |
| VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE VULKAN_HPP_NAMESPACE::MemoryFdPropertiesKHR |
| Device::getMemoryFdPropertiesKHR(VULKAN_HPP_NAMESPACE::ExternalMemoryHandleTypeFlagBits handleType, int fd) const |
| { |
| VULKAN_HPP_ASSERT(getDispatcher()->vkGetMemoryFdPropertiesKHR && |
| "Function <vkGetMemoryFdPropertiesKHR> needs extension <VK_KHR_external_memory_fd> enabled!"); |
| |
| VULKAN_HPP_NAMESPACE::MemoryFdPropertiesKHR memoryFdProperties; |
| VULKAN_HPP_NAMESPACE::Result result = static_cast<VULKAN_HPP_NAMESPACE::Result>( |
| getDispatcher()->vkGetMemoryFdPropertiesKHR(static_cast<VkDevice>(m_device), |
| static_cast<VkExternalMemoryHandleTypeFlagBits>(handleType), |
| fd, |
| reinterpret_cast<VkMemoryFdPropertiesKHR *>(&memoryFdProperties))); |
| if(result != VULKAN_HPP_NAMESPACE::Result::eSuccess) |
| { |
| throwResultException(result, VULKAN_HPP_NAMESPACE_STRING "::Device::getMemoryFdPropertiesKHR"); |
| } |
| return memoryFdProperties; |
| } |
| |
| //=== VK_KHR_external_semaphore_capabilities === |
| |
| VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE VULKAN_HPP_NAMESPACE::ExternalSemaphoreProperties PhysicalDevice::getExternalSemaphorePropertiesKHR( |
| const VULKAN_HPP_NAMESPACE::PhysicalDeviceExternalSemaphoreInfo &externalSemaphoreInfo) const VULKAN_HPP_NOEXCEPT |
| { |
| VULKAN_HPP_ASSERT(getDispatcher()->vkGetPhysicalDeviceExternalSemaphorePropertiesKHR && |
| "Function <vkGetPhysicalDeviceExternalSemaphorePropertiesKHR> needs extension <VK_KHR_external_semaphore_capabilities> enabled!"); |
| |
| VULKAN_HPP_NAMESPACE::ExternalSemaphoreProperties externalSemaphoreProperties; |
| getDispatcher()->vkGetPhysicalDeviceExternalSemaphorePropertiesKHR( |
| static_cast<VkPhysicalDevice>(m_physicalDevice), |
| reinterpret_cast<const VkPhysicalDeviceExternalSemaphoreInfo *>(&externalSemaphoreInfo), |
| reinterpret_cast<VkExternalSemaphoreProperties *>(&externalSemaphoreProperties)); |
| return externalSemaphoreProperties; |
| } |
| |
| # if defined(VK_USE_PLATFORM_WIN32_KHR) |
| //=== VK_KHR_external_semaphore_win32 === |
| |
| VULKAN_HPP_INLINE void |
| Device::importSemaphoreWin32HandleKHR(const VULKAN_HPP_NAMESPACE::ImportSemaphoreWin32HandleInfoKHR &importSemaphoreWin32HandleInfo) const |
| { |
| VULKAN_HPP_ASSERT(getDispatcher()->vkImportSemaphoreWin32HandleKHR && |
| "Function <vkImportSemaphoreWin32HandleKHR> needs extension <VK_KHR_external_semaphore_win32> enabled!"); |
| |
| VULKAN_HPP_NAMESPACE::Result result = static_cast<VULKAN_HPP_NAMESPACE::Result>(getDispatcher()->vkImportSemaphoreWin32HandleKHR( |
| static_cast<VkDevice>(m_device), reinterpret_cast<const VkImportSemaphoreWin32HandleInfoKHR *>(&importSemaphoreWin32HandleInfo))); |
| if(result != VULKAN_HPP_NAMESPACE::Result::eSuccess) |
| { |
| throwResultException(result, VULKAN_HPP_NAMESPACE_STRING "::Device::importSemaphoreWin32HandleKHR"); |
| } |
| } |
| |
| VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE HANDLE |
| Device::getSemaphoreWin32HandleKHR(const VULKAN_HPP_NAMESPACE::SemaphoreGetWin32HandleInfoKHR &getWin32HandleInfo) const |
| { |
| VULKAN_HPP_ASSERT(getDispatcher()->vkGetSemaphoreWin32HandleKHR && |
| "Function <vkGetSemaphoreWin32HandleKHR> needs extension <VK_KHR_external_semaphore_win32> enabled!"); |
| |
| HANDLE handle; |
| VULKAN_HPP_NAMESPACE::Result result = static_cast<VULKAN_HPP_NAMESPACE::Result>(getDispatcher()->vkGetSemaphoreWin32HandleKHR( |
| static_cast<VkDevice>(m_device), reinterpret_cast<const VkSemaphoreGetWin32HandleInfoKHR *>(&getWin32HandleInfo), &handle)); |
| if(result != VULKAN_HPP_NAMESPACE::Result::eSuccess) |
| { |
| throwResultException(result, VULKAN_HPP_NAMESPACE_STRING "::Device::getSemaphoreWin32HandleKHR"); |
| } |
| return handle; |
| } |
| # endif /*VK_USE_PLATFORM_WIN32_KHR*/ |
| |
| //=== VK_KHR_external_semaphore_fd === |
| |
| VULKAN_HPP_INLINE void Device::importSemaphoreFdKHR(const VULKAN_HPP_NAMESPACE::ImportSemaphoreFdInfoKHR &importSemaphoreFdInfo) const |
| { |
| VULKAN_HPP_ASSERT(getDispatcher()->vkImportSemaphoreFdKHR && |
| "Function <vkImportSemaphoreFdKHR> needs extension <VK_KHR_external_semaphore_fd> enabled!"); |
| |
| VULKAN_HPP_NAMESPACE::Result result = static_cast<VULKAN_HPP_NAMESPACE::Result>(getDispatcher()->vkImportSemaphoreFdKHR( |
| static_cast<VkDevice>(m_device), reinterpret_cast<const VkImportSemaphoreFdInfoKHR *>(&importSemaphoreFdInfo))); |
| if(result != VULKAN_HPP_NAMESPACE::Result::eSuccess) |
| { |
| throwResultException(result, VULKAN_HPP_NAMESPACE_STRING "::Device::importSemaphoreFdKHR"); |
| } |
| } |
| |
| VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE int Device::getSemaphoreFdKHR(const VULKAN_HPP_NAMESPACE::SemaphoreGetFdInfoKHR &getFdInfo) const |
| { |
| VULKAN_HPP_ASSERT(getDispatcher()->vkGetSemaphoreFdKHR && "Function <vkGetSemaphoreFdKHR> needs extension <VK_KHR_external_semaphore_fd> enabled!"); |
| |
| int fd; |
| VULKAN_HPP_NAMESPACE::Result result = static_cast<VULKAN_HPP_NAMESPACE::Result>( |
| getDispatcher()->vkGetSemaphoreFdKHR(static_cast<VkDevice>(m_device), reinterpret_cast<const VkSemaphoreGetFdInfoKHR *>(&getFdInfo), &fd)); |
| if(result != VULKAN_HPP_NAMESPACE::Result::eSuccess) |
| { |
| throwResultException(result, VULKAN_HPP_NAMESPACE_STRING "::Device::getSemaphoreFdKHR"); |
| } |
| return fd; |
| } |
| |
| //=== VK_KHR_push_descriptor === |
| |
| VULKAN_HPP_INLINE void |
| CommandBuffer::pushDescriptorSetKHR(VULKAN_HPP_NAMESPACE::PipelineBindPoint pipelineBindPoint, |
| VULKAN_HPP_NAMESPACE::PipelineLayout layout, |
| uint32_t set, |
| ArrayProxy<const VULKAN_HPP_NAMESPACE::WriteDescriptorSet> const &descriptorWrites) const VULKAN_HPP_NOEXCEPT |
| { |
| VULKAN_HPP_ASSERT(getDispatcher()->vkCmdPushDescriptorSetKHR && |
| "Function <vkCmdPushDescriptorSetKHR> needs extension <VK_KHR_push_descriptor> enabled!"); |
| |
| getDispatcher()->vkCmdPushDescriptorSetKHR(static_cast<VkCommandBuffer>(m_commandBuffer), |
| static_cast<VkPipelineBindPoint>(pipelineBindPoint), |
| static_cast<VkPipelineLayout>(layout), |
| set, |
| descriptorWrites.size(), |
| reinterpret_cast<const VkWriteDescriptorSet *>(descriptorWrites.data())); |
| } |
| |
| template<typename DataType> |
| VULKAN_HPP_INLINE void CommandBuffer::pushDescriptorSetWithTemplateKHR(VULKAN_HPP_NAMESPACE::DescriptorUpdateTemplate descriptorUpdateTemplate, |
| VULKAN_HPP_NAMESPACE::PipelineLayout layout, |
| uint32_t set, |
| DataType const &data) const VULKAN_HPP_NOEXCEPT |
| { |
| VULKAN_HPP_ASSERT(getDispatcher()->vkCmdPushDescriptorSetWithTemplateKHR && |
| "Function <vkCmdPushDescriptorSetWithTemplateKHR> needs extension <VK_KHR_push_descriptor> enabled!"); |
| |
| getDispatcher()->vkCmdPushDescriptorSetWithTemplateKHR(static_cast<VkCommandBuffer>(m_commandBuffer), |
| static_cast<VkDescriptorUpdateTemplate>(descriptorUpdateTemplate), |
| static_cast<VkPipelineLayout>(layout), |
| set, |
| reinterpret_cast<const void *>(&data)); |
| } |
| |
| //=== VK_EXT_conditional_rendering === |
| |
| VULKAN_HPP_INLINE void CommandBuffer::beginConditionalRenderingEXT( |
| const VULKAN_HPP_NAMESPACE::ConditionalRenderingBeginInfoEXT &conditionalRenderingBegin) const VULKAN_HPP_NOEXCEPT |
| { |
| VULKAN_HPP_ASSERT(getDispatcher()->vkCmdBeginConditionalRenderingEXT && |
| "Function <vkCmdBeginConditionalRenderingEXT> needs extension <VK_EXT_conditional_rendering> enabled!"); |
| |
| getDispatcher()->vkCmdBeginConditionalRenderingEXT(static_cast<VkCommandBuffer>(m_commandBuffer), |
| reinterpret_cast<const VkConditionalRenderingBeginInfoEXT *>(&conditionalRenderingBegin)); |
| } |
| |
| VULKAN_HPP_INLINE void CommandBuffer::endConditionalRenderingEXT() const VULKAN_HPP_NOEXCEPT |
| { |
| VULKAN_HPP_ASSERT(getDispatcher()->vkCmdEndConditionalRenderingEXT && |
| "Function <vkCmdEndConditionalRenderingEXT> needs extension <VK_EXT_conditional_rendering> enabled!"); |
| |
| getDispatcher()->vkCmdEndConditionalRenderingEXT(static_cast<VkCommandBuffer>(m_commandBuffer)); |
| } |
| |
| //=== VK_KHR_descriptor_update_template === |
| |
| VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE VULKAN_HPP_RAII_NAMESPACE::DescriptorUpdateTemplate |
| Device::createDescriptorUpdateTemplateKHR(VULKAN_HPP_NAMESPACE::DescriptorUpdateTemplateCreateInfo const &createInfo, |
| VULKAN_HPP_NAMESPACE::Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator) const |
| { |
| return VULKAN_HPP_RAII_NAMESPACE::DescriptorUpdateTemplate(*this, createInfo, allocator); |
| } |
| |
| VULKAN_HPP_INLINE void |
| Device::destroyDescriptorUpdateTemplateKHR(VULKAN_HPP_NAMESPACE::DescriptorUpdateTemplate descriptorUpdateTemplate, |
| Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator) const VULKAN_HPP_NOEXCEPT |
| { |
| VULKAN_HPP_ASSERT(getDispatcher()->vkDestroyDescriptorUpdateTemplateKHR && |
| "Function <vkDestroyDescriptorUpdateTemplateKHR> needs extension <VK_KHR_descriptor_update_template> enabled!"); |
| |
| getDispatcher()->vkDestroyDescriptorUpdateTemplateKHR( |
| static_cast<VkDevice>(m_device), |
| static_cast<VkDescriptorUpdateTemplate>(descriptorUpdateTemplate), |
| reinterpret_cast<const VkAllocationCallbacks *>(static_cast<const VULKAN_HPP_NAMESPACE::AllocationCallbacks *>(allocator))); |
| } |
| |
| template<typename DataType> |
| VULKAN_HPP_INLINE void DescriptorSet::updateWithTemplateKHR(VULKAN_HPP_NAMESPACE::DescriptorUpdateTemplate descriptorUpdateTemplate, |
| DataType const &data) const VULKAN_HPP_NOEXCEPT |
| { |
| VULKAN_HPP_ASSERT(getDispatcher()->vkUpdateDescriptorSetWithTemplateKHR && |
| "Function <vkUpdateDescriptorSetWithTemplateKHR> needs extension <VK_KHR_descriptor_update_template> enabled!"); |
| |
| getDispatcher()->vkUpdateDescriptorSetWithTemplateKHR(static_cast<VkDevice>(m_device), |
| static_cast<VkDescriptorSet>(m_descriptorSet), |
| static_cast<VkDescriptorUpdateTemplate>(descriptorUpdateTemplate), |
| reinterpret_cast<const void *>(&data)); |
| } |
| |
| //=== VK_NV_clip_space_w_scaling === |
| |
| VULKAN_HPP_INLINE void |
| CommandBuffer::setViewportWScalingNV(uint32_t firstViewport, |
| ArrayProxy<const VULKAN_HPP_NAMESPACE::ViewportWScalingNV> const &viewportWScalings) const VULKAN_HPP_NOEXCEPT |
| { |
| VULKAN_HPP_ASSERT(getDispatcher()->vkCmdSetViewportWScalingNV && |
| "Function <vkCmdSetViewportWScalingNV> needs extension <VK_NV_clip_space_w_scaling> enabled!"); |
| |
| getDispatcher()->vkCmdSetViewportWScalingNV(static_cast<VkCommandBuffer>(m_commandBuffer), |
| firstViewport, |
| viewportWScalings.size(), |
| reinterpret_cast<const VkViewportWScalingNV *>(viewportWScalings.data())); |
| } |
| |
| # if defined(VK_USE_PLATFORM_XLIB_XRANDR_EXT) |
| //=== VK_EXT_acquire_xlib_display === |
| |
| VULKAN_HPP_INLINE void PhysicalDevice::acquireXlibDisplayEXT(Display &dpy, VULKAN_HPP_NAMESPACE::DisplayKHR display) const |
| { |
| VULKAN_HPP_ASSERT(getDispatcher()->vkAcquireXlibDisplayEXT && |
| "Function <vkAcquireXlibDisplayEXT> needs extension <VK_EXT_acquire_xlib_display> enabled!"); |
| |
| VULKAN_HPP_NAMESPACE::Result result = static_cast<VULKAN_HPP_NAMESPACE::Result>( |
| getDispatcher()->vkAcquireXlibDisplayEXT(static_cast<VkPhysicalDevice>(m_physicalDevice), &dpy, static_cast<VkDisplayKHR>(display))); |
| if(result != VULKAN_HPP_NAMESPACE::Result::eSuccess) |
| { |
| throwResultException(result, VULKAN_HPP_NAMESPACE_STRING "::PhysicalDevice::acquireXlibDisplayEXT"); |
| } |
| } |
| |
| VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE VULKAN_HPP_RAII_NAMESPACE::DisplayKHR PhysicalDevice::getRandROutputDisplayEXT(Display &dpy, |
| RROutput rrOutput) const |
| { |
| return VULKAN_HPP_RAII_NAMESPACE::DisplayKHR(*this, dpy, rrOutput); |
| } |
| # endif /*VK_USE_PLATFORM_XLIB_XRANDR_EXT*/ |
| |
| //=== VK_EXT_display_surface_counter === |
| |
| VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE VULKAN_HPP_NAMESPACE::SurfaceCapabilities2EXT |
| PhysicalDevice::getSurfaceCapabilities2EXT(VULKAN_HPP_NAMESPACE::SurfaceKHR surface) const |
| { |
| VULKAN_HPP_ASSERT(getDispatcher()->vkGetPhysicalDeviceSurfaceCapabilities2EXT && |
| "Function <vkGetPhysicalDeviceSurfaceCapabilities2EXT> needs extension <VK_EXT_display_surface_counter> enabled!"); |
| |
| VULKAN_HPP_NAMESPACE::SurfaceCapabilities2EXT surfaceCapabilities; |
| VULKAN_HPP_NAMESPACE::Result result = static_cast<VULKAN_HPP_NAMESPACE::Result>( |
| getDispatcher()->vkGetPhysicalDeviceSurfaceCapabilities2EXT(static_cast<VkPhysicalDevice>(m_physicalDevice), |
| static_cast<VkSurfaceKHR>(surface), |
| reinterpret_cast<VkSurfaceCapabilities2EXT *>(&surfaceCapabilities))); |
| if(result != VULKAN_HPP_NAMESPACE::Result::eSuccess) |
| { |
| throwResultException(result, VULKAN_HPP_NAMESPACE_STRING "::PhysicalDevice::getSurfaceCapabilities2EXT"); |
| } |
| return surfaceCapabilities; |
| } |
| |
| //=== VK_EXT_display_control === |
| |
| VULKAN_HPP_INLINE void Device::displayPowerControlEXT(VULKAN_HPP_NAMESPACE::DisplayKHR display, |
| const VULKAN_HPP_NAMESPACE::DisplayPowerInfoEXT &displayPowerInfo) const |
| { |
| VULKAN_HPP_ASSERT(getDispatcher()->vkDisplayPowerControlEXT && "Function <vkDisplayPowerControlEXT> needs extension <VK_EXT_display_control> enabled!"); |
| |
| VULKAN_HPP_NAMESPACE::Result result = static_cast<VULKAN_HPP_NAMESPACE::Result>(getDispatcher()->vkDisplayPowerControlEXT( |
| static_cast<VkDevice>(m_device), static_cast<VkDisplayKHR>(display), reinterpret_cast<const VkDisplayPowerInfoEXT *>(&displayPowerInfo))); |
| if(result != VULKAN_HPP_NAMESPACE::Result::eSuccess) |
| { |
| throwResultException(result, VULKAN_HPP_NAMESPACE_STRING "::Device::displayPowerControlEXT"); |
| } |
| } |
| |
| VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE VULKAN_HPP_RAII_NAMESPACE::Fence |
| Device::registerEventEXT(VULKAN_HPP_NAMESPACE::DeviceEventInfoEXT const &deviceEventInfo, |
| VULKAN_HPP_NAMESPACE::Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator) const |
| { |
| return VULKAN_HPP_RAII_NAMESPACE::Fence(*this, deviceEventInfo, allocator); |
| } |
| |
| VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE VULKAN_HPP_RAII_NAMESPACE::Fence |
| Device::registerDisplayEventEXT(VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::DisplayKHR const &display, |
| VULKAN_HPP_NAMESPACE::DisplayEventInfoEXT const &displayEventInfo, |
| VULKAN_HPP_NAMESPACE::Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator) const |
| { |
| return VULKAN_HPP_RAII_NAMESPACE::Fence(*this, display, displayEventInfo, allocator); |
| } |
| |
| VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE uint64_t SwapchainKHR::getCounterEXT(VULKAN_HPP_NAMESPACE::SurfaceCounterFlagBitsEXT counter) const |
| { |
| VULKAN_HPP_ASSERT(getDispatcher()->vkGetSwapchainCounterEXT && "Function <vkGetSwapchainCounterEXT> needs extension <VK_EXT_display_control> enabled!"); |
| |
| uint64_t counterValue; |
| VULKAN_HPP_NAMESPACE::Result result = static_cast<VULKAN_HPP_NAMESPACE::Result>(getDispatcher()->vkGetSwapchainCounterEXT( |
| static_cast<VkDevice>(m_device), static_cast<VkSwapchainKHR>(m_swapchain), static_cast<VkSurfaceCounterFlagBitsEXT>(counter), &counterValue)); |
| if(result != VULKAN_HPP_NAMESPACE::Result::eSuccess) |
| { |
| throwResultException(result, VULKAN_HPP_NAMESPACE_STRING "::SwapchainKHR::getCounterEXT"); |
| } |
| return counterValue; |
| } |
| |
| //=== VK_GOOGLE_display_timing === |
| |
| VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE VULKAN_HPP_NAMESPACE::RefreshCycleDurationGOOGLE SwapchainKHR::getRefreshCycleDurationGOOGLE() const |
| { |
| VULKAN_HPP_ASSERT(getDispatcher()->vkGetRefreshCycleDurationGOOGLE && |
| "Function <vkGetRefreshCycleDurationGOOGLE> needs extension <VK_GOOGLE_display_timing> enabled!"); |
| |
| VULKAN_HPP_NAMESPACE::RefreshCycleDurationGOOGLE displayTimingProperties; |
| VULKAN_HPP_NAMESPACE::Result result = static_cast<VULKAN_HPP_NAMESPACE::Result>( |
| getDispatcher()->vkGetRefreshCycleDurationGOOGLE(static_cast<VkDevice>(m_device), |
| static_cast<VkSwapchainKHR>(m_swapchain), |
| reinterpret_cast<VkRefreshCycleDurationGOOGLE *>(&displayTimingProperties))); |
| if(result != VULKAN_HPP_NAMESPACE::Result::eSuccess) |
| { |
| throwResultException(result, VULKAN_HPP_NAMESPACE_STRING "::SwapchainKHR::getRefreshCycleDurationGOOGLE"); |
| } |
| return displayTimingProperties; |
| } |
| |
| VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE std::vector<VULKAN_HPP_NAMESPACE::PastPresentationTimingGOOGLE> SwapchainKHR::getPastPresentationTimingGOOGLE() const |
| { |
| VULKAN_HPP_ASSERT(getDispatcher()->vkGetPastPresentationTimingGOOGLE && |
| "Function <vkGetPastPresentationTimingGOOGLE> needs extension <VK_GOOGLE_display_timing> enabled!"); |
| |
| std::vector<VULKAN_HPP_NAMESPACE::PastPresentationTimingGOOGLE> presentationTimings; |
| uint32_t presentationTimingCount; |
| VULKAN_HPP_NAMESPACE::Result result; |
| do |
| { |
| result = static_cast<VULKAN_HPP_NAMESPACE::Result>(getDispatcher()->vkGetPastPresentationTimingGOOGLE( |
| static_cast<VkDevice>(m_device), static_cast<VkSwapchainKHR>(m_swapchain), &presentationTimingCount, nullptr)); |
| if((result == VULKAN_HPP_NAMESPACE::Result::eSuccess) && presentationTimingCount) |
| { |
| presentationTimings.resize(presentationTimingCount); |
| result = static_cast<VULKAN_HPP_NAMESPACE::Result>( |
| getDispatcher()->vkGetPastPresentationTimingGOOGLE(static_cast<VkDevice>(m_device), |
| static_cast<VkSwapchainKHR>(m_swapchain), |
| &presentationTimingCount, |
| reinterpret_cast<VkPastPresentationTimingGOOGLE *>(presentationTimings.data()))); |
| } |
| } while(result == VULKAN_HPP_NAMESPACE::Result::eIncomplete); |
| if(result != VULKAN_HPP_NAMESPACE::Result::eSuccess) |
| { |
| throwResultException(result, VULKAN_HPP_NAMESPACE_STRING "::SwapchainKHR::getPastPresentationTimingGOOGLE"); |
| } |
| if(result == VULKAN_HPP_NAMESPACE::Result::eSuccess) |
| { |
| VULKAN_HPP_ASSERT(presentationTimingCount <= presentationTimings.size()); |
| if(presentationTimingCount < presentationTimings.size()) |
| { |
| presentationTimings.resize(presentationTimingCount); |
| } |
| } |
| return presentationTimings; |
| } |
| |
| //=== VK_EXT_discard_rectangles === |
| |
| VULKAN_HPP_INLINE void |
| CommandBuffer::setDiscardRectangleEXT(uint32_t firstDiscardRectangle, |
| ArrayProxy<const VULKAN_HPP_NAMESPACE::Rect2D> const &discardRectangles) const VULKAN_HPP_NOEXCEPT |
| { |
| VULKAN_HPP_ASSERT(getDispatcher()->vkCmdSetDiscardRectangleEXT && |
| "Function <vkCmdSetDiscardRectangleEXT> needs extension <VK_EXT_discard_rectangles> enabled!"); |
| |
| getDispatcher()->vkCmdSetDiscardRectangleEXT(static_cast<VkCommandBuffer>(m_commandBuffer), |
| firstDiscardRectangle, |
| discardRectangles.size(), |
| reinterpret_cast<const VkRect2D *>(discardRectangles.data())); |
| } |
| |
| //=== VK_EXT_hdr_metadata === |
| |
| VULKAN_HPP_INLINE void Device::setHdrMetadataEXT(ArrayProxy<const VULKAN_HPP_NAMESPACE::SwapchainKHR> const &swapchains, |
| ArrayProxy<const VULKAN_HPP_NAMESPACE::HdrMetadataEXT> const &metadata) const |
| { |
| VULKAN_HPP_ASSERT(getDispatcher()->vkSetHdrMetadataEXT && "Function <vkSetHdrMetadataEXT> needs extension <VK_EXT_hdr_metadata> enabled!"); |
| |
| if(swapchains.size() != metadata.size()) |
| { |
| throw LogicError(VULKAN_HPP_NAMESPACE_STRING "::Device::setHdrMetadataEXT: swapchains.size() != metadata.size()"); |
| } |
| getDispatcher()->vkSetHdrMetadataEXT(static_cast<VkDevice>(m_device), |
| swapchains.size(), |
| reinterpret_cast<const VkSwapchainKHR *>(swapchains.data()), |
| reinterpret_cast<const VkHdrMetadataEXT *>(metadata.data())); |
| } |
| |
| //=== VK_KHR_create_renderpass2 === |
| |
| VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE VULKAN_HPP_RAII_NAMESPACE::RenderPass |
| Device::createRenderPass2KHR(VULKAN_HPP_NAMESPACE::RenderPassCreateInfo2 const &createInfo, |
| VULKAN_HPP_NAMESPACE::Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator) const |
| { |
| return VULKAN_HPP_RAII_NAMESPACE::RenderPass(*this, createInfo, allocator); |
| } |
| |
| VULKAN_HPP_INLINE void CommandBuffer::beginRenderPass2KHR(const VULKAN_HPP_NAMESPACE::RenderPassBeginInfo &renderPassBegin, |
| const VULKAN_HPP_NAMESPACE::SubpassBeginInfo &subpassBeginInfo) const VULKAN_HPP_NOEXCEPT |
| { |
| VULKAN_HPP_ASSERT(getDispatcher()->vkCmdBeginRenderPass2KHR && |
| "Function <vkCmdBeginRenderPass2KHR> needs extension <VK_KHR_create_renderpass2> enabled!"); |
| |
| getDispatcher()->vkCmdBeginRenderPass2KHR(static_cast<VkCommandBuffer>(m_commandBuffer), |
| reinterpret_cast<const VkRenderPassBeginInfo *>(&renderPassBegin), |
| reinterpret_cast<const VkSubpassBeginInfo *>(&subpassBeginInfo)); |
| } |
| |
| VULKAN_HPP_INLINE void CommandBuffer::nextSubpass2KHR(const VULKAN_HPP_NAMESPACE::SubpassBeginInfo &subpassBeginInfo, |
| const VULKAN_HPP_NAMESPACE::SubpassEndInfo &subpassEndInfo) const VULKAN_HPP_NOEXCEPT |
| { |
| VULKAN_HPP_ASSERT(getDispatcher()->vkCmdNextSubpass2KHR && "Function <vkCmdNextSubpass2KHR> needs extension <VK_KHR_create_renderpass2> enabled!"); |
| |
| getDispatcher()->vkCmdNextSubpass2KHR(static_cast<VkCommandBuffer>(m_commandBuffer), |
| reinterpret_cast<const VkSubpassBeginInfo *>(&subpassBeginInfo), |
| reinterpret_cast<const VkSubpassEndInfo *>(&subpassEndInfo)); |
| } |
| |
| VULKAN_HPP_INLINE void CommandBuffer::endRenderPass2KHR(const VULKAN_HPP_NAMESPACE::SubpassEndInfo &subpassEndInfo) const VULKAN_HPP_NOEXCEPT |
| { |
| VULKAN_HPP_ASSERT(getDispatcher()->vkCmdEndRenderPass2KHR && "Function <vkCmdEndRenderPass2KHR> needs extension <VK_KHR_create_renderpass2> enabled!"); |
| |
| getDispatcher()->vkCmdEndRenderPass2KHR(static_cast<VkCommandBuffer>(m_commandBuffer), reinterpret_cast<const VkSubpassEndInfo *>(&subpassEndInfo)); |
| } |
| |
| //=== VK_KHR_shared_presentable_image === |
| |
| VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE VULKAN_HPP_NAMESPACE::Result SwapchainKHR::getStatus() const |
| { |
| VULKAN_HPP_ASSERT(getDispatcher()->vkGetSwapchainStatusKHR && |
| "Function <vkGetSwapchainStatusKHR> needs extension <VK_KHR_shared_presentable_image> enabled!"); |
| |
| VULKAN_HPP_NAMESPACE::Result result = static_cast<VULKAN_HPP_NAMESPACE::Result>( |
| getDispatcher()->vkGetSwapchainStatusKHR(static_cast<VkDevice>(m_device), static_cast<VkSwapchainKHR>(m_swapchain))); |
| if((result != VULKAN_HPP_NAMESPACE::Result::eSuccess) && (result != VULKAN_HPP_NAMESPACE::Result::eSuboptimalKHR)) |
| { |
| throwResultException(result, VULKAN_HPP_NAMESPACE_STRING "::SwapchainKHR::getStatus"); |
| } |
| return result; |
| } |
| |
| //=== VK_KHR_external_fence_capabilities === |
| |
| VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE VULKAN_HPP_NAMESPACE::ExternalFenceProperties |
| PhysicalDevice::getExternalFencePropertiesKHR(const VULKAN_HPP_NAMESPACE::PhysicalDeviceExternalFenceInfo &externalFenceInfo) const VULKAN_HPP_NOEXCEPT |
| { |
| VULKAN_HPP_ASSERT(getDispatcher()->vkGetPhysicalDeviceExternalFencePropertiesKHR && |
| "Function <vkGetPhysicalDeviceExternalFencePropertiesKHR> needs extension <VK_KHR_external_fence_capabilities> enabled!"); |
| |
| VULKAN_HPP_NAMESPACE::ExternalFenceProperties externalFenceProperties; |
| getDispatcher()->vkGetPhysicalDeviceExternalFencePropertiesKHR(static_cast<VkPhysicalDevice>(m_physicalDevice), |
| reinterpret_cast<const VkPhysicalDeviceExternalFenceInfo *>(&externalFenceInfo), |
| reinterpret_cast<VkExternalFenceProperties *>(&externalFenceProperties)); |
| return externalFenceProperties; |
| } |
| |
| # if defined(VK_USE_PLATFORM_WIN32_KHR) |
| //=== VK_KHR_external_fence_win32 === |
| |
| VULKAN_HPP_INLINE void Device::importFenceWin32HandleKHR(const VULKAN_HPP_NAMESPACE::ImportFenceWin32HandleInfoKHR &importFenceWin32HandleInfo) const |
| { |
| VULKAN_HPP_ASSERT(getDispatcher()->vkImportFenceWin32HandleKHR && |
| "Function <vkImportFenceWin32HandleKHR> needs extension <VK_KHR_external_fence_win32> enabled!"); |
| |
| VULKAN_HPP_NAMESPACE::Result result = static_cast<VULKAN_HPP_NAMESPACE::Result>(getDispatcher()->vkImportFenceWin32HandleKHR( |
| static_cast<VkDevice>(m_device), reinterpret_cast<const VkImportFenceWin32HandleInfoKHR *>(&importFenceWin32HandleInfo))); |
| if(result != VULKAN_HPP_NAMESPACE::Result::eSuccess) |
| { |
| throwResultException(result, VULKAN_HPP_NAMESPACE_STRING "::Device::importFenceWin32HandleKHR"); |
| } |
| } |
| |
| VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE HANDLE |
| Device::getFenceWin32HandleKHR(const VULKAN_HPP_NAMESPACE::FenceGetWin32HandleInfoKHR &getWin32HandleInfo) const |
| { |
| VULKAN_HPP_ASSERT(getDispatcher()->vkGetFenceWin32HandleKHR && |
| "Function <vkGetFenceWin32HandleKHR> needs extension <VK_KHR_external_fence_win32> enabled!"); |
| |
| HANDLE handle; |
| VULKAN_HPP_NAMESPACE::Result result = static_cast<VULKAN_HPP_NAMESPACE::Result>(getDispatcher()->vkGetFenceWin32HandleKHR( |
| static_cast<VkDevice>(m_device), reinterpret_cast<const VkFenceGetWin32HandleInfoKHR *>(&getWin32HandleInfo), &handle)); |
| if(result != VULKAN_HPP_NAMESPACE::Result::eSuccess) |
| { |
| throwResultException(result, VULKAN_HPP_NAMESPACE_STRING "::Device::getFenceWin32HandleKHR"); |
| } |
| return handle; |
| } |
| # endif /*VK_USE_PLATFORM_WIN32_KHR*/ |
| |
| //=== VK_KHR_external_fence_fd === |
| |
| VULKAN_HPP_INLINE void Device::importFenceFdKHR(const VULKAN_HPP_NAMESPACE::ImportFenceFdInfoKHR &importFenceFdInfo) const |
| { |
| VULKAN_HPP_ASSERT(getDispatcher()->vkImportFenceFdKHR && "Function <vkImportFenceFdKHR> needs extension <VK_KHR_external_fence_fd> enabled!"); |
| |
| VULKAN_HPP_NAMESPACE::Result result = static_cast<VULKAN_HPP_NAMESPACE::Result>( |
| getDispatcher()->vkImportFenceFdKHR(static_cast<VkDevice>(m_device), reinterpret_cast<const VkImportFenceFdInfoKHR *>(&importFenceFdInfo))); |
| if(result != VULKAN_HPP_NAMESPACE::Result::eSuccess) |
| { |
| throwResultException(result, VULKAN_HPP_NAMESPACE_STRING "::Device::importFenceFdKHR"); |
| } |
| } |
| |
| VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE int Device::getFenceFdKHR(const VULKAN_HPP_NAMESPACE::FenceGetFdInfoKHR &getFdInfo) const |
| { |
| VULKAN_HPP_ASSERT(getDispatcher()->vkGetFenceFdKHR && "Function <vkGetFenceFdKHR> needs extension <VK_KHR_external_fence_fd> enabled!"); |
| |
| int fd; |
| VULKAN_HPP_NAMESPACE::Result result = static_cast<VULKAN_HPP_NAMESPACE::Result>( |
| getDispatcher()->vkGetFenceFdKHR(static_cast<VkDevice>(m_device), reinterpret_cast<const VkFenceGetFdInfoKHR *>(&getFdInfo), &fd)); |
| if(result != VULKAN_HPP_NAMESPACE::Result::eSuccess) |
| { |
| throwResultException(result, VULKAN_HPP_NAMESPACE_STRING "::Device::getFenceFdKHR"); |
| } |
| return fd; |
| } |
| |
| //=== VK_KHR_performance_query === |
| |
| VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE std::pair<std::vector<PerformanceCounterKHR>, std::vector<PerformanceCounterDescriptionKHR>> |
| PhysicalDevice::enumerateQueueFamilyPerformanceQueryCountersKHR(uint32_t queueFamilyIndex) const |
| { |
| VULKAN_HPP_ASSERT(getDispatcher()->vkEnumeratePhysicalDeviceQueueFamilyPerformanceQueryCountersKHR && |
| "Function <vkEnumeratePhysicalDeviceQueueFamilyPerformanceQueryCountersKHR> needs extension <VK_KHR_performance_query> enabled!"); |
| |
| std::pair<std::vector<PerformanceCounterKHR>, std::vector<PerformanceCounterDescriptionKHR>> data; |
| std::vector<PerformanceCounterKHR> &counters = data.first; |
| std::vector<PerformanceCounterDescriptionKHR> &counterDescriptions = data.second; |
| uint32_t counterCount; |
| VULKAN_HPP_NAMESPACE::Result result; |
| do |
| { |
| result = static_cast<VULKAN_HPP_NAMESPACE::Result>(getDispatcher()->vkEnumeratePhysicalDeviceQueueFamilyPerformanceQueryCountersKHR( |
| static_cast<VkPhysicalDevice>(m_physicalDevice), queueFamilyIndex, &counterCount, nullptr, nullptr)); |
| if((result == VULKAN_HPP_NAMESPACE::Result::eSuccess) && counterCount) |
| { |
| counters.resize(counterCount); |
| counterDescriptions.resize(counterCount); |
| result = static_cast<VULKAN_HPP_NAMESPACE::Result>(getDispatcher()->vkEnumeratePhysicalDeviceQueueFamilyPerformanceQueryCountersKHR( |
| static_cast<VkPhysicalDevice>(m_physicalDevice), |
| queueFamilyIndex, |
| &counterCount, |
| reinterpret_cast<VkPerformanceCounterKHR *>(counters.data()), |
| reinterpret_cast<VkPerformanceCounterDescriptionKHR *>(counterDescriptions.data()))); |
| VULKAN_HPP_ASSERT(counterCount <= counters.size()); |
| } |
| } while(result == VULKAN_HPP_NAMESPACE::Result::eIncomplete); |
| if((result == VULKAN_HPP_NAMESPACE::Result::eSuccess) && (counterCount < counters.size())) |
| { |
| counters.resize(counterCount); |
| counterDescriptions.resize(counterCount); |
| } |
| if(result != VULKAN_HPP_NAMESPACE::Result::eSuccess) |
| { |
| throwResultException(result, VULKAN_HPP_NAMESPACE_STRING "::PhysicalDevice::enumerateQueueFamilyPerformanceQueryCountersKHR"); |
| } |
| return data; |
| } |
| |
| VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE uint32_t PhysicalDevice::getQueueFamilyPerformanceQueryPassesKHR( |
| const VULKAN_HPP_NAMESPACE::QueryPoolPerformanceCreateInfoKHR &performanceQueryCreateInfo) const VULKAN_HPP_NOEXCEPT |
| { |
| VULKAN_HPP_ASSERT(getDispatcher()->vkGetPhysicalDeviceQueueFamilyPerformanceQueryPassesKHR && |
| "Function <vkGetPhysicalDeviceQueueFamilyPerformanceQueryPassesKHR> needs extension <VK_KHR_performance_query> enabled!"); |
| |
| uint32_t numPasses; |
| getDispatcher()->vkGetPhysicalDeviceQueueFamilyPerformanceQueryPassesKHR( |
| static_cast<VkPhysicalDevice>(m_physicalDevice), |
| reinterpret_cast<const VkQueryPoolPerformanceCreateInfoKHR *>(&performanceQueryCreateInfo), |
| &numPasses); |
| return numPasses; |
| } |
| |
| VULKAN_HPP_INLINE void Device::acquireProfilingLockKHR(const VULKAN_HPP_NAMESPACE::AcquireProfilingLockInfoKHR &info) const |
| { |
| VULKAN_HPP_ASSERT(getDispatcher()->vkAcquireProfilingLockKHR && |
| "Function <vkAcquireProfilingLockKHR> needs extension <VK_KHR_performance_query> enabled!"); |
| |
| VULKAN_HPP_NAMESPACE::Result result = static_cast<VULKAN_HPP_NAMESPACE::Result>( |
| getDispatcher()->vkAcquireProfilingLockKHR(static_cast<VkDevice>(m_device), reinterpret_cast<const VkAcquireProfilingLockInfoKHR *>(&info))); |
| if(result != VULKAN_HPP_NAMESPACE::Result::eSuccess) |
| { |
| throwResultException(result, VULKAN_HPP_NAMESPACE_STRING "::Device::acquireProfilingLockKHR"); |
| } |
| } |
| |
| VULKAN_HPP_INLINE void Device::releaseProfilingLockKHR() const VULKAN_HPP_NOEXCEPT |
| { |
| VULKAN_HPP_ASSERT(getDispatcher()->vkReleaseProfilingLockKHR && |
| "Function <vkReleaseProfilingLockKHR> needs extension <VK_KHR_performance_query> enabled!"); |
| |
| getDispatcher()->vkReleaseProfilingLockKHR(static_cast<VkDevice>(m_device)); |
| } |
| |
| //=== VK_KHR_get_surface_capabilities2 === |
| |
| VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE VULKAN_HPP_NAMESPACE::SurfaceCapabilities2KHR |
| PhysicalDevice::getSurfaceCapabilities2KHR(const VULKAN_HPP_NAMESPACE::PhysicalDeviceSurfaceInfo2KHR &surfaceInfo) const |
| { |
| VULKAN_HPP_ASSERT(getDispatcher()->vkGetPhysicalDeviceSurfaceCapabilities2KHR && |
| "Function <vkGetPhysicalDeviceSurfaceCapabilities2KHR> needs extension <VK_KHR_get_surface_capabilities2> enabled!"); |
| |
| VULKAN_HPP_NAMESPACE::SurfaceCapabilities2KHR surfaceCapabilities; |
| VULKAN_HPP_NAMESPACE::Result result = static_cast<VULKAN_HPP_NAMESPACE::Result>( |
| getDispatcher()->vkGetPhysicalDeviceSurfaceCapabilities2KHR(static_cast<VkPhysicalDevice>(m_physicalDevice), |
| reinterpret_cast<const VkPhysicalDeviceSurfaceInfo2KHR *>(&surfaceInfo), |
| reinterpret_cast<VkSurfaceCapabilities2KHR *>(&surfaceCapabilities))); |
| if(result != VULKAN_HPP_NAMESPACE::Result::eSuccess) |
| { |
| throwResultException(result, VULKAN_HPP_NAMESPACE_STRING "::PhysicalDevice::getSurfaceCapabilities2KHR"); |
| } |
| return surfaceCapabilities; |
| } |
| |
| template<typename X, typename Y, typename... Z> |
| VULKAN_HPP_NODISCARD StructureChain<X, Y, Z...> |
| PhysicalDevice::getSurfaceCapabilities2KHR(const VULKAN_HPP_NAMESPACE::PhysicalDeviceSurfaceInfo2KHR &surfaceInfo) const |
| { |
| StructureChain<X, Y, Z...> structureChain; |
| VULKAN_HPP_NAMESPACE::SurfaceCapabilities2KHR &surfaceCapabilities = structureChain.template get<VULKAN_HPP_NAMESPACE::SurfaceCapabilities2KHR>(); |
| VULKAN_HPP_NAMESPACE::Result result = static_cast<VULKAN_HPP_NAMESPACE::Result>( |
| getDispatcher()->vkGetPhysicalDeviceSurfaceCapabilities2KHR(static_cast<VkPhysicalDevice>(m_physicalDevice), |
| reinterpret_cast<const VkPhysicalDeviceSurfaceInfo2KHR *>(&surfaceInfo), |
| reinterpret_cast<VkSurfaceCapabilities2KHR *>(&surfaceCapabilities))); |
| if(result != VULKAN_HPP_NAMESPACE::Result::eSuccess) |
| { |
| throwResultException(result, VULKAN_HPP_NAMESPACE_STRING "::PhysicalDevice::getSurfaceCapabilities2KHR"); |
| } |
| return structureChain; |
| } |
| |
| VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE std::vector<VULKAN_HPP_NAMESPACE::SurfaceFormat2KHR> |
| PhysicalDevice::getSurfaceFormats2KHR(const VULKAN_HPP_NAMESPACE::PhysicalDeviceSurfaceInfo2KHR &surfaceInfo) const |
| { |
| VULKAN_HPP_ASSERT(getDispatcher()->vkGetPhysicalDeviceSurfaceFormats2KHR && |
| "Function <vkGetPhysicalDeviceSurfaceFormats2KHR> needs extension <VK_KHR_get_surface_capabilities2> enabled!"); |
| |
| std::vector<VULKAN_HPP_NAMESPACE::SurfaceFormat2KHR> surfaceFormats; |
| uint32_t surfaceFormatCount; |
| VULKAN_HPP_NAMESPACE::Result result; |
| do |
| { |
| result = static_cast<VULKAN_HPP_NAMESPACE::Result>( |
| getDispatcher()->vkGetPhysicalDeviceSurfaceFormats2KHR(static_cast<VkPhysicalDevice>(m_physicalDevice), |
| reinterpret_cast<const VkPhysicalDeviceSurfaceInfo2KHR *>(&surfaceInfo), |
| &surfaceFormatCount, |
| nullptr)); |
| if((result == VULKAN_HPP_NAMESPACE::Result::eSuccess) && surfaceFormatCount) |
| { |
| surfaceFormats.resize(surfaceFormatCount); |
| result = static_cast<VULKAN_HPP_NAMESPACE::Result>( |
| getDispatcher()->vkGetPhysicalDeviceSurfaceFormats2KHR(static_cast<VkPhysicalDevice>(m_physicalDevice), |
| reinterpret_cast<const VkPhysicalDeviceSurfaceInfo2KHR *>(&surfaceInfo), |
| &surfaceFormatCount, |
| reinterpret_cast<VkSurfaceFormat2KHR *>(surfaceFormats.data()))); |
| } |
| } while(result == VULKAN_HPP_NAMESPACE::Result::eIncomplete); |
| if(result != VULKAN_HPP_NAMESPACE::Result::eSuccess) |
| { |
| throwResultException(result, VULKAN_HPP_NAMESPACE_STRING "::PhysicalDevice::getSurfaceFormats2KHR"); |
| } |
| if(result == VULKAN_HPP_NAMESPACE::Result::eSuccess) |
| { |
| VULKAN_HPP_ASSERT(surfaceFormatCount <= surfaceFormats.size()); |
| if(surfaceFormatCount < surfaceFormats.size()) |
| { |
| surfaceFormats.resize(surfaceFormatCount); |
| } |
| } |
| return surfaceFormats; |
| } |
| |
| //=== VK_KHR_get_display_properties2 === |
| |
| VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE std::vector<VULKAN_HPP_NAMESPACE::DisplayProperties2KHR> PhysicalDevice::getDisplayProperties2KHR() const |
| { |
| VULKAN_HPP_ASSERT(getDispatcher()->vkGetPhysicalDeviceDisplayProperties2KHR && |
| "Function <vkGetPhysicalDeviceDisplayProperties2KHR> needs extension <VK_KHR_get_display_properties2> enabled!"); |
| |
| std::vector<VULKAN_HPP_NAMESPACE::DisplayProperties2KHR> properties; |
| uint32_t propertyCount; |
| VULKAN_HPP_NAMESPACE::Result result; |
| do |
| { |
| result = static_cast<VULKAN_HPP_NAMESPACE::Result>( |
| getDispatcher()->vkGetPhysicalDeviceDisplayProperties2KHR(static_cast<VkPhysicalDevice>(m_physicalDevice), &propertyCount, nullptr)); |
| if((result == VULKAN_HPP_NAMESPACE::Result::eSuccess) && propertyCount) |
| { |
| properties.resize(propertyCount); |
| result = static_cast<VULKAN_HPP_NAMESPACE::Result>(getDispatcher()->vkGetPhysicalDeviceDisplayProperties2KHR( |
| static_cast<VkPhysicalDevice>(m_physicalDevice), &propertyCount, reinterpret_cast<VkDisplayProperties2KHR *>(properties.data()))); |
| } |
| } while(result == VULKAN_HPP_NAMESPACE::Result::eIncomplete); |
| if(result != VULKAN_HPP_NAMESPACE::Result::eSuccess) |
| { |
| throwResultException(result, VULKAN_HPP_NAMESPACE_STRING "::PhysicalDevice::getDisplayProperties2KHR"); |
| } |
| if(result == VULKAN_HPP_NAMESPACE::Result::eSuccess) |
| { |
| VULKAN_HPP_ASSERT(propertyCount <= properties.size()); |
| if(propertyCount < properties.size()) |
| { |
| properties.resize(propertyCount); |
| } |
| } |
| return properties; |
| } |
| |
| VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE std::vector<VULKAN_HPP_NAMESPACE::DisplayPlaneProperties2KHR> PhysicalDevice::getDisplayPlaneProperties2KHR() const |
| { |
| VULKAN_HPP_ASSERT(getDispatcher()->vkGetPhysicalDeviceDisplayPlaneProperties2KHR && |
| "Function <vkGetPhysicalDeviceDisplayPlaneProperties2KHR> needs extension <VK_KHR_get_display_properties2> enabled!"); |
| |
| std::vector<VULKAN_HPP_NAMESPACE::DisplayPlaneProperties2KHR> properties; |
| uint32_t propertyCount; |
| VULKAN_HPP_NAMESPACE::Result result; |
| do |
| { |
| result = static_cast<VULKAN_HPP_NAMESPACE::Result>( |
| getDispatcher()->vkGetPhysicalDeviceDisplayPlaneProperties2KHR(static_cast<VkPhysicalDevice>(m_physicalDevice), &propertyCount, nullptr)); |
| if((result == VULKAN_HPP_NAMESPACE::Result::eSuccess) && propertyCount) |
| { |
| properties.resize(propertyCount); |
| result = static_cast<VULKAN_HPP_NAMESPACE::Result>(getDispatcher()->vkGetPhysicalDeviceDisplayPlaneProperties2KHR( |
| static_cast<VkPhysicalDevice>(m_physicalDevice), &propertyCount, reinterpret_cast<VkDisplayPlaneProperties2KHR *>(properties.data()))); |
| } |
| } while(result == VULKAN_HPP_NAMESPACE::Result::eIncomplete); |
| if(result != VULKAN_HPP_NAMESPACE::Result::eSuccess) |
| { |
| throwResultException(result, VULKAN_HPP_NAMESPACE_STRING "::PhysicalDevice::getDisplayPlaneProperties2KHR"); |
| } |
| if(result == VULKAN_HPP_NAMESPACE::Result::eSuccess) |
| { |
| VULKAN_HPP_ASSERT(propertyCount <= properties.size()); |
| if(propertyCount < properties.size()) |
| { |
| properties.resize(propertyCount); |
| } |
| } |
| return properties; |
| } |
| |
| VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE std::vector<VULKAN_HPP_NAMESPACE::DisplayModeProperties2KHR> DisplayKHR::getModeProperties2() const |
| { |
| VULKAN_HPP_ASSERT(getDispatcher()->vkGetDisplayModeProperties2KHR && |
| "Function <vkGetDisplayModeProperties2KHR> needs extension <VK_KHR_get_display_properties2> enabled!"); |
| |
| std::vector<VULKAN_HPP_NAMESPACE::DisplayModeProperties2KHR> properties; |
| uint32_t propertyCount; |
| VULKAN_HPP_NAMESPACE::Result result; |
| do |
| { |
| result = static_cast<VULKAN_HPP_NAMESPACE::Result>(getDispatcher()->vkGetDisplayModeProperties2KHR( |
| static_cast<VkPhysicalDevice>(m_physicalDevice), static_cast<VkDisplayKHR>(m_display), &propertyCount, nullptr)); |
| if((result == VULKAN_HPP_NAMESPACE::Result::eSuccess) && propertyCount) |
| { |
| properties.resize(propertyCount); |
| result = static_cast<VULKAN_HPP_NAMESPACE::Result>( |
| getDispatcher()->vkGetDisplayModeProperties2KHR(static_cast<VkPhysicalDevice>(m_physicalDevice), |
| static_cast<VkDisplayKHR>(m_display), |
| &propertyCount, |
| reinterpret_cast<VkDisplayModeProperties2KHR *>(properties.data()))); |
| } |
| } while(result == VULKAN_HPP_NAMESPACE::Result::eIncomplete); |
| if(result != VULKAN_HPP_NAMESPACE::Result::eSuccess) |
| { |
| throwResultException(result, VULKAN_HPP_NAMESPACE_STRING "::DisplayKHR::getModeProperties2"); |
| } |
| if(result == VULKAN_HPP_NAMESPACE::Result::eSuccess) |
| { |
| VULKAN_HPP_ASSERT(propertyCount <= properties.size()); |
| if(propertyCount < properties.size()) |
| { |
| properties.resize(propertyCount); |
| } |
| } |
| return properties; |
| } |
| |
| VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE VULKAN_HPP_NAMESPACE::DisplayPlaneCapabilities2KHR |
| PhysicalDevice::getDisplayPlaneCapabilities2KHR(const VULKAN_HPP_NAMESPACE::DisplayPlaneInfo2KHR &displayPlaneInfo) const |
| { |
| VULKAN_HPP_ASSERT(getDispatcher()->vkGetDisplayPlaneCapabilities2KHR && |
| "Function <vkGetDisplayPlaneCapabilities2KHR> needs extension <VK_KHR_get_display_properties2> enabled!"); |
| |
| VULKAN_HPP_NAMESPACE::DisplayPlaneCapabilities2KHR capabilities; |
| VULKAN_HPP_NAMESPACE::Result result = static_cast<VULKAN_HPP_NAMESPACE::Result>( |
| getDispatcher()->vkGetDisplayPlaneCapabilities2KHR(static_cast<VkPhysicalDevice>(m_physicalDevice), |
| reinterpret_cast<const VkDisplayPlaneInfo2KHR *>(&displayPlaneInfo), |
| reinterpret_cast<VkDisplayPlaneCapabilities2KHR *>(&capabilities))); |
| if(result != VULKAN_HPP_NAMESPACE::Result::eSuccess) |
| { |
| throwResultException(result, VULKAN_HPP_NAMESPACE_STRING "::PhysicalDevice::getDisplayPlaneCapabilities2KHR"); |
| } |
| return capabilities; |
| } |
| |
| # if defined(VK_USE_PLATFORM_IOS_MVK) |
| //=== VK_MVK_ios_surface === |
| |
| VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE VULKAN_HPP_RAII_NAMESPACE::SurfaceKHR |
| Instance::createIOSSurfaceMVK(VULKAN_HPP_NAMESPACE::IOSSurfaceCreateInfoMVK const &createInfo, |
| VULKAN_HPP_NAMESPACE::Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator) const |
| { |
| return VULKAN_HPP_RAII_NAMESPACE::SurfaceKHR(*this, createInfo, allocator); |
| } |
| # endif /*VK_USE_PLATFORM_IOS_MVK*/ |
| |
| # if defined(VK_USE_PLATFORM_MACOS_MVK) |
| //=== VK_MVK_macos_surface === |
| |
| VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE VULKAN_HPP_RAII_NAMESPACE::SurfaceKHR |
| Instance::createMacOSSurfaceMVK(VULKAN_HPP_NAMESPACE::MacOSSurfaceCreateInfoMVK const &createInfo, |
| VULKAN_HPP_NAMESPACE::Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator) const |
| { |
| return VULKAN_HPP_RAII_NAMESPACE::SurfaceKHR(*this, createInfo, allocator); |
| } |
| # endif /*VK_USE_PLATFORM_MACOS_MVK*/ |
| |
| //=== VK_EXT_debug_utils === |
| |
| VULKAN_HPP_INLINE void Device::setDebugUtilsObjectNameEXT(const VULKAN_HPP_NAMESPACE::DebugUtilsObjectNameInfoEXT &nameInfo) const |
| { |
| VULKAN_HPP_ASSERT(getDispatcher()->vkSetDebugUtilsObjectNameEXT && |
| "Function <vkSetDebugUtilsObjectNameEXT> needs extension <VK_EXT_debug_utils> enabled!"); |
| |
| VULKAN_HPP_NAMESPACE::Result result = static_cast<VULKAN_HPP_NAMESPACE::Result>(getDispatcher()->vkSetDebugUtilsObjectNameEXT( |
| static_cast<VkDevice>(m_device), reinterpret_cast<const VkDebugUtilsObjectNameInfoEXT *>(&nameInfo))); |
| if(result != VULKAN_HPP_NAMESPACE::Result::eSuccess) |
| { |
| throwResultException(result, VULKAN_HPP_NAMESPACE_STRING "::Device::setDebugUtilsObjectNameEXT"); |
| } |
| } |
| |
| VULKAN_HPP_INLINE void Device::setDebugUtilsObjectTagEXT(const VULKAN_HPP_NAMESPACE::DebugUtilsObjectTagInfoEXT &tagInfo) const |
| { |
| VULKAN_HPP_ASSERT(getDispatcher()->vkSetDebugUtilsObjectTagEXT && |
| "Function <vkSetDebugUtilsObjectTagEXT> needs extension <VK_EXT_debug_utils> enabled!"); |
| |
| VULKAN_HPP_NAMESPACE::Result result = static_cast<VULKAN_HPP_NAMESPACE::Result>( |
| getDispatcher()->vkSetDebugUtilsObjectTagEXT(static_cast<VkDevice>(m_device), reinterpret_cast<const VkDebugUtilsObjectTagInfoEXT *>(&tagInfo))); |
| if(result != VULKAN_HPP_NAMESPACE::Result::eSuccess) |
| { |
| throwResultException(result, VULKAN_HPP_NAMESPACE_STRING "::Device::setDebugUtilsObjectTagEXT"); |
| } |
| } |
| |
| VULKAN_HPP_INLINE void Queue::beginDebugUtilsLabelEXT(const VULKAN_HPP_NAMESPACE::DebugUtilsLabelEXT &labelInfo) const VULKAN_HPP_NOEXCEPT |
| { |
| VULKAN_HPP_ASSERT(getDispatcher()->vkQueueBeginDebugUtilsLabelEXT && |
| "Function <vkQueueBeginDebugUtilsLabelEXT> needs extension <VK_EXT_debug_utils> enabled!"); |
| |
| getDispatcher()->vkQueueBeginDebugUtilsLabelEXT(static_cast<VkQueue>(m_queue), reinterpret_cast<const VkDebugUtilsLabelEXT *>(&labelInfo)); |
| } |
| |
| VULKAN_HPP_INLINE void Queue::endDebugUtilsLabelEXT() const VULKAN_HPP_NOEXCEPT |
| { |
| VULKAN_HPP_ASSERT(getDispatcher()->vkQueueEndDebugUtilsLabelEXT && |
| "Function <vkQueueEndDebugUtilsLabelEXT> needs extension <VK_EXT_debug_utils> enabled!"); |
| |
| getDispatcher()->vkQueueEndDebugUtilsLabelEXT(static_cast<VkQueue>(m_queue)); |
| } |
| |
| VULKAN_HPP_INLINE void Queue::insertDebugUtilsLabelEXT(const VULKAN_HPP_NAMESPACE::DebugUtilsLabelEXT &labelInfo) const VULKAN_HPP_NOEXCEPT |
| { |
| VULKAN_HPP_ASSERT(getDispatcher()->vkQueueInsertDebugUtilsLabelEXT && |
| "Function <vkQueueInsertDebugUtilsLabelEXT> needs extension <VK_EXT_debug_utils> enabled!"); |
| |
| getDispatcher()->vkQueueInsertDebugUtilsLabelEXT(static_cast<VkQueue>(m_queue), reinterpret_cast<const VkDebugUtilsLabelEXT *>(&labelInfo)); |
| } |
| |
| VULKAN_HPP_INLINE void CommandBuffer::beginDebugUtilsLabelEXT(const VULKAN_HPP_NAMESPACE::DebugUtilsLabelEXT &labelInfo) const VULKAN_HPP_NOEXCEPT |
| { |
| VULKAN_HPP_ASSERT(getDispatcher()->vkCmdBeginDebugUtilsLabelEXT && |
| "Function <vkCmdBeginDebugUtilsLabelEXT> needs extension <VK_EXT_debug_utils> enabled!"); |
| |
| getDispatcher()->vkCmdBeginDebugUtilsLabelEXT(static_cast<VkCommandBuffer>(m_commandBuffer), |
| reinterpret_cast<const VkDebugUtilsLabelEXT *>(&labelInfo)); |
| } |
| |
| VULKAN_HPP_INLINE void CommandBuffer::endDebugUtilsLabelEXT() const VULKAN_HPP_NOEXCEPT |
| { |
| VULKAN_HPP_ASSERT(getDispatcher()->vkCmdEndDebugUtilsLabelEXT && "Function <vkCmdEndDebugUtilsLabelEXT> needs extension <VK_EXT_debug_utils> enabled!"); |
| |
| getDispatcher()->vkCmdEndDebugUtilsLabelEXT(static_cast<VkCommandBuffer>(m_commandBuffer)); |
| } |
| |
| VULKAN_HPP_INLINE void CommandBuffer::insertDebugUtilsLabelEXT(const VULKAN_HPP_NAMESPACE::DebugUtilsLabelEXT &labelInfo) const VULKAN_HPP_NOEXCEPT |
| { |
| VULKAN_HPP_ASSERT(getDispatcher()->vkCmdInsertDebugUtilsLabelEXT && |
| "Function <vkCmdInsertDebugUtilsLabelEXT> needs extension <VK_EXT_debug_utils> enabled!"); |
| |
| getDispatcher()->vkCmdInsertDebugUtilsLabelEXT(static_cast<VkCommandBuffer>(m_commandBuffer), |
| reinterpret_cast<const VkDebugUtilsLabelEXT *>(&labelInfo)); |
| } |
| |
| VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE VULKAN_HPP_RAII_NAMESPACE::DebugUtilsMessengerEXT |
| Instance::createDebugUtilsMessengerEXT(VULKAN_HPP_NAMESPACE::DebugUtilsMessengerCreateInfoEXT const &createInfo, |
| VULKAN_HPP_NAMESPACE::Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator) const |
| { |
| return VULKAN_HPP_RAII_NAMESPACE::DebugUtilsMessengerEXT(*this, createInfo, allocator); |
| } |
| |
| VULKAN_HPP_INLINE void |
| Instance::submitDebugUtilsMessageEXT(VULKAN_HPP_NAMESPACE::DebugUtilsMessageSeverityFlagBitsEXT messageSeverity, |
| VULKAN_HPP_NAMESPACE::DebugUtilsMessageTypeFlagsEXT messageTypes, |
| const VULKAN_HPP_NAMESPACE::DebugUtilsMessengerCallbackDataEXT &callbackData) const VULKAN_HPP_NOEXCEPT |
| { |
| VULKAN_HPP_ASSERT(getDispatcher()->vkSubmitDebugUtilsMessageEXT && |
| "Function <vkSubmitDebugUtilsMessageEXT> needs extension <VK_EXT_debug_utils> enabled!"); |
| |
| getDispatcher()->vkSubmitDebugUtilsMessageEXT(static_cast<VkInstance>(m_instance), |
| static_cast<VkDebugUtilsMessageSeverityFlagBitsEXT>(messageSeverity), |
| static_cast<VkDebugUtilsMessageTypeFlagsEXT>(messageTypes), |
| reinterpret_cast<const VkDebugUtilsMessengerCallbackDataEXT *>(&callbackData)); |
| } |
| |
| # if defined(VK_USE_PLATFORM_ANDROID_KHR) |
| //=== VK_ANDROID_external_memory_android_hardware_buffer === |
| |
| VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE VULKAN_HPP_NAMESPACE::AndroidHardwareBufferPropertiesANDROID |
| Device::getAndroidHardwareBufferPropertiesANDROID(const struct AHardwareBuffer &buffer) const |
| { |
| VULKAN_HPP_ASSERT( |
| getDispatcher()->vkGetAndroidHardwareBufferPropertiesANDROID && |
| "Function <vkGetAndroidHardwareBufferPropertiesANDROID> needs extension <VK_ANDROID_external_memory_android_hardware_buffer> enabled!"); |
| |
| VULKAN_HPP_NAMESPACE::AndroidHardwareBufferPropertiesANDROID properties; |
| VULKAN_HPP_NAMESPACE::Result result = static_cast<VULKAN_HPP_NAMESPACE::Result>(getDispatcher()->vkGetAndroidHardwareBufferPropertiesANDROID( |
| static_cast<VkDevice>(m_device), &buffer, reinterpret_cast<VkAndroidHardwareBufferPropertiesANDROID *>(&properties))); |
| if(result != VULKAN_HPP_NAMESPACE::Result::eSuccess) |
| { |
| throwResultException(result, VULKAN_HPP_NAMESPACE_STRING "::Device::getAndroidHardwareBufferPropertiesANDROID"); |
| } |
| return properties; |
| } |
| |
| template<typename X, typename Y, typename... Z> |
| VULKAN_HPP_NODISCARD StructureChain<X, Y, Z...> Device::getAndroidHardwareBufferPropertiesANDROID(const struct AHardwareBuffer &buffer) const |
| { |
| StructureChain<X, Y, Z...> structureChain; |
| VULKAN_HPP_NAMESPACE::AndroidHardwareBufferPropertiesANDROID &properties = |
| structureChain.template get<VULKAN_HPP_NAMESPACE::AndroidHardwareBufferPropertiesANDROID>(); |
| VULKAN_HPP_NAMESPACE::Result result = static_cast<VULKAN_HPP_NAMESPACE::Result>(getDispatcher()->vkGetAndroidHardwareBufferPropertiesANDROID( |
| static_cast<VkDevice>(m_device), &buffer, reinterpret_cast<VkAndroidHardwareBufferPropertiesANDROID *>(&properties))); |
| if(result != VULKAN_HPP_NAMESPACE::Result::eSuccess) |
| { |
| throwResultException(result, VULKAN_HPP_NAMESPACE_STRING "::Device::getAndroidHardwareBufferPropertiesANDROID"); |
| } |
| return structureChain; |
| } |
| |
| VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE struct AHardwareBuffer * |
| Device::getMemoryAndroidHardwareBufferANDROID(const VULKAN_HPP_NAMESPACE::MemoryGetAndroidHardwareBufferInfoANDROID &info) const |
| { |
| VULKAN_HPP_ASSERT(getDispatcher()->vkGetMemoryAndroidHardwareBufferANDROID && |
| "Function <vkGetMemoryAndroidHardwareBufferANDROID> needs extension <VK_ANDROID_external_memory_android_hardware_buffer> enabled!"); |
| |
| struct AHardwareBuffer *buffer; |
| VULKAN_HPP_NAMESPACE::Result result = static_cast<VULKAN_HPP_NAMESPACE::Result>(getDispatcher()->vkGetMemoryAndroidHardwareBufferANDROID( |
| static_cast<VkDevice>(m_device), reinterpret_cast<const VkMemoryGetAndroidHardwareBufferInfoANDROID *>(&info), &buffer)); |
| if(result != VULKAN_HPP_NAMESPACE::Result::eSuccess) |
| { |
| throwResultException(result, VULKAN_HPP_NAMESPACE_STRING "::Device::getMemoryAndroidHardwareBufferANDROID"); |
| } |
| return buffer; |
| } |
| # endif /*VK_USE_PLATFORM_ANDROID_KHR*/ |
| |
| //=== VK_EXT_sample_locations === |
| |
| VULKAN_HPP_INLINE void |
| CommandBuffer::setSampleLocationsEXT(const VULKAN_HPP_NAMESPACE::SampleLocationsInfoEXT &sampleLocationsInfo) const VULKAN_HPP_NOEXCEPT |
| { |
| VULKAN_HPP_ASSERT(getDispatcher()->vkCmdSetSampleLocationsEXT && |
| "Function <vkCmdSetSampleLocationsEXT> needs extension <VK_EXT_sample_locations> enabled!"); |
| |
| getDispatcher()->vkCmdSetSampleLocationsEXT(static_cast<VkCommandBuffer>(m_commandBuffer), |
| reinterpret_cast<const VkSampleLocationsInfoEXT *>(&sampleLocationsInfo)); |
| } |
| |
| VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE VULKAN_HPP_NAMESPACE::MultisamplePropertiesEXT |
| PhysicalDevice::getMultisamplePropertiesEXT(VULKAN_HPP_NAMESPACE::SampleCountFlagBits samples) const VULKAN_HPP_NOEXCEPT |
| { |
| VULKAN_HPP_ASSERT(getDispatcher()->vkGetPhysicalDeviceMultisamplePropertiesEXT && |
| "Function <vkGetPhysicalDeviceMultisamplePropertiesEXT> needs extension <VK_EXT_sample_locations> enabled!"); |
| |
| VULKAN_HPP_NAMESPACE::MultisamplePropertiesEXT multisampleProperties; |
| getDispatcher()->vkGetPhysicalDeviceMultisamplePropertiesEXT(static_cast<VkPhysicalDevice>(m_physicalDevice), |
| static_cast<VkSampleCountFlagBits>(samples), |
| reinterpret_cast<VkMultisamplePropertiesEXT *>(&multisampleProperties)); |
| return multisampleProperties; |
| } |
| |
| //=== VK_KHR_get_memory_requirements2 === |
| |
| VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE VULKAN_HPP_NAMESPACE::MemoryRequirements2 |
| Device::getImageMemoryRequirements2KHR(const VULKAN_HPP_NAMESPACE::ImageMemoryRequirementsInfo2 &info) const VULKAN_HPP_NOEXCEPT |
| { |
| VULKAN_HPP_ASSERT(getDispatcher()->vkGetImageMemoryRequirements2KHR && |
| "Function <vkGetImageMemoryRequirements2KHR> needs extension <VK_KHR_get_memory_requirements2> enabled!"); |
| |
| VULKAN_HPP_NAMESPACE::MemoryRequirements2 memoryRequirements; |
| getDispatcher()->vkGetImageMemoryRequirements2KHR(static_cast<VkDevice>(m_device), |
| reinterpret_cast<const VkImageMemoryRequirementsInfo2 *>(&info), |
| reinterpret_cast<VkMemoryRequirements2 *>(&memoryRequirements)); |
| return memoryRequirements; |
| } |
| |
| template<typename X, typename Y, typename... Z> |
| VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE StructureChain<X, Y, Z...> |
| Device::getImageMemoryRequirements2KHR(const VULKAN_HPP_NAMESPACE::ImageMemoryRequirementsInfo2 &info) const VULKAN_HPP_NOEXCEPT |
| { |
| VULKAN_HPP_ASSERT(getDispatcher()->vkGetImageMemoryRequirements2KHR && |
| "Function <vkGetImageMemoryRequirements2KHR> needs extension <VK_KHR_get_memory_requirements2> enabled!"); |
| |
| StructureChain<X, Y, Z...> structureChain; |
| VULKAN_HPP_NAMESPACE::MemoryRequirements2 &memoryRequirements = structureChain.template get<VULKAN_HPP_NAMESPACE::MemoryRequirements2>(); |
| getDispatcher()->vkGetImageMemoryRequirements2KHR(static_cast<VkDevice>(m_device), |
| reinterpret_cast<const VkImageMemoryRequirementsInfo2 *>(&info), |
| reinterpret_cast<VkMemoryRequirements2 *>(&memoryRequirements)); |
| return structureChain; |
| } |
| |
| VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE VULKAN_HPP_NAMESPACE::MemoryRequirements2 |
| Device::getBufferMemoryRequirements2KHR(const VULKAN_HPP_NAMESPACE::BufferMemoryRequirementsInfo2 &info) const VULKAN_HPP_NOEXCEPT |
| { |
| VULKAN_HPP_ASSERT(getDispatcher()->vkGetBufferMemoryRequirements2KHR && |
| "Function <vkGetBufferMemoryRequirements2KHR> needs extension <VK_KHR_get_memory_requirements2> enabled!"); |
| |
| VULKAN_HPP_NAMESPACE::MemoryRequirements2 memoryRequirements; |
| getDispatcher()->vkGetBufferMemoryRequirements2KHR(static_cast<VkDevice>(m_device), |
| reinterpret_cast<const VkBufferMemoryRequirementsInfo2 *>(&info), |
| reinterpret_cast<VkMemoryRequirements2 *>(&memoryRequirements)); |
| return memoryRequirements; |
| } |
| |
| template<typename X, typename Y, typename... Z> |
| VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE StructureChain<X, Y, Z...> |
| Device::getBufferMemoryRequirements2KHR(const VULKAN_HPP_NAMESPACE::BufferMemoryRequirementsInfo2 &info) const VULKAN_HPP_NOEXCEPT |
| { |
| VULKAN_HPP_ASSERT(getDispatcher()->vkGetBufferMemoryRequirements2KHR && |
| "Function <vkGetBufferMemoryRequirements2KHR> needs extension <VK_KHR_get_memory_requirements2> enabled!"); |
| |
| StructureChain<X, Y, Z...> structureChain; |
| VULKAN_HPP_NAMESPACE::MemoryRequirements2 &memoryRequirements = structureChain.template get<VULKAN_HPP_NAMESPACE::MemoryRequirements2>(); |
| getDispatcher()->vkGetBufferMemoryRequirements2KHR(static_cast<VkDevice>(m_device), |
| reinterpret_cast<const VkBufferMemoryRequirementsInfo2 *>(&info), |
| reinterpret_cast<VkMemoryRequirements2 *>(&memoryRequirements)); |
| return structureChain; |
| } |
| |
| VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE std::vector<VULKAN_HPP_NAMESPACE::SparseImageMemoryRequirements2> |
| Device::getImageSparseMemoryRequirements2KHR(const VULKAN_HPP_NAMESPACE::ImageSparseMemoryRequirementsInfo2 &info) const VULKAN_HPP_NOEXCEPT |
| { |
| VULKAN_HPP_ASSERT(getDispatcher()->vkGetImageSparseMemoryRequirements2KHR && |
| "Function <vkGetImageSparseMemoryRequirements2KHR> needs extension <VK_KHR_get_memory_requirements2> enabled!"); |
| |
| uint32_t sparseMemoryRequirementCount; |
| getDispatcher()->vkGetImageSparseMemoryRequirements2KHR( |
| static_cast<VkDevice>(m_device), reinterpret_cast<const VkImageSparseMemoryRequirementsInfo2 *>(&info), &sparseMemoryRequirementCount, nullptr); |
| std::vector<VULKAN_HPP_NAMESPACE::SparseImageMemoryRequirements2> sparseMemoryRequirements(sparseMemoryRequirementCount); |
| getDispatcher()->vkGetImageSparseMemoryRequirements2KHR(static_cast<VkDevice>(m_device), |
| reinterpret_cast<const VkImageSparseMemoryRequirementsInfo2 *>(&info), |
| &sparseMemoryRequirementCount, |
| reinterpret_cast<VkSparseImageMemoryRequirements2 *>(sparseMemoryRequirements.data())); |
| VULKAN_HPP_ASSERT(sparseMemoryRequirementCount == sparseMemoryRequirements.size()); |
| return sparseMemoryRequirements; |
| } |
| |
| //=== VK_KHR_acceleration_structure === |
| |
| VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE VULKAN_HPP_RAII_NAMESPACE::AccelerationStructureKHR |
| Device::createAccelerationStructureKHR(VULKAN_HPP_NAMESPACE::AccelerationStructureCreateInfoKHR const &createInfo, |
| VULKAN_HPP_NAMESPACE::Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator) const |
| { |
| return VULKAN_HPP_RAII_NAMESPACE::AccelerationStructureKHR(*this, createInfo, allocator); |
| } |
| |
| VULKAN_HPP_INLINE void CommandBuffer::buildAccelerationStructuresKHR( |
| ArrayProxy<const VULKAN_HPP_NAMESPACE::AccelerationStructureBuildGeometryInfoKHR> const &infos, |
| ArrayProxy<const VULKAN_HPP_NAMESPACE::AccelerationStructureBuildRangeInfoKHR *const> const &pBuildRangeInfos) const |
| { |
| VULKAN_HPP_ASSERT(getDispatcher()->vkCmdBuildAccelerationStructuresKHR && |
| "Function <vkCmdBuildAccelerationStructuresKHR> needs extension <VK_KHR_acceleration_structure> enabled!"); |
| |
| if(infos.size() != pBuildRangeInfos.size()) |
| { |
| throw LogicError(VULKAN_HPP_NAMESPACE_STRING "::CommandBuffer::buildAccelerationStructuresKHR: infos.size() != pBuildRangeInfos.size()"); |
| } |
| getDispatcher()->vkCmdBuildAccelerationStructuresKHR( |
| static_cast<VkCommandBuffer>(m_commandBuffer), |
| infos.size(), |
| reinterpret_cast<const VkAccelerationStructureBuildGeometryInfoKHR *>(infos.data()), |
| reinterpret_cast<const VkAccelerationStructureBuildRangeInfoKHR *const *>(pBuildRangeInfos.data())); |
| } |
| |
| VULKAN_HPP_INLINE void |
| CommandBuffer::buildAccelerationStructuresIndirectKHR(ArrayProxy<const VULKAN_HPP_NAMESPACE::AccelerationStructureBuildGeometryInfoKHR> const &infos, |
| ArrayProxy<const VULKAN_HPP_NAMESPACE::DeviceAddress> const &indirectDeviceAddresses, |
| ArrayProxy<const uint32_t> const &indirectStrides, |
| ArrayProxy<const uint32_t *const> const &pMaxPrimitiveCounts) const |
| { |
| VULKAN_HPP_ASSERT(getDispatcher()->vkCmdBuildAccelerationStructuresIndirectKHR && |
| "Function <vkCmdBuildAccelerationStructuresIndirectKHR> needs extension <VK_KHR_acceleration_structure> enabled!"); |
| |
| if(infos.size() != indirectDeviceAddresses.size()) |
| { |
| throw LogicError(VULKAN_HPP_NAMESPACE_STRING |
| "::CommandBuffer::buildAccelerationStructuresIndirectKHR: infos.size() != indirectDeviceAddresses.size()"); |
| } |
| if(infos.size() != indirectStrides.size()) |
| { |
| throw LogicError(VULKAN_HPP_NAMESPACE_STRING "::CommandBuffer::buildAccelerationStructuresIndirectKHR: infos.size() != indirectStrides.size()"); |
| } |
| if(infos.size() != pMaxPrimitiveCounts.size()) |
| { |
| throw LogicError(VULKAN_HPP_NAMESPACE_STRING "::CommandBuffer::buildAccelerationStructuresIndirectKHR: infos.size() != pMaxPrimitiveCounts.size()"); |
| } |
| getDispatcher()->vkCmdBuildAccelerationStructuresIndirectKHR(static_cast<VkCommandBuffer>(m_commandBuffer), |
| infos.size(), |
| reinterpret_cast<const VkAccelerationStructureBuildGeometryInfoKHR *>(infos.data()), |
| reinterpret_cast<const VkDeviceAddress *>(indirectDeviceAddresses.data()), |
| indirectStrides.data(), |
| pMaxPrimitiveCounts.data()); |
| } |
| |
| VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE VULKAN_HPP_NAMESPACE::Result Device::buildAccelerationStructuresKHR( |
| VULKAN_HPP_NAMESPACE::DeferredOperationKHR deferredOperation, |
| ArrayProxy<const VULKAN_HPP_NAMESPACE::AccelerationStructureBuildGeometryInfoKHR> const &infos, |
| ArrayProxy<const VULKAN_HPP_NAMESPACE::AccelerationStructureBuildRangeInfoKHR *const> const &pBuildRangeInfos) const |
| { |
| VULKAN_HPP_ASSERT(getDispatcher()->vkBuildAccelerationStructuresKHR && |
| "Function <vkBuildAccelerationStructuresKHR> needs extension <VK_KHR_acceleration_structure> enabled!"); |
| |
| if(infos.size() != pBuildRangeInfos.size()) |
| { |
| throw LogicError(VULKAN_HPP_NAMESPACE_STRING "::Device::buildAccelerationStructuresKHR: infos.size() != pBuildRangeInfos.size()"); |
| } |
| |
| VULKAN_HPP_NAMESPACE::Result result = static_cast<VULKAN_HPP_NAMESPACE::Result>(getDispatcher()->vkBuildAccelerationStructuresKHR( |
| static_cast<VkDevice>(m_device), |
| static_cast<VkDeferredOperationKHR>(deferredOperation), |
| infos.size(), |
| reinterpret_cast<const VkAccelerationStructureBuildGeometryInfoKHR *>(infos.data()), |
| reinterpret_cast<const VkAccelerationStructureBuildRangeInfoKHR *const *>(pBuildRangeInfos.data()))); |
| if((result != VULKAN_HPP_NAMESPACE::Result::eSuccess) && (result != VULKAN_HPP_NAMESPACE::Result::eOperationDeferredKHR) && |
| (result != VULKAN_HPP_NAMESPACE::Result::eOperationNotDeferredKHR)) |
| { |
| throwResultException(result, VULKAN_HPP_NAMESPACE_STRING "::Device::buildAccelerationStructuresKHR"); |
| } |
| return result; |
| } |
| |
| VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE VULKAN_HPP_NAMESPACE::Result |
| Device::copyAccelerationStructureKHR(VULKAN_HPP_NAMESPACE::DeferredOperationKHR deferredOperation, |
| const VULKAN_HPP_NAMESPACE::CopyAccelerationStructureInfoKHR &info) const |
| { |
| VULKAN_HPP_ASSERT(getDispatcher()->vkCopyAccelerationStructureKHR && |
| "Function <vkCopyAccelerationStructureKHR> needs extension <VK_KHR_acceleration_structure> enabled!"); |
| |
| VULKAN_HPP_NAMESPACE::Result result = static_cast<VULKAN_HPP_NAMESPACE::Result>( |
| getDispatcher()->vkCopyAccelerationStructureKHR(static_cast<VkDevice>(m_device), |
| static_cast<VkDeferredOperationKHR>(deferredOperation), |
| reinterpret_cast<const VkCopyAccelerationStructureInfoKHR *>(&info))); |
| if((result != VULKAN_HPP_NAMESPACE::Result::eSuccess) && (result != VULKAN_HPP_NAMESPACE::Result::eOperationDeferredKHR) && |
| (result != VULKAN_HPP_NAMESPACE::Result::eOperationNotDeferredKHR)) |
| { |
| throwResultException(result, VULKAN_HPP_NAMESPACE_STRING "::Device::copyAccelerationStructureKHR"); |
| } |
| return result; |
| } |
| |
| VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE VULKAN_HPP_NAMESPACE::Result |
| Device::copyAccelerationStructureToMemoryKHR(VULKAN_HPP_NAMESPACE::DeferredOperationKHR deferredOperation, |
| const VULKAN_HPP_NAMESPACE::CopyAccelerationStructureToMemoryInfoKHR &info) const |
| { |
| VULKAN_HPP_ASSERT(getDispatcher()->vkCopyAccelerationStructureToMemoryKHR && |
| "Function <vkCopyAccelerationStructureToMemoryKHR> needs extension <VK_KHR_acceleration_structure> enabled!"); |
| |
| VULKAN_HPP_NAMESPACE::Result result = static_cast<VULKAN_HPP_NAMESPACE::Result>( |
| getDispatcher()->vkCopyAccelerationStructureToMemoryKHR(static_cast<VkDevice>(m_device), |
| static_cast<VkDeferredOperationKHR>(deferredOperation), |
| reinterpret_cast<const VkCopyAccelerationStructureToMemoryInfoKHR *>(&info))); |
| if((result != VULKAN_HPP_NAMESPACE::Result::eSuccess) && (result != VULKAN_HPP_NAMESPACE::Result::eOperationDeferredKHR) && |
| (result != VULKAN_HPP_NAMESPACE::Result::eOperationNotDeferredKHR)) |
| { |
| throwResultException(result, VULKAN_HPP_NAMESPACE_STRING "::Device::copyAccelerationStructureToMemoryKHR"); |
| } |
| return result; |
| } |
| |
| VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE VULKAN_HPP_NAMESPACE::Result |
| Device::copyMemoryToAccelerationStructureKHR(VULKAN_HPP_NAMESPACE::DeferredOperationKHR deferredOperation, |
| const VULKAN_HPP_NAMESPACE::CopyMemoryToAccelerationStructureInfoKHR &info) const |
| { |
| VULKAN_HPP_ASSERT(getDispatcher()->vkCopyMemoryToAccelerationStructureKHR && |
| "Function <vkCopyMemoryToAccelerationStructureKHR> needs extension <VK_KHR_acceleration_structure> enabled!"); |
| |
| VULKAN_HPP_NAMESPACE::Result result = static_cast<VULKAN_HPP_NAMESPACE::Result>( |
| getDispatcher()->vkCopyMemoryToAccelerationStructureKHR(static_cast<VkDevice>(m_device), |
| static_cast<VkDeferredOperationKHR>(deferredOperation), |
| reinterpret_cast<const VkCopyMemoryToAccelerationStructureInfoKHR *>(&info))); |
| if((result != VULKAN_HPP_NAMESPACE::Result::eSuccess) && (result != VULKAN_HPP_NAMESPACE::Result::eOperationDeferredKHR) && |
| (result != VULKAN_HPP_NAMESPACE::Result::eOperationNotDeferredKHR)) |
| { |
| throwResultException(result, VULKAN_HPP_NAMESPACE_STRING "::Device::copyMemoryToAccelerationStructureKHR"); |
| } |
| return result; |
| } |
| |
| template<typename DataType> |
| VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE std::vector<DataType> |
| Device::writeAccelerationStructuresPropertiesKHR(ArrayProxy<const VULKAN_HPP_NAMESPACE::AccelerationStructureKHR> const &accelerationStructures, |
| VULKAN_HPP_NAMESPACE::QueryType queryType, |
| size_t dataSize, |
| size_t stride) const |
| { |
| VULKAN_HPP_ASSERT(getDispatcher()->vkWriteAccelerationStructuresPropertiesKHR && |
| "Function <vkWriteAccelerationStructuresPropertiesKHR> needs extension <VK_KHR_acceleration_structure> enabled!"); |
| |
| VULKAN_HPP_ASSERT(dataSize % sizeof(DataType) == 0); |
| std::vector<DataType> data(dataSize / sizeof(DataType)); |
| Result result = static_cast<Result>( |
| getDispatcher()->vkWriteAccelerationStructuresPropertiesKHR(static_cast<VkDevice>(m_device), |
| accelerationStructures.size(), |
| reinterpret_cast<const VkAccelerationStructureKHR *>(accelerationStructures.data()), |
| static_cast<VkQueryType>(queryType), |
| data.size() * sizeof(DataType), |
| reinterpret_cast<void *>(data.data()), |
| stride)); |
| if(result != VULKAN_HPP_NAMESPACE::Result::eSuccess) |
| { |
| throwResultException(result, VULKAN_HPP_NAMESPACE_STRING "::Device::writeAccelerationStructuresPropertiesKHR"); |
| } |
| return data; |
| } |
| |
| template<typename DataType> |
| VULKAN_HPP_NODISCARD DataType |
| Device::writeAccelerationStructuresPropertyKHR(ArrayProxy<const VULKAN_HPP_NAMESPACE::AccelerationStructureKHR> const &accelerationStructures, |
| VULKAN_HPP_NAMESPACE::QueryType queryType, |
| size_t stride) const |
| { |
| DataType data; |
| Result result = static_cast<Result>( |
| getDispatcher()->vkWriteAccelerationStructuresPropertiesKHR(static_cast<VkDevice>(m_device), |
| accelerationStructures.size(), |
| reinterpret_cast<const VkAccelerationStructureKHR *>(accelerationStructures.data()), |
| static_cast<VkQueryType>(queryType), |
| sizeof(DataType), |
| reinterpret_cast<void *>(&data), |
| stride)); |
| if(result != VULKAN_HPP_NAMESPACE::Result::eSuccess) |
| { |
| throwResultException(result, VULKAN_HPP_NAMESPACE_STRING "::Device::writeAccelerationStructuresPropertyKHR"); |
| } |
| return data; |
| } |
| |
| VULKAN_HPP_INLINE void |
| CommandBuffer::copyAccelerationStructureKHR(const VULKAN_HPP_NAMESPACE::CopyAccelerationStructureInfoKHR &info) const VULKAN_HPP_NOEXCEPT |
| { |
| VULKAN_HPP_ASSERT(getDispatcher()->vkCmdCopyAccelerationStructureKHR && |
| "Function <vkCmdCopyAccelerationStructureKHR> needs extension <VK_KHR_acceleration_structure> enabled!"); |
| |
| getDispatcher()->vkCmdCopyAccelerationStructureKHR(static_cast<VkCommandBuffer>(m_commandBuffer), |
| reinterpret_cast<const VkCopyAccelerationStructureInfoKHR *>(&info)); |
| } |
| |
| VULKAN_HPP_INLINE void CommandBuffer::copyAccelerationStructureToMemoryKHR( |
| const VULKAN_HPP_NAMESPACE::CopyAccelerationStructureToMemoryInfoKHR &info) const VULKAN_HPP_NOEXCEPT |
| { |
| VULKAN_HPP_ASSERT(getDispatcher()->vkCmdCopyAccelerationStructureToMemoryKHR && |
| "Function <vkCmdCopyAccelerationStructureToMemoryKHR> needs extension <VK_KHR_acceleration_structure> enabled!"); |
| |
| getDispatcher()->vkCmdCopyAccelerationStructureToMemoryKHR(static_cast<VkCommandBuffer>(m_commandBuffer), |
| reinterpret_cast<const VkCopyAccelerationStructureToMemoryInfoKHR *>(&info)); |
| } |
| |
| VULKAN_HPP_INLINE void CommandBuffer::copyMemoryToAccelerationStructureKHR( |
| const VULKAN_HPP_NAMESPACE::CopyMemoryToAccelerationStructureInfoKHR &info) const VULKAN_HPP_NOEXCEPT |
| { |
| VULKAN_HPP_ASSERT(getDispatcher()->vkCmdCopyMemoryToAccelerationStructureKHR && |
| "Function <vkCmdCopyMemoryToAccelerationStructureKHR> needs extension <VK_KHR_acceleration_structure> enabled!"); |
| |
| getDispatcher()->vkCmdCopyMemoryToAccelerationStructureKHR(static_cast<VkCommandBuffer>(m_commandBuffer), |
| reinterpret_cast<const VkCopyMemoryToAccelerationStructureInfoKHR *>(&info)); |
| } |
| |
| VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE VULKAN_HPP_NAMESPACE::DeviceAddress |
| Device::getAccelerationStructureAddressKHR(const VULKAN_HPP_NAMESPACE::AccelerationStructureDeviceAddressInfoKHR &info) const VULKAN_HPP_NOEXCEPT |
| { |
| VULKAN_HPP_ASSERT(getDispatcher()->vkGetAccelerationStructureDeviceAddressKHR && |
| "Function <vkGetAccelerationStructureDeviceAddressKHR> needs extension <VK_KHR_acceleration_structure> enabled!"); |
| |
| return static_cast<VULKAN_HPP_NAMESPACE::DeviceAddress>(getDispatcher()->vkGetAccelerationStructureDeviceAddressKHR( |
| static_cast<VkDevice>(m_device), reinterpret_cast<const VkAccelerationStructureDeviceAddressInfoKHR *>(&info))); |
| } |
| |
| VULKAN_HPP_INLINE void |
| CommandBuffer::writeAccelerationStructuresPropertiesKHR(ArrayProxy<const VULKAN_HPP_NAMESPACE::AccelerationStructureKHR> const &accelerationStructures, |
| VULKAN_HPP_NAMESPACE::QueryType queryType, |
| VULKAN_HPP_NAMESPACE::QueryPool queryPool, |
| uint32_t firstQuery) const VULKAN_HPP_NOEXCEPT |
| { |
| VULKAN_HPP_ASSERT(getDispatcher()->vkCmdWriteAccelerationStructuresPropertiesKHR && |
| "Function <vkCmdWriteAccelerationStructuresPropertiesKHR> needs extension <VK_KHR_acceleration_structure> enabled!"); |
| |
| getDispatcher()->vkCmdWriteAccelerationStructuresPropertiesKHR(static_cast<VkCommandBuffer>(m_commandBuffer), |
| accelerationStructures.size(), |
| reinterpret_cast<const VkAccelerationStructureKHR *>(accelerationStructures.data()), |
| static_cast<VkQueryType>(queryType), |
| static_cast<VkQueryPool>(queryPool), |
| firstQuery); |
| } |
| |
| VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE VULKAN_HPP_NAMESPACE::AccelerationStructureCompatibilityKHR Device::getAccelerationStructureCompatibilityKHR( |
| const VULKAN_HPP_NAMESPACE::AccelerationStructureVersionInfoKHR &versionInfo) const VULKAN_HPP_NOEXCEPT |
| { |
| VULKAN_HPP_ASSERT(getDispatcher()->vkGetDeviceAccelerationStructureCompatibilityKHR && |
| "Function <vkGetDeviceAccelerationStructureCompatibilityKHR> needs extension <VK_KHR_acceleration_structure> enabled!"); |
| |
| VULKAN_HPP_NAMESPACE::AccelerationStructureCompatibilityKHR compatibility; |
| getDispatcher()->vkGetDeviceAccelerationStructureCompatibilityKHR(static_cast<VkDevice>(m_device), |
| reinterpret_cast<const VkAccelerationStructureVersionInfoKHR *>(&versionInfo), |
| reinterpret_cast<VkAccelerationStructureCompatibilityKHR *>(&compatibility)); |
| return compatibility; |
| } |
| |
| VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE VULKAN_HPP_NAMESPACE::AccelerationStructureBuildSizesInfoKHR |
| Device::getAccelerationStructureBuildSizesKHR(VULKAN_HPP_NAMESPACE::AccelerationStructureBuildTypeKHR buildType, |
| const VULKAN_HPP_NAMESPACE::AccelerationStructureBuildGeometryInfoKHR &buildInfo, |
| ArrayProxy<const uint32_t> const &maxPrimitiveCounts) const |
| { |
| VULKAN_HPP_ASSERT(getDispatcher()->vkGetAccelerationStructureBuildSizesKHR && |
| "Function <vkGetAccelerationStructureBuildSizesKHR> needs extension <VK_KHR_acceleration_structure> enabled!"); |
| |
| if(maxPrimitiveCounts.size() != buildInfo.geometryCount) |
| { |
| throw LogicError(VULKAN_HPP_NAMESPACE_STRING "::Device::getAccelerationStructureBuildSizesKHR: maxPrimitiveCounts.size() != buildInfo.geometryCount"); |
| } |
| VULKAN_HPP_NAMESPACE::AccelerationStructureBuildSizesInfoKHR sizeInfo; |
| getDispatcher()->vkGetAccelerationStructureBuildSizesKHR(static_cast<VkDevice>(m_device), |
| static_cast<VkAccelerationStructureBuildTypeKHR>(buildType), |
| reinterpret_cast<const VkAccelerationStructureBuildGeometryInfoKHR *>(&buildInfo), |
| maxPrimitiveCounts.data(), |
| reinterpret_cast<VkAccelerationStructureBuildSizesInfoKHR *>(&sizeInfo)); |
| return sizeInfo; |
| } |
| |
| //=== VK_KHR_sampler_ycbcr_conversion === |
| |
| VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE VULKAN_HPP_RAII_NAMESPACE::SamplerYcbcrConversion |
| Device::createSamplerYcbcrConversionKHR(VULKAN_HPP_NAMESPACE::SamplerYcbcrConversionCreateInfo const &createInfo, |
| VULKAN_HPP_NAMESPACE::Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator) const |
| { |
| return VULKAN_HPP_RAII_NAMESPACE::SamplerYcbcrConversion(*this, createInfo, allocator); |
| } |
| |
| VULKAN_HPP_INLINE void |
| Device::destroySamplerYcbcrConversionKHR(VULKAN_HPP_NAMESPACE::SamplerYcbcrConversion ycbcrConversion, |
| Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator) const VULKAN_HPP_NOEXCEPT |
| { |
| VULKAN_HPP_ASSERT(getDispatcher()->vkDestroySamplerYcbcrConversionKHR && |
| "Function <vkDestroySamplerYcbcrConversionKHR> needs extension <VK_KHR_sampler_ycbcr_conversion> enabled!"); |
| |
| getDispatcher()->vkDestroySamplerYcbcrConversionKHR( |
| static_cast<VkDevice>(m_device), |
| static_cast<VkSamplerYcbcrConversion>(ycbcrConversion), |
| reinterpret_cast<const VkAllocationCallbacks *>(static_cast<const VULKAN_HPP_NAMESPACE::AllocationCallbacks *>(allocator))); |
| } |
| |
| //=== VK_KHR_bind_memory2 === |
| |
| VULKAN_HPP_INLINE void Device::bindBufferMemory2KHR(ArrayProxy<const VULKAN_HPP_NAMESPACE::BindBufferMemoryInfo> const &bindInfos) const |
| { |
| VULKAN_HPP_ASSERT(getDispatcher()->vkBindBufferMemory2KHR && "Function <vkBindBufferMemory2KHR> needs extension <VK_KHR_bind_memory2> enabled!"); |
| |
| VULKAN_HPP_NAMESPACE::Result result = static_cast<VULKAN_HPP_NAMESPACE::Result>(getDispatcher()->vkBindBufferMemory2KHR( |
| static_cast<VkDevice>(m_device), bindInfos.size(), reinterpret_cast<const VkBindBufferMemoryInfo *>(bindInfos.data()))); |
| if(result != VULKAN_HPP_NAMESPACE::Result::eSuccess) |
| { |
| throwResultException(result, VULKAN_HPP_NAMESPACE_STRING "::Device::bindBufferMemory2KHR"); |
| } |
| } |
| |
| VULKAN_HPP_INLINE void Device::bindImageMemory2KHR(ArrayProxy<const VULKAN_HPP_NAMESPACE::BindImageMemoryInfo> const &bindInfos) const |
| { |
| VULKAN_HPP_ASSERT(getDispatcher()->vkBindImageMemory2KHR && "Function <vkBindImageMemory2KHR> needs extension <VK_KHR_bind_memory2> enabled!"); |
| |
| VULKAN_HPP_NAMESPACE::Result result = static_cast<VULKAN_HPP_NAMESPACE::Result>(getDispatcher()->vkBindImageMemory2KHR( |
| static_cast<VkDevice>(m_device), bindInfos.size(), reinterpret_cast<const VkBindImageMemoryInfo *>(bindInfos.data()))); |
| if(result != VULKAN_HPP_NAMESPACE::Result::eSuccess) |
| { |
| throwResultException(result, VULKAN_HPP_NAMESPACE_STRING "::Device::bindImageMemory2KHR"); |
| } |
| } |
| |
| //=== VK_EXT_image_drm_format_modifier === |
| |
| VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE VULKAN_HPP_NAMESPACE::ImageDrmFormatModifierPropertiesEXT Image::getDrmFormatModifierPropertiesEXT() const |
| { |
| VULKAN_HPP_ASSERT(getDispatcher()->vkGetImageDrmFormatModifierPropertiesEXT && |
| "Function <vkGetImageDrmFormatModifierPropertiesEXT> needs extension <VK_EXT_image_drm_format_modifier> enabled!"); |
| |
| VULKAN_HPP_NAMESPACE::ImageDrmFormatModifierPropertiesEXT properties; |
| VULKAN_HPP_NAMESPACE::Result result = static_cast<VULKAN_HPP_NAMESPACE::Result>(getDispatcher()->vkGetImageDrmFormatModifierPropertiesEXT( |
| static_cast<VkDevice>(m_device), static_cast<VkImage>(m_image), reinterpret_cast<VkImageDrmFormatModifierPropertiesEXT *>(&properties))); |
| if(result != VULKAN_HPP_NAMESPACE::Result::eSuccess) |
| { |
| throwResultException(result, VULKAN_HPP_NAMESPACE_STRING "::Image::getDrmFormatModifierPropertiesEXT"); |
| } |
| return properties; |
| } |
| |
| //=== VK_EXT_validation_cache === |
| |
| VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE VULKAN_HPP_RAII_NAMESPACE::ValidationCacheEXT |
| Device::createValidationCacheEXT(VULKAN_HPP_NAMESPACE::ValidationCacheCreateInfoEXT const &createInfo, |
| VULKAN_HPP_NAMESPACE::Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator) const |
| { |
| return VULKAN_HPP_RAII_NAMESPACE::ValidationCacheEXT(*this, createInfo, allocator); |
| } |
| |
| VULKAN_HPP_INLINE void ValidationCacheEXT::merge(ArrayProxy<const VULKAN_HPP_NAMESPACE::ValidationCacheEXT> const &srcCaches) const |
| { |
| VULKAN_HPP_ASSERT(getDispatcher()->vkMergeValidationCachesEXT && |
| "Function <vkMergeValidationCachesEXT> needs extension <VK_EXT_validation_cache> enabled!"); |
| |
| VULKAN_HPP_NAMESPACE::Result result = static_cast<VULKAN_HPP_NAMESPACE::Result>( |
| getDispatcher()->vkMergeValidationCachesEXT(static_cast<VkDevice>(m_device), |
| static_cast<VkValidationCacheEXT>(m_validationCache), |
| srcCaches.size(), |
| reinterpret_cast<const VkValidationCacheEXT *>(srcCaches.data()))); |
| if(result != VULKAN_HPP_NAMESPACE::Result::eSuccess) |
| { |
| throwResultException(result, VULKAN_HPP_NAMESPACE_STRING "::ValidationCacheEXT::merge"); |
| } |
| } |
| |
| VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE std::vector<uint8_t> ValidationCacheEXT::getData() const |
| { |
| VULKAN_HPP_ASSERT(getDispatcher()->vkGetValidationCacheDataEXT && |
| "Function <vkGetValidationCacheDataEXT> needs extension <VK_EXT_validation_cache> enabled!"); |
| |
| std::vector<uint8_t> data; |
| size_t dataSize; |
| VULKAN_HPP_NAMESPACE::Result result; |
| do |
| { |
| result = static_cast<VULKAN_HPP_NAMESPACE::Result>(getDispatcher()->vkGetValidationCacheDataEXT( |
| static_cast<VkDevice>(m_device), static_cast<VkValidationCacheEXT>(m_validationCache), &dataSize, nullptr)); |
| if((result == VULKAN_HPP_NAMESPACE::Result::eSuccess) && dataSize) |
| { |
| data.resize(dataSize); |
| result = static_cast<VULKAN_HPP_NAMESPACE::Result>(getDispatcher()->vkGetValidationCacheDataEXT( |
| static_cast<VkDevice>(m_device), static_cast<VkValidationCacheEXT>(m_validationCache), &dataSize, reinterpret_cast<void *>(data.data()))); |
| } |
| } while(result == VULKAN_HPP_NAMESPACE::Result::eIncomplete); |
| if(result != VULKAN_HPP_NAMESPACE::Result::eSuccess) |
| { |
| throwResultException(result, VULKAN_HPP_NAMESPACE_STRING "::ValidationCacheEXT::getData"); |
| } |
| if(result == VULKAN_HPP_NAMESPACE::Result::eSuccess) |
| { |
| VULKAN_HPP_ASSERT(dataSize <= data.size()); |
| if(dataSize < data.size()) |
| { |
| data.resize(dataSize); |
| } |
| } |
| return data; |
| } |
| |
| //=== VK_NV_shading_rate_image === |
| |
| VULKAN_HPP_INLINE void CommandBuffer::bindShadingRateImageNV(VULKAN_HPP_NAMESPACE::ImageView imageView, |
| VULKAN_HPP_NAMESPACE::ImageLayout imageLayout) const VULKAN_HPP_NOEXCEPT |
| { |
| VULKAN_HPP_ASSERT(getDispatcher()->vkCmdBindShadingRateImageNV && |
| "Function <vkCmdBindShadingRateImageNV> needs extension <VK_NV_shading_rate_image> enabled!"); |
| |
| getDispatcher()->vkCmdBindShadingRateImageNV( |
| static_cast<VkCommandBuffer>(m_commandBuffer), static_cast<VkImageView>(imageView), static_cast<VkImageLayout>(imageLayout)); |
| } |
| |
| VULKAN_HPP_INLINE void CommandBuffer::setViewportShadingRatePaletteNV( |
| uint32_t firstViewport, ArrayProxy<const VULKAN_HPP_NAMESPACE::ShadingRatePaletteNV> const &shadingRatePalettes) const VULKAN_HPP_NOEXCEPT |
| { |
| VULKAN_HPP_ASSERT(getDispatcher()->vkCmdSetViewportShadingRatePaletteNV && |
| "Function <vkCmdSetViewportShadingRatePaletteNV> needs extension <VK_NV_shading_rate_image> enabled!"); |
| |
| getDispatcher()->vkCmdSetViewportShadingRatePaletteNV(static_cast<VkCommandBuffer>(m_commandBuffer), |
| firstViewport, |
| shadingRatePalettes.size(), |
| reinterpret_cast<const VkShadingRatePaletteNV *>(shadingRatePalettes.data())); |
| } |
| |
| VULKAN_HPP_INLINE void CommandBuffer::setCoarseSampleOrderNV( |
| VULKAN_HPP_NAMESPACE::CoarseSampleOrderTypeNV sampleOrderType, |
| ArrayProxy<const VULKAN_HPP_NAMESPACE::CoarseSampleOrderCustomNV> const &customSampleOrders) const VULKAN_HPP_NOEXCEPT |
| { |
| VULKAN_HPP_ASSERT(getDispatcher()->vkCmdSetCoarseSampleOrderNV && |
| "Function <vkCmdSetCoarseSampleOrderNV> needs extension <VK_NV_shading_rate_image> enabled!"); |
| |
| getDispatcher()->vkCmdSetCoarseSampleOrderNV(static_cast<VkCommandBuffer>(m_commandBuffer), |
| static_cast<VkCoarseSampleOrderTypeNV>(sampleOrderType), |
| customSampleOrders.size(), |
| reinterpret_cast<const VkCoarseSampleOrderCustomNV *>(customSampleOrders.data())); |
| } |
| |
| //=== VK_NV_ray_tracing === |
| |
| VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE VULKAN_HPP_RAII_NAMESPACE::AccelerationStructureNV |
| Device::createAccelerationStructureNV(VULKAN_HPP_NAMESPACE::AccelerationStructureCreateInfoNV const &createInfo, |
| VULKAN_HPP_NAMESPACE::Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator) const |
| { |
| return VULKAN_HPP_RAII_NAMESPACE::AccelerationStructureNV(*this, createInfo, allocator); |
| } |
| |
| VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE VULKAN_HPP_NAMESPACE::MemoryRequirements2KHR Device::getAccelerationStructureMemoryRequirementsNV( |
| const VULKAN_HPP_NAMESPACE::AccelerationStructureMemoryRequirementsInfoNV &info) const VULKAN_HPP_NOEXCEPT |
| { |
| VULKAN_HPP_ASSERT(getDispatcher()->vkGetAccelerationStructureMemoryRequirementsNV && |
| "Function <vkGetAccelerationStructureMemoryRequirementsNV> needs extension <VK_NV_ray_tracing> enabled!"); |
| |
| VULKAN_HPP_NAMESPACE::MemoryRequirements2KHR memoryRequirements; |
| getDispatcher()->vkGetAccelerationStructureMemoryRequirementsNV(static_cast<VkDevice>(m_device), |
| reinterpret_cast<const VkAccelerationStructureMemoryRequirementsInfoNV *>(&info), |
| reinterpret_cast<VkMemoryRequirements2KHR *>(&memoryRequirements)); |
| return memoryRequirements; |
| } |
| |
| template<typename X, typename Y, typename... Z> |
| VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE StructureChain<X, Y, Z...> Device::getAccelerationStructureMemoryRequirementsNV( |
| const VULKAN_HPP_NAMESPACE::AccelerationStructureMemoryRequirementsInfoNV &info) const VULKAN_HPP_NOEXCEPT |
| { |
| VULKAN_HPP_ASSERT(getDispatcher()->vkGetAccelerationStructureMemoryRequirementsNV && |
| "Function <vkGetAccelerationStructureMemoryRequirementsNV> needs extension <VK_NV_ray_tracing> enabled!"); |
| |
| StructureChain<X, Y, Z...> structureChain; |
| VULKAN_HPP_NAMESPACE::MemoryRequirements2KHR &memoryRequirements = structureChain.template get<VULKAN_HPP_NAMESPACE::MemoryRequirements2KHR>(); |
| getDispatcher()->vkGetAccelerationStructureMemoryRequirementsNV(static_cast<VkDevice>(m_device), |
| reinterpret_cast<const VkAccelerationStructureMemoryRequirementsInfoNV *>(&info), |
| reinterpret_cast<VkMemoryRequirements2KHR *>(&memoryRequirements)); |
| return structureChain; |
| } |
| |
| VULKAN_HPP_INLINE void |
| Device::bindAccelerationStructureMemoryNV(ArrayProxy<const VULKAN_HPP_NAMESPACE::BindAccelerationStructureMemoryInfoNV> const &bindInfos) const |
| { |
| VULKAN_HPP_ASSERT(getDispatcher()->vkBindAccelerationStructureMemoryNV && |
| "Function <vkBindAccelerationStructureMemoryNV> needs extension <VK_NV_ray_tracing> enabled!"); |
| |
| VULKAN_HPP_NAMESPACE::Result result = static_cast<VULKAN_HPP_NAMESPACE::Result>(getDispatcher()->vkBindAccelerationStructureMemoryNV( |
| static_cast<VkDevice>(m_device), bindInfos.size(), reinterpret_cast<const VkBindAccelerationStructureMemoryInfoNV *>(bindInfos.data()))); |
| if(result != VULKAN_HPP_NAMESPACE::Result::eSuccess) |
| { |
| throwResultException(result, VULKAN_HPP_NAMESPACE_STRING "::Device::bindAccelerationStructureMemoryNV"); |
| } |
| } |
| |
| VULKAN_HPP_INLINE void CommandBuffer::buildAccelerationStructureNV(const VULKAN_HPP_NAMESPACE::AccelerationStructureInfoNV &info, |
| VULKAN_HPP_NAMESPACE::Buffer instanceData, |
| VULKAN_HPP_NAMESPACE::DeviceSize instanceOffset, |
| VULKAN_HPP_NAMESPACE::Bool32 update, |
| VULKAN_HPP_NAMESPACE::AccelerationStructureNV dst, |
| VULKAN_HPP_NAMESPACE::AccelerationStructureNV src, |
| VULKAN_HPP_NAMESPACE::Buffer scratch, |
| VULKAN_HPP_NAMESPACE::DeviceSize scratchOffset) const VULKAN_HPP_NOEXCEPT |
| { |
| VULKAN_HPP_ASSERT(getDispatcher()->vkCmdBuildAccelerationStructureNV && |
| "Function <vkCmdBuildAccelerationStructureNV> needs extension <VK_NV_ray_tracing> enabled!"); |
| |
| getDispatcher()->vkCmdBuildAccelerationStructureNV(static_cast<VkCommandBuffer>(m_commandBuffer), |
| reinterpret_cast<const VkAccelerationStructureInfoNV *>(&info), |
| static_cast<VkBuffer>(instanceData), |
| static_cast<VkDeviceSize>(instanceOffset), |
| static_cast<VkBool32>(update), |
| static_cast<VkAccelerationStructureNV>(dst), |
| static_cast<VkAccelerationStructureNV>(src), |
| static_cast<VkBuffer>(scratch), |
| static_cast<VkDeviceSize>(scratchOffset)); |
| } |
| |
| VULKAN_HPP_INLINE void CommandBuffer::copyAccelerationStructureNV(VULKAN_HPP_NAMESPACE::AccelerationStructureNV dst, |
| VULKAN_HPP_NAMESPACE::AccelerationStructureNV src, |
| VULKAN_HPP_NAMESPACE::CopyAccelerationStructureModeKHR mode) const VULKAN_HPP_NOEXCEPT |
| { |
| VULKAN_HPP_ASSERT(getDispatcher()->vkCmdCopyAccelerationStructureNV && |
| "Function <vkCmdCopyAccelerationStructureNV> needs extension <VK_NV_ray_tracing> enabled!"); |
| |
| getDispatcher()->vkCmdCopyAccelerationStructureNV(static_cast<VkCommandBuffer>(m_commandBuffer), |
| static_cast<VkAccelerationStructureNV>(dst), |
| static_cast<VkAccelerationStructureNV>(src), |
| static_cast<VkCopyAccelerationStructureModeKHR>(mode)); |
| } |
| |
| VULKAN_HPP_INLINE void CommandBuffer::traceRaysNV(VULKAN_HPP_NAMESPACE::Buffer raygenShaderBindingTableBuffer, |
| VULKAN_HPP_NAMESPACE::DeviceSize raygenShaderBindingOffset, |
| VULKAN_HPP_NAMESPACE::Buffer missShaderBindingTableBuffer, |
| VULKAN_HPP_NAMESPACE::DeviceSize missShaderBindingOffset, |
| VULKAN_HPP_NAMESPACE::DeviceSize missShaderBindingStride, |
| VULKAN_HPP_NAMESPACE::Buffer hitShaderBindingTableBuffer, |
| VULKAN_HPP_NAMESPACE::DeviceSize hitShaderBindingOffset, |
| VULKAN_HPP_NAMESPACE::DeviceSize hitShaderBindingStride, |
| VULKAN_HPP_NAMESPACE::Buffer callableShaderBindingTableBuffer, |
| VULKAN_HPP_NAMESPACE::DeviceSize callableShaderBindingOffset, |
| VULKAN_HPP_NAMESPACE::DeviceSize callableShaderBindingStride, |
| uint32_t width, |
| uint32_t height, |
| uint32_t depth) const VULKAN_HPP_NOEXCEPT |
| { |
| VULKAN_HPP_ASSERT(getDispatcher()->vkCmdTraceRaysNV && "Function <vkCmdTraceRaysNV> needs extension <VK_NV_ray_tracing> enabled!"); |
| |
| getDispatcher()->vkCmdTraceRaysNV(static_cast<VkCommandBuffer>(m_commandBuffer), |
| static_cast<VkBuffer>(raygenShaderBindingTableBuffer), |
| static_cast<VkDeviceSize>(raygenShaderBindingOffset), |
| static_cast<VkBuffer>(missShaderBindingTableBuffer), |
| static_cast<VkDeviceSize>(missShaderBindingOffset), |
| static_cast<VkDeviceSize>(missShaderBindingStride), |
| static_cast<VkBuffer>(hitShaderBindingTableBuffer), |
| static_cast<VkDeviceSize>(hitShaderBindingOffset), |
| static_cast<VkDeviceSize>(hitShaderBindingStride), |
| static_cast<VkBuffer>(callableShaderBindingTableBuffer), |
| static_cast<VkDeviceSize>(callableShaderBindingOffset), |
| static_cast<VkDeviceSize>(callableShaderBindingStride), |
| width, |
| height, |
| depth); |
| } |
| |
| VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE std::vector<VULKAN_HPP_RAII_NAMESPACE::Pipeline> Device::createRayTracingPipelinesNV( |
| VULKAN_HPP_NAMESPACE::Optional<const VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::PipelineCache> const &pipelineCache, |
| VULKAN_HPP_NAMESPACE::ArrayProxy<VULKAN_HPP_NAMESPACE::RayTracingPipelineCreateInfoNV> const &createInfos, |
| VULKAN_HPP_NAMESPACE::Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator) const |
| { |
| return VULKAN_HPP_RAII_NAMESPACE::Pipelines(*this, pipelineCache, createInfos, allocator); |
| } |
| |
| VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE VULKAN_HPP_RAII_NAMESPACE::Pipeline Device::createRayTracingPipelineNV( |
| VULKAN_HPP_NAMESPACE::Optional<const VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::PipelineCache> const &pipelineCache, |
| VULKAN_HPP_NAMESPACE::RayTracingPipelineCreateInfoNV const &createInfo, |
| VULKAN_HPP_NAMESPACE::Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator) const |
| { |
| return VULKAN_HPP_RAII_NAMESPACE::Pipeline(*this, pipelineCache, createInfo, allocator); |
| } |
| |
| template<typename DataType> |
| VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE std::vector<DataType> |
| Pipeline::getRayTracingShaderGroupHandlesNV(uint32_t firstGroup, uint32_t groupCount, size_t dataSize) const |
| { |
| VULKAN_HPP_ASSERT(getDispatcher()->vkGetRayTracingShaderGroupHandlesNV && |
| "Function <vkGetRayTracingShaderGroupHandlesNV> needs extension <VK_NV_ray_tracing> enabled!"); |
| |
| VULKAN_HPP_ASSERT(dataSize % sizeof(DataType) == 0); |
| std::vector<DataType> data(dataSize / sizeof(DataType)); |
| Result result = static_cast<Result>(getDispatcher()->vkGetRayTracingShaderGroupHandlesNV(static_cast<VkDevice>(m_device), |
| static_cast<VkPipeline>(m_pipeline), |
| firstGroup, |
| groupCount, |
| data.size() * sizeof(DataType), |
| reinterpret_cast<void *>(data.data()))); |
| if(result != VULKAN_HPP_NAMESPACE::Result::eSuccess) |
| { |
| throwResultException(result, VULKAN_HPP_NAMESPACE_STRING "::Pipeline::getRayTracingShaderGroupHandlesNV"); |
| } |
| return data; |
| } |
| |
| template<typename DataType> |
| VULKAN_HPP_NODISCARD DataType Pipeline::getRayTracingShaderGroupHandleNV(uint32_t firstGroup, uint32_t groupCount) const |
| { |
| DataType data; |
| Result result = static_cast<Result>(getDispatcher()->vkGetRayTracingShaderGroupHandlesNV(static_cast<VkDevice>(m_device), |
| static_cast<VkPipeline>(m_pipeline), |
| firstGroup, |
| groupCount, |
| sizeof(DataType), |
| reinterpret_cast<void *>(&data))); |
| if(result != VULKAN_HPP_NAMESPACE::Result::eSuccess) |
| { |
| throwResultException(result, VULKAN_HPP_NAMESPACE_STRING "::Pipeline::getRayTracingShaderGroupHandleNV"); |
| } |
| return data; |
| } |
| |
| template<typename DataType> |
| VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE std::vector<DataType> AccelerationStructureNV::getHandle(size_t dataSize) const |
| { |
| VULKAN_HPP_ASSERT(getDispatcher()->vkGetAccelerationStructureHandleNV && |
| "Function <vkGetAccelerationStructureHandleNV> needs extension <VK_NV_ray_tracing> enabled!"); |
| |
| VULKAN_HPP_ASSERT(dataSize % sizeof(DataType) == 0); |
| std::vector<DataType> data(dataSize / sizeof(DataType)); |
| Result result = |
| static_cast<Result>(getDispatcher()->vkGetAccelerationStructureHandleNV(static_cast<VkDevice>(m_device), |
| static_cast<VkAccelerationStructureNV>(m_accelerationStructure), |
| data.size() * sizeof(DataType), |
| reinterpret_cast<void *>(data.data()))); |
| if(result != VULKAN_HPP_NAMESPACE::Result::eSuccess) |
| { |
| throwResultException(result, VULKAN_HPP_NAMESPACE_STRING "::AccelerationStructureNV::getHandle"); |
| } |
| return data; |
| } |
| |
| template<typename DataType> |
| VULKAN_HPP_NODISCARD DataType AccelerationStructureNV::getHandle() const |
| { |
| DataType data; |
| Result result = |
| static_cast<Result>(getDispatcher()->vkGetAccelerationStructureHandleNV(static_cast<VkDevice>(m_device), |
| static_cast<VkAccelerationStructureNV>(m_accelerationStructure), |
| sizeof(DataType), |
| reinterpret_cast<void *>(&data))); |
| if(result != VULKAN_HPP_NAMESPACE::Result::eSuccess) |
| { |
| throwResultException(result, VULKAN_HPP_NAMESPACE_STRING "::AccelerationStructureNV::getHandle"); |
| } |
| return data; |
| } |
| |
| VULKAN_HPP_INLINE void |
| CommandBuffer::writeAccelerationStructuresPropertiesNV(ArrayProxy<const VULKAN_HPP_NAMESPACE::AccelerationStructureNV> const &accelerationStructures, |
| VULKAN_HPP_NAMESPACE::QueryType queryType, |
| VULKAN_HPP_NAMESPACE::QueryPool queryPool, |
| uint32_t firstQuery) const VULKAN_HPP_NOEXCEPT |
| { |
| VULKAN_HPP_ASSERT(getDispatcher()->vkCmdWriteAccelerationStructuresPropertiesNV && |
| "Function <vkCmdWriteAccelerationStructuresPropertiesNV> needs extension <VK_NV_ray_tracing> enabled!"); |
| |
| getDispatcher()->vkCmdWriteAccelerationStructuresPropertiesNV(static_cast<VkCommandBuffer>(m_commandBuffer), |
| accelerationStructures.size(), |
| reinterpret_cast<const VkAccelerationStructureNV *>(accelerationStructures.data()), |
| static_cast<VkQueryType>(queryType), |
| static_cast<VkQueryPool>(queryPool), |
| firstQuery); |
| } |
| |
| VULKAN_HPP_INLINE void Pipeline::compileDeferredNV(uint32_t shader) const |
| { |
| VULKAN_HPP_ASSERT(getDispatcher()->vkCompileDeferredNV && "Function <vkCompileDeferredNV> needs extension <VK_NV_ray_tracing> enabled!"); |
| |
| VULKAN_HPP_NAMESPACE::Result result = static_cast<VULKAN_HPP_NAMESPACE::Result>( |
| getDispatcher()->vkCompileDeferredNV(static_cast<VkDevice>(m_device), static_cast<VkPipeline>(m_pipeline), shader)); |
| if(result != VULKAN_HPP_NAMESPACE::Result::eSuccess) |
| { |
| throwResultException(result, VULKAN_HPP_NAMESPACE_STRING "::Pipeline::compileDeferredNV"); |
| } |
| } |
| |
| //=== VK_KHR_maintenance3 === |
| |
| VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE VULKAN_HPP_NAMESPACE::DescriptorSetLayoutSupport |
| Device::getDescriptorSetLayoutSupportKHR(const VULKAN_HPP_NAMESPACE::DescriptorSetLayoutCreateInfo &createInfo) const VULKAN_HPP_NOEXCEPT |
| { |
| VULKAN_HPP_ASSERT(getDispatcher()->vkGetDescriptorSetLayoutSupportKHR && |
| "Function <vkGetDescriptorSetLayoutSupportKHR> needs extension <VK_KHR_maintenance3> enabled!"); |
| |
| VULKAN_HPP_NAMESPACE::DescriptorSetLayoutSupport support; |
| getDispatcher()->vkGetDescriptorSetLayoutSupportKHR(static_cast<VkDevice>(m_device), |
| reinterpret_cast<const VkDescriptorSetLayoutCreateInfo *>(&createInfo), |
| reinterpret_cast<VkDescriptorSetLayoutSupport *>(&support)); |
| return support; |
| } |
| |
| template<typename X, typename Y, typename... Z> |
| VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE StructureChain<X, Y, Z...> |
| Device::getDescriptorSetLayoutSupportKHR(const VULKAN_HPP_NAMESPACE::DescriptorSetLayoutCreateInfo &createInfo) const VULKAN_HPP_NOEXCEPT |
| { |
| VULKAN_HPP_ASSERT(getDispatcher()->vkGetDescriptorSetLayoutSupportKHR && |
| "Function <vkGetDescriptorSetLayoutSupportKHR> needs extension <VK_KHR_maintenance3> enabled!"); |
| |
| StructureChain<X, Y, Z...> structureChain; |
| VULKAN_HPP_NAMESPACE::DescriptorSetLayoutSupport &support = structureChain.template get<VULKAN_HPP_NAMESPACE::DescriptorSetLayoutSupport>(); |
| getDispatcher()->vkGetDescriptorSetLayoutSupportKHR(static_cast<VkDevice>(m_device), |
| reinterpret_cast<const VkDescriptorSetLayoutCreateInfo *>(&createInfo), |
| reinterpret_cast<VkDescriptorSetLayoutSupport *>(&support)); |
| return structureChain; |
| } |
| |
| //=== VK_KHR_draw_indirect_count === |
| |
| VULKAN_HPP_INLINE void CommandBuffer::drawIndirectCountKHR(VULKAN_HPP_NAMESPACE::Buffer buffer, |
| VULKAN_HPP_NAMESPACE::DeviceSize offset, |
| VULKAN_HPP_NAMESPACE::Buffer countBuffer, |
| VULKAN_HPP_NAMESPACE::DeviceSize countBufferOffset, |
| uint32_t maxDrawCount, |
| uint32_t stride) const VULKAN_HPP_NOEXCEPT |
| { |
| VULKAN_HPP_ASSERT(getDispatcher()->vkCmdDrawIndirectCountKHR && |
| "Function <vkCmdDrawIndirectCountKHR> needs extension <VK_KHR_draw_indirect_count> enabled!"); |
| |
| getDispatcher()->vkCmdDrawIndirectCountKHR(static_cast<VkCommandBuffer>(m_commandBuffer), |
| static_cast<VkBuffer>(buffer), |
| static_cast<VkDeviceSize>(offset), |
| static_cast<VkBuffer>(countBuffer), |
| static_cast<VkDeviceSize>(countBufferOffset), |
| maxDrawCount, |
| stride); |
| } |
| |
| VULKAN_HPP_INLINE void CommandBuffer::drawIndexedIndirectCountKHR(VULKAN_HPP_NAMESPACE::Buffer buffer, |
| VULKAN_HPP_NAMESPACE::DeviceSize offset, |
| VULKAN_HPP_NAMESPACE::Buffer countBuffer, |
| VULKAN_HPP_NAMESPACE::DeviceSize countBufferOffset, |
| uint32_t maxDrawCount, |
| uint32_t stride) const VULKAN_HPP_NOEXCEPT |
| { |
| VULKAN_HPP_ASSERT(getDispatcher()->vkCmdDrawIndexedIndirectCountKHR && |
| "Function <vkCmdDrawIndexedIndirectCountKHR> needs extension <VK_KHR_draw_indirect_count> enabled!"); |
| |
| getDispatcher()->vkCmdDrawIndexedIndirectCountKHR(static_cast<VkCommandBuffer>(m_commandBuffer), |
| static_cast<VkBuffer>(buffer), |
| static_cast<VkDeviceSize>(offset), |
| static_cast<VkBuffer>(countBuffer), |
| static_cast<VkDeviceSize>(countBufferOffset), |
| maxDrawCount, |
| stride); |
| } |
| |
| //=== VK_EXT_external_memory_host === |
| |
| VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE VULKAN_HPP_NAMESPACE::MemoryHostPointerPropertiesEXT |
| Device::getMemoryHostPointerPropertiesEXT(VULKAN_HPP_NAMESPACE::ExternalMemoryHandleTypeFlagBits handleType, const void *pHostPointer) const |
| { |
| VULKAN_HPP_ASSERT(getDispatcher()->vkGetMemoryHostPointerPropertiesEXT && |
| "Function <vkGetMemoryHostPointerPropertiesEXT> needs extension <VK_EXT_external_memory_host> enabled!"); |
| |
| VULKAN_HPP_NAMESPACE::MemoryHostPointerPropertiesEXT memoryHostPointerProperties; |
| VULKAN_HPP_NAMESPACE::Result result = static_cast<VULKAN_HPP_NAMESPACE::Result>( |
| getDispatcher()->vkGetMemoryHostPointerPropertiesEXT(static_cast<VkDevice>(m_device), |
| static_cast<VkExternalMemoryHandleTypeFlagBits>(handleType), |
| pHostPointer, |
| reinterpret_cast<VkMemoryHostPointerPropertiesEXT *>(&memoryHostPointerProperties))); |
| if(result != VULKAN_HPP_NAMESPACE::Result::eSuccess) |
| { |
| throwResultException(result, VULKAN_HPP_NAMESPACE_STRING "::Device::getMemoryHostPointerPropertiesEXT"); |
| } |
| return memoryHostPointerProperties; |
| } |
| |
| //=== VK_AMD_buffer_marker === |
| |
| VULKAN_HPP_INLINE void CommandBuffer::writeBufferMarkerAMD(VULKAN_HPP_NAMESPACE::PipelineStageFlagBits pipelineStage, |
| VULKAN_HPP_NAMESPACE::Buffer dstBuffer, |
| VULKAN_HPP_NAMESPACE::DeviceSize dstOffset, |
| uint32_t marker) const VULKAN_HPP_NOEXCEPT |
| { |
| VULKAN_HPP_ASSERT(getDispatcher()->vkCmdWriteBufferMarkerAMD && "Function <vkCmdWriteBufferMarkerAMD> needs extension <VK_AMD_buffer_marker> enabled!"); |
| |
| getDispatcher()->vkCmdWriteBufferMarkerAMD(static_cast<VkCommandBuffer>(m_commandBuffer), |
| static_cast<VkPipelineStageFlagBits>(pipelineStage), |
| static_cast<VkBuffer>(dstBuffer), |
| static_cast<VkDeviceSize>(dstOffset), |
| marker); |
| } |
| |
| //=== VK_EXT_calibrated_timestamps === |
| |
| VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE std::vector<VULKAN_HPP_NAMESPACE::TimeDomainEXT> PhysicalDevice::getCalibrateableTimeDomainsEXT() const |
| { |
| VULKAN_HPP_ASSERT(getDispatcher()->vkGetPhysicalDeviceCalibrateableTimeDomainsEXT && |
| "Function <vkGetPhysicalDeviceCalibrateableTimeDomainsEXT> needs extension <VK_EXT_calibrated_timestamps> enabled!"); |
| |
| std::vector<VULKAN_HPP_NAMESPACE::TimeDomainEXT> timeDomains; |
| uint32_t timeDomainCount; |
| VULKAN_HPP_NAMESPACE::Result result; |
| do |
| { |
| result = static_cast<VULKAN_HPP_NAMESPACE::Result>( |
| getDispatcher()->vkGetPhysicalDeviceCalibrateableTimeDomainsEXT(static_cast<VkPhysicalDevice>(m_physicalDevice), &timeDomainCount, nullptr)); |
| if((result == VULKAN_HPP_NAMESPACE::Result::eSuccess) && timeDomainCount) |
| { |
| timeDomains.resize(timeDomainCount); |
| result = static_cast<VULKAN_HPP_NAMESPACE::Result>(getDispatcher()->vkGetPhysicalDeviceCalibrateableTimeDomainsEXT( |
| static_cast<VkPhysicalDevice>(m_physicalDevice), &timeDomainCount, reinterpret_cast<VkTimeDomainEXT *>(timeDomains.data()))); |
| } |
| } while(result == VULKAN_HPP_NAMESPACE::Result::eIncomplete); |
| if(result != VULKAN_HPP_NAMESPACE::Result::eSuccess) |
| { |
| throwResultException(result, VULKAN_HPP_NAMESPACE_STRING "::PhysicalDevice::getCalibrateableTimeDomainsEXT"); |
| } |
| if(result == VULKAN_HPP_NAMESPACE::Result::eSuccess) |
| { |
| VULKAN_HPP_ASSERT(timeDomainCount <= timeDomains.size()); |
| if(timeDomainCount < timeDomains.size()) |
| { |
| timeDomains.resize(timeDomainCount); |
| } |
| } |
| return timeDomains; |
| } |
| |
| VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE std::pair<std::vector<uint64_t>, uint64_t> |
| Device::getCalibratedTimestampsEXT(ArrayProxy<const VULKAN_HPP_NAMESPACE::CalibratedTimestampInfoEXT> const ×tampInfos) const |
| { |
| VULKAN_HPP_ASSERT(getDispatcher()->vkGetCalibratedTimestampsEXT && |
| "Function <vkGetCalibratedTimestampsEXT> needs extension <VK_EXT_calibrated_timestamps> enabled!"); |
| |
| std::pair<std::vector<uint64_t>, uint64_t> data(std::piecewise_construct, std::forward_as_tuple(timestampInfos.size()), std::forward_as_tuple(0)); |
| std::vector<uint64_t> ×tamps = data.first; |
| uint64_t &maxDeviation = data.second; |
| VULKAN_HPP_NAMESPACE::Result result = static_cast<VULKAN_HPP_NAMESPACE::Result>( |
| getDispatcher()->vkGetCalibratedTimestampsEXT(static_cast<VkDevice>(m_device), |
| timestampInfos.size(), |
| reinterpret_cast<const VkCalibratedTimestampInfoEXT *>(timestampInfos.data()), |
| timestamps.data(), |
| &maxDeviation)); |
| if(result != VULKAN_HPP_NAMESPACE::Result::eSuccess) |
| { |
| throwResultException(result, VULKAN_HPP_NAMESPACE_STRING "::Device::getCalibratedTimestampsEXT"); |
| } |
| return data; |
| } |
| |
| VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE std::pair<uint64_t, uint64_t> |
| Device::getCalibratedTimestampEXT(const VULKAN_HPP_NAMESPACE::CalibratedTimestampInfoEXT ×tampInfo) const |
| { |
| VULKAN_HPP_ASSERT(getDispatcher()->vkGetCalibratedTimestampsEXT && |
| "Function <vkGetCalibratedTimestampsEXT> needs extension <VK_EXT_calibrated_timestamps> enabled!"); |
| |
| std::pair<uint64_t, uint64_t> data; |
| uint64_t ×tamp = data.first; |
| uint64_t &maxDeviation = data.second; |
| VULKAN_HPP_NAMESPACE::Result result = static_cast<VULKAN_HPP_NAMESPACE::Result>(getDispatcher()->vkGetCalibratedTimestampsEXT( |
| static_cast<VkDevice>(m_device), 1, reinterpret_cast<const VkCalibratedTimestampInfoEXT *>(×tampInfo), ×tamp, &maxDeviation)); |
| if(result != VULKAN_HPP_NAMESPACE::Result::eSuccess) |
| { |
| throwResultException(result, VULKAN_HPP_NAMESPACE_STRING "::Device::getCalibratedTimestampEXT"); |
| } |
| return data; |
| } |
| |
| //=== VK_NV_mesh_shader === |
| |
| VULKAN_HPP_INLINE void CommandBuffer::drawMeshTasksNV(uint32_t taskCount, uint32_t firstTask) const VULKAN_HPP_NOEXCEPT |
| { |
| VULKAN_HPP_ASSERT(getDispatcher()->vkCmdDrawMeshTasksNV && "Function <vkCmdDrawMeshTasksNV> needs extension <VK_NV_mesh_shader> enabled!"); |
| |
| getDispatcher()->vkCmdDrawMeshTasksNV(static_cast<VkCommandBuffer>(m_commandBuffer), taskCount, firstTask); |
| } |
| |
| VULKAN_HPP_INLINE void CommandBuffer::drawMeshTasksIndirectNV(VULKAN_HPP_NAMESPACE::Buffer buffer, |
| VULKAN_HPP_NAMESPACE::DeviceSize offset, |
| uint32_t drawCount, |
| uint32_t stride) const VULKAN_HPP_NOEXCEPT |
| { |
| VULKAN_HPP_ASSERT(getDispatcher()->vkCmdDrawMeshTasksIndirectNV && |
| "Function <vkCmdDrawMeshTasksIndirectNV> needs extension <VK_NV_mesh_shader> enabled!"); |
| |
| getDispatcher()->vkCmdDrawMeshTasksIndirectNV( |
| static_cast<VkCommandBuffer>(m_commandBuffer), static_cast<VkBuffer>(buffer), static_cast<VkDeviceSize>(offset), drawCount, stride); |
| } |
| |
| VULKAN_HPP_INLINE void CommandBuffer::drawMeshTasksIndirectCountNV(VULKAN_HPP_NAMESPACE::Buffer buffer, |
| VULKAN_HPP_NAMESPACE::DeviceSize offset, |
| VULKAN_HPP_NAMESPACE::Buffer countBuffer, |
| VULKAN_HPP_NAMESPACE::DeviceSize countBufferOffset, |
| uint32_t maxDrawCount, |
| uint32_t stride) const VULKAN_HPP_NOEXCEPT |
| { |
| VULKAN_HPP_ASSERT(getDispatcher()->vkCmdDrawMeshTasksIndirectCountNV && |
| "Function <vkCmdDrawMeshTasksIndirectCountNV> needs extension <VK_NV_mesh_shader> enabled!"); |
| |
| getDispatcher()->vkCmdDrawMeshTasksIndirectCountNV(static_cast<VkCommandBuffer>(m_commandBuffer), |
| static_cast<VkBuffer>(buffer), |
| static_cast<VkDeviceSize>(offset), |
| static_cast<VkBuffer>(countBuffer), |
| static_cast<VkDeviceSize>(countBufferOffset), |
| maxDrawCount, |
| stride); |
| } |
| |
| //=== VK_NV_scissor_exclusive === |
| |
| VULKAN_HPP_INLINE void |
| CommandBuffer::setExclusiveScissorNV(uint32_t firstExclusiveScissor, |
| ArrayProxy<const VULKAN_HPP_NAMESPACE::Rect2D> const &exclusiveScissors) const VULKAN_HPP_NOEXCEPT |
| { |
| VULKAN_HPP_ASSERT(getDispatcher()->vkCmdSetExclusiveScissorNV && |
| "Function <vkCmdSetExclusiveScissorNV> needs extension <VK_NV_scissor_exclusive> enabled!"); |
| |
| getDispatcher()->vkCmdSetExclusiveScissorNV(static_cast<VkCommandBuffer>(m_commandBuffer), |
| firstExclusiveScissor, |
| exclusiveScissors.size(), |
| reinterpret_cast<const VkRect2D *>(exclusiveScissors.data())); |
| } |
| |
| //=== VK_NV_device_diagnostic_checkpoints === |
| |
| template<typename CheckpointMarkerType> |
| VULKAN_HPP_INLINE void CommandBuffer::setCheckpointNV(CheckpointMarkerType const &checkpointMarker) const VULKAN_HPP_NOEXCEPT |
| { |
| VULKAN_HPP_ASSERT(getDispatcher()->vkCmdSetCheckpointNV && |
| "Function <vkCmdSetCheckpointNV> needs extension <VK_NV_device_diagnostic_checkpoints> enabled!"); |
| |
| getDispatcher()->vkCmdSetCheckpointNV(static_cast<VkCommandBuffer>(m_commandBuffer), reinterpret_cast<const void *>(&checkpointMarker)); |
| } |
| |
| VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE std::vector<VULKAN_HPP_NAMESPACE::CheckpointDataNV> Queue::getCheckpointDataNV() const VULKAN_HPP_NOEXCEPT |
| { |
| VULKAN_HPP_ASSERT(getDispatcher()->vkGetQueueCheckpointDataNV && |
| "Function <vkGetQueueCheckpointDataNV> needs extension <VK_NV_device_diagnostic_checkpoints> enabled!"); |
| |
| uint32_t checkpointDataCount; |
| getDispatcher()->vkGetQueueCheckpointDataNV(static_cast<VkQueue>(m_queue), &checkpointDataCount, nullptr); |
| std::vector<VULKAN_HPP_NAMESPACE::CheckpointDataNV> checkpointData(checkpointDataCount); |
| getDispatcher()->vkGetQueueCheckpointDataNV( |
| static_cast<VkQueue>(m_queue), &checkpointDataCount, reinterpret_cast<VkCheckpointDataNV *>(checkpointData.data())); |
| VULKAN_HPP_ASSERT(checkpointDataCount == checkpointData.size()); |
| return checkpointData; |
| } |
| |
| //=== VK_KHR_timeline_semaphore === |
| |
| VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE uint64_t Semaphore::getCounterValueKHR() const |
| { |
| VULKAN_HPP_ASSERT(getDispatcher()->vkGetSemaphoreCounterValueKHR && |
| "Function <vkGetSemaphoreCounterValueKHR> needs extension <VK_KHR_timeline_semaphore> enabled!"); |
| |
| uint64_t value; |
| VULKAN_HPP_NAMESPACE::Result result = static_cast<VULKAN_HPP_NAMESPACE::Result>( |
| getDispatcher()->vkGetSemaphoreCounterValueKHR(static_cast<VkDevice>(m_device), static_cast<VkSemaphore>(m_semaphore), &value)); |
| if(result != VULKAN_HPP_NAMESPACE::Result::eSuccess) |
| { |
| throwResultException(result, VULKAN_HPP_NAMESPACE_STRING "::Semaphore::getCounterValueKHR"); |
| } |
| return value; |
| } |
| |
| VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE VULKAN_HPP_NAMESPACE::Result Device::waitSemaphoresKHR(const VULKAN_HPP_NAMESPACE::SemaphoreWaitInfo &waitInfo, |
| uint64_t timeout) const |
| { |
| VULKAN_HPP_ASSERT(getDispatcher()->vkWaitSemaphoresKHR && "Function <vkWaitSemaphoresKHR> needs extension <VK_KHR_timeline_semaphore> enabled!"); |
| |
| VULKAN_HPP_NAMESPACE::Result result = static_cast<VULKAN_HPP_NAMESPACE::Result>( |
| getDispatcher()->vkWaitSemaphoresKHR(static_cast<VkDevice>(m_device), reinterpret_cast<const VkSemaphoreWaitInfo *>(&waitInfo), timeout)); |
| if((result != VULKAN_HPP_NAMESPACE::Result::eSuccess) && (result != VULKAN_HPP_NAMESPACE::Result::eTimeout)) |
| { |
| throwResultException(result, VULKAN_HPP_NAMESPACE_STRING "::Device::waitSemaphoresKHR"); |
| } |
| return result; |
| } |
| |
| VULKAN_HPP_INLINE void Device::signalSemaphoreKHR(const VULKAN_HPP_NAMESPACE::SemaphoreSignalInfo &signalInfo) const |
| { |
| VULKAN_HPP_ASSERT(getDispatcher()->vkSignalSemaphoreKHR && "Function <vkSignalSemaphoreKHR> needs extension <VK_KHR_timeline_semaphore> enabled!"); |
| |
| VULKAN_HPP_NAMESPACE::Result result = static_cast<VULKAN_HPP_NAMESPACE::Result>( |
| getDispatcher()->vkSignalSemaphoreKHR(static_cast<VkDevice>(m_device), reinterpret_cast<const VkSemaphoreSignalInfo *>(&signalInfo))); |
| if(result != VULKAN_HPP_NAMESPACE::Result::eSuccess) |
| { |
| throwResultException(result, VULKAN_HPP_NAMESPACE_STRING "::Device::signalSemaphoreKHR"); |
| } |
| } |
| |
| //=== VK_INTEL_performance_query === |
| |
| VULKAN_HPP_INLINE void Device::initializePerformanceApiINTEL(const VULKAN_HPP_NAMESPACE::InitializePerformanceApiInfoINTEL &initializeInfo) const |
| { |
| VULKAN_HPP_ASSERT(getDispatcher()->vkInitializePerformanceApiINTEL && |
| "Function <vkInitializePerformanceApiINTEL> needs extension <VK_INTEL_performance_query> enabled!"); |
| |
| VULKAN_HPP_NAMESPACE::Result result = static_cast<VULKAN_HPP_NAMESPACE::Result>(getDispatcher()->vkInitializePerformanceApiINTEL( |
| static_cast<VkDevice>(m_device), reinterpret_cast<const VkInitializePerformanceApiInfoINTEL *>(&initializeInfo))); |
| if(result != VULKAN_HPP_NAMESPACE::Result::eSuccess) |
| { |
| throwResultException(result, VULKAN_HPP_NAMESPACE_STRING "::Device::initializePerformanceApiINTEL"); |
| } |
| } |
| |
| VULKAN_HPP_INLINE void Device::uninitializePerformanceApiINTEL() const VULKAN_HPP_NOEXCEPT |
| { |
| VULKAN_HPP_ASSERT(getDispatcher()->vkUninitializePerformanceApiINTEL && |
| "Function <vkUninitializePerformanceApiINTEL> needs extension <VK_INTEL_performance_query> enabled!"); |
| |
| getDispatcher()->vkUninitializePerformanceApiINTEL(static_cast<VkDevice>(m_device)); |
| } |
| |
| VULKAN_HPP_INLINE void CommandBuffer::setPerformanceMarkerINTEL(const VULKAN_HPP_NAMESPACE::PerformanceMarkerInfoINTEL &markerInfo) const |
| { |
| VULKAN_HPP_ASSERT(getDispatcher()->vkCmdSetPerformanceMarkerINTEL && |
| "Function <vkCmdSetPerformanceMarkerINTEL> needs extension <VK_INTEL_performance_query> enabled!"); |
| |
| VULKAN_HPP_NAMESPACE::Result result = static_cast<VULKAN_HPP_NAMESPACE::Result>(getDispatcher()->vkCmdSetPerformanceMarkerINTEL( |
| static_cast<VkCommandBuffer>(m_commandBuffer), reinterpret_cast<const VkPerformanceMarkerInfoINTEL *>(&markerInfo))); |
| if(result != VULKAN_HPP_NAMESPACE::Result::eSuccess) |
| { |
| throwResultException(result, VULKAN_HPP_NAMESPACE_STRING "::CommandBuffer::setPerformanceMarkerINTEL"); |
| } |
| } |
| |
| VULKAN_HPP_INLINE void CommandBuffer::setPerformanceStreamMarkerINTEL(const VULKAN_HPP_NAMESPACE::PerformanceStreamMarkerInfoINTEL &markerInfo) const |
| { |
| VULKAN_HPP_ASSERT(getDispatcher()->vkCmdSetPerformanceStreamMarkerINTEL && |
| "Function <vkCmdSetPerformanceStreamMarkerINTEL> needs extension <VK_INTEL_performance_query> enabled!"); |
| |
| VULKAN_HPP_NAMESPACE::Result result = static_cast<VULKAN_HPP_NAMESPACE::Result>(getDispatcher()->vkCmdSetPerformanceStreamMarkerINTEL( |
| static_cast<VkCommandBuffer>(m_commandBuffer), reinterpret_cast<const VkPerformanceStreamMarkerInfoINTEL *>(&markerInfo))); |
| if(result != VULKAN_HPP_NAMESPACE::Result::eSuccess) |
| { |
| throwResultException(result, VULKAN_HPP_NAMESPACE_STRING "::CommandBuffer::setPerformanceStreamMarkerINTEL"); |
| } |
| } |
| |
| VULKAN_HPP_INLINE void CommandBuffer::setPerformanceOverrideINTEL(const VULKAN_HPP_NAMESPACE::PerformanceOverrideInfoINTEL &overrideInfo) const |
| { |
| VULKAN_HPP_ASSERT(getDispatcher()->vkCmdSetPerformanceOverrideINTEL && |
| "Function <vkCmdSetPerformanceOverrideINTEL> needs extension <VK_INTEL_performance_query> enabled!"); |
| |
| VULKAN_HPP_NAMESPACE::Result result = static_cast<VULKAN_HPP_NAMESPACE::Result>(getDispatcher()->vkCmdSetPerformanceOverrideINTEL( |
| static_cast<VkCommandBuffer>(m_commandBuffer), reinterpret_cast<const VkPerformanceOverrideInfoINTEL *>(&overrideInfo))); |
| if(result != VULKAN_HPP_NAMESPACE::Result::eSuccess) |
| { |
| throwResultException(result, VULKAN_HPP_NAMESPACE_STRING "::CommandBuffer::setPerformanceOverrideINTEL"); |
| } |
| } |
| |
| VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE VULKAN_HPP_RAII_NAMESPACE::PerformanceConfigurationINTEL |
| Device::acquirePerformanceConfigurationINTEL(VULKAN_HPP_NAMESPACE::PerformanceConfigurationAcquireInfoINTEL const &acquireInfo) const |
| { |
| return VULKAN_HPP_RAII_NAMESPACE::PerformanceConfigurationINTEL(*this, acquireInfo); |
| } |
| |
| VULKAN_HPP_INLINE void Queue::setPerformanceConfigurationINTEL(VULKAN_HPP_NAMESPACE::PerformanceConfigurationINTEL configuration) const |
| { |
| VULKAN_HPP_ASSERT(getDispatcher()->vkQueueSetPerformanceConfigurationINTEL && |
| "Function <vkQueueSetPerformanceConfigurationINTEL> needs extension <VK_INTEL_performance_query> enabled!"); |
| |
| VULKAN_HPP_NAMESPACE::Result result = static_cast<VULKAN_HPP_NAMESPACE::Result>(getDispatcher()->vkQueueSetPerformanceConfigurationINTEL( |
| static_cast<VkQueue>(m_queue), static_cast<VkPerformanceConfigurationINTEL>(configuration))); |
| if(result != VULKAN_HPP_NAMESPACE::Result::eSuccess) |
| { |
| throwResultException(result, VULKAN_HPP_NAMESPACE_STRING "::Queue::setPerformanceConfigurationINTEL"); |
| } |
| } |
| |
| VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE VULKAN_HPP_NAMESPACE::PerformanceValueINTEL |
| Device::getPerformanceParameterINTEL(VULKAN_HPP_NAMESPACE::PerformanceParameterTypeINTEL parameter) const |
| { |
| VULKAN_HPP_ASSERT(getDispatcher()->vkGetPerformanceParameterINTEL && |
| "Function <vkGetPerformanceParameterINTEL> needs extension <VK_INTEL_performance_query> enabled!"); |
| |
| VULKAN_HPP_NAMESPACE::PerformanceValueINTEL value; |
| VULKAN_HPP_NAMESPACE::Result result = static_cast<VULKAN_HPP_NAMESPACE::Result>(getDispatcher()->vkGetPerformanceParameterINTEL( |
| static_cast<VkDevice>(m_device), static_cast<VkPerformanceParameterTypeINTEL>(parameter), reinterpret_cast<VkPerformanceValueINTEL *>(&value))); |
| if(result != VULKAN_HPP_NAMESPACE::Result::eSuccess) |
| { |
| throwResultException(result, VULKAN_HPP_NAMESPACE_STRING "::Device::getPerformanceParameterINTEL"); |
| } |
| return value; |
| } |
| |
| //=== VK_AMD_display_native_hdr === |
| |
| VULKAN_HPP_INLINE void SwapchainKHR::setLocalDimmingAMD(VULKAN_HPP_NAMESPACE::Bool32 localDimmingEnable) const VULKAN_HPP_NOEXCEPT |
| { |
| VULKAN_HPP_ASSERT(getDispatcher()->vkSetLocalDimmingAMD && "Function <vkSetLocalDimmingAMD> needs extension <VK_AMD_display_native_hdr> enabled!"); |
| |
| getDispatcher()->vkSetLocalDimmingAMD( |
| static_cast<VkDevice>(m_device), static_cast<VkSwapchainKHR>(m_swapchain), static_cast<VkBool32>(localDimmingEnable)); |
| } |
| |
| # if defined(VK_USE_PLATFORM_FUCHSIA) |
| //=== VK_FUCHSIA_imagepipe_surface === |
| |
| VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE VULKAN_HPP_RAII_NAMESPACE::SurfaceKHR |
| Instance::createImagePipeSurfaceFUCHSIA(VULKAN_HPP_NAMESPACE::ImagePipeSurfaceCreateInfoFUCHSIA const &createInfo, |
| VULKAN_HPP_NAMESPACE::Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator) const |
| { |
| return VULKAN_HPP_RAII_NAMESPACE::SurfaceKHR(*this, createInfo, allocator); |
| } |
| # endif /*VK_USE_PLATFORM_FUCHSIA*/ |
| |
| # if defined(VK_USE_PLATFORM_METAL_EXT) |
| //=== VK_EXT_metal_surface === |
| |
| VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE VULKAN_HPP_RAII_NAMESPACE::SurfaceKHR |
| Instance::createMetalSurfaceEXT(VULKAN_HPP_NAMESPACE::MetalSurfaceCreateInfoEXT const &createInfo, |
| VULKAN_HPP_NAMESPACE::Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator) const |
| { |
| return VULKAN_HPP_RAII_NAMESPACE::SurfaceKHR(*this, createInfo, allocator); |
| } |
| # endif /*VK_USE_PLATFORM_METAL_EXT*/ |
| |
| //=== VK_KHR_fragment_shading_rate === |
| |
| VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE std::vector<VULKAN_HPP_NAMESPACE::PhysicalDeviceFragmentShadingRateKHR> |
| PhysicalDevice::getFragmentShadingRatesKHR() const |
| { |
| VULKAN_HPP_ASSERT(getDispatcher()->vkGetPhysicalDeviceFragmentShadingRatesKHR && |
| "Function <vkGetPhysicalDeviceFragmentShadingRatesKHR> needs extension <VK_KHR_fragment_shading_rate> enabled!"); |
| |
| std::vector<VULKAN_HPP_NAMESPACE::PhysicalDeviceFragmentShadingRateKHR> fragmentShadingRates; |
| uint32_t fragmentShadingRateCount; |
| VULKAN_HPP_NAMESPACE::Result result; |
| do |
| { |
| result = static_cast<VULKAN_HPP_NAMESPACE::Result>(getDispatcher()->vkGetPhysicalDeviceFragmentShadingRatesKHR( |
| static_cast<VkPhysicalDevice>(m_physicalDevice), &fragmentShadingRateCount, nullptr)); |
| if((result == VULKAN_HPP_NAMESPACE::Result::eSuccess) && fragmentShadingRateCount) |
| { |
| fragmentShadingRates.resize(fragmentShadingRateCount); |
| result = static_cast<VULKAN_HPP_NAMESPACE::Result>(getDispatcher()->vkGetPhysicalDeviceFragmentShadingRatesKHR( |
| static_cast<VkPhysicalDevice>(m_physicalDevice), |
| &fragmentShadingRateCount, |
| reinterpret_cast<VkPhysicalDeviceFragmentShadingRateKHR *>(fragmentShadingRates.data()))); |
| } |
| } while(result == VULKAN_HPP_NAMESPACE::Result::eIncomplete); |
| if(result != VULKAN_HPP_NAMESPACE::Result::eSuccess) |
| { |
| throwResultException(result, VULKAN_HPP_NAMESPACE_STRING "::PhysicalDevice::getFragmentShadingRatesKHR"); |
| } |
| if(result == VULKAN_HPP_NAMESPACE::Result::eSuccess) |
| { |
| VULKAN_HPP_ASSERT(fragmentShadingRateCount <= fragmentShadingRates.size()); |
| if(fragmentShadingRateCount < fragmentShadingRates.size()) |
| { |
| fragmentShadingRates.resize(fragmentShadingRateCount); |
| } |
| } |
| return fragmentShadingRates; |
| } |
| |
| VULKAN_HPP_INLINE void |
| CommandBuffer::setFragmentShadingRateKHR(const VULKAN_HPP_NAMESPACE::Extent2D &fragmentSize, |
| const VULKAN_HPP_NAMESPACE::FragmentShadingRateCombinerOpKHR combinerOps[2]) const VULKAN_HPP_NOEXCEPT |
| { |
| VULKAN_HPP_ASSERT(getDispatcher()->vkCmdSetFragmentShadingRateKHR && |
| "Function <vkCmdSetFragmentShadingRateKHR> needs extension <VK_KHR_fragment_shading_rate> enabled!"); |
| |
| getDispatcher()->vkCmdSetFragmentShadingRateKHR(static_cast<VkCommandBuffer>(m_commandBuffer), |
| reinterpret_cast<const VkExtent2D *>(&fragmentSize), |
| reinterpret_cast<const VkFragmentShadingRateCombinerOpKHR *>(combinerOps)); |
| } |
| |
| //=== VK_EXT_buffer_device_address === |
| |
| VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE VULKAN_HPP_NAMESPACE::DeviceAddress |
| Device::getBufferAddressEXT(const VULKAN_HPP_NAMESPACE::BufferDeviceAddressInfo &info) const VULKAN_HPP_NOEXCEPT |
| { |
| VULKAN_HPP_ASSERT(getDispatcher()->vkGetBufferDeviceAddressEXT && |
| "Function <vkGetBufferDeviceAddressEXT> needs extension <VK_EXT_buffer_device_address> enabled!"); |
| |
| return static_cast<VULKAN_HPP_NAMESPACE::DeviceAddress>( |
| getDispatcher()->vkGetBufferDeviceAddressEXT(static_cast<VkDevice>(m_device), reinterpret_cast<const VkBufferDeviceAddressInfo *>(&info))); |
| } |
| |
| //=== VK_EXT_tooling_info === |
| |
| VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE std::vector<VULKAN_HPP_NAMESPACE::PhysicalDeviceToolProperties> PhysicalDevice::getToolPropertiesEXT() const |
| { |
| VULKAN_HPP_ASSERT(getDispatcher()->vkGetPhysicalDeviceToolPropertiesEXT && |
| "Function <vkGetPhysicalDeviceToolPropertiesEXT> needs extension <VK_EXT_tooling_info> enabled!"); |
| |
| std::vector<VULKAN_HPP_NAMESPACE::PhysicalDeviceToolProperties> toolProperties; |
| uint32_t toolCount; |
| VULKAN_HPP_NAMESPACE::Result result; |
| do |
| { |
| result = static_cast<VULKAN_HPP_NAMESPACE::Result>( |
| getDispatcher()->vkGetPhysicalDeviceToolPropertiesEXT(static_cast<VkPhysicalDevice>(m_physicalDevice), &toolCount, nullptr)); |
| if((result == VULKAN_HPP_NAMESPACE::Result::eSuccess) && toolCount) |
| { |
| toolProperties.resize(toolCount); |
| result = static_cast<VULKAN_HPP_NAMESPACE::Result>(getDispatcher()->vkGetPhysicalDeviceToolPropertiesEXT( |
| static_cast<VkPhysicalDevice>(m_physicalDevice), &toolCount, reinterpret_cast<VkPhysicalDeviceToolProperties *>(toolProperties.data()))); |
| } |
| } while(result == VULKAN_HPP_NAMESPACE::Result::eIncomplete); |
| if(result != VULKAN_HPP_NAMESPACE::Result::eSuccess) |
| { |
| throwResultException(result, VULKAN_HPP_NAMESPACE_STRING "::PhysicalDevice::getToolPropertiesEXT"); |
| } |
| if(result == VULKAN_HPP_NAMESPACE::Result::eSuccess) |
| { |
| VULKAN_HPP_ASSERT(toolCount <= toolProperties.size()); |
| if(toolCount < toolProperties.size()) |
| { |
| toolProperties.resize(toolCount); |
| } |
| } |
| return toolProperties; |
| } |
| |
| //=== VK_KHR_present_wait === |
| |
| VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE VULKAN_HPP_NAMESPACE::Result SwapchainKHR::waitForPresent(uint64_t presentId, uint64_t timeout) const |
| { |
| VULKAN_HPP_ASSERT(getDispatcher()->vkWaitForPresentKHR && "Function <vkWaitForPresentKHR> needs extension <VK_KHR_present_wait> enabled!"); |
| |
| VULKAN_HPP_NAMESPACE::Result result = static_cast<VULKAN_HPP_NAMESPACE::Result>( |
| getDispatcher()->vkWaitForPresentKHR(static_cast<VkDevice>(m_device), static_cast<VkSwapchainKHR>(m_swapchain), presentId, timeout)); |
| if((result != VULKAN_HPP_NAMESPACE::Result::eSuccess) && (result != VULKAN_HPP_NAMESPACE::Result::eTimeout) && |
| (result != VULKAN_HPP_NAMESPACE::Result::eSuboptimalKHR)) |
| { |
| throwResultException(result, VULKAN_HPP_NAMESPACE_STRING "::SwapchainKHR::waitForPresent"); |
| } |
| return result; |
| } |
| |
| //=== VK_NV_cooperative_matrix === |
| |
| VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE std::vector<VULKAN_HPP_NAMESPACE::CooperativeMatrixPropertiesNV> |
| PhysicalDevice::getCooperativeMatrixPropertiesNV() const |
| { |
| VULKAN_HPP_ASSERT(getDispatcher()->vkGetPhysicalDeviceCooperativeMatrixPropertiesNV && |
| "Function <vkGetPhysicalDeviceCooperativeMatrixPropertiesNV> needs extension <VK_NV_cooperative_matrix> enabled!"); |
| |
| std::vector<VULKAN_HPP_NAMESPACE::CooperativeMatrixPropertiesNV> properties; |
| uint32_t propertyCount; |
| VULKAN_HPP_NAMESPACE::Result result; |
| do |
| { |
| result = static_cast<VULKAN_HPP_NAMESPACE::Result>( |
| getDispatcher()->vkGetPhysicalDeviceCooperativeMatrixPropertiesNV(static_cast<VkPhysicalDevice>(m_physicalDevice), &propertyCount, nullptr)); |
| if((result == VULKAN_HPP_NAMESPACE::Result::eSuccess) && propertyCount) |
| { |
| properties.resize(propertyCount); |
| result = static_cast<VULKAN_HPP_NAMESPACE::Result>(getDispatcher()->vkGetPhysicalDeviceCooperativeMatrixPropertiesNV( |
| static_cast<VkPhysicalDevice>(m_physicalDevice), &propertyCount, reinterpret_cast<VkCooperativeMatrixPropertiesNV *>(properties.data()))); |
| } |
| } while(result == VULKAN_HPP_NAMESPACE::Result::eIncomplete); |
| if(result != VULKAN_HPP_NAMESPACE::Result::eSuccess) |
| { |
| throwResultException(result, VULKAN_HPP_NAMESPACE_STRING "::PhysicalDevice::getCooperativeMatrixPropertiesNV"); |
| } |
| if(result == VULKAN_HPP_NAMESPACE::Result::eSuccess) |
| { |
| VULKAN_HPP_ASSERT(propertyCount <= properties.size()); |
| if(propertyCount < properties.size()) |
| { |
| properties.resize(propertyCount); |
| } |
| } |
| return properties; |
| } |
| |
| //=== VK_NV_coverage_reduction_mode === |
| |
| VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE std::vector<VULKAN_HPP_NAMESPACE::FramebufferMixedSamplesCombinationNV> |
| PhysicalDevice::getSupportedFramebufferMixedSamplesCombinationsNV() const |
| { |
| VULKAN_HPP_ASSERT( |
| getDispatcher()->vkGetPhysicalDeviceSupportedFramebufferMixedSamplesCombinationsNV && |
| "Function <vkGetPhysicalDeviceSupportedFramebufferMixedSamplesCombinationsNV> needs extension <VK_NV_coverage_reduction_mode> enabled!"); |
| |
| std::vector<VULKAN_HPP_NAMESPACE::FramebufferMixedSamplesCombinationNV> combinations; |
| uint32_t combinationCount; |
| VULKAN_HPP_NAMESPACE::Result result; |
| do |
| { |
| result = static_cast<VULKAN_HPP_NAMESPACE::Result>(getDispatcher()->vkGetPhysicalDeviceSupportedFramebufferMixedSamplesCombinationsNV( |
| static_cast<VkPhysicalDevice>(m_physicalDevice), &combinationCount, nullptr)); |
| if((result == VULKAN_HPP_NAMESPACE::Result::eSuccess) && combinationCount) |
| { |
| combinations.resize(combinationCount); |
| result = static_cast<VULKAN_HPP_NAMESPACE::Result>(getDispatcher()->vkGetPhysicalDeviceSupportedFramebufferMixedSamplesCombinationsNV( |
| static_cast<VkPhysicalDevice>(m_physicalDevice), |
| &combinationCount, |
| reinterpret_cast<VkFramebufferMixedSamplesCombinationNV *>(combinations.data()))); |
| } |
| } while(result == VULKAN_HPP_NAMESPACE::Result::eIncomplete); |
| if(result != VULKAN_HPP_NAMESPACE::Result::eSuccess) |
| { |
| throwResultException(result, VULKAN_HPP_NAMESPACE_STRING "::PhysicalDevice::getSupportedFramebufferMixedSamplesCombinationsNV"); |
| } |
| if(result == VULKAN_HPP_NAMESPACE::Result::eSuccess) |
| { |
| VULKAN_HPP_ASSERT(combinationCount <= combinations.size()); |
| if(combinationCount < combinations.size()) |
| { |
| combinations.resize(combinationCount); |
| } |
| } |
| return combinations; |
| } |
| |
| # if defined(VK_USE_PLATFORM_WIN32_KHR) |
| //=== VK_EXT_full_screen_exclusive === |
| |
| VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE std::vector<VULKAN_HPP_NAMESPACE::PresentModeKHR> |
| PhysicalDevice::getSurfacePresentModes2EXT(const VULKAN_HPP_NAMESPACE::PhysicalDeviceSurfaceInfo2KHR &surfaceInfo) const |
| { |
| VULKAN_HPP_ASSERT(getDispatcher()->vkGetPhysicalDeviceSurfacePresentModes2EXT && |
| "Function <vkGetPhysicalDeviceSurfacePresentModes2EXT> needs extension <VK_EXT_full_screen_exclusive> enabled!"); |
| |
| std::vector<VULKAN_HPP_NAMESPACE::PresentModeKHR> presentModes; |
| uint32_t presentModeCount; |
| VULKAN_HPP_NAMESPACE::Result result; |
| do |
| { |
| result = static_cast<VULKAN_HPP_NAMESPACE::Result>( |
| getDispatcher()->vkGetPhysicalDeviceSurfacePresentModes2EXT(static_cast<VkPhysicalDevice>(m_physicalDevice), |
| reinterpret_cast<const VkPhysicalDeviceSurfaceInfo2KHR *>(&surfaceInfo), |
| &presentModeCount, |
| nullptr)); |
| if((result == VULKAN_HPP_NAMESPACE::Result::eSuccess) && presentModeCount) |
| { |
| presentModes.resize(presentModeCount); |
| result = static_cast<VULKAN_HPP_NAMESPACE::Result>( |
| getDispatcher()->vkGetPhysicalDeviceSurfacePresentModes2EXT(static_cast<VkPhysicalDevice>(m_physicalDevice), |
| reinterpret_cast<const VkPhysicalDeviceSurfaceInfo2KHR *>(&surfaceInfo), |
| &presentModeCount, |
| reinterpret_cast<VkPresentModeKHR *>(presentModes.data()))); |
| } |
| } while(result == VULKAN_HPP_NAMESPACE::Result::eIncomplete); |
| if(result != VULKAN_HPP_NAMESPACE::Result::eSuccess) |
| { |
| throwResultException(result, VULKAN_HPP_NAMESPACE_STRING "::PhysicalDevice::getSurfacePresentModes2EXT"); |
| } |
| if(result == VULKAN_HPP_NAMESPACE::Result::eSuccess) |
| { |
| VULKAN_HPP_ASSERT(presentModeCount <= presentModes.size()); |
| if(presentModeCount < presentModes.size()) |
| { |
| presentModes.resize(presentModeCount); |
| } |
| } |
| return presentModes; |
| } |
| |
| VULKAN_HPP_INLINE void SwapchainKHR::acquireFullScreenExclusiveModeEXT() const |
| { |
| VULKAN_HPP_ASSERT(getDispatcher()->vkAcquireFullScreenExclusiveModeEXT && |
| "Function <vkAcquireFullScreenExclusiveModeEXT> needs extension <VK_EXT_full_screen_exclusive> enabled!"); |
| |
| VULKAN_HPP_NAMESPACE::Result result = static_cast<VULKAN_HPP_NAMESPACE::Result>( |
| getDispatcher()->vkAcquireFullScreenExclusiveModeEXT(static_cast<VkDevice>(m_device), static_cast<VkSwapchainKHR>(m_swapchain))); |
| if(result != VULKAN_HPP_NAMESPACE::Result::eSuccess) |
| { |
| throwResultException(result, VULKAN_HPP_NAMESPACE_STRING "::SwapchainKHR::acquireFullScreenExclusiveModeEXT"); |
| } |
| } |
| |
| VULKAN_HPP_INLINE void SwapchainKHR::releaseFullScreenExclusiveModeEXT() const |
| { |
| VULKAN_HPP_ASSERT(getDispatcher()->vkReleaseFullScreenExclusiveModeEXT && |
| "Function <vkReleaseFullScreenExclusiveModeEXT> needs extension <VK_EXT_full_screen_exclusive> enabled!"); |
| |
| VULKAN_HPP_NAMESPACE::Result result = static_cast<VULKAN_HPP_NAMESPACE::Result>( |
| getDispatcher()->vkReleaseFullScreenExclusiveModeEXT(static_cast<VkDevice>(m_device), static_cast<VkSwapchainKHR>(m_swapchain))); |
| if(result != VULKAN_HPP_NAMESPACE::Result::eSuccess) |
| { |
| throwResultException(result, VULKAN_HPP_NAMESPACE_STRING "::SwapchainKHR::releaseFullScreenExclusiveModeEXT"); |
| } |
| } |
| |
| VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE VULKAN_HPP_NAMESPACE::DeviceGroupPresentModeFlagsKHR |
| Device::getGroupSurfacePresentModes2EXT(const VULKAN_HPP_NAMESPACE::PhysicalDeviceSurfaceInfo2KHR &surfaceInfo) const |
| { |
| VULKAN_HPP_ASSERT(getDispatcher()->vkGetDeviceGroupSurfacePresentModes2EXT && |
| "Function <vkGetDeviceGroupSurfacePresentModes2EXT> needs extension <VK_EXT_full_screen_exclusive> enabled!"); |
| |
| VULKAN_HPP_NAMESPACE::DeviceGroupPresentModeFlagsKHR modes; |
| VULKAN_HPP_NAMESPACE::Result result = static_cast<VULKAN_HPP_NAMESPACE::Result>( |
| getDispatcher()->vkGetDeviceGroupSurfacePresentModes2EXT(static_cast<VkDevice>(m_device), |
| reinterpret_cast<const VkPhysicalDeviceSurfaceInfo2KHR *>(&surfaceInfo), |
| reinterpret_cast<VkDeviceGroupPresentModeFlagsKHR *>(&modes))); |
| if(result != VULKAN_HPP_NAMESPACE::Result::eSuccess) |
| { |
| throwResultException(result, VULKAN_HPP_NAMESPACE_STRING "::Device::getGroupSurfacePresentModes2EXT"); |
| } |
| return modes; |
| } |
| # endif /*VK_USE_PLATFORM_WIN32_KHR*/ |
| |
| //=== VK_EXT_headless_surface === |
| |
| VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE VULKAN_HPP_RAII_NAMESPACE::SurfaceKHR |
| Instance::createHeadlessSurfaceEXT(VULKAN_HPP_NAMESPACE::HeadlessSurfaceCreateInfoEXT const &createInfo, |
| VULKAN_HPP_NAMESPACE::Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator) const |
| { |
| return VULKAN_HPP_RAII_NAMESPACE::SurfaceKHR(*this, createInfo, allocator); |
| } |
| |
| //=== VK_KHR_buffer_device_address === |
| |
| VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE VULKAN_HPP_NAMESPACE::DeviceAddress |
| Device::getBufferAddressKHR(const VULKAN_HPP_NAMESPACE::BufferDeviceAddressInfo &info) const VULKAN_HPP_NOEXCEPT |
| { |
| VULKAN_HPP_ASSERT(getDispatcher()->vkGetBufferDeviceAddressKHR && |
| "Function <vkGetBufferDeviceAddressKHR> needs extension <VK_KHR_buffer_device_address> enabled!"); |
| |
| return static_cast<VULKAN_HPP_NAMESPACE::DeviceAddress>( |
| getDispatcher()->vkGetBufferDeviceAddressKHR(static_cast<VkDevice>(m_device), reinterpret_cast<const VkBufferDeviceAddressInfo *>(&info))); |
| } |
| |
| VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE uint64_t |
| Device::getBufferOpaqueCaptureAddressKHR(const VULKAN_HPP_NAMESPACE::BufferDeviceAddressInfo &info) const VULKAN_HPP_NOEXCEPT |
| { |
| VULKAN_HPP_ASSERT(getDispatcher()->vkGetBufferOpaqueCaptureAddressKHR && |
| "Function <vkGetBufferOpaqueCaptureAddressKHR> needs extension <VK_KHR_buffer_device_address> enabled!"); |
| |
| return getDispatcher()->vkGetBufferOpaqueCaptureAddressKHR(static_cast<VkDevice>(m_device), |
| reinterpret_cast<const VkBufferDeviceAddressInfo *>(&info)); |
| } |
| |
| VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE uint64_t |
| Device::getMemoryOpaqueCaptureAddressKHR(const VULKAN_HPP_NAMESPACE::DeviceMemoryOpaqueCaptureAddressInfo &info) const VULKAN_HPP_NOEXCEPT |
| { |
| VULKAN_HPP_ASSERT(getDispatcher()->vkGetDeviceMemoryOpaqueCaptureAddressKHR && |
| "Function <vkGetDeviceMemoryOpaqueCaptureAddressKHR> needs extension <VK_KHR_buffer_device_address> enabled!"); |
| |
| return getDispatcher()->vkGetDeviceMemoryOpaqueCaptureAddressKHR(static_cast<VkDevice>(m_device), |
| reinterpret_cast<const VkDeviceMemoryOpaqueCaptureAddressInfo *>(&info)); |
| } |
| |
| //=== VK_EXT_line_rasterization === |
| |
| VULKAN_HPP_INLINE void CommandBuffer::setLineStippleEXT(uint32_t lineStippleFactor, uint16_t lineStipplePattern) const VULKAN_HPP_NOEXCEPT |
| { |
| VULKAN_HPP_ASSERT(getDispatcher()->vkCmdSetLineStippleEXT && "Function <vkCmdSetLineStippleEXT> needs extension <VK_EXT_line_rasterization> enabled!"); |
| |
| getDispatcher()->vkCmdSetLineStippleEXT(static_cast<VkCommandBuffer>(m_commandBuffer), lineStippleFactor, lineStipplePattern); |
| } |
| |
| //=== VK_EXT_host_query_reset === |
| |
| VULKAN_HPP_INLINE void QueryPool::resetEXT(uint32_t firstQuery, uint32_t queryCount) const VULKAN_HPP_NOEXCEPT |
| { |
| VULKAN_HPP_ASSERT(getDispatcher()->vkResetQueryPoolEXT && "Function <vkResetQueryPoolEXT> needs extension <VK_EXT_host_query_reset> enabled!"); |
| |
| getDispatcher()->vkResetQueryPoolEXT(static_cast<VkDevice>(m_device), static_cast<VkQueryPool>(m_queryPool), firstQuery, queryCount); |
| } |
| |
| //=== VK_EXT_extended_dynamic_state === |
| |
| VULKAN_HPP_INLINE void CommandBuffer::setCullModeEXT(VULKAN_HPP_NAMESPACE::CullModeFlags cullMode) const VULKAN_HPP_NOEXCEPT |
| { |
| VULKAN_HPP_ASSERT(getDispatcher()->vkCmdSetCullModeEXT && "Function <vkCmdSetCullModeEXT> needs extension <VK_EXT_extended_dynamic_state> enabled!"); |
| |
| getDispatcher()->vkCmdSetCullModeEXT(static_cast<VkCommandBuffer>(m_commandBuffer), static_cast<VkCullModeFlags>(cullMode)); |
| } |
| |
| VULKAN_HPP_INLINE void CommandBuffer::setFrontFaceEXT(VULKAN_HPP_NAMESPACE::FrontFace frontFace) const VULKAN_HPP_NOEXCEPT |
| { |
| VULKAN_HPP_ASSERT(getDispatcher()->vkCmdSetFrontFaceEXT && "Function <vkCmdSetFrontFaceEXT> needs extension <VK_EXT_extended_dynamic_state> enabled!"); |
| |
| getDispatcher()->vkCmdSetFrontFaceEXT(static_cast<VkCommandBuffer>(m_commandBuffer), static_cast<VkFrontFace>(frontFace)); |
| } |
| |
| VULKAN_HPP_INLINE void CommandBuffer::setPrimitiveTopologyEXT(VULKAN_HPP_NAMESPACE::PrimitiveTopology primitiveTopology) const VULKAN_HPP_NOEXCEPT |
| { |
| VULKAN_HPP_ASSERT(getDispatcher()->vkCmdSetPrimitiveTopologyEXT && |
| "Function <vkCmdSetPrimitiveTopologyEXT> needs extension <VK_EXT_extended_dynamic_state> enabled!"); |
| |
| getDispatcher()->vkCmdSetPrimitiveTopologyEXT(static_cast<VkCommandBuffer>(m_commandBuffer), static_cast<VkPrimitiveTopology>(primitiveTopology)); |
| } |
| |
| VULKAN_HPP_INLINE void |
| CommandBuffer::setViewportWithCountEXT(ArrayProxy<const VULKAN_HPP_NAMESPACE::Viewport> const &viewports) const VULKAN_HPP_NOEXCEPT |
| { |
| VULKAN_HPP_ASSERT(getDispatcher()->vkCmdSetViewportWithCountEXT && |
| "Function <vkCmdSetViewportWithCountEXT> needs extension <VK_EXT_extended_dynamic_state> enabled!"); |
| |
| getDispatcher()->vkCmdSetViewportWithCountEXT( |
| static_cast<VkCommandBuffer>(m_commandBuffer), viewports.size(), reinterpret_cast<const VkViewport *>(viewports.data())); |
| } |
| |
| VULKAN_HPP_INLINE void CommandBuffer::setScissorWithCountEXT(ArrayProxy<const VULKAN_HPP_NAMESPACE::Rect2D> const &scissors) const VULKAN_HPP_NOEXCEPT |
| { |
| VULKAN_HPP_ASSERT(getDispatcher()->vkCmdSetScissorWithCountEXT && |
| "Function <vkCmdSetScissorWithCountEXT> needs extension <VK_EXT_extended_dynamic_state> enabled!"); |
| |
| getDispatcher()->vkCmdSetScissorWithCountEXT( |
| static_cast<VkCommandBuffer>(m_commandBuffer), scissors.size(), reinterpret_cast<const VkRect2D *>(scissors.data())); |
| } |
| |
| VULKAN_HPP_INLINE void CommandBuffer::bindVertexBuffers2EXT(uint32_t firstBinding, |
| ArrayProxy<const VULKAN_HPP_NAMESPACE::Buffer> const &buffers, |
| ArrayProxy<const VULKAN_HPP_NAMESPACE::DeviceSize> const &offsets, |
| ArrayProxy<const VULKAN_HPP_NAMESPACE::DeviceSize> const &sizes, |
| ArrayProxy<const VULKAN_HPP_NAMESPACE::DeviceSize> const &strides) const |
| { |
| VULKAN_HPP_ASSERT(getDispatcher()->vkCmdBindVertexBuffers2EXT && |
| "Function <vkCmdBindVertexBuffers2EXT> needs extension <VK_EXT_extended_dynamic_state> enabled!"); |
| |
| if(buffers.size() != offsets.size()) |
| { |
| throw LogicError(VULKAN_HPP_NAMESPACE_STRING "::CommandBuffer::bindVertexBuffers2EXT: buffers.size() != offsets.size()"); |
| } |
| if(!sizes.empty() && buffers.size() != sizes.size()) |
| { |
| throw LogicError(VULKAN_HPP_NAMESPACE_STRING "::CommandBuffer::bindVertexBuffers2EXT: buffers.size() != sizes.size()"); |
| } |
| if(!strides.empty() && buffers.size() != strides.size()) |
| { |
| throw LogicError(VULKAN_HPP_NAMESPACE_STRING "::CommandBuffer::bindVertexBuffers2EXT: buffers.size() != strides.size()"); |
| } |
| getDispatcher()->vkCmdBindVertexBuffers2EXT(static_cast<VkCommandBuffer>(m_commandBuffer), |
| firstBinding, |
| buffers.size(), |
| reinterpret_cast<const VkBuffer *>(buffers.data()), |
| reinterpret_cast<const VkDeviceSize *>(offsets.data()), |
| reinterpret_cast<const VkDeviceSize *>(sizes.data()), |
| reinterpret_cast<const VkDeviceSize *>(strides.data())); |
| } |
| |
| VULKAN_HPP_INLINE void CommandBuffer::setDepthTestEnableEXT(VULKAN_HPP_NAMESPACE::Bool32 depthTestEnable) const VULKAN_HPP_NOEXCEPT |
| { |
| VULKAN_HPP_ASSERT(getDispatcher()->vkCmdSetDepthTestEnableEXT && |
| "Function <vkCmdSetDepthTestEnableEXT> needs extension <VK_EXT_extended_dynamic_state> enabled!"); |
| |
| getDispatcher()->vkCmdSetDepthTestEnableEXT(static_cast<VkCommandBuffer>(m_commandBuffer), static_cast<VkBool32>(depthTestEnable)); |
| } |
| |
| VULKAN_HPP_INLINE void CommandBuffer::setDepthWriteEnableEXT(VULKAN_HPP_NAMESPACE::Bool32 depthWriteEnable) const VULKAN_HPP_NOEXCEPT |
| { |
| VULKAN_HPP_ASSERT(getDispatcher()->vkCmdSetDepthWriteEnableEXT && |
| "Function <vkCmdSetDepthWriteEnableEXT> needs extension <VK_EXT_extended_dynamic_state> enabled!"); |
| |
| getDispatcher()->vkCmdSetDepthWriteEnableEXT(static_cast<VkCommandBuffer>(m_commandBuffer), static_cast<VkBool32>(depthWriteEnable)); |
| } |
| |
| VULKAN_HPP_INLINE void CommandBuffer::setDepthCompareOpEXT(VULKAN_HPP_NAMESPACE::CompareOp depthCompareOp) const VULKAN_HPP_NOEXCEPT |
| { |
| VULKAN_HPP_ASSERT(getDispatcher()->vkCmdSetDepthCompareOpEXT && |
| "Function <vkCmdSetDepthCompareOpEXT> needs extension <VK_EXT_extended_dynamic_state> enabled!"); |
| |
| getDispatcher()->vkCmdSetDepthCompareOpEXT(static_cast<VkCommandBuffer>(m_commandBuffer), static_cast<VkCompareOp>(depthCompareOp)); |
| } |
| |
| VULKAN_HPP_INLINE void CommandBuffer::setDepthBoundsTestEnableEXT(VULKAN_HPP_NAMESPACE::Bool32 depthBoundsTestEnable) const VULKAN_HPP_NOEXCEPT |
| { |
| VULKAN_HPP_ASSERT(getDispatcher()->vkCmdSetDepthBoundsTestEnableEXT && |
| "Function <vkCmdSetDepthBoundsTestEnableEXT> needs extension <VK_EXT_extended_dynamic_state> enabled!"); |
| |
| getDispatcher()->vkCmdSetDepthBoundsTestEnableEXT(static_cast<VkCommandBuffer>(m_commandBuffer), static_cast<VkBool32>(depthBoundsTestEnable)); |
| } |
| |
| VULKAN_HPP_INLINE void CommandBuffer::setStencilTestEnableEXT(VULKAN_HPP_NAMESPACE::Bool32 stencilTestEnable) const VULKAN_HPP_NOEXCEPT |
| { |
| VULKAN_HPP_ASSERT(getDispatcher()->vkCmdSetStencilTestEnableEXT && |
| "Function <vkCmdSetStencilTestEnableEXT> needs extension <VK_EXT_extended_dynamic_state> enabled!"); |
| |
| getDispatcher()->vkCmdSetStencilTestEnableEXT(static_cast<VkCommandBuffer>(m_commandBuffer), static_cast<VkBool32>(stencilTestEnable)); |
| } |
| |
| VULKAN_HPP_INLINE void CommandBuffer::setStencilOpEXT(VULKAN_HPP_NAMESPACE::StencilFaceFlags faceMask, |
| VULKAN_HPP_NAMESPACE::StencilOp failOp, |
| VULKAN_HPP_NAMESPACE::StencilOp passOp, |
| VULKAN_HPP_NAMESPACE::StencilOp depthFailOp, |
| VULKAN_HPP_NAMESPACE::CompareOp compareOp) const VULKAN_HPP_NOEXCEPT |
| { |
| VULKAN_HPP_ASSERT(getDispatcher()->vkCmdSetStencilOpEXT && "Function <vkCmdSetStencilOpEXT> needs extension <VK_EXT_extended_dynamic_state> enabled!"); |
| |
| getDispatcher()->vkCmdSetStencilOpEXT(static_cast<VkCommandBuffer>(m_commandBuffer), |
| static_cast<VkStencilFaceFlags>(faceMask), |
| static_cast<VkStencilOp>(failOp), |
| static_cast<VkStencilOp>(passOp), |
| static_cast<VkStencilOp>(depthFailOp), |
| static_cast<VkCompareOp>(compareOp)); |
| } |
| |
| //=== VK_KHR_deferred_host_operations === |
| |
| VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE VULKAN_HPP_RAII_NAMESPACE::DeferredOperationKHR |
| Device::createDeferredOperationKHR(VULKAN_HPP_NAMESPACE::Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator) const |
| { |
| return VULKAN_HPP_RAII_NAMESPACE::DeferredOperationKHR(*this, allocator); |
| } |
| |
| VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE uint32_t DeferredOperationKHR::getMaxConcurrency() const VULKAN_HPP_NOEXCEPT |
| { |
| VULKAN_HPP_ASSERT(getDispatcher()->vkGetDeferredOperationMaxConcurrencyKHR && |
| "Function <vkGetDeferredOperationMaxConcurrencyKHR> needs extension <VK_KHR_deferred_host_operations> enabled!"); |
| |
| return getDispatcher()->vkGetDeferredOperationMaxConcurrencyKHR(static_cast<VkDevice>(m_device), static_cast<VkDeferredOperationKHR>(m_operation)); |
| } |
| |
| VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE VULKAN_HPP_NAMESPACE::Result DeferredOperationKHR::getResult() const VULKAN_HPP_NOEXCEPT |
| { |
| VULKAN_HPP_ASSERT(getDispatcher()->vkGetDeferredOperationResultKHR && |
| "Function <vkGetDeferredOperationResultKHR> needs extension <VK_KHR_deferred_host_operations> enabled!"); |
| |
| return static_cast<VULKAN_HPP_NAMESPACE::Result>( |
| getDispatcher()->vkGetDeferredOperationResultKHR(static_cast<VkDevice>(m_device), static_cast<VkDeferredOperationKHR>(m_operation))); |
| } |
| |
| VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE VULKAN_HPP_NAMESPACE::Result DeferredOperationKHR::join() const |
| { |
| VULKAN_HPP_ASSERT(getDispatcher()->vkDeferredOperationJoinKHR && |
| "Function <vkDeferredOperationJoinKHR> needs extension <VK_KHR_deferred_host_operations> enabled!"); |
| |
| VULKAN_HPP_NAMESPACE::Result result = static_cast<VULKAN_HPP_NAMESPACE::Result>( |
| getDispatcher()->vkDeferredOperationJoinKHR(static_cast<VkDevice>(m_device), static_cast<VkDeferredOperationKHR>(m_operation))); |
| if((result != VULKAN_HPP_NAMESPACE::Result::eSuccess) && (result != VULKAN_HPP_NAMESPACE::Result::eThreadDoneKHR) && |
| (result != VULKAN_HPP_NAMESPACE::Result::eThreadIdleKHR)) |
| { |
| throwResultException(result, VULKAN_HPP_NAMESPACE_STRING "::DeferredOperationKHR::join"); |
| } |
| return result; |
| } |
| |
| //=== VK_KHR_pipeline_executable_properties === |
| |
| VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE std::vector<VULKAN_HPP_NAMESPACE::PipelineExecutablePropertiesKHR> |
| Device::getPipelineExecutablePropertiesKHR(const VULKAN_HPP_NAMESPACE::PipelineInfoKHR &pipelineInfo) const |
| { |
| VULKAN_HPP_ASSERT(getDispatcher()->vkGetPipelineExecutablePropertiesKHR && |
| "Function <vkGetPipelineExecutablePropertiesKHR> needs extension <VK_KHR_pipeline_executable_properties> enabled!"); |
| |
| std::vector<VULKAN_HPP_NAMESPACE::PipelineExecutablePropertiesKHR> properties; |
| uint32_t executableCount; |
| VULKAN_HPP_NAMESPACE::Result result; |
| do |
| { |
| result = static_cast<VULKAN_HPP_NAMESPACE::Result>(getDispatcher()->vkGetPipelineExecutablePropertiesKHR( |
| static_cast<VkDevice>(m_device), reinterpret_cast<const VkPipelineInfoKHR *>(&pipelineInfo), &executableCount, nullptr)); |
| if((result == VULKAN_HPP_NAMESPACE::Result::eSuccess) && executableCount) |
| { |
| properties.resize(executableCount); |
| result = static_cast<VULKAN_HPP_NAMESPACE::Result>( |
| getDispatcher()->vkGetPipelineExecutablePropertiesKHR(static_cast<VkDevice>(m_device), |
| reinterpret_cast<const VkPipelineInfoKHR *>(&pipelineInfo), |
| &executableCount, |
| reinterpret_cast<VkPipelineExecutablePropertiesKHR *>(properties.data()))); |
| } |
| } while(result == VULKAN_HPP_NAMESPACE::Result::eIncomplete); |
| if(result != VULKAN_HPP_NAMESPACE::Result::eSuccess) |
| { |
| throwResultException(result, VULKAN_HPP_NAMESPACE_STRING "::Device::getPipelineExecutablePropertiesKHR"); |
| } |
| if(result == VULKAN_HPP_NAMESPACE::Result::eSuccess) |
| { |
| VULKAN_HPP_ASSERT(executableCount <= properties.size()); |
| if(executableCount < properties.size()) |
| { |
| properties.resize(executableCount); |
| } |
| } |
| return properties; |
| } |
| |
| VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE std::vector<VULKAN_HPP_NAMESPACE::PipelineExecutableStatisticKHR> |
| Device::getPipelineExecutableStatisticsKHR(const VULKAN_HPP_NAMESPACE::PipelineExecutableInfoKHR &executableInfo) const |
| { |
| VULKAN_HPP_ASSERT(getDispatcher()->vkGetPipelineExecutableStatisticsKHR && |
| "Function <vkGetPipelineExecutableStatisticsKHR> needs extension <VK_KHR_pipeline_executable_properties> enabled!"); |
| |
| std::vector<VULKAN_HPP_NAMESPACE::PipelineExecutableStatisticKHR> statistics; |
| uint32_t statisticCount; |
| VULKAN_HPP_NAMESPACE::Result result; |
| do |
| { |
| result = static_cast<VULKAN_HPP_NAMESPACE::Result>(getDispatcher()->vkGetPipelineExecutableStatisticsKHR( |
| static_cast<VkDevice>(m_device), reinterpret_cast<const VkPipelineExecutableInfoKHR *>(&executableInfo), &statisticCount, nullptr)); |
| if((result == VULKAN_HPP_NAMESPACE::Result::eSuccess) && statisticCount) |
| { |
| statistics.resize(statisticCount); |
| result = static_cast<VULKAN_HPP_NAMESPACE::Result>( |
| getDispatcher()->vkGetPipelineExecutableStatisticsKHR(static_cast<VkDevice>(m_device), |
| reinterpret_cast<const VkPipelineExecutableInfoKHR *>(&executableInfo), |
| &statisticCount, |
| reinterpret_cast<VkPipelineExecutableStatisticKHR *>(statistics.data()))); |
| } |
| } while(result == VULKAN_HPP_NAMESPACE::Result::eIncomplete); |
| if(result != VULKAN_HPP_NAMESPACE::Result::eSuccess) |
| { |
| throwResultException(result, VULKAN_HPP_NAMESPACE_STRING "::Device::getPipelineExecutableStatisticsKHR"); |
| } |
| if(result == VULKAN_HPP_NAMESPACE::Result::eSuccess) |
| { |
| VULKAN_HPP_ASSERT(statisticCount <= statistics.size()); |
| if(statisticCount < statistics.size()) |
| { |
| statistics.resize(statisticCount); |
| } |
| } |
| return statistics; |
| } |
| |
| VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE std::vector<VULKAN_HPP_NAMESPACE::PipelineExecutableInternalRepresentationKHR> |
| Device::getPipelineExecutableInternalRepresentationsKHR(const VULKAN_HPP_NAMESPACE::PipelineExecutableInfoKHR &executableInfo) const |
| { |
| VULKAN_HPP_ASSERT(getDispatcher()->vkGetPipelineExecutableInternalRepresentationsKHR && |
| "Function <vkGetPipelineExecutableInternalRepresentationsKHR> needs extension <VK_KHR_pipeline_executable_properties> enabled!"); |
| |
| std::vector<VULKAN_HPP_NAMESPACE::PipelineExecutableInternalRepresentationKHR> internalRepresentations; |
| uint32_t internalRepresentationCount; |
| VULKAN_HPP_NAMESPACE::Result result; |
| do |
| { |
| result = static_cast<VULKAN_HPP_NAMESPACE::Result>( |
| getDispatcher()->vkGetPipelineExecutableInternalRepresentationsKHR(static_cast<VkDevice>(m_device), |
| reinterpret_cast<const VkPipelineExecutableInfoKHR *>(&executableInfo), |
| &internalRepresentationCount, |
| nullptr)); |
| if((result == VULKAN_HPP_NAMESPACE::Result::eSuccess) && internalRepresentationCount) |
| { |
| internalRepresentations.resize(internalRepresentationCount); |
| result = static_cast<VULKAN_HPP_NAMESPACE::Result>(getDispatcher()->vkGetPipelineExecutableInternalRepresentationsKHR( |
| static_cast<VkDevice>(m_device), |
| reinterpret_cast<const VkPipelineExecutableInfoKHR *>(&executableInfo), |
| &internalRepresentationCount, |
| reinterpret_cast<VkPipelineExecutableInternalRepresentationKHR *>(internalRepresentations.data()))); |
| } |
| } while(result == VULKAN_HPP_NAMESPACE::Result::eIncomplete); |
| if(result != VULKAN_HPP_NAMESPACE::Result::eSuccess) |
| { |
| throwResultException(result, VULKAN_HPP_NAMESPACE_STRING "::Device::getPipelineExecutableInternalRepresentationsKHR"); |
| } |
| if(result == VULKAN_HPP_NAMESPACE::Result::eSuccess) |
| { |
| VULKAN_HPP_ASSERT(internalRepresentationCount <= internalRepresentations.size()); |
| if(internalRepresentationCount < internalRepresentations.size()) |
| { |
| internalRepresentations.resize(internalRepresentationCount); |
| } |
| } |
| return internalRepresentations; |
| } |
| |
| //=== VK_NV_device_generated_commands === |
| |
| VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE VULKAN_HPP_NAMESPACE::MemoryRequirements2 |
| Device::getGeneratedCommandsMemoryRequirementsNV(const VULKAN_HPP_NAMESPACE::GeneratedCommandsMemoryRequirementsInfoNV &info) const VULKAN_HPP_NOEXCEPT |
| { |
| VULKAN_HPP_ASSERT(getDispatcher()->vkGetGeneratedCommandsMemoryRequirementsNV && |
| "Function <vkGetGeneratedCommandsMemoryRequirementsNV> needs extension <VK_NV_device_generated_commands> enabled!"); |
| |
| VULKAN_HPP_NAMESPACE::MemoryRequirements2 memoryRequirements; |
| getDispatcher()->vkGetGeneratedCommandsMemoryRequirementsNV(static_cast<VkDevice>(m_device), |
| reinterpret_cast<const VkGeneratedCommandsMemoryRequirementsInfoNV *>(&info), |
| reinterpret_cast<VkMemoryRequirements2 *>(&memoryRequirements)); |
| return memoryRequirements; |
| } |
| |
| template<typename X, typename Y, typename... Z> |
| VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE StructureChain<X, Y, Z...> |
| Device::getGeneratedCommandsMemoryRequirementsNV(const VULKAN_HPP_NAMESPACE::GeneratedCommandsMemoryRequirementsInfoNV &info) const VULKAN_HPP_NOEXCEPT |
| { |
| VULKAN_HPP_ASSERT(getDispatcher()->vkGetGeneratedCommandsMemoryRequirementsNV && |
| "Function <vkGetGeneratedCommandsMemoryRequirementsNV> needs extension <VK_NV_device_generated_commands> enabled!"); |
| |
| StructureChain<X, Y, Z...> structureChain; |
| VULKAN_HPP_NAMESPACE::MemoryRequirements2 &memoryRequirements = structureChain.template get<VULKAN_HPP_NAMESPACE::MemoryRequirements2>(); |
| getDispatcher()->vkGetGeneratedCommandsMemoryRequirementsNV(static_cast<VkDevice>(m_device), |
| reinterpret_cast<const VkGeneratedCommandsMemoryRequirementsInfoNV *>(&info), |
| reinterpret_cast<VkMemoryRequirements2 *>(&memoryRequirements)); |
| return structureChain; |
| } |
| |
| VULKAN_HPP_INLINE void |
| CommandBuffer::preprocessGeneratedCommandsNV(const VULKAN_HPP_NAMESPACE::GeneratedCommandsInfoNV &generatedCommandsInfo) const VULKAN_HPP_NOEXCEPT |
| { |
| VULKAN_HPP_ASSERT(getDispatcher()->vkCmdPreprocessGeneratedCommandsNV && |
| "Function <vkCmdPreprocessGeneratedCommandsNV> needs extension <VK_NV_device_generated_commands> enabled!"); |
| |
| getDispatcher()->vkCmdPreprocessGeneratedCommandsNV(static_cast<VkCommandBuffer>(m_commandBuffer), |
| reinterpret_cast<const VkGeneratedCommandsInfoNV *>(&generatedCommandsInfo)); |
| } |
| |
| VULKAN_HPP_INLINE void |
| CommandBuffer::executeGeneratedCommandsNV(VULKAN_HPP_NAMESPACE::Bool32 isPreprocessed, |
| const VULKAN_HPP_NAMESPACE::GeneratedCommandsInfoNV &generatedCommandsInfo) const VULKAN_HPP_NOEXCEPT |
| { |
| VULKAN_HPP_ASSERT(getDispatcher()->vkCmdExecuteGeneratedCommandsNV && |
| "Function <vkCmdExecuteGeneratedCommandsNV> needs extension <VK_NV_device_generated_commands> enabled!"); |
| |
| getDispatcher()->vkCmdExecuteGeneratedCommandsNV(static_cast<VkCommandBuffer>(m_commandBuffer), |
| static_cast<VkBool32>(isPreprocessed), |
| reinterpret_cast<const VkGeneratedCommandsInfoNV *>(&generatedCommandsInfo)); |
| } |
| |
| VULKAN_HPP_INLINE void CommandBuffer::bindPipelineShaderGroupNV(VULKAN_HPP_NAMESPACE::PipelineBindPoint pipelineBindPoint, |
| VULKAN_HPP_NAMESPACE::Pipeline pipeline, |
| uint32_t groupIndex) const VULKAN_HPP_NOEXCEPT |
| { |
| VULKAN_HPP_ASSERT(getDispatcher()->vkCmdBindPipelineShaderGroupNV && |
| "Function <vkCmdBindPipelineShaderGroupNV> needs extension <VK_NV_device_generated_commands> enabled!"); |
| |
| getDispatcher()->vkCmdBindPipelineShaderGroupNV(static_cast<VkCommandBuffer>(m_commandBuffer), |
| static_cast<VkPipelineBindPoint>(pipelineBindPoint), |
| static_cast<VkPipeline>(pipeline), |
| groupIndex); |
| } |
| |
| VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE VULKAN_HPP_RAII_NAMESPACE::IndirectCommandsLayoutNV |
| Device::createIndirectCommandsLayoutNV(VULKAN_HPP_NAMESPACE::IndirectCommandsLayoutCreateInfoNV const &createInfo, |
| VULKAN_HPP_NAMESPACE::Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator) const |
| { |
| return VULKAN_HPP_RAII_NAMESPACE::IndirectCommandsLayoutNV(*this, createInfo, allocator); |
| } |
| |
| //=== VK_EXT_acquire_drm_display === |
| |
| VULKAN_HPP_INLINE void PhysicalDevice::acquireDrmDisplayEXT(int32_t drmFd, VULKAN_HPP_NAMESPACE::DisplayKHR display) const |
| { |
| VULKAN_HPP_ASSERT(getDispatcher()->vkAcquireDrmDisplayEXT && "Function <vkAcquireDrmDisplayEXT> needs extension <VK_EXT_acquire_drm_display> enabled!"); |
| |
| VULKAN_HPP_NAMESPACE::Result result = static_cast<VULKAN_HPP_NAMESPACE::Result>( |
| getDispatcher()->vkAcquireDrmDisplayEXT(static_cast<VkPhysicalDevice>(m_physicalDevice), drmFd, static_cast<VkDisplayKHR>(display))); |
| if(result != VULKAN_HPP_NAMESPACE::Result::eSuccess) |
| { |
| throwResultException(result, VULKAN_HPP_NAMESPACE_STRING "::PhysicalDevice::acquireDrmDisplayEXT"); |
| } |
| } |
| |
| VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE VULKAN_HPP_RAII_NAMESPACE::DisplayKHR PhysicalDevice::getDrmDisplayEXT(int32_t drmFd, uint32_t connectorId) const |
| { |
| return VULKAN_HPP_RAII_NAMESPACE::DisplayKHR(*this, drmFd, connectorId); |
| } |
| |
| //=== VK_EXT_private_data === |
| |
| VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE VULKAN_HPP_RAII_NAMESPACE::PrivateDataSlot |
| Device::createPrivateDataSlotEXT(VULKAN_HPP_NAMESPACE::PrivateDataSlotCreateInfo const &createInfo, |
| VULKAN_HPP_NAMESPACE::Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator) const |
| { |
| return VULKAN_HPP_RAII_NAMESPACE::PrivateDataSlot(*this, createInfo, allocator); |
| } |
| |
| VULKAN_HPP_INLINE void Device::destroyPrivateDataSlotEXT(VULKAN_HPP_NAMESPACE::PrivateDataSlot privateDataSlot, |
| Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator) const VULKAN_HPP_NOEXCEPT |
| { |
| VULKAN_HPP_ASSERT(getDispatcher()->vkDestroyPrivateDataSlotEXT && |
| "Function <vkDestroyPrivateDataSlotEXT> needs extension <VK_EXT_private_data> enabled!"); |
| |
| getDispatcher()->vkDestroyPrivateDataSlotEXT( |
| static_cast<VkDevice>(m_device), |
| static_cast<VkPrivateDataSlot>(privateDataSlot), |
| reinterpret_cast<const VkAllocationCallbacks *>(static_cast<const VULKAN_HPP_NAMESPACE::AllocationCallbacks *>(allocator))); |
| } |
| |
| VULKAN_HPP_INLINE void Device::setPrivateDataEXT(VULKAN_HPP_NAMESPACE::ObjectType objectType_, |
| uint64_t objectHandle, |
| VULKAN_HPP_NAMESPACE::PrivateDataSlot privateDataSlot, |
| uint64_t data) const |
| { |
| VULKAN_HPP_ASSERT(getDispatcher()->vkSetPrivateDataEXT && "Function <vkSetPrivateDataEXT> needs extension <VK_EXT_private_data> enabled!"); |
| |
| VULKAN_HPP_NAMESPACE::Result result = static_cast<VULKAN_HPP_NAMESPACE::Result>(getDispatcher()->vkSetPrivateDataEXT( |
| static_cast<VkDevice>(m_device), static_cast<VkObjectType>(objectType_), objectHandle, static_cast<VkPrivateDataSlot>(privateDataSlot), data)); |
| if(result != VULKAN_HPP_NAMESPACE::Result::eSuccess) |
| { |
| throwResultException(result, VULKAN_HPP_NAMESPACE_STRING "::Device::setPrivateDataEXT"); |
| } |
| } |
| |
| VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE uint64_t Device::getPrivateDataEXT(VULKAN_HPP_NAMESPACE::ObjectType objectType_, |
| uint64_t objectHandle, |
| VULKAN_HPP_NAMESPACE::PrivateDataSlot privateDataSlot) const VULKAN_HPP_NOEXCEPT |
| { |
| VULKAN_HPP_ASSERT(getDispatcher()->vkGetPrivateDataEXT && "Function <vkGetPrivateDataEXT> needs extension <VK_EXT_private_data> enabled!"); |
| |
| uint64_t data; |
| getDispatcher()->vkGetPrivateDataEXT( |
| static_cast<VkDevice>(m_device), static_cast<VkObjectType>(objectType_), objectHandle, static_cast<VkPrivateDataSlot>(privateDataSlot), &data); |
| return data; |
| } |
| |
| # if defined(VK_ENABLE_BETA_EXTENSIONS) |
| //=== VK_KHR_video_encode_queue === |
| |
| VULKAN_HPP_INLINE void CommandBuffer::encodeVideoKHR(const VULKAN_HPP_NAMESPACE::VideoEncodeInfoKHR &encodeInfo) const VULKAN_HPP_NOEXCEPT |
| { |
| VULKAN_HPP_ASSERT(getDispatcher()->vkCmdEncodeVideoKHR && "Function <vkCmdEncodeVideoKHR> needs extension <VK_KHR_video_encode_queue> enabled!"); |
| |
| getDispatcher()->vkCmdEncodeVideoKHR(static_cast<VkCommandBuffer>(m_commandBuffer), reinterpret_cast<const VkVideoEncodeInfoKHR *>(&encodeInfo)); |
| } |
| # endif /*VK_ENABLE_BETA_EXTENSIONS*/ |
| |
| //=== VK_KHR_synchronization2 === |
| |
| VULKAN_HPP_INLINE void CommandBuffer::setEvent2KHR(VULKAN_HPP_NAMESPACE::Event event, |
| const VULKAN_HPP_NAMESPACE::DependencyInfo &dependencyInfo) const VULKAN_HPP_NOEXCEPT |
| { |
| VULKAN_HPP_ASSERT(getDispatcher()->vkCmdSetEvent2KHR && "Function <vkCmdSetEvent2KHR> needs extension <VK_KHR_synchronization2> enabled!"); |
| |
| getDispatcher()->vkCmdSetEvent2KHR( |
| static_cast<VkCommandBuffer>(m_commandBuffer), static_cast<VkEvent>(event), reinterpret_cast<const VkDependencyInfo *>(&dependencyInfo)); |
| } |
| |
| VULKAN_HPP_INLINE void CommandBuffer::resetEvent2KHR(VULKAN_HPP_NAMESPACE::Event event, |
| VULKAN_HPP_NAMESPACE::PipelineStageFlags2 stageMask) const VULKAN_HPP_NOEXCEPT |
| { |
| VULKAN_HPP_ASSERT(getDispatcher()->vkCmdResetEvent2KHR && "Function <vkCmdResetEvent2KHR> needs extension <VK_KHR_synchronization2> enabled!"); |
| |
| getDispatcher()->vkCmdResetEvent2KHR( |
| static_cast<VkCommandBuffer>(m_commandBuffer), static_cast<VkEvent>(event), static_cast<VkPipelineStageFlags2>(stageMask)); |
| } |
| |
| VULKAN_HPP_INLINE void CommandBuffer::waitEvents2KHR(ArrayProxy<const VULKAN_HPP_NAMESPACE::Event> const &events, |
| ArrayProxy<const VULKAN_HPP_NAMESPACE::DependencyInfo> const &dependencyInfos) const |
| { |
| VULKAN_HPP_ASSERT(getDispatcher()->vkCmdWaitEvents2KHR && "Function <vkCmdWaitEvents2KHR> needs extension <VK_KHR_synchronization2> enabled!"); |
| |
| if(events.size() != dependencyInfos.size()) |
| { |
| throw LogicError(VULKAN_HPP_NAMESPACE_STRING "::CommandBuffer::waitEvents2KHR: events.size() != dependencyInfos.size()"); |
| } |
| getDispatcher()->vkCmdWaitEvents2KHR(static_cast<VkCommandBuffer>(m_commandBuffer), |
| events.size(), |
| reinterpret_cast<const VkEvent *>(events.data()), |
| reinterpret_cast<const VkDependencyInfo *>(dependencyInfos.data())); |
| } |
| |
| VULKAN_HPP_INLINE void CommandBuffer::pipelineBarrier2KHR(const VULKAN_HPP_NAMESPACE::DependencyInfo &dependencyInfo) const VULKAN_HPP_NOEXCEPT |
| { |
| VULKAN_HPP_ASSERT(getDispatcher()->vkCmdPipelineBarrier2KHR && |
| "Function <vkCmdPipelineBarrier2KHR> needs extension <VK_KHR_synchronization2> enabled!"); |
| |
| getDispatcher()->vkCmdPipelineBarrier2KHR(static_cast<VkCommandBuffer>(m_commandBuffer), |
| reinterpret_cast<const VkDependencyInfo *>(&dependencyInfo)); |
| } |
| |
| VULKAN_HPP_INLINE void CommandBuffer::writeTimestamp2KHR(VULKAN_HPP_NAMESPACE::PipelineStageFlags2 stage, |
| VULKAN_HPP_NAMESPACE::QueryPool queryPool, |
| uint32_t query) const VULKAN_HPP_NOEXCEPT |
| { |
| VULKAN_HPP_ASSERT(getDispatcher()->vkCmdWriteTimestamp2KHR && "Function <vkCmdWriteTimestamp2KHR> needs extension <VK_KHR_synchronization2> enabled!"); |
| |
| getDispatcher()->vkCmdWriteTimestamp2KHR( |
| static_cast<VkCommandBuffer>(m_commandBuffer), static_cast<VkPipelineStageFlags2>(stage), static_cast<VkQueryPool>(queryPool), query); |
| } |
| |
| VULKAN_HPP_INLINE void Queue::submit2KHR(ArrayProxy<const VULKAN_HPP_NAMESPACE::SubmitInfo2> const &submits, VULKAN_HPP_NAMESPACE::Fence fence) const |
| { |
| VULKAN_HPP_ASSERT(getDispatcher()->vkQueueSubmit2KHR && "Function <vkQueueSubmit2KHR> needs extension <VK_KHR_synchronization2> enabled!"); |
| |
| VULKAN_HPP_NAMESPACE::Result result = static_cast<VULKAN_HPP_NAMESPACE::Result>(getDispatcher()->vkQueueSubmit2KHR( |
| static_cast<VkQueue>(m_queue), submits.size(), reinterpret_cast<const VkSubmitInfo2 *>(submits.data()), static_cast<VkFence>(fence))); |
| if(result != VULKAN_HPP_NAMESPACE::Result::eSuccess) |
| { |
| throwResultException(result, VULKAN_HPP_NAMESPACE_STRING "::Queue::submit2KHR"); |
| } |
| } |
| |
| VULKAN_HPP_INLINE void CommandBuffer::writeBufferMarker2AMD(VULKAN_HPP_NAMESPACE::PipelineStageFlags2 stage, |
| VULKAN_HPP_NAMESPACE::Buffer dstBuffer, |
| VULKAN_HPP_NAMESPACE::DeviceSize dstOffset, |
| uint32_t marker) const VULKAN_HPP_NOEXCEPT |
| { |
| VULKAN_HPP_ASSERT(getDispatcher()->vkCmdWriteBufferMarker2AMD && |
| "Function <vkCmdWriteBufferMarker2AMD> needs extension <VK_KHR_synchronization2> enabled!"); |
| |
| getDispatcher()->vkCmdWriteBufferMarker2AMD(static_cast<VkCommandBuffer>(m_commandBuffer), |
| static_cast<VkPipelineStageFlags2>(stage), |
| static_cast<VkBuffer>(dstBuffer), |
| static_cast<VkDeviceSize>(dstOffset), |
| marker); |
| } |
| |
| VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE std::vector<VULKAN_HPP_NAMESPACE::CheckpointData2NV> Queue::getCheckpointData2NV() const VULKAN_HPP_NOEXCEPT |
| { |
| VULKAN_HPP_ASSERT(getDispatcher()->vkGetQueueCheckpointData2NV && |
| "Function <vkGetQueueCheckpointData2NV> needs extension <VK_KHR_synchronization2> enabled!"); |
| |
| uint32_t checkpointDataCount; |
| getDispatcher()->vkGetQueueCheckpointData2NV(static_cast<VkQueue>(m_queue), &checkpointDataCount, nullptr); |
| std::vector<VULKAN_HPP_NAMESPACE::CheckpointData2NV> checkpointData(checkpointDataCount); |
| getDispatcher()->vkGetQueueCheckpointData2NV( |
| static_cast<VkQueue>(m_queue), &checkpointDataCount, reinterpret_cast<VkCheckpointData2NV *>(checkpointData.data())); |
| VULKAN_HPP_ASSERT(checkpointDataCount == checkpointData.size()); |
| return checkpointData; |
| } |
| |
| //=== VK_NV_fragment_shading_rate_enums === |
| |
| VULKAN_HPP_INLINE void |
| CommandBuffer::setFragmentShadingRateEnumNV(VULKAN_HPP_NAMESPACE::FragmentShadingRateNV shadingRate, |
| const VULKAN_HPP_NAMESPACE::FragmentShadingRateCombinerOpKHR combinerOps[2]) const VULKAN_HPP_NOEXCEPT |
| { |
| VULKAN_HPP_ASSERT(getDispatcher()->vkCmdSetFragmentShadingRateEnumNV && |
| "Function <vkCmdSetFragmentShadingRateEnumNV> needs extension <VK_NV_fragment_shading_rate_enums> enabled!"); |
| |
| getDispatcher()->vkCmdSetFragmentShadingRateEnumNV(static_cast<VkCommandBuffer>(m_commandBuffer), |
| static_cast<VkFragmentShadingRateNV>(shadingRate), |
| reinterpret_cast<const VkFragmentShadingRateCombinerOpKHR *>(combinerOps)); |
| } |
| |
| //=== VK_KHR_copy_commands2 === |
| |
| VULKAN_HPP_INLINE void CommandBuffer::copyBuffer2KHR(const VULKAN_HPP_NAMESPACE::CopyBufferInfo2 ©BufferInfo) const VULKAN_HPP_NOEXCEPT |
| { |
| VULKAN_HPP_ASSERT(getDispatcher()->vkCmdCopyBuffer2KHR && "Function <vkCmdCopyBuffer2KHR> needs extension <VK_KHR_copy_commands2> enabled!"); |
| |
| getDispatcher()->vkCmdCopyBuffer2KHR(static_cast<VkCommandBuffer>(m_commandBuffer), reinterpret_cast<const VkCopyBufferInfo2 *>(©BufferInfo)); |
| } |
| |
| VULKAN_HPP_INLINE void CommandBuffer::copyImage2KHR(const VULKAN_HPP_NAMESPACE::CopyImageInfo2 ©ImageInfo) const VULKAN_HPP_NOEXCEPT |
| { |
| VULKAN_HPP_ASSERT(getDispatcher()->vkCmdCopyImage2KHR && "Function <vkCmdCopyImage2KHR> needs extension <VK_KHR_copy_commands2> enabled!"); |
| |
| getDispatcher()->vkCmdCopyImage2KHR(static_cast<VkCommandBuffer>(m_commandBuffer), reinterpret_cast<const VkCopyImageInfo2 *>(©ImageInfo)); |
| } |
| |
| VULKAN_HPP_INLINE void |
| CommandBuffer::copyBufferToImage2KHR(const VULKAN_HPP_NAMESPACE::CopyBufferToImageInfo2 ©BufferToImageInfo) const VULKAN_HPP_NOEXCEPT |
| { |
| VULKAN_HPP_ASSERT(getDispatcher()->vkCmdCopyBufferToImage2KHR && |
| "Function <vkCmdCopyBufferToImage2KHR> needs extension <VK_KHR_copy_commands2> enabled!"); |
| |
| getDispatcher()->vkCmdCopyBufferToImage2KHR(static_cast<VkCommandBuffer>(m_commandBuffer), |
| reinterpret_cast<const VkCopyBufferToImageInfo2 *>(©BufferToImageInfo)); |
| } |
| |
| VULKAN_HPP_INLINE void |
| CommandBuffer::copyImageToBuffer2KHR(const VULKAN_HPP_NAMESPACE::CopyImageToBufferInfo2 ©ImageToBufferInfo) const VULKAN_HPP_NOEXCEPT |
| { |
| VULKAN_HPP_ASSERT(getDispatcher()->vkCmdCopyImageToBuffer2KHR && |
| "Function <vkCmdCopyImageToBuffer2KHR> needs extension <VK_KHR_copy_commands2> enabled!"); |
| |
| getDispatcher()->vkCmdCopyImageToBuffer2KHR(static_cast<VkCommandBuffer>(m_commandBuffer), |
| reinterpret_cast<const VkCopyImageToBufferInfo2 *>(©ImageToBufferInfo)); |
| } |
| |
| VULKAN_HPP_INLINE void CommandBuffer::blitImage2KHR(const VULKAN_HPP_NAMESPACE::BlitImageInfo2 &blitImageInfo) const VULKAN_HPP_NOEXCEPT |
| { |
| VULKAN_HPP_ASSERT(getDispatcher()->vkCmdBlitImage2KHR && "Function <vkCmdBlitImage2KHR> needs extension <VK_KHR_copy_commands2> enabled!"); |
| |
| getDispatcher()->vkCmdBlitImage2KHR(static_cast<VkCommandBuffer>(m_commandBuffer), reinterpret_cast<const VkBlitImageInfo2 *>(&blitImageInfo)); |
| } |
| |
| VULKAN_HPP_INLINE void CommandBuffer::resolveImage2KHR(const VULKAN_HPP_NAMESPACE::ResolveImageInfo2 &resolveImageInfo) const VULKAN_HPP_NOEXCEPT |
| { |
| VULKAN_HPP_ASSERT(getDispatcher()->vkCmdResolveImage2KHR && "Function <vkCmdResolveImage2KHR> needs extension <VK_KHR_copy_commands2> enabled!"); |
| |
| getDispatcher()->vkCmdResolveImage2KHR(static_cast<VkCommandBuffer>(m_commandBuffer), |
| reinterpret_cast<const VkResolveImageInfo2 *>(&resolveImageInfo)); |
| } |
| |
| # if defined(VK_USE_PLATFORM_WIN32_KHR) |
| //=== VK_NV_acquire_winrt_display === |
| |
| VULKAN_HPP_INLINE void DisplayKHR::acquireWinrtNV() const |
| { |
| VULKAN_HPP_ASSERT(getDispatcher()->vkAcquireWinrtDisplayNV && |
| "Function <vkAcquireWinrtDisplayNV> needs extension <VK_NV_acquire_winrt_display> enabled!"); |
| |
| VULKAN_HPP_NAMESPACE::Result result = static_cast<VULKAN_HPP_NAMESPACE::Result>( |
| getDispatcher()->vkAcquireWinrtDisplayNV(static_cast<VkPhysicalDevice>(m_physicalDevice), static_cast<VkDisplayKHR>(m_display))); |
| if(result != VULKAN_HPP_NAMESPACE::Result::eSuccess) |
| { |
| throwResultException(result, VULKAN_HPP_NAMESPACE_STRING "::DisplayKHR::acquireWinrtNV"); |
| } |
| } |
| |
| VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE VULKAN_HPP_RAII_NAMESPACE::DisplayKHR PhysicalDevice::getWinrtDisplayNV(uint32_t deviceRelativeId) const |
| { |
| return VULKAN_HPP_RAII_NAMESPACE::DisplayKHR(*this, deviceRelativeId); |
| } |
| # endif /*VK_USE_PLATFORM_WIN32_KHR*/ |
| |
| # if defined(VK_USE_PLATFORM_DIRECTFB_EXT) |
| //=== VK_EXT_directfb_surface === |
| |
| VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE VULKAN_HPP_RAII_NAMESPACE::SurfaceKHR |
| Instance::createDirectFBSurfaceEXT(VULKAN_HPP_NAMESPACE::DirectFBSurfaceCreateInfoEXT const &createInfo, |
| VULKAN_HPP_NAMESPACE::Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator) const |
| { |
| return VULKAN_HPP_RAII_NAMESPACE::SurfaceKHR(*this, createInfo, allocator); |
| } |
| |
| VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE VULKAN_HPP_NAMESPACE::Bool32 |
| PhysicalDevice::getDirectFBPresentationSupportEXT(uint32_t queueFamilyIndex, IDirectFB &dfb) const VULKAN_HPP_NOEXCEPT |
| { |
| VULKAN_HPP_ASSERT(getDispatcher()->vkGetPhysicalDeviceDirectFBPresentationSupportEXT && |
| "Function <vkGetPhysicalDeviceDirectFBPresentationSupportEXT> needs extension <VK_EXT_directfb_surface> enabled!"); |
| |
| return static_cast<VULKAN_HPP_NAMESPACE::Bool32>( |
| getDispatcher()->vkGetPhysicalDeviceDirectFBPresentationSupportEXT(static_cast<VkPhysicalDevice>(m_physicalDevice), queueFamilyIndex, &dfb)); |
| } |
| # endif /*VK_USE_PLATFORM_DIRECTFB_EXT*/ |
| |
| //=== VK_KHR_ray_tracing_pipeline === |
| |
| VULKAN_HPP_INLINE void CommandBuffer::traceRaysKHR(const VULKAN_HPP_NAMESPACE::StridedDeviceAddressRegionKHR &raygenShaderBindingTable, |
| const VULKAN_HPP_NAMESPACE::StridedDeviceAddressRegionKHR &missShaderBindingTable, |
| const VULKAN_HPP_NAMESPACE::StridedDeviceAddressRegionKHR &hitShaderBindingTable, |
| const VULKAN_HPP_NAMESPACE::StridedDeviceAddressRegionKHR &callableShaderBindingTable, |
| uint32_t width, |
| uint32_t height, |
| uint32_t depth) const VULKAN_HPP_NOEXCEPT |
| { |
| VULKAN_HPP_ASSERT(getDispatcher()->vkCmdTraceRaysKHR && "Function <vkCmdTraceRaysKHR> needs extension <VK_KHR_ray_tracing_pipeline> enabled!"); |
| |
| getDispatcher()->vkCmdTraceRaysKHR(static_cast<VkCommandBuffer>(m_commandBuffer), |
| reinterpret_cast<const VkStridedDeviceAddressRegionKHR *>(&raygenShaderBindingTable), |
| reinterpret_cast<const VkStridedDeviceAddressRegionKHR *>(&missShaderBindingTable), |
| reinterpret_cast<const VkStridedDeviceAddressRegionKHR *>(&hitShaderBindingTable), |
| reinterpret_cast<const VkStridedDeviceAddressRegionKHR *>(&callableShaderBindingTable), |
| width, |
| height, |
| depth); |
| } |
| |
| VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE std::vector<VULKAN_HPP_RAII_NAMESPACE::Pipeline> Device::createRayTracingPipelinesKHR( |
| VULKAN_HPP_NAMESPACE::Optional<const VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::DeferredOperationKHR> const &deferredOperation, |
| VULKAN_HPP_NAMESPACE::Optional<const VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::PipelineCache> const &pipelineCache, |
| VULKAN_HPP_NAMESPACE::ArrayProxy<VULKAN_HPP_NAMESPACE::RayTracingPipelineCreateInfoKHR> const &createInfos, |
| VULKAN_HPP_NAMESPACE::Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator) const |
| { |
| return VULKAN_HPP_RAII_NAMESPACE::Pipelines(*this, deferredOperation, pipelineCache, createInfos, allocator); |
| } |
| |
| VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE VULKAN_HPP_RAII_NAMESPACE::Pipeline Device::createRayTracingPipelineKHR( |
| VULKAN_HPP_NAMESPACE::Optional<const VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::DeferredOperationKHR> const &deferredOperation, |
| VULKAN_HPP_NAMESPACE::Optional<const VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::PipelineCache> const &pipelineCache, |
| VULKAN_HPP_NAMESPACE::RayTracingPipelineCreateInfoKHR const &createInfo, |
| VULKAN_HPP_NAMESPACE::Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator) const |
| { |
| return VULKAN_HPP_RAII_NAMESPACE::Pipeline(*this, deferredOperation, pipelineCache, createInfo, allocator); |
| } |
| |
| template<typename DataType> |
| VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE std::vector<DataType> |
| Pipeline::getRayTracingShaderGroupHandlesKHR(uint32_t firstGroup, uint32_t groupCount, size_t dataSize) const |
| { |
| VULKAN_HPP_ASSERT(getDispatcher()->vkGetRayTracingShaderGroupHandlesKHR && |
| "Function <vkGetRayTracingShaderGroupHandlesKHR> needs extension <VK_KHR_ray_tracing_pipeline> enabled!"); |
| |
| VULKAN_HPP_ASSERT(dataSize % sizeof(DataType) == 0); |
| std::vector<DataType> data(dataSize / sizeof(DataType)); |
| Result result = static_cast<Result>(getDispatcher()->vkGetRayTracingShaderGroupHandlesKHR(static_cast<VkDevice>(m_device), |
| static_cast<VkPipeline>(m_pipeline), |
| firstGroup, |
| groupCount, |
| data.size() * sizeof(DataType), |
| reinterpret_cast<void *>(data.data()))); |
| if(result != VULKAN_HPP_NAMESPACE::Result::eSuccess) |
| { |
| throwResultException(result, VULKAN_HPP_NAMESPACE_STRING "::Pipeline::getRayTracingShaderGroupHandlesKHR"); |
| } |
| return data; |
| } |
| |
| template<typename DataType> |
| VULKAN_HPP_NODISCARD DataType Pipeline::getRayTracingShaderGroupHandleKHR(uint32_t firstGroup, uint32_t groupCount) const |
| { |
| DataType data; |
| Result result = static_cast<Result>(getDispatcher()->vkGetRayTracingShaderGroupHandlesKHR(static_cast<VkDevice>(m_device), |
| static_cast<VkPipeline>(m_pipeline), |
| firstGroup, |
| groupCount, |
| sizeof(DataType), |
| reinterpret_cast<void *>(&data))); |
| if(result != VULKAN_HPP_NAMESPACE::Result::eSuccess) |
| { |
| throwResultException(result, VULKAN_HPP_NAMESPACE_STRING "::Pipeline::getRayTracingShaderGroupHandleKHR"); |
| } |
| return data; |
| } |
| |
| template<typename DataType> |
| VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE std::vector<DataType> |
| Pipeline::getRayTracingCaptureReplayShaderGroupHandlesKHR(uint32_t firstGroup, uint32_t groupCount, size_t dataSize) const |
| { |
| VULKAN_HPP_ASSERT(getDispatcher()->vkGetRayTracingCaptureReplayShaderGroupHandlesKHR && |
| "Function <vkGetRayTracingCaptureReplayShaderGroupHandlesKHR> needs extension <VK_KHR_ray_tracing_pipeline> enabled!"); |
| |
| VULKAN_HPP_ASSERT(dataSize % sizeof(DataType) == 0); |
| std::vector<DataType> data(dataSize / sizeof(DataType)); |
| Result result = static_cast<Result>(getDispatcher()->vkGetRayTracingCaptureReplayShaderGroupHandlesKHR(static_cast<VkDevice>(m_device), |
| static_cast<VkPipeline>(m_pipeline), |
| firstGroup, |
| groupCount, |
| data.size() * sizeof(DataType), |
| reinterpret_cast<void *>(data.data()))); |
| if(result != VULKAN_HPP_NAMESPACE::Result::eSuccess) |
| { |
| throwResultException(result, VULKAN_HPP_NAMESPACE_STRING "::Pipeline::getRayTracingCaptureReplayShaderGroupHandlesKHR"); |
| } |
| return data; |
| } |
| |
| template<typename DataType> |
| VULKAN_HPP_NODISCARD DataType Pipeline::getRayTracingCaptureReplayShaderGroupHandleKHR(uint32_t firstGroup, uint32_t groupCount) const |
| { |
| DataType data; |
| Result result = static_cast<Result>(getDispatcher()->vkGetRayTracingCaptureReplayShaderGroupHandlesKHR(static_cast<VkDevice>(m_device), |
| static_cast<VkPipeline>(m_pipeline), |
| firstGroup, |
| groupCount, |
| sizeof(DataType), |
| reinterpret_cast<void *>(&data))); |
| if(result != VULKAN_HPP_NAMESPACE::Result::eSuccess) |
| { |
| throwResultException(result, VULKAN_HPP_NAMESPACE_STRING "::Pipeline::getRayTracingCaptureReplayShaderGroupHandleKHR"); |
| } |
| return data; |
| } |
| |
| VULKAN_HPP_INLINE void CommandBuffer::traceRaysIndirectKHR(const VULKAN_HPP_NAMESPACE::StridedDeviceAddressRegionKHR &raygenShaderBindingTable, |
| const VULKAN_HPP_NAMESPACE::StridedDeviceAddressRegionKHR &missShaderBindingTable, |
| const VULKAN_HPP_NAMESPACE::StridedDeviceAddressRegionKHR &hitShaderBindingTable, |
| const VULKAN_HPP_NAMESPACE::StridedDeviceAddressRegionKHR &callableShaderBindingTable, |
| VULKAN_HPP_NAMESPACE::DeviceAddress indirectDeviceAddress) const VULKAN_HPP_NOEXCEPT |
| { |
| VULKAN_HPP_ASSERT(getDispatcher()->vkCmdTraceRaysIndirectKHR && |
| "Function <vkCmdTraceRaysIndirectKHR> needs extension <VK_KHR_ray_tracing_pipeline> enabled!"); |
| |
| getDispatcher()->vkCmdTraceRaysIndirectKHR(static_cast<VkCommandBuffer>(m_commandBuffer), |
| reinterpret_cast<const VkStridedDeviceAddressRegionKHR *>(&raygenShaderBindingTable), |
| reinterpret_cast<const VkStridedDeviceAddressRegionKHR *>(&missShaderBindingTable), |
| reinterpret_cast<const VkStridedDeviceAddressRegionKHR *>(&hitShaderBindingTable), |
| reinterpret_cast<const VkStridedDeviceAddressRegionKHR *>(&callableShaderBindingTable), |
| static_cast<VkDeviceAddress>(indirectDeviceAddress)); |
| } |
| |
| VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE VULKAN_HPP_NAMESPACE::DeviceSize |
| Pipeline::getRayTracingShaderGroupStackSizeKHR(uint32_t group, VULKAN_HPP_NAMESPACE::ShaderGroupShaderKHR groupShader) const VULKAN_HPP_NOEXCEPT |
| { |
| VULKAN_HPP_ASSERT(getDispatcher()->vkGetRayTracingShaderGroupStackSizeKHR && |
| "Function <vkGetRayTracingShaderGroupStackSizeKHR> needs extension <VK_KHR_ray_tracing_pipeline> enabled!"); |
| |
| return static_cast<VULKAN_HPP_NAMESPACE::DeviceSize>(getDispatcher()->vkGetRayTracingShaderGroupStackSizeKHR( |
| static_cast<VkDevice>(m_device), static_cast<VkPipeline>(m_pipeline), group, static_cast<VkShaderGroupShaderKHR>(groupShader))); |
| } |
| |
| VULKAN_HPP_INLINE void CommandBuffer::setRayTracingPipelineStackSizeKHR(uint32_t pipelineStackSize) const VULKAN_HPP_NOEXCEPT |
| { |
| VULKAN_HPP_ASSERT(getDispatcher()->vkCmdSetRayTracingPipelineStackSizeKHR && |
| "Function <vkCmdSetRayTracingPipelineStackSizeKHR> needs extension <VK_KHR_ray_tracing_pipeline> enabled!"); |
| |
| getDispatcher()->vkCmdSetRayTracingPipelineStackSizeKHR(static_cast<VkCommandBuffer>(m_commandBuffer), pipelineStackSize); |
| } |
| |
| //=== VK_EXT_vertex_input_dynamic_state === |
| |
| VULKAN_HPP_INLINE void CommandBuffer::setVertexInputEXT( |
| ArrayProxy<const VULKAN_HPP_NAMESPACE::VertexInputBindingDescription2EXT> const &vertexBindingDescriptions, |
| ArrayProxy<const VULKAN_HPP_NAMESPACE::VertexInputAttributeDescription2EXT> const &vertexAttributeDescriptions) const VULKAN_HPP_NOEXCEPT |
| { |
| VULKAN_HPP_ASSERT(getDispatcher()->vkCmdSetVertexInputEXT && |
| "Function <vkCmdSetVertexInputEXT> needs extension <VK_EXT_vertex_input_dynamic_state> enabled!"); |
| |
| getDispatcher()->vkCmdSetVertexInputEXT(static_cast<VkCommandBuffer>(m_commandBuffer), |
| vertexBindingDescriptions.size(), |
| reinterpret_cast<const VkVertexInputBindingDescription2EXT *>(vertexBindingDescriptions.data()), |
| vertexAttributeDescriptions.size(), |
| reinterpret_cast<const VkVertexInputAttributeDescription2EXT *>(vertexAttributeDescriptions.data())); |
| } |
| |
| # if defined(VK_USE_PLATFORM_FUCHSIA) |
| //=== VK_FUCHSIA_external_memory === |
| |
| VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE zx_handle_t |
| Device::getMemoryZirconHandleFUCHSIA(const VULKAN_HPP_NAMESPACE::MemoryGetZirconHandleInfoFUCHSIA &getZirconHandleInfo) const |
| { |
| VULKAN_HPP_ASSERT(getDispatcher()->vkGetMemoryZirconHandleFUCHSIA && |
| "Function <vkGetMemoryZirconHandleFUCHSIA> needs extension <VK_FUCHSIA_external_memory> enabled!"); |
| |
| zx_handle_t zirconHandle; |
| VULKAN_HPP_NAMESPACE::Result result = static_cast<VULKAN_HPP_NAMESPACE::Result>(getDispatcher()->vkGetMemoryZirconHandleFUCHSIA( |
| static_cast<VkDevice>(m_device), reinterpret_cast<const VkMemoryGetZirconHandleInfoFUCHSIA *>(&getZirconHandleInfo), &zirconHandle)); |
| if(result != VULKAN_HPP_NAMESPACE::Result::eSuccess) |
| { |
| throwResultException(result, VULKAN_HPP_NAMESPACE_STRING "::Device::getMemoryZirconHandleFUCHSIA"); |
| } |
| return zirconHandle; |
| } |
| |
| VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE VULKAN_HPP_NAMESPACE::MemoryZirconHandlePropertiesFUCHSIA |
| Device::getMemoryZirconHandlePropertiesFUCHSIA(VULKAN_HPP_NAMESPACE::ExternalMemoryHandleTypeFlagBits handleType, zx_handle_t zirconHandle) const |
| { |
| VULKAN_HPP_ASSERT(getDispatcher()->vkGetMemoryZirconHandlePropertiesFUCHSIA && |
| "Function <vkGetMemoryZirconHandlePropertiesFUCHSIA> needs extension <VK_FUCHSIA_external_memory> enabled!"); |
| |
| VULKAN_HPP_NAMESPACE::MemoryZirconHandlePropertiesFUCHSIA memoryZirconHandleProperties; |
| VULKAN_HPP_NAMESPACE::Result result = static_cast<VULKAN_HPP_NAMESPACE::Result>(getDispatcher()->vkGetMemoryZirconHandlePropertiesFUCHSIA( |
| static_cast<VkDevice>(m_device), |
| static_cast<VkExternalMemoryHandleTypeFlagBits>(handleType), |
| zirconHandle, |
| reinterpret_cast<VkMemoryZirconHandlePropertiesFUCHSIA *>(&memoryZirconHandleProperties))); |
| if(result != VULKAN_HPP_NAMESPACE::Result::eSuccess) |
| { |
| throwResultException(result, VULKAN_HPP_NAMESPACE_STRING "::Device::getMemoryZirconHandlePropertiesFUCHSIA"); |
| } |
| return memoryZirconHandleProperties; |
| } |
| # endif /*VK_USE_PLATFORM_FUCHSIA*/ |
| |
| # if defined(VK_USE_PLATFORM_FUCHSIA) |
| //=== VK_FUCHSIA_external_semaphore === |
| |
| VULKAN_HPP_INLINE void |
| Device::importSemaphoreZirconHandleFUCHSIA(const VULKAN_HPP_NAMESPACE::ImportSemaphoreZirconHandleInfoFUCHSIA &importSemaphoreZirconHandleInfo) const |
| { |
| VULKAN_HPP_ASSERT(getDispatcher()->vkImportSemaphoreZirconHandleFUCHSIA && |
| "Function <vkImportSemaphoreZirconHandleFUCHSIA> needs extension <VK_FUCHSIA_external_semaphore> enabled!"); |
| |
| VULKAN_HPP_NAMESPACE::Result result = static_cast<VULKAN_HPP_NAMESPACE::Result>(getDispatcher()->vkImportSemaphoreZirconHandleFUCHSIA( |
| static_cast<VkDevice>(m_device), reinterpret_cast<const VkImportSemaphoreZirconHandleInfoFUCHSIA *>(&importSemaphoreZirconHandleInfo))); |
| if(result != VULKAN_HPP_NAMESPACE::Result::eSuccess) |
| { |
| throwResultException(result, VULKAN_HPP_NAMESPACE_STRING "::Device::importSemaphoreZirconHandleFUCHSIA"); |
| } |
| } |
| |
| VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE zx_handle_t |
| Device::getSemaphoreZirconHandleFUCHSIA(const VULKAN_HPP_NAMESPACE::SemaphoreGetZirconHandleInfoFUCHSIA &getZirconHandleInfo) const |
| { |
| VULKAN_HPP_ASSERT(getDispatcher()->vkGetSemaphoreZirconHandleFUCHSIA && |
| "Function <vkGetSemaphoreZirconHandleFUCHSIA> needs extension <VK_FUCHSIA_external_semaphore> enabled!"); |
| |
| zx_handle_t zirconHandle; |
| VULKAN_HPP_NAMESPACE::Result result = static_cast<VULKAN_HPP_NAMESPACE::Result>(getDispatcher()->vkGetSemaphoreZirconHandleFUCHSIA( |
| static_cast<VkDevice>(m_device), reinterpret_cast<const VkSemaphoreGetZirconHandleInfoFUCHSIA *>(&getZirconHandleInfo), &zirconHandle)); |
| if(result != VULKAN_HPP_NAMESPACE::Result::eSuccess) |
| { |
| throwResultException(result, VULKAN_HPP_NAMESPACE_STRING "::Device::getSemaphoreZirconHandleFUCHSIA"); |
| } |
| return zirconHandle; |
| } |
| # endif /*VK_USE_PLATFORM_FUCHSIA*/ |
| |
| # if defined(VK_USE_PLATFORM_FUCHSIA) |
| //=== VK_FUCHSIA_buffer_collection === |
| |
| VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE VULKAN_HPP_RAII_NAMESPACE::BufferCollectionFUCHSIA |
| Device::createBufferCollectionFUCHSIA(VULKAN_HPP_NAMESPACE::BufferCollectionCreateInfoFUCHSIA const &createInfo, |
| VULKAN_HPP_NAMESPACE::Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator) const |
| { |
| return VULKAN_HPP_RAII_NAMESPACE::BufferCollectionFUCHSIA(*this, createInfo, allocator); |
| } |
| |
| VULKAN_HPP_INLINE void BufferCollectionFUCHSIA::setImageConstraints(const VULKAN_HPP_NAMESPACE::ImageConstraintsInfoFUCHSIA &imageConstraintsInfo) const |
| { |
| VULKAN_HPP_ASSERT(getDispatcher()->vkSetBufferCollectionImageConstraintsFUCHSIA && |
| "Function <vkSetBufferCollectionImageConstraintsFUCHSIA> needs extension <VK_FUCHSIA_buffer_collection> enabled!"); |
| |
| VULKAN_HPP_NAMESPACE::Result result = static_cast<VULKAN_HPP_NAMESPACE::Result>( |
| getDispatcher()->vkSetBufferCollectionImageConstraintsFUCHSIA(static_cast<VkDevice>(m_device), |
| static_cast<VkBufferCollectionFUCHSIA>(m_collection), |
| reinterpret_cast<const VkImageConstraintsInfoFUCHSIA *>(&imageConstraintsInfo))); |
| if(result != VULKAN_HPP_NAMESPACE::Result::eSuccess) |
| { |
| throwResultException(result, VULKAN_HPP_NAMESPACE_STRING "::BufferCollectionFUCHSIA::setImageConstraints"); |
| } |
| } |
| |
| VULKAN_HPP_INLINE void |
| BufferCollectionFUCHSIA::setBufferConstraints(const VULKAN_HPP_NAMESPACE::BufferConstraintsInfoFUCHSIA &bufferConstraintsInfo) const |
| { |
| VULKAN_HPP_ASSERT(getDispatcher()->vkSetBufferCollectionBufferConstraintsFUCHSIA && |
| "Function <vkSetBufferCollectionBufferConstraintsFUCHSIA> needs extension <VK_FUCHSIA_buffer_collection> enabled!"); |
| |
| VULKAN_HPP_NAMESPACE::Result result = static_cast<VULKAN_HPP_NAMESPACE::Result>( |
| getDispatcher()->vkSetBufferCollectionBufferConstraintsFUCHSIA(static_cast<VkDevice>(m_device), |
| static_cast<VkBufferCollectionFUCHSIA>(m_collection), |
| reinterpret_cast<const VkBufferConstraintsInfoFUCHSIA *>(&bufferConstraintsInfo))); |
| if(result != VULKAN_HPP_NAMESPACE::Result::eSuccess) |
| { |
| throwResultException(result, VULKAN_HPP_NAMESPACE_STRING "::BufferCollectionFUCHSIA::setBufferConstraints"); |
| } |
| } |
| |
| VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE VULKAN_HPP_NAMESPACE::BufferCollectionPropertiesFUCHSIA BufferCollectionFUCHSIA::getProperties() const |
| { |
| VULKAN_HPP_ASSERT(getDispatcher()->vkGetBufferCollectionPropertiesFUCHSIA && |
| "Function <vkGetBufferCollectionPropertiesFUCHSIA> needs extension <VK_FUCHSIA_buffer_collection> enabled!"); |
| |
| VULKAN_HPP_NAMESPACE::BufferCollectionPropertiesFUCHSIA properties; |
| VULKAN_HPP_NAMESPACE::Result result = static_cast<VULKAN_HPP_NAMESPACE::Result>( |
| getDispatcher()->vkGetBufferCollectionPropertiesFUCHSIA(static_cast<VkDevice>(m_device), |
| static_cast<VkBufferCollectionFUCHSIA>(m_collection), |
| reinterpret_cast<VkBufferCollectionPropertiesFUCHSIA *>(&properties))); |
| if(result != VULKAN_HPP_NAMESPACE::Result::eSuccess) |
| { |
| throwResultException(result, VULKAN_HPP_NAMESPACE_STRING "::BufferCollectionFUCHSIA::getProperties"); |
| } |
| return properties; |
| } |
| # endif /*VK_USE_PLATFORM_FUCHSIA*/ |
| |
| //=== VK_HUAWEI_subpass_shading === |
| |
| VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE std::pair<VULKAN_HPP_NAMESPACE::Result, VULKAN_HPP_NAMESPACE::Extent2D> |
| RenderPass::getSubpassShadingMaxWorkgroupSizeHUAWEI() const |
| { |
| VULKAN_HPP_ASSERT(getDispatcher()->vkGetDeviceSubpassShadingMaxWorkgroupSizeHUAWEI && |
| "Function <vkGetDeviceSubpassShadingMaxWorkgroupSizeHUAWEI> needs extension <VK_HUAWEI_subpass_shading> enabled!"); |
| |
| VULKAN_HPP_NAMESPACE::Extent2D maxWorkgroupSize; |
| VULKAN_HPP_NAMESPACE::Result result = static_cast<VULKAN_HPP_NAMESPACE::Result>(getDispatcher()->vkGetDeviceSubpassShadingMaxWorkgroupSizeHUAWEI( |
| static_cast<VkDevice>(m_device), static_cast<VkRenderPass>(m_renderPass), reinterpret_cast<VkExtent2D *>(&maxWorkgroupSize))); |
| if((result != VULKAN_HPP_NAMESPACE::Result::eSuccess) && (result != VULKAN_HPP_NAMESPACE::Result::eIncomplete)) |
| { |
| throwResultException(result, VULKAN_HPP_NAMESPACE_STRING "::RenderPass::getSubpassShadingMaxWorkgroupSizeHUAWEI"); |
| } |
| return std::make_pair(result, maxWorkgroupSize); |
| } |
| |
| VULKAN_HPP_INLINE void CommandBuffer::subpassShadingHUAWEI() const VULKAN_HPP_NOEXCEPT |
| { |
| VULKAN_HPP_ASSERT(getDispatcher()->vkCmdSubpassShadingHUAWEI && |
| "Function <vkCmdSubpassShadingHUAWEI> needs extension <VK_HUAWEI_subpass_shading> enabled!"); |
| |
| getDispatcher()->vkCmdSubpassShadingHUAWEI(static_cast<VkCommandBuffer>(m_commandBuffer)); |
| } |
| |
| //=== VK_HUAWEI_invocation_mask === |
| |
| VULKAN_HPP_INLINE void CommandBuffer::bindInvocationMaskHUAWEI(VULKAN_HPP_NAMESPACE::ImageView imageView, |
| VULKAN_HPP_NAMESPACE::ImageLayout imageLayout) const VULKAN_HPP_NOEXCEPT |
| { |
| VULKAN_HPP_ASSERT(getDispatcher()->vkCmdBindInvocationMaskHUAWEI && |
| "Function <vkCmdBindInvocationMaskHUAWEI> needs extension <VK_HUAWEI_invocation_mask> enabled!"); |
| |
| getDispatcher()->vkCmdBindInvocationMaskHUAWEI( |
| static_cast<VkCommandBuffer>(m_commandBuffer), static_cast<VkImageView>(imageView), static_cast<VkImageLayout>(imageLayout)); |
| } |
| |
| //=== VK_NV_external_memory_rdma === |
| |
| VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE VULKAN_HPP_NAMESPACE::RemoteAddressNV |
| Device::getMemoryRemoteAddressNV(const VULKAN_HPP_NAMESPACE::MemoryGetRemoteAddressInfoNV &memoryGetRemoteAddressInfo) const |
| { |
| VULKAN_HPP_ASSERT(getDispatcher()->vkGetMemoryRemoteAddressNV && |
| "Function <vkGetMemoryRemoteAddressNV> needs extension <VK_NV_external_memory_rdma> enabled!"); |
| |
| VULKAN_HPP_NAMESPACE::RemoteAddressNV address; |
| VULKAN_HPP_NAMESPACE::Result result = static_cast<VULKAN_HPP_NAMESPACE::Result>( |
| getDispatcher()->vkGetMemoryRemoteAddressNV(static_cast<VkDevice>(m_device), |
| reinterpret_cast<const VkMemoryGetRemoteAddressInfoNV *>(&memoryGetRemoteAddressInfo), |
| reinterpret_cast<VkRemoteAddressNV *>(&address))); |
| if(result != VULKAN_HPP_NAMESPACE::Result::eSuccess) |
| { |
| throwResultException(result, VULKAN_HPP_NAMESPACE_STRING "::Device::getMemoryRemoteAddressNV"); |
| } |
| return address; |
| } |
| |
| //=== VK_EXT_extended_dynamic_state2 === |
| |
| VULKAN_HPP_INLINE void CommandBuffer::setPatchControlPointsEXT(uint32_t patchControlPoints) const VULKAN_HPP_NOEXCEPT |
| { |
| VULKAN_HPP_ASSERT(getDispatcher()->vkCmdSetPatchControlPointsEXT && |
| "Function <vkCmdSetPatchControlPointsEXT> needs extension <VK_EXT_extended_dynamic_state2> enabled!"); |
| |
| getDispatcher()->vkCmdSetPatchControlPointsEXT(static_cast<VkCommandBuffer>(m_commandBuffer), patchControlPoints); |
| } |
| |
| VULKAN_HPP_INLINE void CommandBuffer::setRasterizerDiscardEnableEXT(VULKAN_HPP_NAMESPACE::Bool32 rasterizerDiscardEnable) const VULKAN_HPP_NOEXCEPT |
| { |
| VULKAN_HPP_ASSERT(getDispatcher()->vkCmdSetRasterizerDiscardEnableEXT && |
| "Function <vkCmdSetRasterizerDiscardEnableEXT> needs extension <VK_EXT_extended_dynamic_state2> enabled!"); |
| |
| getDispatcher()->vkCmdSetRasterizerDiscardEnableEXT(static_cast<VkCommandBuffer>(m_commandBuffer), static_cast<VkBool32>(rasterizerDiscardEnable)); |
| } |
| |
| VULKAN_HPP_INLINE void CommandBuffer::setDepthBiasEnableEXT(VULKAN_HPP_NAMESPACE::Bool32 depthBiasEnable) const VULKAN_HPP_NOEXCEPT |
| { |
| VULKAN_HPP_ASSERT(getDispatcher()->vkCmdSetDepthBiasEnableEXT && |
| "Function <vkCmdSetDepthBiasEnableEXT> needs extension <VK_EXT_extended_dynamic_state2> enabled!"); |
| |
| getDispatcher()->vkCmdSetDepthBiasEnableEXT(static_cast<VkCommandBuffer>(m_commandBuffer), static_cast<VkBool32>(depthBiasEnable)); |
| } |
| |
| VULKAN_HPP_INLINE void CommandBuffer::setLogicOpEXT(VULKAN_HPP_NAMESPACE::LogicOp logicOp) const VULKAN_HPP_NOEXCEPT |
| { |
| VULKAN_HPP_ASSERT(getDispatcher()->vkCmdSetLogicOpEXT && "Function <vkCmdSetLogicOpEXT> needs extension <VK_EXT_extended_dynamic_state2> enabled!"); |
| |
| getDispatcher()->vkCmdSetLogicOpEXT(static_cast<VkCommandBuffer>(m_commandBuffer), static_cast<VkLogicOp>(logicOp)); |
| } |
| |
| VULKAN_HPP_INLINE void CommandBuffer::setPrimitiveRestartEnableEXT(VULKAN_HPP_NAMESPACE::Bool32 primitiveRestartEnable) const VULKAN_HPP_NOEXCEPT |
| { |
| VULKAN_HPP_ASSERT(getDispatcher()->vkCmdSetPrimitiveRestartEnableEXT && |
| "Function <vkCmdSetPrimitiveRestartEnableEXT> needs extension <VK_EXT_extended_dynamic_state2> enabled!"); |
| |
| getDispatcher()->vkCmdSetPrimitiveRestartEnableEXT(static_cast<VkCommandBuffer>(m_commandBuffer), static_cast<VkBool32>(primitiveRestartEnable)); |
| } |
| |
| # if defined(VK_USE_PLATFORM_SCREEN_QNX) |
| //=== VK_QNX_screen_surface === |
| |
| VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE VULKAN_HPP_RAII_NAMESPACE::SurfaceKHR |
| Instance::createScreenSurfaceQNX(VULKAN_HPP_NAMESPACE::ScreenSurfaceCreateInfoQNX const &createInfo, |
| VULKAN_HPP_NAMESPACE::Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator) const |
| { |
| return VULKAN_HPP_RAII_NAMESPACE::SurfaceKHR(*this, createInfo, allocator); |
| } |
| |
| VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE VULKAN_HPP_NAMESPACE::Bool32 |
| PhysicalDevice::getScreenPresentationSupportQNX(uint32_t queueFamilyIndex, struct _screen_window &window) const VULKAN_HPP_NOEXCEPT |
| { |
| VULKAN_HPP_ASSERT(getDispatcher()->vkGetPhysicalDeviceScreenPresentationSupportQNX && |
| "Function <vkGetPhysicalDeviceScreenPresentationSupportQNX> needs extension <VK_QNX_screen_surface> enabled!"); |
| |
| return static_cast<VULKAN_HPP_NAMESPACE::Bool32>( |
| getDispatcher()->vkGetPhysicalDeviceScreenPresentationSupportQNX(static_cast<VkPhysicalDevice>(m_physicalDevice), queueFamilyIndex, &window)); |
| } |
| # endif /*VK_USE_PLATFORM_SCREEN_QNX*/ |
| |
| //=== VK_EXT_color_write_enable === |
| |
| VULKAN_HPP_INLINE void |
| CommandBuffer::setColorWriteEnableEXT(ArrayProxy<const VULKAN_HPP_NAMESPACE::Bool32> const &colorWriteEnables) const VULKAN_HPP_NOEXCEPT |
| { |
| VULKAN_HPP_ASSERT(getDispatcher()->vkCmdSetColorWriteEnableEXT && |
| "Function <vkCmdSetColorWriteEnableEXT> needs extension <VK_EXT_color_write_enable> enabled!"); |
| |
| getDispatcher()->vkCmdSetColorWriteEnableEXT( |
| static_cast<VkCommandBuffer>(m_commandBuffer), colorWriteEnables.size(), reinterpret_cast<const VkBool32 *>(colorWriteEnables.data())); |
| } |
| |
| //=== VK_EXT_multi_draw === |
| |
| VULKAN_HPP_INLINE void CommandBuffer::drawMultiEXT(ArrayProxy<const VULKAN_HPP_NAMESPACE::MultiDrawInfoEXT> const &vertexInfo, |
| uint32_t instanceCount, |
| uint32_t firstInstance, |
| uint32_t stride) const VULKAN_HPP_NOEXCEPT |
| { |
| VULKAN_HPP_ASSERT(getDispatcher()->vkCmdDrawMultiEXT && "Function <vkCmdDrawMultiEXT> needs extension <VK_EXT_multi_draw> enabled!"); |
| |
| getDispatcher()->vkCmdDrawMultiEXT(static_cast<VkCommandBuffer>(m_commandBuffer), |
| vertexInfo.size(), |
| reinterpret_cast<const VkMultiDrawInfoEXT *>(vertexInfo.data()), |
| instanceCount, |
| firstInstance, |
| stride); |
| } |
| |
| VULKAN_HPP_INLINE void CommandBuffer::drawMultiIndexedEXT(ArrayProxy<const VULKAN_HPP_NAMESPACE::MultiDrawIndexedInfoEXT> const &indexInfo, |
| uint32_t instanceCount, |
| uint32_t firstInstance, |
| uint32_t stride, |
| Optional<const int32_t> vertexOffset) const VULKAN_HPP_NOEXCEPT |
| { |
| VULKAN_HPP_ASSERT(getDispatcher()->vkCmdDrawMultiIndexedEXT && "Function <vkCmdDrawMultiIndexedEXT> needs extension <VK_EXT_multi_draw> enabled!"); |
| |
| getDispatcher()->vkCmdDrawMultiIndexedEXT(static_cast<VkCommandBuffer>(m_commandBuffer), |
| indexInfo.size(), |
| reinterpret_cast<const VkMultiDrawIndexedInfoEXT *>(indexInfo.data()), |
| instanceCount, |
| firstInstance, |
| stride, |
| static_cast<const int32_t *>(vertexOffset)); |
| } |
| |
| //=== VK_EXT_pageable_device_local_memory === |
| |
| VULKAN_HPP_INLINE void DeviceMemory::setPriorityEXT(float priority) const VULKAN_HPP_NOEXCEPT |
| { |
| VULKAN_HPP_ASSERT(getDispatcher()->vkSetDeviceMemoryPriorityEXT && |
| "Function <vkSetDeviceMemoryPriorityEXT> needs extension <VK_EXT_pageable_device_local_memory> enabled!"); |
| |
| getDispatcher()->vkSetDeviceMemoryPriorityEXT(static_cast<VkDevice>(m_device), static_cast<VkDeviceMemory>(m_memory), priority); |
| } |
| |
| //=== VK_KHR_maintenance4 === |
| |
| VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE VULKAN_HPP_NAMESPACE::MemoryRequirements2 |
| Device::getBufferMemoryRequirementsKHR(const VULKAN_HPP_NAMESPACE::DeviceBufferMemoryRequirements &info) const VULKAN_HPP_NOEXCEPT |
| { |
| VULKAN_HPP_ASSERT(getDispatcher()->vkGetDeviceBufferMemoryRequirementsKHR && |
| "Function <vkGetDeviceBufferMemoryRequirementsKHR> needs extension <VK_KHR_maintenance4> enabled!"); |
| |
| VULKAN_HPP_NAMESPACE::MemoryRequirements2 memoryRequirements; |
| getDispatcher()->vkGetDeviceBufferMemoryRequirementsKHR(static_cast<VkDevice>(m_device), |
| reinterpret_cast<const VkDeviceBufferMemoryRequirements *>(&info), |
| reinterpret_cast<VkMemoryRequirements2 *>(&memoryRequirements)); |
| return memoryRequirements; |
| } |
| |
| template<typename X, typename Y, typename... Z> |
| VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE StructureChain<X, Y, Z...> |
| Device::getBufferMemoryRequirementsKHR(const VULKAN_HPP_NAMESPACE::DeviceBufferMemoryRequirements &info) const VULKAN_HPP_NOEXCEPT |
| { |
| VULKAN_HPP_ASSERT(getDispatcher()->vkGetDeviceBufferMemoryRequirementsKHR && |
| "Function <vkGetDeviceBufferMemoryRequirementsKHR> needs extension <VK_KHR_maintenance4> enabled!"); |
| |
| StructureChain<X, Y, Z...> structureChain; |
| VULKAN_HPP_NAMESPACE::MemoryRequirements2 &memoryRequirements = structureChain.template get<VULKAN_HPP_NAMESPACE::MemoryRequirements2>(); |
| getDispatcher()->vkGetDeviceBufferMemoryRequirementsKHR(static_cast<VkDevice>(m_device), |
| reinterpret_cast<const VkDeviceBufferMemoryRequirements *>(&info), |
| reinterpret_cast<VkMemoryRequirements2 *>(&memoryRequirements)); |
| return structureChain; |
| } |
| |
| VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE VULKAN_HPP_NAMESPACE::MemoryRequirements2 |
| Device::getImageMemoryRequirementsKHR(const VULKAN_HPP_NAMESPACE::DeviceImageMemoryRequirements &info) const VULKAN_HPP_NOEXCEPT |
| { |
| VULKAN_HPP_ASSERT(getDispatcher()->vkGetDeviceImageMemoryRequirementsKHR && |
| "Function <vkGetDeviceImageMemoryRequirementsKHR> needs extension <VK_KHR_maintenance4> enabled!"); |
| |
| VULKAN_HPP_NAMESPACE::MemoryRequirements2 memoryRequirements; |
| getDispatcher()->vkGetDeviceImageMemoryRequirementsKHR(static_cast<VkDevice>(m_device), |
| reinterpret_cast<const VkDeviceImageMemoryRequirements *>(&info), |
| reinterpret_cast<VkMemoryRequirements2 *>(&memoryRequirements)); |
| return memoryRequirements; |
| } |
| |
| template<typename X, typename Y, typename... Z> |
| VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE StructureChain<X, Y, Z...> |
| Device::getImageMemoryRequirementsKHR(const VULKAN_HPP_NAMESPACE::DeviceImageMemoryRequirements &info) const VULKAN_HPP_NOEXCEPT |
| { |
| VULKAN_HPP_ASSERT(getDispatcher()->vkGetDeviceImageMemoryRequirementsKHR && |
| "Function <vkGetDeviceImageMemoryRequirementsKHR> needs extension <VK_KHR_maintenance4> enabled!"); |
| |
| StructureChain<X, Y, Z...> structureChain; |
| VULKAN_HPP_NAMESPACE::MemoryRequirements2 &memoryRequirements = structureChain.template get<VULKAN_HPP_NAMESPACE::MemoryRequirements2>(); |
| getDispatcher()->vkGetDeviceImageMemoryRequirementsKHR(static_cast<VkDevice>(m_device), |
| reinterpret_cast<const VkDeviceImageMemoryRequirements *>(&info), |
| reinterpret_cast<VkMemoryRequirements2 *>(&memoryRequirements)); |
| return structureChain; |
| } |
| |
| VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE std::vector<VULKAN_HPP_NAMESPACE::SparseImageMemoryRequirements2> |
| Device::getImageSparseMemoryRequirementsKHR(const VULKAN_HPP_NAMESPACE::DeviceImageMemoryRequirements &info) const VULKAN_HPP_NOEXCEPT |
| { |
| VULKAN_HPP_ASSERT(getDispatcher()->vkGetDeviceImageSparseMemoryRequirementsKHR && |
| "Function <vkGetDeviceImageSparseMemoryRequirementsKHR> needs extension <VK_KHR_maintenance4> enabled!"); |
| |
| uint32_t sparseMemoryRequirementCount; |
| getDispatcher()->vkGetDeviceImageSparseMemoryRequirementsKHR( |
| static_cast<VkDevice>(m_device), reinterpret_cast<const VkDeviceImageMemoryRequirements *>(&info), &sparseMemoryRequirementCount, nullptr); |
| std::vector<VULKAN_HPP_NAMESPACE::SparseImageMemoryRequirements2> sparseMemoryRequirements(sparseMemoryRequirementCount); |
| getDispatcher()->vkGetDeviceImageSparseMemoryRequirementsKHR(static_cast<VkDevice>(m_device), |
| reinterpret_cast<const VkDeviceImageMemoryRequirements *>(&info), |
| &sparseMemoryRequirementCount, |
| reinterpret_cast<VkSparseImageMemoryRequirements2 *>(sparseMemoryRequirements.data())); |
| VULKAN_HPP_ASSERT(sparseMemoryRequirementCount == sparseMemoryRequirements.size()); |
| return sparseMemoryRequirements; |
| } |
| |
| //=== VK_VALVE_descriptor_set_host_mapping === |
| |
| VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE VULKAN_HPP_NAMESPACE::DescriptorSetLayoutHostMappingInfoVALVE Device::getDescriptorSetLayoutHostMappingInfoVALVE( |
| const VULKAN_HPP_NAMESPACE::DescriptorSetBindingReferenceVALVE &bindingReference) const VULKAN_HPP_NOEXCEPT |
| { |
| VULKAN_HPP_ASSERT(getDispatcher()->vkGetDescriptorSetLayoutHostMappingInfoVALVE && |
| "Function <vkGetDescriptorSetLayoutHostMappingInfoVALVE> needs extension <VK_VALVE_descriptor_set_host_mapping> enabled!"); |
| |
| VULKAN_HPP_NAMESPACE::DescriptorSetLayoutHostMappingInfoVALVE hostMapping; |
| getDispatcher()->vkGetDescriptorSetLayoutHostMappingInfoVALVE(static_cast<VkDevice>(m_device), |
| reinterpret_cast<const VkDescriptorSetBindingReferenceVALVE *>(&bindingReference), |
| reinterpret_cast<VkDescriptorSetLayoutHostMappingInfoVALVE *>(&hostMapping)); |
| return hostMapping; |
| } |
| |
| VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE void *DescriptorSet::getHostMappingVALVE() const VULKAN_HPP_NOEXCEPT |
| { |
| VULKAN_HPP_ASSERT(getDispatcher()->vkGetDescriptorSetHostMappingVALVE && |
| "Function <vkGetDescriptorSetHostMappingVALVE> needs extension <VK_VALVE_descriptor_set_host_mapping> enabled!"); |
| |
| void *pData; |
| getDispatcher()->vkGetDescriptorSetHostMappingVALVE(static_cast<VkDevice>(m_device), static_cast<VkDescriptorSet>(m_descriptorSet), &pData); |
| return pData; |
| } |
| |
| #endif |
| } // namespace VULKAN_HPP_RAII_NAMESPACE |
| } // namespace VULKAN_HPP_NAMESPACE |
| #endif |
