From ee3524a1ad54d5682f1abb8fbb46a95ca950ea38 Mon Sep 17 00:00:00 2001 From: Mark Young Date: Mon, 12 Dec 2016 16:14:55 -0700 Subject: loader: Add support for 1.0.35 extension Add support for the NVX_device_generated_commands. This was necessary since it exposes one instance command (which takes a VkPhysicalDevice). Change-Id: I1da4c24ca0d385a6485581f55a1b19aa7ea51d24 --- layers/parameter_validation.cpp | 172 ++++++++++++++++++++++++++++++++++++++-- loader/extensions.c | 134 +++++++++++++++++++++++++++++++ loader/extensions.h | 8 ++ loader/loader.c | 7 ++ loader/loader.h | 5 ++ loader/table_ops.h | 30 +++++++ 6 files changed, 348 insertions(+), 8 deletions(-) diff --git a/layers/parameter_validation.cpp b/layers/parameter_validation.cpp index b76a5815..36dd87dc 100644 --- a/layers/parameter_validation.cpp +++ b/layers/parameter_validation.cpp @@ -82,6 +82,7 @@ struct layer_data { bool swapchain_enabled = false; bool display_swapchain_enabled = false; bool amd_negative_viewport_height_enabled = false; + bool nvx_device_generated_commands_enabled = false; VkLayerDispatchTable dispatch_table = {}; }; @@ -1613,6 +1614,9 @@ static void CheckDeviceRegisterExtensions(const VkDeviceCreateInfo *pCreateInfo, 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; + } } } @@ -5520,7 +5524,147 @@ VKAPI_ATTR VkResult VKAPI_CALL GetMemoryWin32HandleNV(VkDevice device, VkDeviceM } #endif // VK_USE_PLATFORM_WIN32_KHR +// 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", + VK_NVX_DEVICE_GENERATED_COMMANDS_EXTENSION_NAME); + skip |= parameter_validation_vkCmdProcessCommandsNVX(report_data, pProcessCommandsInfo); + + if (!skip) { + device_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); + + if (!skip) { + device_data->dispatch_table.CmdReserveSpaceForCommandsNVX(commandBuffer, pReserveSpaceInfo); + } +} + +VKAPI_ATTR VkResult VKAPI_CALL CreateIndirectCommandsLayoutNVX(VkDevice device, + const VkIndirectCommandsLayoutCreateInfoNVX *pCreateInfo, + const VkAllocationCallbacks *pAllocator, + VkIndirectCommandsLayoutNVX *pIndirectCommandsLayout) { + 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, &layer_data::nvx_device_generated_commands_enabled, + "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; +} + +VKAPI_ATTR void VKAPI_CALL DestroyIndirectCommandsLayoutNVX(VkDevice device, VkIndirectCommandsLayoutNVX indirectCommandsLayout, + const VkAllocationCallbacks *pAllocator) { + 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 |= parameter_validation_vkDestroyIndirectCommandsLayoutNVX(my_data->report_data, indirectCommandsLayout, pAllocator); + if (!skip) { + my_data->dispatch_table.DestroyIndirectCommandsLayoutNVX(device, indirectCommandsLayout, pAllocator); + } +} + +VKAPI_ATTR VkResult VKAPI_CALL CreateObjectTableNVX(VkDevice device, const VkObjectTableCreateInfoNVX *pCreateInfo, + const VkAllocationCallbacks *pAllocator, VkObjectTableNVX *pObjectTable) { + 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, &layer_data::nvx_device_generated_commands_enabled, "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); + } + return result; +} + +VKAPI_ATTR void VKAPI_CALL DestroyObjectTableNVX(VkDevice device, VkObjectTableNVX objectTable, + const VkAllocationCallbacks *pAllocator) { + 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", + VK_NVX_DEVICE_GENERATED_COMMANDS_EXTENSION_NAME); + skip |= parameter_validation_vkDestroyObjectTableNVX(my_data->report_data, objectTable, pAllocator); + if (!skip) { + my_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) { + 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, &layer_data::nvx_device_generated_commands_enabled, "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); + } + return result; +} + +VKAPI_ATTR VkResult VKAPI_CALL UnregisterObjectsNVX(VkDevice device, VkObjectTableNVX objectTable, uint32_t objectCount, + const VkObjectEntryTypeNVX *pObjectEntryTypes, const uint32_t *pObjectIndices) { + 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, &layer_data::nvx_device_generated_commands_enabled, "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); + } + return result; +} +VKAPI_ATTR void VKAPI_CALL GetPhysicalDeviceGeneratedCommandsPropertiesNVX(VkPhysicalDevice physicalDevice, + VkDeviceGeneratedCommandsFeaturesNVX *pFeatures, + VkDeviceGeneratedCommandsLimitsNVX *pLimits) { + 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); + } +} static PFN_vkVoidFunction intercept_core_instance_command(const char *name); @@ -5601,7 +5745,11 @@ static PFN_vkVoidFunction intercept_core_instance_command(const char *name) { {"vkEnumerateDeviceLayerProperties", reinterpret_cast(EnumerateDeviceLayerProperties)}, {"vkEnumerateInstanceExtensionProperties", reinterpret_cast(EnumerateInstanceExtensionProperties)}, {"vkEnumerateDeviceExtensionProperties", reinterpret_cast(EnumerateDeviceExtensionProperties)}, - {"vkGetPhysicalDeviceExternalImageFormatPropertiesNV", reinterpret_cast(GetPhysicalDeviceExternalImageFormatPropertiesNV) }, + {"vkGetPhysicalDeviceExternalImageFormatPropertiesNV", + reinterpret_cast(GetPhysicalDeviceExternalImageFormatPropertiesNV)}, + // NVX_device_generated_commands + {"vkGetPhysicalDeviceGeneratedCommandsPropertiesNVX", + reinterpret_cast(GetPhysicalDeviceGeneratedCommandsPropertiesNVX)}, }; for (size_t i = 0; i < ARRAY_SIZE(core_instance_commands); i++) { @@ -5734,15 +5882,23 @@ static PFN_vkVoidFunction intercept_core_device_command(const char *name) { {"vkCmdNextSubpass", reinterpret_cast(CmdNextSubpass)}, {"vkCmdExecuteCommands", reinterpret_cast(CmdExecuteCommands)}, {"vkCmdEndRenderPass", reinterpret_cast(CmdEndRenderPass)}, - {"vkDebugMarkerSetObjectTagEXT", reinterpret_cast(DebugMarkerSetObjectTagEXT) }, - {"vkDebugMarkerSetObjectNameEXT", reinterpret_cast(DebugMarkerSetObjectNameEXT) }, - {"vkCmdDebugMarkerBeginEXT", reinterpret_cast(CmdDebugMarkerBeginEXT) }, - {"vkCmdDebugMarkerInsertEXT", reinterpret_cast(CmdDebugMarkerInsertEXT) }, + {"vkDebugMarkerSetObjectTagEXT", reinterpret_cast(DebugMarkerSetObjectTagEXT)}, + {"vkDebugMarkerSetObjectNameEXT", reinterpret_cast(DebugMarkerSetObjectNameEXT)}, + {"vkCmdDebugMarkerBeginEXT", reinterpret_cast(CmdDebugMarkerBeginEXT)}, + {"vkCmdDebugMarkerInsertEXT", reinterpret_cast(CmdDebugMarkerInsertEXT)}, #ifdef VK_USE_PLATFORM_WIN32_KHR - {"vkGetMemoryWin32HandleNV", reinterpret_cast(GetMemoryWin32HandleNV) }, + {"vkGetMemoryWin32HandleNV", reinterpret_cast(GetMemoryWin32HandleNV)}, #endif // VK_USE_PLATFORM_WIN32_KHR -}; - + // NVX_device_generated_commands + {"vkCmdProcessCommandsNVX", reinterpret_cast(CmdProcessCommandsNVX)}, + {"vkCmdReserveSpaceForCommandsNVX", reinterpret_cast(CmdReserveSpaceForCommandsNVX)}, + {"vkCreateIndirectCommandsLayoutNVX", reinterpret_cast(CreateIndirectCommandsLayoutNVX)}, + {"vkDestroyIndirectCommandsLayoutNVX", reinterpret_cast(DestroyIndirectCommandsLayoutNVX)}, + {"vkCreateObjectTableNVX", reinterpret_cast(CreateObjectTableNVX)}, + {"vkDestroyObjectTableNVX", reinterpret_cast(DestroyObjectTableNVX)}, + {"vkRegisterObjectsNVX", reinterpret_cast(RegisterObjectsNVX)}, + {"vkUnregisterObjectsNVX", reinterpret_cast(UnregisterObjectsNVX)}, + }; for (size_t i = 0; i < ARRAY_SIZE(core_device_commands); i++) { if (!strcmp(core_device_commands[i].name, name)) diff --git a/loader/extensions.c b/loader/extensions.c index 5503df52..a57ab729 100644 --- a/loader/extensions.c +++ b/loader/extensions.c @@ -215,6 +215,101 @@ VKAPI_ATTR VkResult VKAPI_CALL vkGetMemoryWin32HandleNV( #endif // VK_USE_PLATFORM_WIN32_KHR +// Definitions for the VK_NVX_device_generated_commands + +VKAPI_ATTR void VKAPI_CALL vkCmdProcessCommandsNVX( + VkCommandBuffer commandBuffer, + const VkCmdProcessCommandsInfoNVX *pProcessCommandsInfo) { + const VkLayerDispatchTable *disp = loader_get_dispatch(commandBuffer); + disp->CmdProcessCommandsNVX(commandBuffer, pProcessCommandsInfo); +} + +VKAPI_ATTR void VKAPI_CALL vkCmdReserveSpaceForCommandsNVX( + VkCommandBuffer commandBuffer, + const VkCmdReserveSpaceForCommandsInfoNVX *pReserveSpaceInfo) { + const VkLayerDispatchTable *disp = loader_get_dispatch(commandBuffer); + disp->CmdReserveSpaceForCommandsNVX(commandBuffer, pReserveSpaceInfo); +} + +VKAPI_ATTR VkResult VKAPI_CALL vkCreateIndirectCommandsLayoutNVX( + VkDevice device, const VkIndirectCommandsLayoutCreateInfoNVX *pCreateInfo, + const VkAllocationCallbacks *pAllocator, + VkIndirectCommandsLayoutNVX *pIndirectCommandsLayout) { + const VkLayerDispatchTable *disp = loader_get_dispatch(device); + return disp->CreateIndirectCommandsLayoutNVX( + device, pCreateInfo, pAllocator, pIndirectCommandsLayout); +} + +VKAPI_ATTR void VKAPI_CALL vkDestroyIndirectCommandsLayoutNVX( + VkDevice device, VkIndirectCommandsLayoutNVX indirectCommandsLayout, + const VkAllocationCallbacks *pAllocator) { + const VkLayerDispatchTable *disp = loader_get_dispatch(device); + disp->DestroyIndirectCommandsLayoutNVX(device, indirectCommandsLayout, + pAllocator); +} + +VKAPI_ATTR VkResult VKAPI_CALL vkCreateObjectTableNVX( + VkDevice device, const VkObjectTableCreateInfoNVX *pCreateInfo, + const VkAllocationCallbacks *pAllocator, VkObjectTableNVX *pObjectTable) { + const VkLayerDispatchTable *disp = loader_get_dispatch(device); + return disp->CreateObjectTableNVX(device, pCreateInfo, pAllocator, + pObjectTable); +} + +VKAPI_ATTR void VKAPI_CALL +vkDestroyObjectTableNVX(VkDevice device, VkObjectTableNVX objectTable, + const VkAllocationCallbacks *pAllocator) { + const VkLayerDispatchTable *disp = loader_get_dispatch(device); + disp->DestroyObjectTableNVX(device, objectTable, pAllocator); +} + +VKAPI_ATTR VkResult VKAPI_CALL vkRegisterObjectsNVX( + VkDevice device, VkObjectTableNVX objectTable, uint32_t objectCount, + const VkObjectTableEntryNVX *const *ppObjectTableEntries, + const uint32_t *pObjectIndices) { + const VkLayerDispatchTable *disp = loader_get_dispatch(device); + return disp->RegisterObjectsNVX(device, objectTable, objectCount, + ppObjectTableEntries, pObjectIndices); +} + +VKAPI_ATTR VkResult VKAPI_CALL vkUnregisterObjectsNVX( + VkDevice device, VkObjectTableNVX objectTable, uint32_t objectCount, + const VkObjectEntryTypeNVX *pObjectEntryTypes, + const uint32_t *pObjectIndices) { + const VkLayerDispatchTable *disp = loader_get_dispatch(device); + return disp->UnregisterObjectsNVX(device, objectTable, objectCount, + pObjectEntryTypes, pObjectIndices); +} + +VKAPI_ATTR void VKAPI_CALL vkGetPhysicalDeviceGeneratedCommandsPropertiesNVX( + VkPhysicalDevice physicalDevice, + VkDeviceGeneratedCommandsFeaturesNVX *pFeatures, + VkDeviceGeneratedCommandsLimitsNVX *pLimits) { + const VkLayerInstanceDispatchTable *disp; + VkPhysicalDevice unwrapped_phys_dev = + loader_unwrap_physical_device(physicalDevice); + disp = loader_get_instance_dispatch(physicalDevice); + disp->GetPhysicalDeviceGeneratedCommandsPropertiesNVX(unwrapped_phys_dev, + pFeatures, pLimits); +} + +VKAPI_ATTR void VKAPI_CALL +terminator_GetPhysicalDeviceGeneratedCommandsPropertiesNVX( + VkPhysicalDevice physicalDevice, + VkDeviceGeneratedCommandsFeaturesNVX *pFeatures, + VkDeviceGeneratedCommandsLimitsNVX *pLimits) { + struct loader_physical_device_term *phys_dev_term = + (struct loader_physical_device_term *)physicalDevice; + struct loader_icd_term *icd_term = phys_dev_term->this_icd_term; + if (NULL == icd_term->GetPhysicalDeviceGeneratedCommandsPropertiesNVX) { + loader_log(icd_term->this_instance, VK_DEBUG_REPORT_ERROR_BIT_EXT, 0, + "ICD associated with VkPhysicalDevice does not support " + "vkGetPhysicalDeviceGeneratedCommandsPropertiesNVX"); + } + icd_term->GetPhysicalDeviceGeneratedCommandsPropertiesNVX( + phys_dev_term->phys_dev, pFeatures, pLimits); +} + // GPA helpers for non-KHR extensions bool extension_instance_gpa(struct loader_instance *ptr_instance, @@ -267,6 +362,45 @@ bool extension_instance_gpa(struct loader_instance *ptr_instance, #endif // VK_USE_PLATFORM_WIN32_KHR + // Functions for the VK_NVX_device_generated_commands extension + + if (!strcmp("vkCmdProcessCommandsNVX", name)) { + *addr = (void *)vkCmdProcessCommandsNVX; + return true; + } + if (!strcmp("vkCmdReserveSpaceForCommandsNVX", name)) { + *addr = (void *)vkCmdReserveSpaceForCommandsNVX; + return true; + } + if (!strcmp("vkCreateIndirectCommandsLayoutNVX", name)) { + *addr = (void *)vkCreateIndirectCommandsLayoutNVX; + return true; + } + if (!strcmp("vkDestroyIndirectCommandsLayoutNVX", name)) { + *addr = (void *)vkDestroyIndirectCommandsLayoutNVX; + return true; + } + if (!strcmp("vkCreateObjectTableNVX", name)) { + *addr = (void *)vkCreateObjectTableNVX; + return true; + } + if (!strcmp("vkDestroyObjectTableNVX", name)) { + *addr = (void *)vkDestroyObjectTableNVX; + return true; + } + if (!strcmp("vkRegisterObjectsNVX", name)) { + *addr = (void *)vkRegisterObjectsNVX; + return true; + } + if (!strcmp("vkUnregisterObjectsNVX", name)) { + *addr = (void *)vkUnregisterObjectsNVX; + return true; + } + if (!strcmp("vkGetPhysicalDeviceGeneratedCommandsPropertiesNVX", name)) { + *addr = (void *)vkGetPhysicalDeviceGeneratedCommandsPropertiesNVX; + return true; + } + return false; } diff --git a/loader/extensions.h b/loader/extensions.h index 2e922e5a..71759650 100644 --- a/loader/extensions.h +++ b/loader/extensions.h @@ -45,3 +45,11 @@ terminator_GetPhysicalDeviceExternalImageFormatPropertiesNV( VkImageTiling tiling, VkImageUsageFlags usage, VkImageCreateFlags flags, VkExternalMemoryHandleTypeFlagsNV externalHandleType, VkExternalImageFormatPropertiesNV *pExternalImageFormatProperties); + +// Instance extension terminators for the VK_NVX_device_generated_commands +// extension +VKAPI_ATTR void VKAPI_CALL +terminator_GetPhysicalDeviceGeneratedCommandsPropertiesNVX( + VkPhysicalDevice physicalDevice, + VkDeviceGeneratedCommandsFeaturesNVX *pFeatures, + VkDeviceGeneratedCommandsLimitsNVX *pLimits); diff --git a/loader/loader.c b/loader/loader.c index 3ddbfe31..85b5f48c 100644 --- a/loader/loader.c +++ b/loader/loader.c @@ -158,6 +158,10 @@ const VkLayerInstanceDispatchTable instance_disp = { .CreateDisplayModeKHR = terminator_CreateDisplayModeKHR, .GetDisplayPlaneCapabilitiesKHR = terminator_GetDisplayPlaneCapabilitiesKHR, .CreateDisplayPlaneSurfaceKHR = terminator_CreateDisplayPlaneSurfaceKHR, + + // NVX_device_generated_commands + .GetPhysicalDeviceGeneratedCommandsPropertiesNVX = + terminator_GetPhysicalDeviceGeneratedCommandsPropertiesNVX, }; LOADER_PLATFORM_THREAD_ONCE_DECLARATION(once_init); @@ -1680,7 +1684,10 @@ static bool loader_icd_init_entrys(struct loader_icd_term *icd_term, LOOKUP_GIPA(CreateWaylandSurfaceKHR, false); LOOKUP_GIPA(GetPhysicalDeviceWaylandPresentationSupportKHR, false); #endif + // NV_external_memory_capabilities LOOKUP_GIPA(GetPhysicalDeviceExternalImageFormatPropertiesNV, false); + // NVX_device_generated_commands + LOOKUP_GIPA(GetPhysicalDeviceGeneratedCommandsPropertiesNVX, false); #undef LOOKUP_GIPA diff --git a/loader/loader.h b/loader/loader.h index fc035ed3..a8a5a2a2 100644 --- a/loader/loader.h +++ b/loader/loader.h @@ -249,6 +249,11 @@ struct loader_icd_term { PFN_vkCreateDisplayPlaneSurfaceKHR CreateDisplayPlaneSurfaceKHR; PFN_vkDestroySurfaceKHR DestroySurfaceKHR; PFN_vkCreateSwapchainKHR CreateSwapchainKHR; + + // NVX_device_generated_commands + PFN_vkGetPhysicalDeviceGeneratedCommandsPropertiesNVX + GetPhysicalDeviceGeneratedCommandsPropertiesNVX; + struct loader_icd_term *next; }; diff --git a/loader/table_ops.h b/loader/table_ops.h index 0e42d0ca..13c9ac7e 100644 --- a/loader/table_ops.h +++ b/loader/table_ops.h @@ -290,6 +290,27 @@ static inline void loader_init_device_extension_dispatch_table( (PFN_vkCmdDebugMarkerEndEXT)gpa(dev, "vkCmdDebugMarkerEndEXT"); table->CmdDebugMarkerInsertEXT = (PFN_vkCmdDebugMarkerInsertEXT)gpa(dev, "vkCmdDebugMarkerInsertEXT"); + + // NVX_device_generated_commands + table->CmdProcessCommandsNVX = + (PFN_vkCmdProcessCommandsNVX)gpa(dev, "vkCmdProcessCommandsNVX"); + table->CmdReserveSpaceForCommandsNVX = + (PFN_vkCmdReserveSpaceForCommandsNVX)gpa( + dev, "vkCmdReserveSpaceForCommandsNVX"); + table->CreateIndirectCommandsLayoutNVX = + (PFN_vkCreateIndirectCommandsLayoutNVX)gpa( + dev, "vkCreateIndirectCommandsLayoutNVX"); + table->DestroyIndirectCommandsLayoutNVX = + (PFN_vkDestroyIndirectCommandsLayoutNVX)gpa( + dev, "vkDestroyIndirectCommandsLayoutNVX"); + table->CreateObjectTableNVX = + (PFN_vkCreateObjectTableNVX)gpa(dev, "vkCreateObjectTableNVX"); + table->DestroyObjectTableNVX = + (PFN_vkDestroyObjectTableNVX)gpa(dev, "vkDestroyObjectTableNVX"); + table->RegisterObjectsNVX = + (PFN_vkRegisterObjectsNVX)gpa(dev, "vkRegisterObjectsNVX"); + table->UnregisterObjectsNVX = + (PFN_vkUnregisterObjectsNVX)gpa(dev, "vkUnregisterObjectsNVX"); } static inline void * @@ -687,6 +708,11 @@ static inline void loader_init_instance_extension_dispatch_table( table->CreateDisplayPlaneSurfaceKHR = (PFN_vkCreateDisplayPlaneSurfaceKHR)gpa( inst, "vkCreateDisplayPlaneSurfaceKHR"); + + // NVX_device_generated_commands (physical device commands) + table->GetPhysicalDeviceGeneratedCommandsPropertiesNVX = + (PFN_vkGetPhysicalDeviceGeneratedCommandsPropertiesNVX)gpa( + inst, "vkGetPhysicalDeviceGeneratedCommandsPropertiesNVX"); } static inline void * @@ -787,6 +813,10 @@ loader_lookup_instance_dispatch_table(const VkLayerInstanceDispatchTable *table, if (!strcmp(name, "DebugReportMessageEXT")) return (void *)table->DebugReportMessageEXT; + // NVX_device_generated_commands + if (!strcmp(name, "GetPhysicalDeviceGeneratedCommandsPropertiesNVX")) + return (void *)table->GetPhysicalDeviceGeneratedCommandsPropertiesNVX; + *found_name = false; return NULL; } -- cgit v1.2.3