diff options
Diffstat (limited to 'layers/parameter_validation.cpp')
| -rw-r--r-- | layers/parameter_validation.cpp | 545 |
1 files changed, 465 insertions, 80 deletions
diff --git a/layers/parameter_validation.cpp b/layers/parameter_validation.cpp index 970fc7bb..332fd8b8 100644 --- a/layers/parameter_validation.cpp +++ b/layers/parameter_validation.cpp @@ -77,14 +77,28 @@ struct layer_data { VkPhysicalDeviceFeatures physical_device_features = {}; VkPhysicalDevice physical_device = VK_NULL_HANDLE; - bool swapchain_enabled = false; - bool display_swapchain_enabled = false; - bool amd_negative_viewport_height_enabled = false; - bool nvx_device_generated_commands_enabled = false; + union loader_device_extension_enables { + struct { + bool khr_swapchain_enabled : 1; + bool khr_display_swapchain_enabled : 1; + bool khr_maintenance1 : 1; + bool ext_debug_marker : 1; + bool amd_negative_viewport_height : 1; + bool nv_external_memory : 1; + bool nv_external_memory_win32 : 1; + bool nvx_device_generated_commands : 1; + }; + uint64_t padding[4]; + } enables; + + layer_data() { + memset(enables.padding, 0, sizeof(uint64_t) * 4); + } VkLayerDispatchTable dispatch_table = {}; }; +static uint32_t loader_layer_if_version = CURRENT_LOADER_LAYER_INTERFACE_VERSION; static std::unordered_map<void *, layer_data *> layer_data_map; static std::unordered_map<void *, instance_layer_data *> instance_layer_data_map; @@ -1559,61 +1573,71 @@ static void CheckInstanceRegisterExtensions(const VkInstanceCreateInfo *pCreateI if (strcmp(name, VK_KHR_SURFACE_EXTENSION_NAME) == 0) { instance_data->extensions.surface_enabled = true; - } #ifdef VK_USE_PLATFORM_XLIB_KHR - if (strcmp(name, VK_KHR_XLIB_SURFACE_EXTENSION_NAME) == 0) { + } else if (strcmp(name, VK_KHR_XLIB_SURFACE_EXTENSION_NAME) == 0) { instance_data->extensions.xlib_enabled = true; - } #endif #ifdef VK_USE_PLATFORM_XCB_KHR - if (strcmp(name, VK_KHR_XCB_SURFACE_EXTENSION_NAME) == 0) { + } else if (strcmp(name, VK_KHR_XCB_SURFACE_EXTENSION_NAME) == 0) { instance_data->extensions.xcb_enabled = true; - } #endif #ifdef VK_USE_PLATFORM_WAYLAND_KHR - if (strcmp(name, VK_KHR_WAYLAND_SURFACE_EXTENSION_NAME) == 0) { + } else if (strcmp(name, VK_KHR_WAYLAND_SURFACE_EXTENSION_NAME) == 0) { instance_data->extensions.wayland_enabled = true; - } #endif #ifdef VK_USE_PLATFORM_MIR_KHR - if (strcmp(name, VK_KHR_MIR_SURFACE_EXTENSION_NAME) == 0) { + } else if (strcmp(name, VK_KHR_MIR_SURFACE_EXTENSION_NAME) == 0) { instance_data->extensions.mir_enabled = true; - } #endif #ifdef VK_USE_PLATFORM_ANDROID_KHR - if (strcmp(name, VK_KHR_ANDROID_SURFACE_EXTENSION_NAME) == 0) { + } else if (strcmp(name, VK_KHR_ANDROID_SURFACE_EXTENSION_NAME) == 0) { instance_data->extensions.android_enabled = true; - } #endif #ifdef VK_USE_PLATFORM_WIN32_KHR - if (strcmp(name, VK_KHR_WIN32_SURFACE_EXTENSION_NAME) == 0) { + } else if (strcmp(name, VK_KHR_WIN32_SURFACE_EXTENSION_NAME) == 0) { instance_data->extensions.win32_enabled = true; - } #endif - if (strcmp(name, VK_KHR_DISPLAY_EXTENSION_NAME) == 0) { + } else if (strcmp(name, VK_KHR_DISPLAY_EXTENSION_NAME) == 0) { instance_data->extensions.display_enabled = true; + } else if (strcmp(name, VK_KHR_GET_PHYSICAL_DEVICE_PROPERTIES_2_EXTENSION_NAME) == 0) { + instance_data->extensions.khr_get_phys_dev_properties2_enabled = true; + } else if (strcmp(name, VK_NV_EXTERNAL_MEMORY_CAPABILITIES_EXTENSION_NAME) == 0) { + instance_data->extensions.nv_external_memory_capabilities_enabled = true; +#ifdef VK_USE_PLATFORM_XLIB_XRANDR_EXT + } else if (strcmp(name, VK_EXT_ACQUIRE_XLIB_DISPLAY_EXTENSION_NAME) == 0) { + instance_data->extensions.ext_acquire_xlib_display_enabled = true; +#endif + } else if (strcmp(name, VK_EXT_DIRECT_MODE_DISPLAY_EXTENSION_NAME) == 0) { + instance_data->extensions.ext_direct_mode_display_enabled = true; + } else if (strcmp(name, VK_EXT_DISPLAY_SURFACE_COUNTER_EXTENSION_NAME) == 0) { + instance_data->extensions.ext_display_surface_counter_enabled = true; + } else if (strcmp(name, VK_NV_EXTERNAL_MEMORY_CAPABILITIES_EXTENSION_NAME) == 0) { + instance_data->extensions.nv_external_memory_capabilities_enabled = true; } } } static void CheckDeviceRegisterExtensions(const VkDeviceCreateInfo *pCreateInfo, VkDevice device) { layer_data *device_data = get_my_data_ptr(get_dispatch_key(device), layer_data_map); - device_data->swapchain_enabled = false; - device_data->display_swapchain_enabled = false; - device_data->amd_negative_viewport_height_enabled = false; - for (uint32_t i = 0; i < pCreateInfo->enabledExtensionCount; i++) { if (strcmp(pCreateInfo->ppEnabledExtensionNames[i], VK_KHR_SWAPCHAIN_EXTENSION_NAME) == 0) { - device_data->swapchain_enabled = true; - } - if (strcmp(pCreateInfo->ppEnabledExtensionNames[i], VK_KHR_DISPLAY_SWAPCHAIN_EXTENSION_NAME) == 0) { - device_data->display_swapchain_enabled = true; - } - if (strcmp(pCreateInfo->ppEnabledExtensionNames[i], VK_AMD_NEGATIVE_VIEWPORT_HEIGHT_EXTENSION_NAME) == 0) { - device_data->amd_negative_viewport_height_enabled = true; - } - if (strcmp(pCreateInfo->ppEnabledExtensionNames[i], VK_NVX_DEVICE_GENERATED_COMMANDS_EXTENSION_NAME) == 0) { - device_data->nvx_device_generated_commands_enabled = true; + device_data->enables.khr_swapchain_enabled = true; + } else if (strcmp(pCreateInfo->ppEnabledExtensionNames[i], VK_KHR_DISPLAY_SWAPCHAIN_EXTENSION_NAME) == 0) { + device_data->enables.khr_display_swapchain_enabled = true; + } else if (strcmp(pCreateInfo->ppEnabledExtensionNames[i], VK_KHR_MAINTENANCE1_EXTENSION_NAME) == 0) { + device_data->enables.khr_maintenance1 = true; +#ifdef VK_USE_PLATFORM_WIN32_KHR + } else if (strcmp(pCreateInfo->ppEnabledExtensionNames[i], VK_NV_EXTERNAL_MEMORY_WIN32_EXTENSION_NAME) == 0) { + device_data->enables.nv_external_memory_win32 = true; +#endif + } else if (strcmp(pCreateInfo->ppEnabledExtensionNames[i], VK_EXT_DEBUG_MARKER_EXTENSION_NAME) == 0) { + device_data->enables.ext_debug_marker = true; + } else if (strcmp(pCreateInfo->ppEnabledExtensionNames[i], VK_AMD_NEGATIVE_VIEWPORT_HEIGHT_EXTENSION_NAME) == 0) { + device_data->enables.amd_negative_viewport_height = true; + } else if (strcmp(pCreateInfo->ppEnabledExtensionNames[i], VK_NV_EXTERNAL_MEMORY_EXTENSION_NAME) == 0) { + device_data->enables.nv_external_memory = true; + } else if (strcmp(pCreateInfo->ppEnabledExtensionNames[i], VK_NVX_DEVICE_GENERATED_COMMANDS_EXTENSION_NAME) == 0) { + device_data->enables.nvx_device_generated_commands = true; } } } @@ -3995,7 +4019,7 @@ static bool preCmdSetViewport(layer_data *my_data, uint32_t viewport_count, cons } bool invalid_height = (viewport.height <= 0 || viewport.height > limits.maxViewportDimensions[1]); - if (my_data->amd_negative_viewport_height_enabled && (viewport.height < 0)) { + if (my_data->enables.amd_negative_viewport_height && (viewport.height < 0)) { // VALIDATION_ERROR_01790 invalid_height = false; } @@ -4817,9 +4841,9 @@ VKAPI_ATTR VkResult VKAPI_CALL EnumerateDeviceExtensionProperties(VkPhysicalDevi ->dispatch_table.EnumerateDeviceExtensionProperties(physicalDevice, NULL, pCount, pProperties); } -static bool require_device_extension(layer_data *my_data, bool layer_data::*flag, char const *function_name, char const *extension_name) +static bool require_device_extension(layer_data *my_data, bool flag, char const *function_name, char const *extension_name) { - if (!(my_data->*flag)) { + if (!flag) { return log_msg(my_data->report_data, VK_DEBUG_REPORT_ERROR_BIT_EXT, VK_DEBUG_REPORT_OBJECT_TYPE_UNKNOWN_EXT, 0, __LINE__, EXTENSION_NOT_ENABLED, LayerName, "%s() called even though the %s extension was not enabled for this VkDevice.", @@ -4838,7 +4862,7 @@ VKAPI_ATTR VkResult VKAPI_CALL CreateSwapchainKHR(VkDevice device, const VkSwapc layer_data *my_data = get_my_data_ptr(get_dispatch_key(device), layer_data_map); assert(my_data != NULL); - skip |= require_device_extension(my_data, &layer_data::swapchain_enabled, "vkCreateSwapchainKHR", VK_KHR_SWAPCHAIN_EXTENSION_NAME); + skip |= require_device_extension(my_data, my_data->enables.khr_swapchain_enabled, "vkCreateSwapchainKHR", VK_KHR_SWAPCHAIN_EXTENSION_NAME); skip |= parameter_validation_vkCreateSwapchainKHR(my_data->report_data, pCreateInfo, pAllocator, pSwapchain); @@ -4858,7 +4882,7 @@ VKAPI_ATTR VkResult VKAPI_CALL GetSwapchainImagesKHR(VkDevice device, VkSwapchai layer_data *my_data = get_my_data_ptr(get_dispatch_key(device), layer_data_map); assert(my_data != NULL); - skip |= require_device_extension(my_data, &layer_data::swapchain_enabled, "vkGetSwapchainImagesKHR", VK_KHR_SWAPCHAIN_EXTENSION_NAME); + skip |= require_device_extension(my_data, my_data->enables.khr_swapchain_enabled, "vkGetSwapchainImagesKHR", VK_KHR_SWAPCHAIN_EXTENSION_NAME); skip |= parameter_validation_vkGetSwapchainImagesKHR(my_data->report_data, swapchain, pSwapchainImageCount, pSwapchainImages); @@ -4879,7 +4903,7 @@ VKAPI_ATTR VkResult VKAPI_CALL AcquireNextImageKHR(VkDevice device, VkSwapchainK layer_data *my_data = get_my_data_ptr(get_dispatch_key(device), layer_data_map); assert(my_data != NULL); - skip |= require_device_extension(my_data, &layer_data::swapchain_enabled, "vkAcquireNextImageKHR", VK_KHR_SWAPCHAIN_EXTENSION_NAME); + skip |= require_device_extension(my_data, my_data->enables.khr_swapchain_enabled, "vkAcquireNextImageKHR", VK_KHR_SWAPCHAIN_EXTENSION_NAME); skip |= parameter_validation_vkAcquireNextImageKHR(my_data->report_data, swapchain, timeout, semaphore, fence, pImageIndex); @@ -4899,7 +4923,7 @@ VKAPI_ATTR VkResult VKAPI_CALL QueuePresentKHR(VkQueue queue, const VkPresentInf layer_data *my_data = get_my_data_ptr(get_dispatch_key(queue), layer_data_map); assert(my_data != NULL); - skip |= require_device_extension(my_data, &layer_data::swapchain_enabled, "vkQueuePresentKHR", VK_KHR_SWAPCHAIN_EXTENSION_NAME); + skip |= require_device_extension(my_data, my_data->enables.khr_swapchain_enabled, "vkQueuePresentKHR", VK_KHR_SWAPCHAIN_EXTENSION_NAME); skip |= parameter_validation_vkQueuePresentKHR(my_data->report_data, pPresentInfo); @@ -4917,7 +4941,7 @@ VKAPI_ATTR void VKAPI_CALL DestroySwapchainKHR(VkDevice device, VkSwapchainKHR s layer_data *my_data = get_my_data_ptr(get_dispatch_key(device), layer_data_map); assert(my_data != NULL); - skip |= require_device_extension(my_data, &layer_data::swapchain_enabled, "vkDestroySwapchainKHR", VK_KHR_SWAPCHAIN_EXTENSION_NAME); + skip |= require_device_extension(my_data, my_data->enables.khr_swapchain_enabled, "vkDestroySwapchainKHR", VK_KHR_SWAPCHAIN_EXTENSION_NAME); /* No generated validation function for this call */ @@ -5280,8 +5304,8 @@ VKAPI_ATTR VkResult VKAPI_CALL CreateAndroidSurfaceKHR(VkInstance instance, cons assert(my_data != NULL); bool skip = false; - skip |= require_instance_extension(instance, &instance_extension_enables::android_enabled, - "vkCreateAndroidSurfaceKHR", VK_KHR_ANDROID_SURFACE_EXTENSION_NAME); + skip |= require_instance_extension(instance, &instance_extension_enables::android_enabled, "vkCreateAndroidSurfaceKHR", + VK_KHR_ANDROID_SURFACE_EXTENSION_NAME); skip |= parameter_validation_vkCreateAndroidSurfaceKHR(my_data->report_data, pCreateInfo, pAllocator, pSurface); @@ -5303,10 +5327,11 @@ VKAPI_ATTR VkResult VKAPI_CALL CreateSharedSwapchainsKHR(VkDevice device, uint32 auto my_data = get_my_data_ptr(get_dispatch_key(device), layer_data_map); assert(my_data != NULL); - skip |= require_device_extension(my_data, &layer_data::display_swapchain_enabled, "vkCreateSharedSwapchainsKHR", VK_KHR_DISPLAY_SWAPCHAIN_EXTENSION_NAME); + skip |= require_device_extension(my_data, my_data->enables.khr_display_swapchain_enabled, "vkCreateSharedSwapchainsKHR", + VK_KHR_DISPLAY_SWAPCHAIN_EXTENSION_NAME); skip |= parameter_validation_vkCreateSharedSwapchainsKHR(my_data->report_data, swapchainCount, pCreateInfos, pAllocator, - pSwapchains); + pSwapchains); if (!skip) { result = my_data->dispatch_table.CreateSharedSwapchainsKHR(device, swapchainCount, pCreateInfos, pAllocator, pSwapchains); @@ -5409,8 +5434,8 @@ VKAPI_ATTR VkResult VKAPI_CALL CreateDisplayModeKHR(VkPhysicalDevice physicalDev auto my_data = get_my_data_ptr(get_dispatch_key(physicalDevice), instance_layer_data_map); assert(my_data != NULL); - skip |= require_instance_extension(physicalDevice, &instance_extension_enables::display_enabled, - "vkCreateDisplayModeKHR", VK_KHR_DISPLAY_EXTENSION_NAME); + skip |= require_instance_extension(physicalDevice, &instance_extension_enables::display_enabled, "vkCreateDisplayModeKHR", + VK_KHR_DISPLAY_EXTENSION_NAME); // No parameter validation function for this call? @@ -5451,8 +5476,8 @@ VKAPI_ATTR VkResult VKAPI_CALL CreateDisplayPlaneSurfaceKHR(VkInstance instance, auto my_data = get_my_data_ptr(get_dispatch_key(instance), instance_layer_data_map); assert(my_data != NULL); - skip |= require_instance_extension(instance, &instance_extension_enables::display_enabled, - "vkCreateDisplayPlaneSurfaceKHR", VK_KHR_DISPLAY_EXTENSION_NAME); + skip |= require_instance_extension(instance, &instance_extension_enables::display_enabled, "vkCreateDisplayPlaneSurfaceKHR", + VK_KHR_DISPLAY_EXTENSION_NAME); // No parameter validation function for this call? @@ -5465,13 +5490,204 @@ VKAPI_ATTR VkResult VKAPI_CALL CreateDisplayPlaneSurfaceKHR(VkInstance instance, return result; } -// VK_EXT_debug_marker Extension +// Definitions for the VK_KHR_get_physical_device_properties2 extension + +VKAPI_ATTR void VKAPI_CALL GetPhysicalDeviceFeatures2KHR(VkPhysicalDevice physicalDevice, VkPhysicalDeviceFeatures2KHR *pFeatures) { + bool skip_call = false; + auto my_data = get_my_data_ptr(get_dispatch_key(physicalDevice), instance_layer_data_map); + assert(my_data != NULL); + + skip_call |= + require_instance_extension(physicalDevice, &instance_extension_enables::khr_get_phys_dev_properties2_enabled, + "vkGetPhysicalDeviceFeatures2KHR", VK_KHR_GET_PHYSICAL_DEVICE_PROPERTIES_2_EXTENSION_NAME); + + skip_call |= parameter_validation_vkGetPhysicalDeviceFeatures2KHR(my_data->report_data, pFeatures); + + if (!skip_call) { + my_data->dispatch_table.GetPhysicalDeviceFeatures2KHR(physicalDevice, pFeatures); + } +} + +VKAPI_ATTR void VKAPI_CALL GetPhysicalDeviceProperties2KHR(VkPhysicalDevice physicalDevice, + VkPhysicalDeviceProperties2KHR *pProperties) { + bool skip_call = false; + auto my_data = get_my_data_ptr(get_dispatch_key(physicalDevice), instance_layer_data_map); + assert(my_data != NULL); + + skip_call |= + require_instance_extension(physicalDevice, &instance_extension_enables::khr_get_phys_dev_properties2_enabled, + "vkGetPhysicalDeviceProperties2KHR", VK_KHR_GET_PHYSICAL_DEVICE_PROPERTIES_2_EXTENSION_NAME); + + skip_call |= parameter_validation_vkGetPhysicalDeviceProperties2KHR(my_data->report_data, pProperties); + + if (!skip_call) { + my_data->dispatch_table.GetPhysicalDeviceProperties2KHR(physicalDevice, pProperties); + } +} + +VKAPI_ATTR void VKAPI_CALL GetPhysicalDeviceFormatProperties2KHR(VkPhysicalDevice physicalDevice, VkFormat format, + VkFormatProperties2KHR *pFormatProperties) { + bool skip_call = false; + auto my_data = get_my_data_ptr(get_dispatch_key(physicalDevice), instance_layer_data_map); + assert(my_data != NULL); + + skip_call |= require_instance_extension(physicalDevice, &instance_extension_enables::khr_get_phys_dev_properties2_enabled, + "vkGetPhysicalDeviceFormatProperties2KHR", + VK_KHR_GET_PHYSICAL_DEVICE_PROPERTIES_2_EXTENSION_NAME); + + skip_call |= parameter_validation_vkGetPhysicalDeviceFormatProperties2KHR(my_data->report_data, format, pFormatProperties); + + if (!skip_call) { + my_data->dispatch_table.GetPhysicalDeviceFormatProperties2KHR(physicalDevice, format, pFormatProperties); + } +} + +VKAPI_ATTR VkResult VKAPI_CALL GetPhysicalDeviceImageFormatProperties2KHR( + VkPhysicalDevice physicalDevice, const VkPhysicalDeviceImageFormatInfo2KHR *pImageFormatInfo, + VkImageFormatProperties2KHR *pImageFormatProperties) { + VkResult result = VK_ERROR_VALIDATION_FAILED_EXT; + bool skip_call = false; + auto my_data = get_my_data_ptr(get_dispatch_key(physicalDevice), instance_layer_data_map); + assert(my_data != NULL); + + skip_call |= require_instance_extension(physicalDevice, &instance_extension_enables::khr_get_phys_dev_properties2_enabled, + "vkGetPhysicalDeviceImageFormatProperties2KHR", + VK_KHR_GET_PHYSICAL_DEVICE_PROPERTIES_2_EXTENSION_NAME); + + skip_call |= parameter_validation_vkGetPhysicalDeviceImageFormatProperties2KHR(my_data->report_data, pImageFormatInfo, + pImageFormatProperties); + + if (!skip_call) { + result = my_data->dispatch_table.GetPhysicalDeviceImageFormatProperties2KHR(physicalDevice, pImageFormatInfo, + pImageFormatProperties); + validate_result(my_data->report_data, "vkGetPhysicalDeviceImageFormatProperties2KHR", result); + } + + return result; +} + +VKAPI_ATTR void VKAPI_CALL GetPhysicalDeviceQueueFamilyProperties2KHR(VkPhysicalDevice physicalDevice, + uint32_t *pQueueFamilyPropertyCount, + VkQueueFamilyProperties2KHR *pQueueFamilyProperties) { + bool skip_call = false; + auto my_data = get_my_data_ptr(get_dispatch_key(physicalDevice), instance_layer_data_map); + assert(my_data != NULL); + + skip_call |= require_instance_extension(physicalDevice, &instance_extension_enables::khr_get_phys_dev_properties2_enabled, + "vkGetPhysicalDeviceQueueFamilyProperties2KHR", + VK_KHR_GET_PHYSICAL_DEVICE_PROPERTIES_2_EXTENSION_NAME); + + skip_call |= parameter_validation_vkGetPhysicalDeviceQueueFamilyProperties2KHR(my_data->report_data, pQueueFamilyPropertyCount, + pQueueFamilyProperties); + + if (!skip_call) { + my_data->dispatch_table.GetPhysicalDeviceQueueFamilyProperties2KHR(physicalDevice, pQueueFamilyPropertyCount, + pQueueFamilyProperties); + } +} + +VKAPI_ATTR void VKAPI_CALL GetPhysicalDeviceMemoryProperties2KHR(VkPhysicalDevice physicalDevice, + VkPhysicalDeviceMemoryProperties2KHR *pMemoryProperties) { + bool skip_call = false; + auto my_data = get_my_data_ptr(get_dispatch_key(physicalDevice), instance_layer_data_map); + assert(my_data != NULL); + + skip_call |= require_instance_extension(physicalDevice, &instance_extension_enables::khr_get_phys_dev_properties2_enabled, + "vkGetPhysicalDeviceMemoryProperties2KHR", + VK_KHR_GET_PHYSICAL_DEVICE_PROPERTIES_2_EXTENSION_NAME); + + skip_call |= parameter_validation_vkGetPhysicalDeviceMemoryProperties2KHR(my_data->report_data, pMemoryProperties); + + if (!skip_call) { + my_data->dispatch_table.GetPhysicalDeviceMemoryProperties2KHR(physicalDevice, pMemoryProperties); + } +} + +VKAPI_ATTR void VKAPI_CALL GetPhysicalDeviceSparseImageFormatProperties2KHR( + VkPhysicalDevice physicalDevice, const VkPhysicalDeviceSparseImageFormatInfo2KHR *pFormatInfo, uint32_t *pPropertyCount, + VkSparseImageFormatProperties2KHR *pProperties) { + bool skip_call = false; + auto my_data = get_my_data_ptr(get_dispatch_key(physicalDevice), instance_layer_data_map); + assert(my_data != NULL); + + skip_call |= require_instance_extension(physicalDevice, &instance_extension_enables::khr_get_phys_dev_properties2_enabled, + "vkGetPhysicalDeviceSparseImageFormatProperties2KHR", + VK_KHR_GET_PHYSICAL_DEVICE_PROPERTIES_2_EXTENSION_NAME); + + skip_call |= parameter_validation_vkGetPhysicalDeviceSparseImageFormatProperties2KHR(my_data->report_data, pFormatInfo, + pPropertyCount, pProperties); + + if (!skip_call) { + my_data->dispatch_table.GetPhysicalDeviceSparseImageFormatProperties2KHR(physicalDevice, pFormatInfo, pPropertyCount, + pProperties); + } +} + +// Definitions for the VK_KHR_maintenance1 extension + +VKAPI_ATTR void VKAPI_CALL TrimCommandPoolKHR(VkDevice device, VkCommandPool commandPool, VkCommandPoolTrimFlagsKHR flags) { + bool skip_call = false; + layer_data *my_data = get_my_data_ptr(get_dispatch_key(device), layer_data_map); + assert(my_data != NULL); + + skip_call |= require_device_extension(my_data, my_data->enables.khr_maintenance1, "vkTrimCommandPoolKHR", + VK_KHR_MAINTENANCE1_EXTENSION_NAME); + + skip_call |= parameter_validation_vkTrimCommandPoolKHR(my_data->report_data, commandPool, flags); + + if (!skip_call) { + my_data->dispatch_table.TrimCommandPoolKHR(device, commandPool, flags); + } +} + +// Definitions for the VK_EXT_acquire_xlib_display extension + +#ifdef VK_USE_PLATFORM_XLIB_XRANDR_EXT +VKAPI_ATTR VkResult VKAPI_CALL AcquireXlibDisplayEXT(VkPhysicalDevice physicalDevice, Display *dpy, VkDisplayKHR display) { + + VkResult result = VK_ERROR_VALIDATION_FAILED_EXT; + auto my_data = get_my_data_ptr(get_dispatch_key(physicalDevice), instance_layer_data_map); + assert(my_data != NULL); + bool skip = false; + skip |= require_instance_extension(physicalDevice, &instance_extension_enables::ext_acquire_xlib_display_enabled, + "vkAcquireXlibDisplayEXT", VK_EXT_ACQUIRE_XLIB_DISPLAY_EXTENSION_NAME); + skip |= parameter_validation_vkAcquireXlibDisplayEXT(my_data->report_data, dpy, display); + if (!skip) { + result = my_data->dispatch_table.AcquireXlibDisplayEXT(physicalDevice, dpy, display); + validate_result(my_data->report_data, "vkAcquireXlibDisplayEXT", result); + } + return result; +} + +VKAPI_ATTR VkResult VKAPI_CALL GetRandROutputDisplayEXT(VkPhysicalDevice physicalDevice, Display *dpy, RROutput rrOutput, + VkDisplayKHR *pDisplay) { + + VkResult result = VK_ERROR_VALIDATION_FAILED_EXT; + auto my_data = get_my_data_ptr(get_dispatch_key(physicalDevice), instance_layer_data_map); + assert(my_data != NULL); + bool skip = false; + skip |= require_instance_extension(physicalDevice, &instance_extension_enables::ext_acquire_xlib_display_enabled, + "vkGetRandROutputDisplayEXT", VK_EXT_ACQUIRE_XLIB_DISPLAY_EXTENSION_NAME); + skip |= parameter_validation_vkGetRandROutputDisplayEXT(my_data->report_data, dpy, rrOutput, pDisplay); + if (!skip) { + result = my_data->dispatch_table.GetRandROutputDisplayEXT(physicalDevice, dpy, rrOutput, pDisplay); + validate_result(my_data->report_data, "vkGetRandROutputDisplayEXT", result); + } + return result; +} +#endif // VK_USE_PLATFORM_XLIB_XRANDR_EXT + +// Definitions for the VK_EXT_debug_marker Extension + VKAPI_ATTR VkResult VKAPI_CALL DebugMarkerSetObjectTagEXT(VkDevice device, VkDebugMarkerObjectTagInfoEXT *pTagInfo) { VkResult result = VK_ERROR_VALIDATION_FAILED_EXT; bool skip = false; layer_data *my_data = get_my_data_ptr(get_dispatch_key(device), layer_data_map); assert(my_data != NULL); + skip |= require_device_extension(my_data, my_data->enables.ext_debug_marker, "vkDebugMarkerSetObjectTagEXT", + VK_EXT_DEBUG_MARKER_EXTENSION_NAME); + skip |= parameter_validation_vkDebugMarkerSetObjectTagEXT(my_data->report_data, pTagInfo); if (!skip) { @@ -5492,6 +5708,9 @@ VKAPI_ATTR VkResult VKAPI_CALL DebugMarkerSetObjectNameEXT(VkDevice device, VkDe layer_data *my_data = get_my_data_ptr(get_dispatch_key(device), layer_data_map); assert(my_data != NULL); + skip |= require_device_extension(my_data, my_data->enables.ext_debug_marker, "vkDebugMarkerSetObjectNameEXT", + VK_EXT_DEBUG_MARKER_EXTENSION_NAME); + skip |= parameter_validation_vkDebugMarkerSetObjectNameEXT(my_data->report_data, pNameInfo); if (!skip) { @@ -5511,6 +5730,9 @@ VKAPI_ATTR void VKAPI_CALL CmdDebugMarkerBeginEXT(VkCommandBuffer commandBuffer, layer_data *my_data = get_my_data_ptr(get_dispatch_key(commandBuffer), layer_data_map); assert(my_data != NULL); + skip |= require_device_extension(my_data, my_data->enables.ext_debug_marker, "vkCmdDebugMarkerBeginEXT", + VK_EXT_DEBUG_MARKER_EXTENSION_NAME); + skip |= parameter_validation_vkCmdDebugMarkerBeginEXT(my_data->report_data, pMarkerInfo); if (!skip && my_data->dispatch_table.CmdDebugMarkerBeginEXT) { @@ -5523,6 +5745,9 @@ VKAPI_ATTR void VKAPI_CALL CmdDebugMarkerInsertEXT(VkCommandBuffer commandBuffer layer_data *my_data = get_my_data_ptr(get_dispatch_key(commandBuffer), layer_data_map); assert(my_data != NULL); + skip |= require_device_extension(my_data, my_data->enables.ext_debug_marker, "vkCmdDebugMarkerInsertEXT", + VK_EXT_DEBUG_MARKER_EXTENSION_NAME); + skip |= parameter_validation_vkCmdDebugMarkerInsertEXT(my_data->report_data, pMarkerInfo); if (!skip && my_data->dispatch_table.CmdDebugMarkerInsertEXT) { @@ -5530,7 +5755,48 @@ VKAPI_ATTR void VKAPI_CALL CmdDebugMarkerInsertEXT(VkCommandBuffer commandBuffer } } -// VK_NV_external_memory_capabilities Extension +// Definitions for the VK_EXT_direct_mode_display extension + +VKAPI_ATTR VkResult VKAPI_CALL ReleaseDisplayEXT(VkPhysicalDevice physicalDevice, VkDisplayKHR display) { + + VkResult result = VK_ERROR_VALIDATION_FAILED_EXT; + auto my_data = get_my_data_ptr(get_dispatch_key(physicalDevice), instance_layer_data_map); + assert(my_data != NULL); + bool skip = false; + skip |= require_instance_extension(physicalDevice, &instance_extension_enables::ext_direct_mode_display_enabled, + "vkReleaseDisplayEXT", VK_EXT_DIRECT_MODE_DISPLAY_EXTENSION_NAME); +#if 0 // Validation not automatically generated + skip |= parameter_validation_vkReleaseDisplayEXT(my_data->report_data, display); +#endif + if (!skip) { + result = my_data->dispatch_table.ReleaseDisplayEXT(physicalDevice, display); + validate_result(my_data->report_data, "vkGetRandROutputDisplayEXT", result); + } + return result; +} + +// Definitions for the VK_EXT_display_surface_counter extension + +VKAPI_ATTR VkResult VKAPI_CALL GetPhysicalDeviceSurfaceCapabilities2EXT(VkPhysicalDevice physicalDevice, VkSurfaceKHR surface, + VkSurfaceCapabilities2EXT *pSurfaceCapabilities) { + + VkResult result = VK_ERROR_VALIDATION_FAILED_EXT; + auto my_data = get_my_data_ptr(get_dispatch_key(physicalDevice), instance_layer_data_map); + assert(my_data != NULL); + bool skip = false; + skip |= require_instance_extension(physicalDevice, &instance_extension_enables::ext_display_surface_counter_enabled, + "vkGetPhysicalDeviceSurfaceCapabilities2EXT", VK_EXT_DISPLAY_SURFACE_COUNTER_EXTENSION_NAME); + skip |= + parameter_validation_vkGetPhysicalDeviceSurfaceCapabilities2EXT(my_data->report_data, surface, pSurfaceCapabilities); + if (!skip) { + result = my_data->dispatch_table.GetPhysicalDeviceSurfaceCapabilities2EXT(physicalDevice, surface, pSurfaceCapabilities); + validate_result(my_data->report_data, "vkGetPhysicalDeviceSurfaceCapabilities2EXT", result); + } + return result; +} + +// Definitions for the VK_NV_external_memory_capabilities Extension + VKAPI_ATTR VkResult VKAPI_CALL GetPhysicalDeviceExternalImageFormatPropertiesNV( VkPhysicalDevice physicalDevice, VkFormat format, VkImageType type, VkImageTiling tiling, VkImageUsageFlags usage, VkImageCreateFlags flags, VkExternalMemoryHandleTypeFlagsNV externalHandleType, @@ -5541,6 +5807,10 @@ VKAPI_ATTR VkResult VKAPI_CALL GetPhysicalDeviceExternalImageFormatPropertiesNV( auto my_data = get_my_data_ptr(get_dispatch_key(physicalDevice), instance_layer_data_map); assert(my_data != NULL); + skip |= require_instance_extension(physicalDevice, &instance_extension_enables::nv_external_memory_capabilities_enabled, + "vkGetPhysicalDeviceExternalImageFormatPropertiesNV", + VK_NV_EXTERNAL_MEMORY_CAPABILITIES_EXTENSION_NAME); + skip |= parameter_validation_vkGetPhysicalDeviceExternalImageFormatPropertiesNV( my_data->report_data, format, type, tiling, usage, flags, externalHandleType, pExternalImageFormatProperties); @@ -5554,8 +5824,9 @@ VKAPI_ATTR VkResult VKAPI_CALL GetPhysicalDeviceExternalImageFormatPropertiesNV( return result; } -#ifdef VK_USE_PLATFORM_WIN32_KHR // VK_NV_external_memory_win32 Extension + +#ifdef VK_USE_PLATFORM_WIN32_KHR VKAPI_ATTR VkResult VKAPI_CALL GetMemoryWin32HandleNV(VkDevice device, VkDeviceMemory memory, VkExternalMemoryHandleTypeFlagsNV handleType, HANDLE *pHandle) { @@ -5564,6 +5835,9 @@ VKAPI_ATTR VkResult VKAPI_CALL GetMemoryWin32HandleNV(VkDevice device, VkDeviceM layer_data *my_data = get_my_data_ptr(get_dispatch_key(device), layer_data_map); assert(my_data != NULL); + skip |= require_device_extension(my_data, my_data->enables.nv_external_memory_win32, "vkGetMemoryWin32HandleNV", + VK_NV_EXTERNAL_MEMORY_WIN32_EXTENSION_NAME); + skip |= parameter_validation_vkGetMemoryWin32HandleNV(my_data->report_data, memory, handleType, pHandle); if (!skip) { @@ -5574,37 +5848,31 @@ VKAPI_ATTR VkResult VKAPI_CALL GetMemoryWin32HandleNV(VkDevice device, VkDeviceM } #endif // VK_USE_PLATFORM_WIN32_KHR -// VK_NVX_device_generated_commands extension +// VK_NVX_device_generated_commands Extension VKAPI_ATTR void VKAPI_CALL CmdProcessCommandsNVX(VkCommandBuffer commandBuffer, const VkCmdProcessCommandsInfoNVX *pProcessCommandsInfo) { bool skip = false; - layer_data *device_data = get_my_data_ptr(get_dispatch_key(commandBuffer), layer_data_map); - assert(device_data != nullptr); - debug_report_data *report_data = device_data->report_data; - - skip |= require_device_extension(device_data, &layer_data::nvx_device_generated_commands_enabled, "vkCmdProcessCommandsNVX", + layer_data *my_data = get_my_data_ptr(get_dispatch_key(commandBuffer), layer_data_map); + assert(my_data != NULL); + skip |= require_device_extension(my_data, my_data->enables.nvx_device_generated_commands, "vkCmdProcessCommandsNVX", VK_NVX_DEVICE_GENERATED_COMMANDS_EXTENSION_NAME); - skip |= parameter_validation_vkCmdProcessCommandsNVX(report_data, pProcessCommandsInfo); - + skip |= parameter_validation_vkCmdProcessCommandsNVX(my_data->report_data, pProcessCommandsInfo); if (!skip) { - device_data->dispatch_table.CmdProcessCommandsNVX(commandBuffer, pProcessCommandsInfo); + my_data->dispatch_table.CmdProcessCommandsNVX(commandBuffer, pProcessCommandsInfo); } } VKAPI_ATTR void VKAPI_CALL CmdReserveSpaceForCommandsNVX(VkCommandBuffer commandBuffer, const VkCmdReserveSpaceForCommandsInfoNVX *pReserveSpaceInfo) { bool skip = false; - layer_data *device_data = get_my_data_ptr(get_dispatch_key(commandBuffer), layer_data_map); - assert(device_data != nullptr); - debug_report_data *report_data = device_data->report_data; - - skip |= require_device_extension(device_data, &layer_data::nvx_device_generated_commands_enabled, - "vkCmdReserveSpaceForCommandsNVX", VK_NVX_DEVICE_GENERATED_COMMANDS_EXTENSION_NAME); - skip |= parameter_validation_vkCmdReserveSpaceForCommandsNVX(report_data, pReserveSpaceInfo); - + layer_data *my_data = get_my_data_ptr(get_dispatch_key(commandBuffer), layer_data_map); + assert(my_data != NULL); + skip |= require_device_extension(my_data, my_data->enables.nvx_device_generated_commands, "vkCmdReserveSpaceForCommandsNVX", + VK_NVX_DEVICE_GENERATED_COMMANDS_EXTENSION_NAME); + skip |= parameter_validation_vkCmdReserveSpaceForCommandsNVX(my_data->report_data, pReserveSpaceInfo); if (!skip) { - device_data->dispatch_table.CmdReserveSpaceForCommandsNVX(commandBuffer, pReserveSpaceInfo); + my_data->dispatch_table.CmdReserveSpaceForCommandsNVX(commandBuffer, pReserveSpaceInfo); } } @@ -5616,13 +5884,12 @@ VKAPI_ATTR VkResult VKAPI_CALL CreateIndirectCommandsLayoutNVX(VkDevice device, bool skip = false; layer_data *my_data = get_my_data_ptr(get_dispatch_key(device), layer_data_map); assert(my_data != NULL); - skip |= require_device_extension(my_data, &layer_data::nvx_device_generated_commands_enabled, - "vkCreateIndirectCommandsLayoutNVX", VK_NVX_DEVICE_GENERATED_COMMANDS_EXTENSION_NAME); + skip |= require_device_extension(my_data, my_data->enables.nvx_device_generated_commands, "vkCreateIndirectCommandsLayoutNVX", + VK_NVX_DEVICE_GENERATED_COMMANDS_EXTENSION_NAME); skip |= parameter_validation_vkCreateIndirectCommandsLayoutNVX(my_data->report_data, pCreateInfo, pAllocator, pIndirectCommandsLayout); if (!skip) { result = my_data->dispatch_table.CreateIndirectCommandsLayoutNVX(device, pCreateInfo, pAllocator, pIndirectCommandsLayout); - validate_result(my_data->report_data, "vkCreateIndirectCommandsLayoutNVX", result); } return result; @@ -5633,9 +5900,11 @@ VKAPI_ATTR void VKAPI_CALL DestroyIndirectCommandsLayoutNVX(VkDevice device, VkI bool skip = false; layer_data *my_data = get_my_data_ptr(get_dispatch_key(device), layer_data_map); assert(my_data != NULL); - skip |= require_device_extension(my_data, &layer_data::nvx_device_generated_commands_enabled, - "vkDestroyIndirectCommandsLayoutNVX", VK_NVX_DEVICE_GENERATED_COMMANDS_EXTENSION_NAME); + skip |= require_device_extension(my_data, my_data->enables.nvx_device_generated_commands, "vkDestroyIndirectCommandsLayoutNVX", + VK_NVX_DEVICE_GENERATED_COMMANDS_EXTENSION_NAME); +#if 0 // Validation not automatically generated skip |= parameter_validation_vkDestroyIndirectCommandsLayoutNVX(my_data->report_data, indirectCommandsLayout, pAllocator); +#endif if (!skip) { my_data->dispatch_table.DestroyIndirectCommandsLayoutNVX(device, indirectCommandsLayout, pAllocator); } @@ -5647,11 +5916,12 @@ VKAPI_ATTR VkResult VKAPI_CALL CreateObjectTableNVX(VkDevice device, const VkObj bool skip = false; layer_data *my_data = get_my_data_ptr(get_dispatch_key(device), layer_data_map); assert(my_data != NULL); - skip |= require_device_extension(my_data, &layer_data::nvx_device_generated_commands_enabled, "vkCreateObjectTableNVX", + skip |= require_device_extension(my_data, my_data->enables.nvx_device_generated_commands, "vkCreateObjectTableNVX", VK_NVX_DEVICE_GENERATED_COMMANDS_EXTENSION_NAME); skip |= parameter_validation_vkCreateObjectTableNVX(my_data->report_data, pCreateInfo, pAllocator, pObjectTable); if (!skip) { result = my_data->dispatch_table.CreateObjectTableNVX(device, pCreateInfo, pAllocator, pObjectTable); + validate_result(my_data->report_data, "vkCreateObjectTableNVX", result); } return result; } @@ -5661,9 +5931,11 @@ VKAPI_ATTR void VKAPI_CALL DestroyObjectTableNVX(VkDevice device, VkObjectTableN bool skip = false; layer_data *my_data = get_my_data_ptr(get_dispatch_key(device), layer_data_map); assert(my_data != NULL); - skip |= require_device_extension(my_data, &layer_data::nvx_device_generated_commands_enabled, "vkDestroyObjectTableNVX", + skip |= require_device_extension(my_data, my_data->enables.nvx_device_generated_commands, "vkDestroyObjectTableNVX", VK_NVX_DEVICE_GENERATED_COMMANDS_EXTENSION_NAME); +#if 0 // Validation not automatically generated skip |= parameter_validation_vkDestroyObjectTableNVX(my_data->report_data, objectTable, pAllocator); +#endif if (!skip) { my_data->dispatch_table.DestroyObjectTableNVX(device, objectTable, pAllocator); } @@ -5676,12 +5948,13 @@ VKAPI_ATTR VkResult VKAPI_CALL RegisterObjectsNVX(VkDevice device, VkObjectTable bool skip = false; layer_data *my_data = get_my_data_ptr(get_dispatch_key(device), layer_data_map); assert(my_data != NULL); - skip |= require_device_extension(my_data, &layer_data::nvx_device_generated_commands_enabled, "vkRegisterObjectsNVX", + skip |= require_device_extension(my_data, my_data->enables.nvx_device_generated_commands, "vkRegisterObjectsNVX", VK_NVX_DEVICE_GENERATED_COMMANDS_EXTENSION_NAME); skip |= parameter_validation_vkRegisterObjectsNVX(my_data->report_data, objectTable, objectCount, ppObjectTableEntries, pObjectIndices); if (!skip) { result = my_data->dispatch_table.RegisterObjectsNVX(device, objectTable, objectCount, ppObjectTableEntries, pObjectIndices); + validate_result(my_data->report_data, "vkRegisterObjectsNVX", result); } return result; } @@ -5692,12 +5965,13 @@ VKAPI_ATTR VkResult VKAPI_CALL UnregisterObjectsNVX(VkDevice device, VkObjectTab bool skip = false; layer_data *my_data = get_my_data_ptr(get_dispatch_key(device), layer_data_map); assert(my_data != NULL); - skip |= require_device_extension(my_data, &layer_data::nvx_device_generated_commands_enabled, "vkUnregisterObjectsNVX", + skip |= require_device_extension(my_data, my_data->enables.nvx_device_generated_commands, "vkUnregisterObjectsNVX", VK_NVX_DEVICE_GENERATED_COMMANDS_EXTENSION_NAME); skip |= parameter_validation_vkUnregisterObjectsNVX(my_data->report_data, objectTable, objectCount, pObjectEntryTypes, pObjectIndices); if (!skip) { result = my_data->dispatch_table.UnregisterObjectsNVX(device, objectTable, objectCount, pObjectEntryTypes, pObjectIndices); + validate_result(my_data->report_data, "vkUnregisterObjectsNVX", result); } return result; } @@ -5708,9 +5982,7 @@ VKAPI_ATTR void VKAPI_CALL GetPhysicalDeviceGeneratedCommandsPropertiesNVX(VkPhy bool skip = false; auto my_data = get_my_data_ptr(get_dispatch_key(physicalDevice), instance_layer_data_map); assert(my_data != NULL); - skip |= parameter_validation_vkGetPhysicalDeviceGeneratedCommandsPropertiesNVX(my_data->report_data, pFeatures, pLimits); - if (!skip) { my_data->dispatch_table.GetPhysicalDeviceGeneratedCommandsPropertiesNVX(physicalDevice, pFeatures, pLimits); } @@ -5724,6 +5996,10 @@ static PFN_vkVoidFunction InterceptWsiEnabledCommand(const char *name, VkDevice static PFN_vkVoidFunction InterceptWsiEnabledCommand(const char *name, VkInstance instance); +static PFN_vkVoidFunction intercept_extension_instance_command(const char *name, VkInstance instance); + +static PFN_vkVoidFunction intercept_extension_device_command(const char *name, VkDevice device); + VKAPI_ATTR PFN_vkVoidFunction VKAPI_CALL GetDeviceProcAddr(VkDevice device, const char *funcName) { assert(device); @@ -5741,6 +6017,10 @@ VKAPI_ATTR PFN_vkVoidFunction VKAPI_CALL GetDeviceProcAddr(VkDevice device, cons if (proc) return proc; + proc = intercept_extension_device_command(funcName, device); + if (proc) + return proc; + if (!data->dispatch_table.GetDeviceProcAddr) return nullptr; return data->dispatch_table.GetDeviceProcAddr(device, funcName); @@ -5765,6 +6045,9 @@ VKAPI_ATTR PFN_vkVoidFunction VKAPI_CALL GetInstanceProcAddr(VkInstance instance if (!proc) proc = InterceptWsiEnabledCommand(funcName, instance); + if (!proc) + proc = intercept_extension_instance_command(funcName, instance); + if (proc) return proc; @@ -5773,6 +6056,15 @@ VKAPI_ATTR PFN_vkVoidFunction VKAPI_CALL GetInstanceProcAddr(VkInstance instance return data->dispatch_table.GetInstanceProcAddr(instance, funcName); } +VKAPI_ATTR PFN_vkVoidFunction VKAPI_CALL GetPhysicalDeviceProcAddr(VkInstance instance, const char *funcName) { + assert(instance); + auto data = get_my_data_ptr(get_dispatch_key(instance), instance_layer_data_map); + + if (!data->dispatch_table.GetPhysicalDeviceProcAddr) + return nullptr; + return data->dispatch_table.GetPhysicalDeviceProcAddr(instance, funcName); +} + static PFN_vkVoidFunction intercept_core_instance_command(const char *name) { static const struct { const char *name; @@ -5783,6 +6075,7 @@ static PFN_vkVoidFunction intercept_core_instance_command(const char *name) { {"vkDestroyInstance", reinterpret_cast<PFN_vkVoidFunction>(DestroyInstance)}, {"vkCreateDevice", reinterpret_cast<PFN_vkVoidFunction>(CreateDevice)}, {"vkEnumeratePhysicalDevices", reinterpret_cast<PFN_vkVoidFunction>(EnumeratePhysicalDevices)}, + {"vk_layerGetPhysicalDeviceProcAddr", reinterpret_cast<PFN_vkVoidFunction>(GetPhysicalDeviceProcAddr)}, {"vkGetPhysicalDeviceProperties", reinterpret_cast<PFN_vkVoidFunction>(GetPhysicalDeviceProperties)}, {"vkGetPhysicalDeviceFeatures", reinterpret_cast<PFN_vkVoidFunction>(GetPhysicalDeviceFeatures)}, {"vkGetPhysicalDeviceFormatProperties", reinterpret_cast<PFN_vkVoidFunction>(GetPhysicalDeviceFormatProperties)}, @@ -5976,6 +6269,10 @@ static PFN_vkVoidFunction InterceptWsiEnabledCommand(const char *name, VkDevice if (!strcmp(wsi_device_commands[i].name, name)) return wsi_device_commands[i].proc; } + + if (!strcmp("vkCreateSharedSwapchainsKHR", name)) { + return reinterpret_cast<PFN_vkVoidFunction>(CreateSharedSwapchainsKHR); + } } return nullptr; @@ -6034,6 +6331,70 @@ static PFN_vkVoidFunction InterceptWsiEnabledCommand(const char *name, VkInstanc return nullptr; } +static PFN_vkVoidFunction intercept_extension_instance_command(const char *name, VkInstance instance) { + static const struct { + const char *name; + PFN_vkVoidFunction proc; + } extension_instance_commands[] = { + {"vkGetPhysicalDeviceFeatures2KHR", reinterpret_cast<PFN_vkVoidFunction>(GetPhysicalDeviceFeatures2KHR)}, + {"vkGetPhysicalDeviceProperties2KHR", reinterpret_cast<PFN_vkVoidFunction>(GetPhysicalDeviceProperties2KHR)}, + {"vkGetPhysicalDeviceFormatProperties2KHR", reinterpret_cast<PFN_vkVoidFunction>(GetPhysicalDeviceFormatProperties2KHR)}, + {"vkGetPhysicalDeviceImageFormatProperties2KHR", reinterpret_cast<PFN_vkVoidFunction>(GetPhysicalDeviceImageFormatProperties2KHR)}, + {"vkGetPhysicalDeviceQueueFamilyProperties2KHR", reinterpret_cast<PFN_vkVoidFunction>(GetPhysicalDeviceQueueFamilyProperties2KHR)}, + {"vkGetPhysicalDeviceMemoryProperties2KHR", reinterpret_cast<PFN_vkVoidFunction>(GetPhysicalDeviceMemoryProperties2KHR)}, + {"vkGetPhysicalDeviceSparseImageFormatProperties2KHR", reinterpret_cast<PFN_vkVoidFunction>(GetPhysicalDeviceSparseImageFormatProperties2KHR)}, + // NV_external_memory_capabilities + {"vkGetPhysicalDeviceExternalImageFormatPropertiesNV", + reinterpret_cast<PFN_vkVoidFunction>(GetPhysicalDeviceExternalImageFormatPropertiesNV)}, + // NVX_device_generated_commands + {"vkGetPhysicalDeviceGeneratedCommandsPropertiesNVX", reinterpret_cast<PFN_vkVoidFunction>(GetPhysicalDeviceGeneratedCommandsPropertiesNVX)}, + }; + + for (size_t i = 0; i < ARRAY_SIZE(extension_instance_commands); i++) { + if (!strcmp(extension_instance_commands[i].name, name)) + return extension_instance_commands[i].proc; + } + + return nullptr; +} + +static PFN_vkVoidFunction intercept_extension_device_command(const char *name, VkDevice device) { + struct ExtProc { + const char *name; + PFN_vkVoidFunction proc; + } extension_device_commands[] = { + // KHR_maintenance1 + {"vkTrimCommandPoolKHR", reinterpret_cast<PFN_vkVoidFunction>(TrimCommandPoolKHR)}, +#ifdef VK_USE_PLATFORM_WIN32_KHR + // NV_external_memory_win32 + {"vkGetMemoryWin32HandleNV", reinterpret_cast<PFN_vkVoidFunction>(GetMemoryWin32HandleNV)}, +#endif // VK_USE_PLATFORM_WIN32_KHR + // EXT_debug_marker + {"vkDebugMarkerSetObjectTagEXT", reinterpret_cast<PFN_vkVoidFunction>(DebugMarkerSetObjectTagEXT)}, + {"vkDebugMarkerSetObjectNameEXT", reinterpret_cast<PFN_vkVoidFunction>(DebugMarkerSetObjectNameEXT)}, + {"vkCmdDebugMarkerBeginEXT", reinterpret_cast<PFN_vkVoidFunction>(CmdDebugMarkerBeginEXT)}, + {"vkCmdDebugMarkerInsertEXT", reinterpret_cast<PFN_vkVoidFunction>(CmdDebugMarkerInsertEXT)}, + // NVX_device_generated_commands + {"vkCmdProcessCommandsNVX", reinterpret_cast<PFN_vkVoidFunction>(CmdProcessCommandsNVX)}, + {"vkCmdReserveSpaceForCommandsNVX", reinterpret_cast<PFN_vkVoidFunction>(CmdReserveSpaceForCommandsNVX)}, + {"vkCreateIndirectCommandsLayoutNVX", reinterpret_cast<PFN_vkVoidFunction>(CreateIndirectCommandsLayoutNVX)}, + {"vkDestroyIndirectCommandsLayoutNVX", reinterpret_cast<PFN_vkVoidFunction>(DestroyIndirectCommandsLayoutNVX)}, + {"vkCreateObjectTableNVX", reinterpret_cast<PFN_vkVoidFunction>(CreateObjectTableNVX)}, + {"vkDestroyObjectTableNVX", reinterpret_cast<PFN_vkVoidFunction>(DestroyObjectTableNVX)}, + {"vkRegisterObjectsNVX", reinterpret_cast<PFN_vkVoidFunction>(RegisterObjectsNVX)}, + {"vkUnregisterObjectsNVX", reinterpret_cast<PFN_vkVoidFunction>(UnregisterObjectsNVX)}, + }; + + if (device) { + for (size_t i = 0; i < ARRAY_SIZE(extension_device_commands); i++) { + if (!strcmp(extension_device_commands[i].name, name)) + return extension_device_commands[i].proc; + } + } + + return nullptr; +} + } // namespace parameter_validation // vk_layer_logging.h expects these to be defined @@ -6090,3 +6451,27 @@ VK_LAYER_EXPORT VKAPI_ATTR PFN_vkVoidFunction VKAPI_CALL vkGetDeviceProcAddr(VkD VK_LAYER_EXPORT VKAPI_ATTR PFN_vkVoidFunction VKAPI_CALL vkGetInstanceProcAddr(VkInstance instance, const char *funcName) { return parameter_validation::GetInstanceProcAddr(instance, funcName); } + +VK_LAYER_EXPORT VKAPI_ATTR PFN_vkVoidFunction VKAPI_CALL vk_layerGetPhysicalDeviceProcAddr(VkInstance instance, const char *funcName) { + return parameter_validation::GetPhysicalDeviceProcAddr(instance, funcName); +} + +VK_LAYER_EXPORT VKAPI_ATTR VkResult VKAPI_CALL vkNegotiateLoaderLayerInterfaceVersion(VkNegotiateLayerInterface *pVersionStruct) { + assert(pVersionStruct != NULL); + assert(pVersionStruct->sType == LAYER_NEGOTIATE_INTERFACE_STRUCT); + + // Fill in the function pointers if our version is at least capable of having the structure contain them. + if (pVersionStruct->loaderLayerInterfaceVersion >= 2) { + pVersionStruct->pfnGetInstanceProcAddr = vkGetInstanceProcAddr; + pVersionStruct->pfnGetDeviceProcAddr = vkGetDeviceProcAddr; + pVersionStruct->pfnGetPhysicalDeviceProcAddr = vk_layerGetPhysicalDeviceProcAddr; + } + + if (pVersionStruct->loaderLayerInterfaceVersion < CURRENT_LOADER_LAYER_INTERFACE_VERSION) { + parameter_validation::loader_layer_if_version = pVersionStruct->loaderLayerInterfaceVersion; + } else if (pVersionStruct->loaderLayerInterfaceVersion > CURRENT_LOADER_LAYER_INTERFACE_VERSION) { + pVersionStruct->loaderLayerInterfaceVersion = CURRENT_LOADER_LAYER_INTERFACE_VERSION; + } + + return VK_SUCCESS; +} |