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
diff --git a/layers/object_tracker.cpp b/layers/object_tracker.cpp
index 00d19f3..fb3354b 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 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 @@
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 @@
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 @@
}
}
+// VK_KHR_get_physical_device_properties2 Extension
+VKAPI_ATTR void VKAPI_CALL GetPhysicalDeviceFeatures2KHR(VkPhysicalDevice physicalDevice, VkPhysicalDeviceFeatures2KHR *pFeatures) {
+ bool skip = false;
+ {
+ std::unique_lock<std::mutex> 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<std::mutex> 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<std::mutex> 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<std::mutex> 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<std::mutex> 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<std::mutex> 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<std::mutex> 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<std::mutex> 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<std::mutex> 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<std::mutex> 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<std::mutex> 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<std::mutex> 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<std::mutex> 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<std::mutex> 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<std::mutex> 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<std::mutex> 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<std::mutex> 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<std::mutex> 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<std::mutex> 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<std::mutex> 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<std::mutex> 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<std::mutex> 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<std::mutex> 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<std::mutex> 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<std::mutex> 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<std::mutex> 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<std::mutex> 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 @@
return NULL;
}
+
static inline PFN_vkVoidFunction InterceptCoreInstanceCommand(const char *name) {
if (!name || name[0] != 'v' || name[1] != 'k')
return NULL;
@@ -4259,6 +4670,8 @@
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 @@
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 @@
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 @@
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 @@
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;
+}