From 82ea0b0103880d011ca679b14f0fc5542c5b2012 Mon Sep 17 00:00:00 2001 From: Mark Young Date: Thu, 19 Jan 2017 21:10:49 -0700 Subject: loader: Update the loader to 1.0.39 Add new extensions for 1.0.39. Also, updated layers to include minimal set of functionality for 1.0.39 extensions. Extensions include: - VK_KHR_get_physical_device_properties2 - VK_KHR_shader_draw_parameters - VK_EXT_direct_mode_display - VK_EXT_display_surface_counter - VK_EXT_display_control Also, redo the LoaderAndLayerIf document. Change-Id: I10412086da7a798afe832a3892e18f606259b5af --- layers/object_tracker.cpp | 539 +++++++++++++++++++++++++++++++++++++++++++++- 1 file changed, 538 insertions(+), 1 deletion(-) (limited to 'layers/object_tracker.cpp') diff --git a/layers/object_tracker.cpp b/layers/object_tracker.cpp index 00d19f31..fb3354ba 100644 --- a/layers/object_tracker.cpp +++ b/layers/object_tracker.cpp @@ -46,6 +46,8 @@ namespace object_tracker { +static uint32_t loader_layer_if_version = CURRENT_LOADER_LAYER_INTERFACE_VERSION; + static void InitObjectTracker(layer_data *my_data, const VkAllocationCallbacks *pAllocator) { layer_debug_actions(my_data->report_data, my_data->logging_callback, pAllocator, "lunarg_object_tracker"); @@ -573,6 +575,8 @@ VKAPI_ATTR PFN_vkVoidFunction VKAPI_CALL GetInstanceProcAddr(VkInstance instance VKAPI_ATTR PFN_vkVoidFunction VKAPI_CALL GetDeviceProcAddr(VkDevice device, const char *pName); +VKAPI_ATTR PFN_vkVoidFunction VKAPI_CALL GetPhysicalDeviceProcAddr(VkInstance instance, const char *funcName); + VKAPI_ATTR VkResult VKAPI_CALL EnumerateInstanceExtensionProperties(const char *pLayerName, uint32_t *pPropertyCount, VkExtensionProperties *pProperties); @@ -3150,6 +3154,8 @@ static void CheckDeviceRegisterExtensions(const VkDeviceCreateInfo *pCreateInfo, device_data->wsi_display_swapchain_enabled = false; device_data->wsi_display_extension_enabled = false; device_data->objtrack_extensions_enabled = false; + device_data->nvx_device_generated_commands_enabled = false; + device_data->ext_display_control_enabled = false; for (uint32_t i = 0; i < pCreateInfo->enabledExtensionCount; i++) { if (strcmp(pCreateInfo->ppEnabledExtensionNames[i], VK_KHR_SWAPCHAIN_EXTENSION_NAME) == 0) { @@ -3164,12 +3170,17 @@ static void CheckDeviceRegisterExtensions(const VkDeviceCreateInfo *pCreateInfo, if (strcmp(pCreateInfo->ppEnabledExtensionNames[i], "OBJTRACK_EXTENSIONS") == 0) { device_data->objtrack_extensions_enabled = true; } + if (strcmp(pCreateInfo->ppEnabledExtensionNames[i], VK_NVX_DEVICE_GENERATED_COMMANDS_EXTENSION_NAME) == 0) { + device_data->nvx_device_generated_commands_enabled = true; + } + if (strcmp(pCreateInfo->ppEnabledExtensionNames[i], VK_EXT_DISPLAY_CONTROL_EXTENSION_NAME) == 0) { + device_data->ext_display_control_enabled = true; + } } } static void CheckInstanceRegisterExtensions(const VkInstanceCreateInfo *pCreateInfo, VkInstance instance) { VkLayerInstanceDispatchTable *pDisp = get_dispatch_table(ot_instance_table_map, instance); - instanceExtMap[pDisp] = {}; @@ -3979,6 +3990,405 @@ VKAPI_ATTR void VKAPI_CALL CmdDrawIndexedIndirectCountAMD(VkCommandBuffer comman } } +// VK_KHR_get_physical_device_properties2 Extension +VKAPI_ATTR void VKAPI_CALL GetPhysicalDeviceFeatures2KHR(VkPhysicalDevice physicalDevice, VkPhysicalDeviceFeatures2KHR *pFeatures) { + bool skip = false; + { + std::unique_lock lock(global_lock); + skip |= ValidateObject(physicalDevice, physicalDevice, VK_DEBUG_REPORT_OBJECT_TYPE_PHYSICAL_DEVICE_EXT, false, + VALIDATION_ERROR_UNDEFINED); + } + if (!skip) { + get_dispatch_table(ot_instance_table_map, physicalDevice)->GetPhysicalDeviceFeatures2KHR(physicalDevice, pFeatures); + } +} + +VKAPI_ATTR void VKAPI_CALL GetPhysicalDeviceProperties2KHR(VkPhysicalDevice physicalDevice, + VkPhysicalDeviceProperties2KHR *pProperties) { + bool skip = false; + { + std::unique_lock lock(global_lock); + skip |= ValidateObject(physicalDevice, physicalDevice, VK_DEBUG_REPORT_OBJECT_TYPE_PHYSICAL_DEVICE_EXT, false, + VALIDATION_ERROR_UNDEFINED); + } + if (!skip) { + get_dispatch_table(ot_instance_table_map, physicalDevice)->GetPhysicalDeviceProperties2KHR(physicalDevice, pProperties); + } +} + +VKAPI_ATTR void VKAPI_CALL GetPhysicalDeviceFormatProperties2KHR(VkPhysicalDevice physicalDevice, VkFormat format, + VkFormatProperties2KHR *pFormatProperties) { + bool skip = false; + { + std::unique_lock lock(global_lock); + skip |= ValidateObject(physicalDevice, physicalDevice, VK_DEBUG_REPORT_OBJECT_TYPE_PHYSICAL_DEVICE_EXT, false, + VALIDATION_ERROR_UNDEFINED); + } + if (!skip) { + get_dispatch_table(ot_instance_table_map, physicalDevice) + ->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 = false; + { + std::unique_lock lock(global_lock); + skip |= ValidateObject(physicalDevice, physicalDevice, VK_DEBUG_REPORT_OBJECT_TYPE_PHYSICAL_DEVICE_EXT, false, + VALIDATION_ERROR_UNDEFINED); + } + if (skip) { + return VK_ERROR_VALIDATION_FAILED_EXT; + } + result = get_dispatch_table(ot_instance_table_map, physicalDevice) + ->GetPhysicalDeviceImageFormatProperties2KHR(physicalDevice, pImageFormatInfo, pImageFormatProperties); + + return result; +} + +VKAPI_ATTR void VKAPI_CALL GetPhysicalDeviceQueueFamilyProperties2KHR(VkPhysicalDevice physicalDevice, + uint32_t *pQueueFamilyPropertyCount, + VkQueueFamilyProperties2KHR *pQueueFamilyProperties) { + bool skip = false; + { + std::unique_lock lock(global_lock); + skip |= ValidateObject(physicalDevice, physicalDevice, VK_DEBUG_REPORT_OBJECT_TYPE_PHYSICAL_DEVICE_EXT, false, + VALIDATION_ERROR_UNDEFINED); + } + if (!skip) { + get_dispatch_table(ot_instance_table_map, physicalDevice) + ->GetPhysicalDeviceQueueFamilyProperties2KHR(physicalDevice, pQueueFamilyPropertyCount, pQueueFamilyProperties); + } +} + +VKAPI_ATTR void VKAPI_CALL GetPhysicalDeviceMemoryProperties2KHR(VkPhysicalDevice physicalDevice, + VkPhysicalDeviceMemoryProperties2KHR *pMemoryProperties) { + bool skip = false; + { + std::unique_lock lock(global_lock); + skip |= ValidateObject(physicalDevice, physicalDevice, VK_DEBUG_REPORT_OBJECT_TYPE_PHYSICAL_DEVICE_EXT, false, + VALIDATION_ERROR_UNDEFINED); + } + if (!skip) { + get_dispatch_table(ot_instance_table_map, physicalDevice) + ->GetPhysicalDeviceMemoryProperties2KHR(physicalDevice, pMemoryProperties); + } +} + +VKAPI_ATTR void VKAPI_CALL GetPhysicalDeviceSparseImageFormatProperties2KHR( + VkPhysicalDevice physicalDevice, const VkPhysicalDeviceSparseImageFormatInfo2KHR *pFormatInfo, uint32_t *pPropertyCount, + VkSparseImageFormatProperties2KHR *pProperties) { + bool skip = false; + { + std::unique_lock lock(global_lock); + skip |= ValidateObject(physicalDevice, physicalDevice, VK_DEBUG_REPORT_OBJECT_TYPE_PHYSICAL_DEVICE_EXT, false, + VALIDATION_ERROR_UNDEFINED); + } + if (!skip) { + get_dispatch_table(ot_instance_table_map, physicalDevice) + ->GetPhysicalDeviceSparseImageFormatProperties2KHR(physicalDevice, pFormatInfo, pPropertyCount, pProperties); + } +} + +// VK_NVX_device_generated_commands Extension +VKAPI_ATTR void VKAPI_CALL CmdProcessCommandsNVX(VkCommandBuffer commandBuffer, + const VkCmdProcessCommandsInfoNVX *pProcessCommandsInfo) { + bool skip_call = VK_FALSE; + std::unique_lock lock(global_lock); + skip_call |= ValidateObject(commandBuffer, commandBuffer, VK_DEBUG_REPORT_OBJECT_TYPE_COMMAND_BUFFER_EXT, false, + VALIDATION_ERROR_UNDEFINED); + lock.unlock(); + layer_data *dev_data = get_my_data_ptr(get_dispatch_key(commandBuffer), layer_data_map); + if (!skip_call && dev_data->dispatch_table.CmdProcessCommandsNVX) { + dev_data->dispatch_table.CmdProcessCommandsNVX(commandBuffer, pProcessCommandsInfo); + } +} + +VKAPI_ATTR void VKAPI_CALL CmdReserveSpaceForCommandsNVX(VkCommandBuffer commandBuffer, + const VkCmdReserveSpaceForCommandsInfoNVX *pReserveSpaceInfo) { + bool skip_call = VK_FALSE; + std::unique_lock lock(global_lock); + skip_call |= ValidateObject(commandBuffer, commandBuffer, VK_DEBUG_REPORT_OBJECT_TYPE_COMMAND_BUFFER_EXT, false, + VALIDATION_ERROR_UNDEFINED); + lock.unlock(); + layer_data *dev_data = get_my_data_ptr(get_dispatch_key(commandBuffer), layer_data_map); + if (!skip_call && dev_data->dispatch_table.CmdReserveSpaceForCommandsNVX) { + dev_data->dispatch_table.CmdReserveSpaceForCommandsNVX(commandBuffer, pReserveSpaceInfo); + } +} + +VKAPI_ATTR VkResult VKAPI_CALL CreateIndirectCommandsLayoutNVX(VkDevice device, + const VkIndirectCommandsLayoutCreateInfoNVX *pCreateInfo, + const VkAllocationCallbacks *pAllocator, + VkIndirectCommandsLayoutNVX *pIndirectCommandsLayout) { + bool skip_call = VK_FALSE; + std::unique_lock lock(global_lock); + skip_call |= ValidateObject(device, device, VK_DEBUG_REPORT_OBJECT_TYPE_DEVICE_EXT, false, VALIDATION_ERROR_UNDEFINED); + lock.unlock(); + if (skip_call) { + return VK_ERROR_VALIDATION_FAILED_EXT; + } + layer_data *dev_data = get_my_data_ptr(get_dispatch_key(device), layer_data_map); + VkResult result = VK_SUCCESS; + if (dev_data->dispatch_table.CreateIndirectCommandsLayoutNVX) { + result = dev_data->dispatch_table.CreateIndirectCommandsLayoutNVX(device, pCreateInfo, pAllocator, pIndirectCommandsLayout); + } + return result; +} + +VKAPI_ATTR void VKAPI_CALL DestroyIndirectCommandsLayoutNVX(VkDevice device, VkIndirectCommandsLayoutNVX indirectCommandsLayout, + const VkAllocationCallbacks *pAllocator) { + bool skip_call = VK_FALSE; + std::unique_lock lock(global_lock); + skip_call |= ValidateObject(device, device, VK_DEBUG_REPORT_OBJECT_TYPE_DEVICE_EXT, false, VALIDATION_ERROR_UNDEFINED); + lock.unlock(); + if (!skip_call) { + layer_data *dev_data = get_my_data_ptr(get_dispatch_key(device), layer_data_map); + if (dev_data->dispatch_table.DestroyIndirectCommandsLayoutNVX) { + dev_data->dispatch_table.DestroyIndirectCommandsLayoutNVX(device, indirectCommandsLayout, pAllocator); + } + } +} + +VKAPI_ATTR VkResult VKAPI_CALL CreateObjectTableNVX(VkDevice device, const VkObjectTableCreateInfoNVX *pCreateInfo, + const VkAllocationCallbacks *pAllocator, VkObjectTableNVX *pObjectTable) { + bool skip_call = VK_FALSE; + std::unique_lock lock(global_lock); + skip_call |= ValidateObject(device, device, VK_DEBUG_REPORT_OBJECT_TYPE_DEVICE_EXT, false, VALIDATION_ERROR_UNDEFINED); + lock.unlock(); + if (skip_call) { + return VK_ERROR_VALIDATION_FAILED_EXT; + } + layer_data *dev_data = get_my_data_ptr(get_dispatch_key(device), layer_data_map); + VkResult result = VK_SUCCESS; + if (dev_data->dispatch_table.CreateObjectTableNVX) { + result = dev_data->dispatch_table.CreateObjectTableNVX(device, pCreateInfo, pAllocator, pObjectTable); + } + return result; +} + +VKAPI_ATTR void VKAPI_CALL DestroyObjectTableNVX(VkDevice device, VkObjectTableNVX objectTable, + const VkAllocationCallbacks *pAllocator) { + bool skip_call = VK_FALSE; + std::unique_lock lock(global_lock); + skip_call |= ValidateObject(device, device, VK_DEBUG_REPORT_OBJECT_TYPE_DEVICE_EXT, false, VALIDATION_ERROR_UNDEFINED); + lock.unlock(); + if (!skip_call) { + layer_data *dev_data = get_my_data_ptr(get_dispatch_key(device), layer_data_map); + if (dev_data->dispatch_table.DestroyObjectTableNVX) { + dev_data->dispatch_table.DestroyObjectTableNVX(device, objectTable, pAllocator); + } + } +} + +VKAPI_ATTR VkResult VKAPI_CALL RegisterObjectsNVX(VkDevice device, VkObjectTableNVX objectTable, uint32_t objectCount, + const VkObjectTableEntryNVX *const *ppObjectTableEntries, + const uint32_t *pObjectIndices) { + bool skip_call = VK_FALSE; + std::unique_lock lock(global_lock); + skip_call |= ValidateObject(device, device, VK_DEBUG_REPORT_OBJECT_TYPE_DEVICE_EXT, false, VALIDATION_ERROR_UNDEFINED); + lock.unlock(); + if (skip_call) { + return VK_ERROR_VALIDATION_FAILED_EXT; + } + layer_data *dev_data = get_my_data_ptr(get_dispatch_key(device), layer_data_map); + VkResult result = VK_SUCCESS; + if (dev_data->dispatch_table.RegisterObjectsNVX) { + result = + dev_data->dispatch_table.RegisterObjectsNVX(device, objectTable, objectCount, ppObjectTableEntries, pObjectIndices); + } + return result; +} + +VKAPI_ATTR VkResult VKAPI_CALL UnregisterObjectsNVX(VkDevice device, VkObjectTableNVX objectTable, uint32_t objectCount, + const VkObjectEntryTypeNVX *pObjectEntryTypes, const uint32_t *pObjectIndices) { + bool skip_call = VK_FALSE; + std::unique_lock lock(global_lock); + skip_call |= ValidateObject(device, device, VK_DEBUG_REPORT_OBJECT_TYPE_DEVICE_EXT, false, VALIDATION_ERROR_UNDEFINED); + lock.unlock(); + if (skip_call) { + return VK_ERROR_VALIDATION_FAILED_EXT; + } + layer_data *dev_data = get_my_data_ptr(get_dispatch_key(device), layer_data_map); + VkResult result = VK_SUCCESS; + if (dev_data->dispatch_table.UnregisterObjectsNVX) { + result = dev_data->dispatch_table.UnregisterObjectsNVX(device, objectTable, objectCount, pObjectEntryTypes, pObjectIndices); + } + return result; +} + +VKAPI_ATTR void VKAPI_CALL GetPhysicalDeviceGeneratedCommandsPropertiesNVX(VkPhysicalDevice physicalDevice, + VkDeviceGeneratedCommandsFeaturesNVX *pFeatures, + VkDeviceGeneratedCommandsLimitsNVX *pLimits) { + bool skip = false; + { + std::unique_lock lock(global_lock); + skip |= ValidateObject(physicalDevice, physicalDevice, VK_DEBUG_REPORT_OBJECT_TYPE_PHYSICAL_DEVICE_EXT, false, + VALIDATION_ERROR_UNDEFINED); + } + if (skip) { + get_dispatch_table(ot_instance_table_map, physicalDevice) + ->GetPhysicalDeviceGeneratedCommandsPropertiesNVX(physicalDevice, pFeatures, pLimits); + } +} + +// VK_EXT_direct_mode_display Extension +VKAPI_ATTR VkResult VKAPI_CALL ReleaseDisplayEXT(VkPhysicalDevice physicalDevice, VkDisplayKHR display) { + VkResult result = VK_ERROR_VALIDATION_FAILED_EXT; + bool skip = false; + { + std::unique_lock lock(global_lock); + skip |= ValidateObject(physicalDevice, physicalDevice, VK_DEBUG_REPORT_OBJECT_TYPE_PHYSICAL_DEVICE_EXT, false, + VALIDATION_ERROR_UNDEFINED); + } + if (skip) { + return VK_ERROR_VALIDATION_FAILED_EXT; + } + result = get_dispatch_table(ot_instance_table_map, physicalDevice)->ReleaseDisplayEXT(physicalDevice, display); + + return result; +} + +// 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; + bool skip = false; + { + std::unique_lock lock(global_lock); + skip |= ValidateObject(physicalDevice, physicalDevice, VK_DEBUG_REPORT_OBJECT_TYPE_PHYSICAL_DEVICE_EXT, false, + VALIDATION_ERROR_UNDEFINED); + } + if (skip) { + return VK_ERROR_VALIDATION_FAILED_EXT; + } + result = get_dispatch_table(ot_instance_table_map, physicalDevice)->AcquireXlibDisplayEXT(physicalDevice, dpy, display); + + return result; +} + +VKAPI_ATTR VkResult VKAPI_CALL GetRandROutputDisplayEXT(VkPhysicalDevice physicalDevice, Display *dpy, RROutput rrOutput, + VkDisplayKHR *pDisplay) { + VkResult result = VK_ERROR_VALIDATION_FAILED_EXT; + bool skip = false; + { + std::unique_lock lock(global_lock); + skip |= ValidateObject(physicalDevice, physicalDevice, VK_DEBUG_REPORT_OBJECT_TYPE_PHYSICAL_DEVICE_EXT, false, + VALIDATION_ERROR_UNDEFINED); + } + if (skip) { + return VK_ERROR_VALIDATION_FAILED_EXT; + } + result = get_dispatch_table(ot_instance_table_map, physicalDevice) + ->GetRandROutputDisplayEXT(physicalDevice, dpy, rrOutput, pDisplay); + if (result == VK_SUCCESS && pDisplay != NULL) { + std::lock_guard lock(global_lock); + CreateObject(physicalDevice, pDisplay, VK_DEBUG_REPORT_OBJECT_TYPE_DISPLAY_KHR_EXT, nullptr); + } + + return result; +} +#endif // VK_USE_PLATFORM_XLIB_XRANDR_EXT + +// 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; + bool skip = false; + { + std::unique_lock lock(global_lock); + skip |= ValidateObject(physicalDevice, physicalDevice, VK_DEBUG_REPORT_OBJECT_TYPE_PHYSICAL_DEVICE_EXT, false, + VALIDATION_ERROR_UNDEFINED); + } + if (skip) { + return VK_ERROR_VALIDATION_FAILED_EXT; + } + result = get_dispatch_table(ot_instance_table_map, physicalDevice) + ->GetPhysicalDeviceSurfaceCapabilities2EXT(physicalDevice, surface, pSurfaceCapabilities); + + return result; +} + +// VK_EXT_display_control Extension +VKAPI_ATTR VkResult VKAPI_CALL DisplayPowerControlEXT(VkDevice device, VkDisplayKHR display, + const VkDisplayPowerInfoEXT *pDisplayPowerInfo) { + bool skip_call = VK_FALSE; + std::unique_lock lock(global_lock); + skip_call |= ValidateObject(device, device, VK_DEBUG_REPORT_OBJECT_TYPE_DEVICE_EXT, false, VALIDATION_ERROR_UNDEFINED); + lock.unlock(); + if (skip_call) { + return VK_ERROR_VALIDATION_FAILED_EXT; + } + layer_data *dev_data = get_my_data_ptr(get_dispatch_key(device), layer_data_map); + VkResult result = VK_SUCCESS; + if (dev_data->dispatch_table.DisplayPowerControlEXT) { + result = dev_data->dispatch_table.DisplayPowerControlEXT(device, display, pDisplayPowerInfo); + } + return result; +} + +VKAPI_ATTR VkResult VKAPI_CALL RegisterDeviceEventEXT(VkDevice device, const VkDeviceEventInfoEXT *pDeviceEventInfo, + const VkAllocationCallbacks *pAllocator, VkFence *pFence) { + bool skip_call = VK_FALSE; + std::unique_lock lock(global_lock); + skip_call |= ValidateObject(device, device, VK_DEBUG_REPORT_OBJECT_TYPE_DEVICE_EXT, false, VALIDATION_ERROR_UNDEFINED); + lock.unlock(); + if (skip_call) { + return VK_ERROR_VALIDATION_FAILED_EXT; + } + layer_data *dev_data = get_my_data_ptr(get_dispatch_key(device), layer_data_map); + VkResult result = VK_SUCCESS; + if (dev_data->dispatch_table.RegisterDeviceEventEXT) { + result = dev_data->dispatch_table.RegisterDeviceEventEXT(device, pDeviceEventInfo, pAllocator, pFence); + if (result == VK_SUCCESS && pFence != NULL) { + std::lock_guard lock(global_lock); + CreateObject(device, *pFence, VK_DEBUG_REPORT_OBJECT_TYPE_FENCE_EXT, pAllocator); + } + } + return result; +} + +VKAPI_ATTR VkResult VKAPI_CALL RegisterDisplayEventEXT(VkDevice device, VkDisplayKHR display, + const VkDisplayEventInfoEXT *pDisplayEventInfo, + const VkAllocationCallbacks *pAllocator, VkFence *pFence) { + bool skip_call = VK_FALSE; + std::unique_lock lock(global_lock); + skip_call |= ValidateObject(device, device, VK_DEBUG_REPORT_OBJECT_TYPE_DEVICE_EXT, false, VALIDATION_ERROR_UNDEFINED); + lock.unlock(); + if (skip_call) { + return VK_ERROR_VALIDATION_FAILED_EXT; + } + layer_data *dev_data = get_my_data_ptr(get_dispatch_key(device), layer_data_map); + VkResult result = VK_SUCCESS; + if (dev_data->dispatch_table.RegisterDisplayEventEXT) { + result = dev_data->dispatch_table.RegisterDisplayEventEXT(device, display, pDisplayEventInfo, pAllocator, pFence); + if (result == VK_SUCCESS && pFence != NULL) { + std::lock_guard lock(global_lock); + CreateObject(device, *pFence, VK_DEBUG_REPORT_OBJECT_TYPE_FENCE_EXT, pAllocator); + } + } + return result; +} + +VKAPI_ATTR VkResult VKAPI_CALL GetSwapchainCounterEXT(VkDevice device, VkSwapchainKHR swapchain, + VkSurfaceCounterFlagBitsEXT counter, uint64_t *pCounterValue) { + bool skip_call = VK_FALSE; + std::unique_lock lock(global_lock); + skip_call |= ValidateObject(device, device, VK_DEBUG_REPORT_OBJECT_TYPE_DEVICE_EXT, false, VALIDATION_ERROR_UNDEFINED); + lock.unlock(); + if (skip_call) { + return VK_ERROR_VALIDATION_FAILED_EXT; + } + layer_data *dev_data = get_my_data_ptr(get_dispatch_key(device), layer_data_map); + VkResult result = VK_SUCCESS; + if (dev_data->dispatch_table.GetSwapchainCounterEXT) { + result = dev_data->dispatch_table.GetSwapchainCounterEXT(device, swapchain, counter, pCounterValue); + } + return result; +} static inline PFN_vkVoidFunction InterceptCoreDeviceCommand(const char *name) { if (!name || name[0] != 'v' || name[1] != 'k') @@ -4248,6 +4658,7 @@ static inline PFN_vkVoidFunction InterceptCoreDeviceCommand(const char *name) { return NULL; } + static inline PFN_vkVoidFunction InterceptCoreInstanceCommand(const char *name) { if (!name || name[0] != 'v' || name[1] != 'k') return NULL; @@ -4259,6 +4670,8 @@ static inline PFN_vkVoidFunction InterceptCoreInstanceCommand(const char *name) return (PFN_vkVoidFunction)DestroyInstance; if (!strcmp(name, "EnumeratePhysicalDevices")) return (PFN_vkVoidFunction)EnumeratePhysicalDevices; + if (!strcmp(name, "_layerGetPhysicalDeviceProcAddr")) + return (PFN_vkVoidFunction)GetPhysicalDeviceProcAddr; if (!strcmp(name, "GetPhysicalDeviceFeatures")) return (PFN_vkVoidFunction)GetPhysicalDeviceFeatures; if (!strcmp(name, "GetPhysicalDeviceFormatProperties")) @@ -4289,6 +4702,89 @@ static inline PFN_vkVoidFunction InterceptCoreInstanceCommand(const char *name) return NULL; } +static inline PFN_vkVoidFunction InterceptDeviceExtensionCommand(const char *name, VkDevice device) { + if (device) { + layer_data *device_data = get_my_data_ptr(get_dispatch_key(device), layer_data_map); + + if (!name || name[0] != 'v' || name[1] != 'k') + return NULL; + + name += 2; + + if (device_data->nvx_device_generated_commands_enabled) { + if (!strcmp(name, "CmdProcessCommandsNVX")) + return (PFN_vkVoidFunction)CmdProcessCommandsNVX; + if (!strcmp(name, "CmdReserveSpaceForCommandsNVX")) + return (PFN_vkVoidFunction)CmdReserveSpaceForCommandsNVX; + if (!strcmp(name, "CreateIndirectCommandsLayoutNVX")) + return (PFN_vkVoidFunction)CreateIndirectCommandsLayoutNVX; + if (!strcmp(name, "DestroyIndirectCommandsLayoutNVX")) + return (PFN_vkVoidFunction)DestroyIndirectCommandsLayoutNVX; + if (!strcmp(name, "CreateObjectTableNVX")) + return (PFN_vkVoidFunction)CreateObjectTableNVX; + if (!strcmp(name, "DestroyObjectTableNVX")) + return (PFN_vkVoidFunction)DestroyObjectTableNVX; + if (!strcmp(name, "RegisterObjectsNVX")) + return (PFN_vkVoidFunction)RegisterObjectsNVX; + if (!strcmp(name, "UnregisterObjectsNVX")) + return (PFN_vkVoidFunction)UnregisterObjectsNVX; + } + if (device_data->ext_display_control_enabled) { + if (!strcmp(name, "DisplayPowerControlEXT")) + return (PFN_vkVoidFunction)DisplayPowerControlEXT; + if (!strcmp(name, "RegisterDeviceEventEXT")) + return (PFN_vkVoidFunction)RegisterDeviceEventEXT; + if (!strcmp(name, "RegisterDisplayEventEXT")) + return (PFN_vkVoidFunction)RegisterDisplayEventEXT; + if (!strcmp(name, "GetSwapchainCounterEXT")) + return (PFN_vkVoidFunction)GetSwapchainCounterEXT; + } + } + + return NULL; +} + +static inline PFN_vkVoidFunction InterceptInstanceExtensionCommand(const char *name) { + if (!name || name[0] != 'v' || name[1] != 'k') + return NULL; + + name += 2; + + // VK_KHR_get_physical_device_properties2 Extension + if (!strcmp(name, "GetPhysicalDeviceFeatures2KHR")) + return (PFN_vkVoidFunction)GetPhysicalDeviceFeatures2KHR; + if (!strcmp(name, "GetPhysicalDeviceProperties2KHR")) + return (PFN_vkVoidFunction)GetPhysicalDeviceProperties2KHR; + if (!strcmp(name, "GetPhysicalDeviceFormatProperties2KHR")) + return (PFN_vkVoidFunction)GetPhysicalDeviceFormatProperties2KHR; + if (!strcmp(name, "GetPhysicalDeviceImageFormatProperties2KHR")) + return (PFN_vkVoidFunction)GetPhysicalDeviceImageFormatProperties2KHR; + if (!strcmp(name, "GetPhysicalDeviceQueueFamilyProperties2KHR")) + return (PFN_vkVoidFunction)GetPhysicalDeviceQueueFamilyProperties2KHR; + if (!strcmp(name, "GetPhysicalDeviceMemoryProperties2KHR")) + return (PFN_vkVoidFunction)GetPhysicalDeviceMemoryProperties2KHR; + if (!strcmp(name, "GetPhysicalDeviceSparseImageFormatProperties2KHR")) + return (PFN_vkVoidFunction)GetPhysicalDeviceSparseImageFormatProperties2KHR; + // VK_NVX_device_generated_commands Extension + if (!strcmp(name, "GetPhysicalDeviceGeneratedCommandsPropertiesNVX")) + return (PFN_vkVoidFunction)GetPhysicalDeviceGeneratedCommandsPropertiesNVX; + // VK_EXT_direct_mode_display Extension + if (!strcmp(name, "ReleaseDisplayEXT")) + return (PFN_vkVoidFunction)ReleaseDisplayEXT; +#ifdef VK_USE_PLATFORM_XLIB_XRANDR_EXT + // VK_EXT_acquire_xlib_display Extension + if (!strcmp(name, "AcquireXlibDisplayEXT")) + return (PFN_vkVoidFunction)AcquireXlibDisplayEXT; + if (!strcmp(name, "GetRandROutputDisplayEXT")) + return (PFN_vkVoidFunction)GetRandROutputDisplayEXT; +#endif // VK_USE_PLATFORM_XLIB_XRANDR_EXT + // VK_EXT_display_surface_counter Extension + if (!strcmp(name, "GetPhysicalDeviceSurfaceCapabilities2EXT")) + return (PFN_vkVoidFunction)GetPhysicalDeviceSurfaceCapabilities2EXT; + + return NULL; +} + static inline PFN_vkVoidFunction InterceptWsiEnabledCommand(const char *name, VkDevice device) { if (device) { layer_data *device_data = get_my_data_ptr(get_dispatch_key(device), layer_data_map); @@ -4345,6 +4841,10 @@ VKAPI_ATTR PFN_vkVoidFunction VKAPI_CALL GetDeviceProcAddr(VkDevice device, cons if (addr) { return addr; } + addr = InterceptDeviceExtensionCommand(funcName, device); + if (addr) { + return addr; + } if (get_dispatch_table(ot_device_table_map, device)->GetDeviceProcAddr == NULL) { return NULL; } @@ -4373,12 +4873,25 @@ VKAPI_ATTR PFN_vkVoidFunction VKAPI_CALL GetInstanceProcAddr(VkInstance instance if (addr) { return addr; } + addr = InterceptInstanceExtensionCommand(funcName); + if (addr) { + return addr; + } if (get_dispatch_table(ot_instance_table_map, instance)->GetInstanceProcAddr == NULL) { return NULL; } return get_dispatch_table(ot_instance_table_map, instance)->GetInstanceProcAddr(instance, funcName); } +VKAPI_ATTR PFN_vkVoidFunction VKAPI_CALL GetPhysicalDeviceProcAddr(VkInstance instance, const char *funcName) { + assert(instance); + + if (get_dispatch_table(ot_instance_table_map, instance)->GetPhysicalDeviceProcAddr == NULL) { + return NULL; + } + return get_dispatch_table(ot_instance_table_map, instance)->GetPhysicalDeviceProcAddr(instance, funcName); +} + } // namespace object_tracker // vk_layer_logging.h expects these to be defined @@ -4433,3 +4946,27 @@ VK_LAYER_EXPORT VKAPI_ATTR VkResult VKAPI_CALL vkEnumerateDeviceExtensionPropert assert(physicalDevice == VK_NULL_HANDLE); return object_tracker::EnumerateDeviceExtensionProperties(VK_NULL_HANDLE, pLayerName, pCount, pProperties); } + +VK_LAYER_EXPORT VKAPI_ATTR PFN_vkVoidFunction VKAPI_CALL vk_layerGetPhysicalDeviceProcAddr(VkInstance instance, const char *funcName) { + return object_tracker::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) { + object_tracker::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; +} -- cgit v1.2.3