From: Paul Gofman <pgofman@codeweavers.com> --- dlls/winevulkan/loader.c | 44 +- dlls/winevulkan/loader_thunks.c | 1656 ++++++++----------------------- dlls/winevulkan/make_vulkan | 5 +- dlls/winevulkan/vulkan_loader.h | 10 +- 4 files changed, 435 insertions(+), 1280 deletions(-) diff --git a/dlls/winevulkan/loader.c b/dlls/winevulkan/loader.c index 684d201339f..864328e3f4f 100644 --- a/dlls/winevulkan/loader.c +++ b/dlls/winevulkan/loader.c @@ -376,7 +376,6 @@ VkResult WINAPI vkCreateInstance(const VkInstanceCreateInfo *create_info, const VkApplicationInfo *app_info; struct VkInstance_T *instance; uint32_t device_count = 8, i; - NTSTATUS status; TRACE("create_info %p, allocator %p, instance %p\n", create_info, allocator, ret); @@ -415,8 +414,7 @@ VkResult WINAPI vkCreateInstance(const VkInstanceCreateInfo *create_info, params.pCreateInfo = create_info; params.pAllocator = allocator; params.pInstance = ret; - status = UNIX_CALL(vkCreateInstance, ¶ms); - assert(!status); + UNIX_CALL_CHECKED(vkCreateInstance, ¶ms); if (instance->physical_device_count <= device_count) break; device_count = instance->physical_device_count; @@ -435,12 +433,10 @@ VkResult WINAPI vkCreateInstance(const VkInstanceCreateInfo *create_info, void WINAPI vkDestroyInstance(VkInstance instance, const VkAllocationCallbacks *pAllocator) { struct vkDestroyInstance_params params; - NTSTATUS status; params.instance = instance; params.pAllocator = pAllocator; - status = UNIX_CALL(vkDestroyInstance, ¶ms); - assert(!status); + UNIX_CALL_CHECKED(vkDestroyInstance, ¶ms); free(instance); } @@ -452,13 +448,11 @@ static VkResult enum_host_instance_extension_properties(const char *layer_name, .pLayerName = layer_name, .pPropertyCount = count, }; - NTSTATUS status; for (;;) { *properties = params.pProperties; - status = UNIX_CALL(vkEnumerateInstanceExtensionProperties, ¶ms); - assert(!status && "vkEnumerateInstanceExtensionProperties"); + UNIX_CALL_CHECKED(vkEnumerateInstanceExtensionProperties, ¶ms); if (params.result == VK_INCOMPLETE) { free(params.pProperties); @@ -527,13 +521,11 @@ static VkResult enum_host_device_extension_properties(VkPhysicalDevice physical_ .pLayerName = layer_name, .pPropertyCount = count, }; - NTSTATUS status; for (;;) { *properties = params.pProperties; - status = UNIX_CALL(vkEnumerateDeviceExtensionProperties, ¶ms); - assert(!status && "vkEnumerateDeviceExtensionProperties"); + UNIX_CALL_CHECKED(vkEnumerateDeviceExtensionProperties, ¶ms); if (params.result == VK_INCOMPLETE) { free(params.pProperties); @@ -608,7 +600,6 @@ done: VkResult WINAPI vkEnumerateInstanceVersion(uint32_t *version) { struct vkEnumerateInstanceVersion_params params; - NTSTATUS status; TRACE("%p\n", version); @@ -619,8 +610,7 @@ VkResult WINAPI vkEnumerateInstanceVersion(uint32_t *version) } params.pApiVersion = version; - status = UNIX_CALL(vkEnumerateInstanceVersion, ¶ms); - assert(!status); + UNIX_CALL_CHECKED(vkEnumerateInstanceVersion, ¶ms); return params.result; } @@ -631,7 +621,6 @@ VkResult WINAPI vkCreateDevice(VkPhysicalDevice physical_device, const VkDeviceC struct vkCreateDevice_params params; uint32_t queue_count = 0, i; VkDevice device; - NTSTATUS status; TRACE("Enabling %u client device extensions\n", create_info->enabledExtensionCount); for (uint32_t i = 0; i < create_info->enabledExtensionCount; i++) @@ -656,8 +645,7 @@ VkResult WINAPI vkCreateDevice(VkPhysicalDevice physical_device, const VkDeviceC params.pAllocator = allocator; params.pDevice = ret; - status = UNIX_CALL(vkCreateDevice, ¶ms); - assert(!status); + UNIX_CALL_CHECKED(vkCreateDevice, ¶ms); if (params.result) { free(device); @@ -669,12 +657,10 @@ VkResult WINAPI vkCreateDevice(VkPhysicalDevice physical_device, const VkDeviceC void WINAPI vkDestroyDevice(VkDevice device, const VkAllocationCallbacks *allocator) { struct vkDestroyDevice_params params; - NTSTATUS status; params.device = device; params.pAllocator = allocator; - status = UNIX_CALL(vkDestroyDevice, ¶ms); - assert(!status); + UNIX_CALL_CHECKED(vkDestroyDevice, ¶ms); free(device); } @@ -683,7 +669,6 @@ VkResult WINAPI vkCreateCommandPool(VkDevice device, const VkCommandPoolCreateIn { struct vkCreateCommandPool_params params; struct vk_command_pool *cmd_pool; - NTSTATUS status; if (!(cmd_pool = vulkan_client_object_create(sizeof(*cmd_pool)))) return VK_ERROR_OUT_OF_HOST_MEMORY; @@ -694,8 +679,7 @@ VkResult WINAPI vkCreateCommandPool(VkDevice device, const VkCommandPoolCreateIn params.pCreateInfo = create_info; params.pAllocator = allocator; params.pCommandPool = ret; - status = UNIX_CALL(vkCreateCommandPool, ¶ms); - assert(!status); + UNIX_CALL_CHECKED(vkCreateCommandPool, ¶ms); if (params.result) { free(cmd_pool); @@ -709,7 +693,6 @@ void WINAPI vkDestroyCommandPool(VkDevice device, VkCommandPool handle, const Vk struct vk_command_pool *cmd_pool = command_pool_from_handle(handle); struct vkDestroyCommandPool_params params; VkCommandBuffer buffer, cursor; - NTSTATUS status; if (!cmd_pool) return; @@ -726,8 +709,7 @@ void WINAPI vkDestroyCommandPool(VkDevice device, VkCommandPool handle, const Vk params.device = device; params.commandPool = handle; params.pAllocator = allocator; - status = UNIX_CALL(vkDestroyCommandPool, ¶ms); - assert(!status); + UNIX_CALL_CHECKED(vkDestroyCommandPool, ¶ms); free(cmd_pool); } @@ -736,7 +718,6 @@ VkResult WINAPI vkAllocateCommandBuffers(VkDevice device, const VkCommandBufferA { struct vk_command_pool *pool = command_pool_from_handle(allocate_info->commandPool); struct vkAllocateCommandBuffers_params params; - NTSTATUS status; uint32_t i; for (i = 0; i < allocate_info->commandBufferCount; i++) @@ -745,8 +726,7 @@ VkResult WINAPI vkAllocateCommandBuffers(VkDevice device, const VkCommandBufferA params.device = device; params.pAllocateInfo = allocate_info; params.pCommandBuffers = buffers; - status = UNIX_CALL(vkAllocateCommandBuffers, ¶ms); - assert(!status); + UNIX_CALL_CHECKED(vkAllocateCommandBuffers, ¶ms); if (params.result == VK_SUCCESS) { for (i = 0; i < allocate_info->commandBufferCount; i++) @@ -767,15 +747,13 @@ void WINAPI vkFreeCommandBuffers(VkDevice device, VkCommandPool cmd_pool, uint32 const VkCommandBuffer *buffers) { struct vkFreeCommandBuffers_params params; - NTSTATUS status; uint32_t i; params.device = device; params.commandPool = cmd_pool; params.commandBufferCount = count; params.pCommandBuffers = buffers; - status = UNIX_CALL(vkFreeCommandBuffers, ¶ms); - assert(!status); + UNIX_CALL_CHECKED(vkFreeCommandBuffers, ¶ms); for (i = 0; i < count; i++) { if (!buffers[i]) diff --git a/dlls/winevulkan/loader_thunks.c b/dlls/winevulkan/loader_thunks.c index d8d2365a0e3..6a0cfdebf59 100644 --- a/dlls/winevulkan/loader_thunks.c +++ b/dlls/winevulkan/loader_thunks.c @@ -21,271 +21,227 @@ WINE_DEFAULT_DEBUG_CHANNEL(vulkan); VkResult WINAPI vkAcquireNextImage2KHR(VkDevice device, const VkAcquireNextImageInfoKHR *pAcquireInfo, uint32_t *pImageIndex) { struct vkAcquireNextImage2KHR_params params; - NTSTATUS status; params.device = device; params.pAcquireInfo = pAcquireInfo; params.pImageIndex = pImageIndex; - status = UNIX_CALL(vkAcquireNextImage2KHR, ¶ms); - assert(!status && "vkAcquireNextImage2KHR"); + UNIX_CALL_CHECKED(vkAcquireNextImage2KHR, ¶ms); return params.result; } VkResult WINAPI vkAcquireNextImageKHR(VkDevice device, VkSwapchainKHR swapchain, uint64_t timeout, VkSemaphore semaphore, VkFence fence, uint32_t *pImageIndex) { struct vkAcquireNextImageKHR_params params; - NTSTATUS status; params.device = device; params.swapchain = swapchain; params.timeout = timeout; params.semaphore = semaphore; params.fence = fence; params.pImageIndex = pImageIndex; - status = UNIX_CALL(vkAcquireNextImageKHR, ¶ms); - assert(!status && "vkAcquireNextImageKHR"); + UNIX_CALL_CHECKED(vkAcquireNextImageKHR, ¶ms); return params.result; } VkResult WINAPI vkAcquirePerformanceConfigurationINTEL(VkDevice device, const VkPerformanceConfigurationAcquireInfoINTEL *pAcquireInfo, VkPerformanceConfigurationINTEL *pConfiguration) { struct vkAcquirePerformanceConfigurationINTEL_params params; - NTSTATUS status; params.device = device; params.pAcquireInfo = pAcquireInfo; params.pConfiguration = pConfiguration; - status = UNIX_CALL(vkAcquirePerformanceConfigurationINTEL, ¶ms); - assert(!status && "vkAcquirePerformanceConfigurationINTEL"); + UNIX_CALL_CHECKED(vkAcquirePerformanceConfigurationINTEL, ¶ms); return params.result; } VkResult WINAPI vkAcquireProfilingLockKHR(VkDevice device, const VkAcquireProfilingLockInfoKHR *pInfo) { struct vkAcquireProfilingLockKHR_params params; - NTSTATUS status; params.device = device; params.pInfo = pInfo; - status = UNIX_CALL(vkAcquireProfilingLockKHR, ¶ms); - assert(!status && "vkAcquireProfilingLockKHR"); + UNIX_CALL_CHECKED(vkAcquireProfilingLockKHR, ¶ms); return params.result; } VkResult WINAPI vkAllocateDescriptorSets(VkDevice device, const VkDescriptorSetAllocateInfo *pAllocateInfo, VkDescriptorSet *pDescriptorSets) { struct vkAllocateDescriptorSets_params params; - NTSTATUS status; params.device = device; params.pAllocateInfo = pAllocateInfo; params.pDescriptorSets = pDescriptorSets; - status = UNIX_CALL(vkAllocateDescriptorSets, ¶ms); - assert(!status && "vkAllocateDescriptorSets"); + UNIX_CALL_CHECKED(vkAllocateDescriptorSets, ¶ms); return params.result; } VkResult WINAPI vkAllocateMemory(VkDevice device, const VkMemoryAllocateInfo *pAllocateInfo, const VkAllocationCallbacks *pAllocator, VkDeviceMemory *pMemory) { struct vkAllocateMemory_params params; - NTSTATUS status; params.device = device; params.pAllocateInfo = pAllocateInfo; params.pAllocator = pAllocator; params.pMemory = pMemory; - status = UNIX_CALL(vkAllocateMemory, ¶ms); - assert(!status && "vkAllocateMemory"); + UNIX_CALL_CHECKED(vkAllocateMemory, ¶ms); return params.result; } void WINAPI vkAntiLagUpdateAMD(VkDevice device, const VkAntiLagDataAMD *pData) { struct vkAntiLagUpdateAMD_params params; - NTSTATUS status; params.device = device; params.pData = pData; - status = UNIX_CALL(vkAntiLagUpdateAMD, ¶ms); - assert(!status && "vkAntiLagUpdateAMD"); + UNIX_CALL_CHECKED(vkAntiLagUpdateAMD, ¶ms); } VkResult WINAPI vkBeginCommandBuffer(VkCommandBuffer commandBuffer, const VkCommandBufferBeginInfo *pBeginInfo) { struct vkBeginCommandBuffer_params params; - NTSTATUS status; params.commandBuffer = commandBuffer; params.pBeginInfo = pBeginInfo; - status = UNIX_CALL(vkBeginCommandBuffer, ¶ms); - assert(!status && "vkBeginCommandBuffer"); + UNIX_CALL_CHECKED(vkBeginCommandBuffer, ¶ms); return params.result; } VkResult WINAPI vkBindAccelerationStructureMemoryNV(VkDevice device, uint32_t bindInfoCount, const VkBindAccelerationStructureMemoryInfoNV *pBindInfos) { struct vkBindAccelerationStructureMemoryNV_params params; - NTSTATUS status; params.device = device; params.bindInfoCount = bindInfoCount; params.pBindInfos = pBindInfos; - status = UNIX_CALL(vkBindAccelerationStructureMemoryNV, ¶ms); - assert(!status && "vkBindAccelerationStructureMemoryNV"); + UNIX_CALL_CHECKED(vkBindAccelerationStructureMemoryNV, ¶ms); return params.result; } VkResult WINAPI vkBindBufferMemory(VkDevice device, VkBuffer buffer, VkDeviceMemory memory, VkDeviceSize memoryOffset) { struct vkBindBufferMemory_params params; - NTSTATUS status; params.device = device; params.buffer = buffer; params.memory = memory; params.memoryOffset = memoryOffset; - status = UNIX_CALL(vkBindBufferMemory, ¶ms); - assert(!status && "vkBindBufferMemory"); + UNIX_CALL_CHECKED(vkBindBufferMemory, ¶ms); return params.result; } VkResult WINAPI vkBindBufferMemory2(VkDevice device, uint32_t bindInfoCount, const VkBindBufferMemoryInfo *pBindInfos) { struct vkBindBufferMemory2_params params; - NTSTATUS status; params.device = device; params.bindInfoCount = bindInfoCount; params.pBindInfos = pBindInfos; - status = UNIX_CALL(vkBindBufferMemory2, ¶ms); - assert(!status && "vkBindBufferMemory2"); + UNIX_CALL_CHECKED(vkBindBufferMemory2, ¶ms); return params.result; } VkResult WINAPI vkBindBufferMemory2KHR(VkDevice device, uint32_t bindInfoCount, const VkBindBufferMemoryInfo *pBindInfos) { struct vkBindBufferMemory2KHR_params params; - NTSTATUS status; params.device = device; params.bindInfoCount = bindInfoCount; params.pBindInfos = pBindInfos; - status = UNIX_CALL(vkBindBufferMemory2KHR, ¶ms); - assert(!status && "vkBindBufferMemory2KHR"); + UNIX_CALL_CHECKED(vkBindBufferMemory2KHR, ¶ms); return params.result; } VkResult WINAPI vkBindDataGraphPipelineSessionMemoryARM(VkDevice device, uint32_t bindInfoCount, const VkBindDataGraphPipelineSessionMemoryInfoARM *pBindInfos) { struct vkBindDataGraphPipelineSessionMemoryARM_params params; - NTSTATUS status; params.device = device; params.bindInfoCount = bindInfoCount; params.pBindInfos = pBindInfos; - status = UNIX_CALL(vkBindDataGraphPipelineSessionMemoryARM, ¶ms); - assert(!status && "vkBindDataGraphPipelineSessionMemoryARM"); + UNIX_CALL_CHECKED(vkBindDataGraphPipelineSessionMemoryARM, ¶ms); return params.result; } VkResult WINAPI vkBindImageMemory(VkDevice device, VkImage image, VkDeviceMemory memory, VkDeviceSize memoryOffset) { struct vkBindImageMemory_params params; - NTSTATUS status; params.device = device; params.image = image; params.memory = memory; params.memoryOffset = memoryOffset; - status = UNIX_CALL(vkBindImageMemory, ¶ms); - assert(!status && "vkBindImageMemory"); + UNIX_CALL_CHECKED(vkBindImageMemory, ¶ms); return params.result; } VkResult WINAPI vkBindImageMemory2(VkDevice device, uint32_t bindInfoCount, const VkBindImageMemoryInfo *pBindInfos) { struct vkBindImageMemory2_params params; - NTSTATUS status; params.device = device; params.bindInfoCount = bindInfoCount; params.pBindInfos = pBindInfos; - status = UNIX_CALL(vkBindImageMemory2, ¶ms); - assert(!status && "vkBindImageMemory2"); + UNIX_CALL_CHECKED(vkBindImageMemory2, ¶ms); return params.result; } VkResult WINAPI vkBindImageMemory2KHR(VkDevice device, uint32_t bindInfoCount, const VkBindImageMemoryInfo *pBindInfos) { struct vkBindImageMemory2KHR_params params; - NTSTATUS status; params.device = device; params.bindInfoCount = bindInfoCount; params.pBindInfos = pBindInfos; - status = UNIX_CALL(vkBindImageMemory2KHR, ¶ms); - assert(!status && "vkBindImageMemory2KHR"); + UNIX_CALL_CHECKED(vkBindImageMemory2KHR, ¶ms); return params.result; } VkResult WINAPI vkBindOpticalFlowSessionImageNV(VkDevice device, VkOpticalFlowSessionNV session, VkOpticalFlowSessionBindingPointNV bindingPoint, VkImageView view, VkImageLayout layout) { struct vkBindOpticalFlowSessionImageNV_params params; - NTSTATUS status; params.device = device; params.session = session; params.bindingPoint = bindingPoint; params.view = view; params.layout = layout; - status = UNIX_CALL(vkBindOpticalFlowSessionImageNV, ¶ms); - assert(!status && "vkBindOpticalFlowSessionImageNV"); + UNIX_CALL_CHECKED(vkBindOpticalFlowSessionImageNV, ¶ms); return params.result; } VkResult WINAPI vkBindTensorMemoryARM(VkDevice device, uint32_t bindInfoCount, const VkBindTensorMemoryInfoARM *pBindInfos) { struct vkBindTensorMemoryARM_params params; - NTSTATUS status; params.device = device; params.bindInfoCount = bindInfoCount; params.pBindInfos = pBindInfos; - status = UNIX_CALL(vkBindTensorMemoryARM, ¶ms); - assert(!status && "vkBindTensorMemoryARM"); + UNIX_CALL_CHECKED(vkBindTensorMemoryARM, ¶ms); return params.result; } VkResult WINAPI vkBindVideoSessionMemoryKHR(VkDevice device, VkVideoSessionKHR videoSession, uint32_t bindSessionMemoryInfoCount, const VkBindVideoSessionMemoryInfoKHR *pBindSessionMemoryInfos) { struct vkBindVideoSessionMemoryKHR_params params; - NTSTATUS status; params.device = device; params.videoSession = videoSession; params.bindSessionMemoryInfoCount = bindSessionMemoryInfoCount; params.pBindSessionMemoryInfos = pBindSessionMemoryInfos; - status = UNIX_CALL(vkBindVideoSessionMemoryKHR, ¶ms); - assert(!status && "vkBindVideoSessionMemoryKHR"); + UNIX_CALL_CHECKED(vkBindVideoSessionMemoryKHR, ¶ms); return params.result; } VkResult WINAPI vkBuildAccelerationStructuresKHR(VkDevice device, VkDeferredOperationKHR deferredOperation, uint32_t infoCount, const VkAccelerationStructureBuildGeometryInfoKHR *pInfos, const VkAccelerationStructureBuildRangeInfoKHR * const*ppBuildRangeInfos) { struct vkBuildAccelerationStructuresKHR_params params; - NTSTATUS status; params.device = device; params.deferredOperation = deferredOperation; params.infoCount = infoCount; params.pInfos = pInfos; params.ppBuildRangeInfos = ppBuildRangeInfos; - status = UNIX_CALL(vkBuildAccelerationStructuresKHR, ¶ms); - assert(!status && "vkBuildAccelerationStructuresKHR"); + UNIX_CALL_CHECKED(vkBuildAccelerationStructuresKHR, ¶ms); return params.result; } VkResult WINAPI vkBuildMicromapsEXT(VkDevice device, VkDeferredOperationKHR deferredOperation, uint32_t infoCount, const VkMicromapBuildInfoEXT *pInfos) { struct vkBuildMicromapsEXT_params params; - NTSTATUS status; params.device = device; params.deferredOperation = deferredOperation; params.infoCount = infoCount; params.pInfos = pInfos; - status = UNIX_CALL(vkBuildMicromapsEXT, ¶ms); - assert(!status && "vkBuildMicromapsEXT"); + UNIX_CALL_CHECKED(vkBuildMicromapsEXT, ¶ms); return params.result; } void WINAPI vkClearShaderInstrumentationMetricsARM(VkDevice device, VkShaderInstrumentationARM instrumentation) { struct vkClearShaderInstrumentationMetricsARM_params params; - NTSTATUS status; params.device = device; params.instrumentation = instrumentation; - status = UNIX_CALL(vkClearShaderInstrumentationMetricsARM, ¶ms); - assert(!status && "vkClearShaderInstrumentationMetricsARM"); + UNIX_CALL_CHECKED(vkClearShaderInstrumentationMetricsARM, ¶ms); } void WINAPI vkCmdBeginConditionalRendering2EXT(VkCommandBuffer commandBuffer, const VkConditionalRenderingBeginInfo2EXT *pConditionalRenderingBegin) @@ -323,24 +279,20 @@ void WINAPI vkCmdBeginDebugUtilsLabelEXT(VkCommandBuffer commandBuffer, const Vk VkResult WINAPI vkCmdBeginGpaSampleAMD(VkCommandBuffer commandBuffer, VkGpaSessionAMD gpaSession, const VkGpaSampleBeginInfoAMD *pGpaSampleBeginInfo, uint32_t *pSampleID) { struct vkCmdBeginGpaSampleAMD_params params; - NTSTATUS status; params.commandBuffer = commandBuffer; params.gpaSession = gpaSession; params.pGpaSampleBeginInfo = pGpaSampleBeginInfo; params.pSampleID = pSampleID; - status = UNIX_CALL(vkCmdBeginGpaSampleAMD, ¶ms); - assert(!status && "vkCmdBeginGpaSampleAMD"); + UNIX_CALL_CHECKED(vkCmdBeginGpaSampleAMD, ¶ms); return params.result; } VkResult WINAPI vkCmdBeginGpaSessionAMD(VkCommandBuffer commandBuffer, VkGpaSessionAMD gpaSession) { struct vkCmdBeginGpaSessionAMD_params params; - NTSTATUS status; params.commandBuffer = commandBuffer; params.gpaSession = gpaSession; - status = UNIX_CALL(vkCmdBeginGpaSessionAMD, ¶ms); - assert(!status && "vkCmdBeginGpaSessionAMD"); + UNIX_CALL_CHECKED(vkCmdBeginGpaSessionAMD, ¶ms); return params.result; } @@ -1599,11 +1551,9 @@ void WINAPI vkCmdEndGpaSampleAMD(VkCommandBuffer commandBuffer, VkGpaSessionAMD VkResult WINAPI vkCmdEndGpaSessionAMD(VkCommandBuffer commandBuffer, VkGpaSessionAMD gpaSession) { struct vkCmdEndGpaSessionAMD_params params; - NTSTATUS status; params.commandBuffer = commandBuffer; params.gpaSession = gpaSession; - status = UNIX_CALL(vkCmdEndGpaSessionAMD, ¶ms); - assert(!status && "vkCmdEndGpaSessionAMD"); + UNIX_CALL_CHECKED(vkCmdEndGpaSessionAMD, ¶ms); return params.result; } @@ -2601,33 +2551,27 @@ void WINAPI vkCmdSetPatchControlPointsEXT(VkCommandBuffer commandBuffer, uint32_ VkResult WINAPI vkCmdSetPerformanceMarkerINTEL(VkCommandBuffer commandBuffer, const VkPerformanceMarkerInfoINTEL *pMarkerInfo) { struct vkCmdSetPerformanceMarkerINTEL_params params; - NTSTATUS status; params.commandBuffer = commandBuffer; params.pMarkerInfo = pMarkerInfo; - status = UNIX_CALL(vkCmdSetPerformanceMarkerINTEL, ¶ms); - assert(!status && "vkCmdSetPerformanceMarkerINTEL"); + UNIX_CALL_CHECKED(vkCmdSetPerformanceMarkerINTEL, ¶ms); return params.result; } VkResult WINAPI vkCmdSetPerformanceOverrideINTEL(VkCommandBuffer commandBuffer, const VkPerformanceOverrideInfoINTEL *pOverrideInfo) { struct vkCmdSetPerformanceOverrideINTEL_params params; - NTSTATUS status; params.commandBuffer = commandBuffer; params.pOverrideInfo = pOverrideInfo; - status = UNIX_CALL(vkCmdSetPerformanceOverrideINTEL, ¶ms); - assert(!status && "vkCmdSetPerformanceOverrideINTEL"); + UNIX_CALL_CHECKED(vkCmdSetPerformanceOverrideINTEL, ¶ms); return params.result; } VkResult WINAPI vkCmdSetPerformanceStreamMarkerINTEL(VkCommandBuffer commandBuffer, const VkPerformanceStreamMarkerInfoINTEL *pMarkerInfo) { struct vkCmdSetPerformanceStreamMarkerINTEL_params params; - NTSTATUS status; params.commandBuffer = commandBuffer; params.pMarkerInfo = pMarkerInfo; - status = UNIX_CALL(vkCmdSetPerformanceStreamMarkerINTEL, ¶ms); - assert(!status && "vkCmdSetPerformanceStreamMarkerINTEL"); + UNIX_CALL_CHECKED(vkCmdSetPerformanceStreamMarkerINTEL, ¶ms); return params.result; } @@ -3209,287 +3153,240 @@ void WINAPI vkCmdWriteTimestamp2KHR(VkCommandBuffer commandBuffer, VkPipelineSta VkResult WINAPI vkCompileDeferredNV(VkDevice device, VkPipeline pipeline, uint32_t shader) { struct vkCompileDeferredNV_params params; - NTSTATUS status; params.device = device; params.pipeline = pipeline; params.shader = shader; - status = UNIX_CALL(vkCompileDeferredNV, ¶ms); - assert(!status && "vkCompileDeferredNV"); + UNIX_CALL_CHECKED(vkCompileDeferredNV, ¶ms); return params.result; } VkResult WINAPI vkConvertCooperativeVectorMatrixNV(VkDevice device, const VkConvertCooperativeVectorMatrixInfoNV *pInfo) { struct vkConvertCooperativeVectorMatrixNV_params params; - NTSTATUS status; params.device = device; params.pInfo = pInfo; - status = UNIX_CALL(vkConvertCooperativeVectorMatrixNV, ¶ms); - assert(!status && "vkConvertCooperativeVectorMatrixNV"); + UNIX_CALL_CHECKED(vkConvertCooperativeVectorMatrixNV, ¶ms); return params.result; } VkResult WINAPI vkCopyAccelerationStructureKHR(VkDevice device, VkDeferredOperationKHR deferredOperation, const VkCopyAccelerationStructureInfoKHR *pInfo) { struct vkCopyAccelerationStructureKHR_params params; - NTSTATUS status; params.device = device; params.deferredOperation = deferredOperation; params.pInfo = pInfo; - status = UNIX_CALL(vkCopyAccelerationStructureKHR, ¶ms); - assert(!status && "vkCopyAccelerationStructureKHR"); + UNIX_CALL_CHECKED(vkCopyAccelerationStructureKHR, ¶ms); return params.result; } VkResult WINAPI vkCopyAccelerationStructureToMemoryKHR(VkDevice device, VkDeferredOperationKHR deferredOperation, const VkCopyAccelerationStructureToMemoryInfoKHR *pInfo) { struct vkCopyAccelerationStructureToMemoryKHR_params params; - NTSTATUS status; params.device = device; params.deferredOperation = deferredOperation; params.pInfo = pInfo; - status = UNIX_CALL(vkCopyAccelerationStructureToMemoryKHR, ¶ms); - assert(!status && "vkCopyAccelerationStructureToMemoryKHR"); + UNIX_CALL_CHECKED(vkCopyAccelerationStructureToMemoryKHR, ¶ms); return params.result; } VkResult WINAPI vkCopyImageToImage(VkDevice device, const VkCopyImageToImageInfo *pCopyImageToImageInfo) { struct vkCopyImageToImage_params params; - NTSTATUS status; params.device = device; params.pCopyImageToImageInfo = pCopyImageToImageInfo; - status = UNIX_CALL(vkCopyImageToImage, ¶ms); - assert(!status && "vkCopyImageToImage"); + UNIX_CALL_CHECKED(vkCopyImageToImage, ¶ms); return params.result; } VkResult WINAPI vkCopyImageToImageEXT(VkDevice device, const VkCopyImageToImageInfo *pCopyImageToImageInfo) { struct vkCopyImageToImageEXT_params params; - NTSTATUS status; params.device = device; params.pCopyImageToImageInfo = pCopyImageToImageInfo; - status = UNIX_CALL(vkCopyImageToImageEXT, ¶ms); - assert(!status && "vkCopyImageToImageEXT"); + UNIX_CALL_CHECKED(vkCopyImageToImageEXT, ¶ms); return params.result; } VkResult WINAPI vkCopyImageToMemory(VkDevice device, const VkCopyImageToMemoryInfo *pCopyImageToMemoryInfo) { struct vkCopyImageToMemory_params params; - NTSTATUS status; params.device = device; params.pCopyImageToMemoryInfo = pCopyImageToMemoryInfo; - status = UNIX_CALL(vkCopyImageToMemory, ¶ms); - assert(!status && "vkCopyImageToMemory"); + UNIX_CALL_CHECKED(vkCopyImageToMemory, ¶ms); return params.result; } VkResult WINAPI vkCopyImageToMemoryEXT(VkDevice device, const VkCopyImageToMemoryInfo *pCopyImageToMemoryInfo) { struct vkCopyImageToMemoryEXT_params params; - NTSTATUS status; params.device = device; params.pCopyImageToMemoryInfo = pCopyImageToMemoryInfo; - status = UNIX_CALL(vkCopyImageToMemoryEXT, ¶ms); - assert(!status && "vkCopyImageToMemoryEXT"); + UNIX_CALL_CHECKED(vkCopyImageToMemoryEXT, ¶ms); return params.result; } VkResult WINAPI vkCopyMemoryToAccelerationStructureKHR(VkDevice device, VkDeferredOperationKHR deferredOperation, const VkCopyMemoryToAccelerationStructureInfoKHR *pInfo) { struct vkCopyMemoryToAccelerationStructureKHR_params params; - NTSTATUS status; params.device = device; params.deferredOperation = deferredOperation; params.pInfo = pInfo; - status = UNIX_CALL(vkCopyMemoryToAccelerationStructureKHR, ¶ms); - assert(!status && "vkCopyMemoryToAccelerationStructureKHR"); + UNIX_CALL_CHECKED(vkCopyMemoryToAccelerationStructureKHR, ¶ms); return params.result; } VkResult WINAPI vkCopyMemoryToImage(VkDevice device, const VkCopyMemoryToImageInfo *pCopyMemoryToImageInfo) { struct vkCopyMemoryToImage_params params; - NTSTATUS status; params.device = device; params.pCopyMemoryToImageInfo = pCopyMemoryToImageInfo; - status = UNIX_CALL(vkCopyMemoryToImage, ¶ms); - assert(!status && "vkCopyMemoryToImage"); + UNIX_CALL_CHECKED(vkCopyMemoryToImage, ¶ms); return params.result; } VkResult WINAPI vkCopyMemoryToImageEXT(VkDevice device, const VkCopyMemoryToImageInfo *pCopyMemoryToImageInfo) { struct vkCopyMemoryToImageEXT_params params; - NTSTATUS status; params.device = device; params.pCopyMemoryToImageInfo = pCopyMemoryToImageInfo; - status = UNIX_CALL(vkCopyMemoryToImageEXT, ¶ms); - assert(!status && "vkCopyMemoryToImageEXT"); + UNIX_CALL_CHECKED(vkCopyMemoryToImageEXT, ¶ms); return params.result; } VkResult WINAPI vkCopyMemoryToMicromapEXT(VkDevice device, VkDeferredOperationKHR deferredOperation, const VkCopyMemoryToMicromapInfoEXT *pInfo) { struct vkCopyMemoryToMicromapEXT_params params; - NTSTATUS status; params.device = device; params.deferredOperation = deferredOperation; params.pInfo = pInfo; - status = UNIX_CALL(vkCopyMemoryToMicromapEXT, ¶ms); - assert(!status && "vkCopyMemoryToMicromapEXT"); + UNIX_CALL_CHECKED(vkCopyMemoryToMicromapEXT, ¶ms); return params.result; } VkResult WINAPI vkCopyMicromapEXT(VkDevice device, VkDeferredOperationKHR deferredOperation, const VkCopyMicromapInfoEXT *pInfo) { struct vkCopyMicromapEXT_params params; - NTSTATUS status; params.device = device; params.deferredOperation = deferredOperation; params.pInfo = pInfo; - status = UNIX_CALL(vkCopyMicromapEXT, ¶ms); - assert(!status && "vkCopyMicromapEXT"); + UNIX_CALL_CHECKED(vkCopyMicromapEXT, ¶ms); return params.result; } VkResult WINAPI vkCopyMicromapToMemoryEXT(VkDevice device, VkDeferredOperationKHR deferredOperation, const VkCopyMicromapToMemoryInfoEXT *pInfo) { struct vkCopyMicromapToMemoryEXT_params params; - NTSTATUS status; params.device = device; params.deferredOperation = deferredOperation; params.pInfo = pInfo; - status = UNIX_CALL(vkCopyMicromapToMemoryEXT, ¶ms); - assert(!status && "vkCopyMicromapToMemoryEXT"); + UNIX_CALL_CHECKED(vkCopyMicromapToMemoryEXT, ¶ms); return params.result; } VkResult WINAPI vkCreateAccelerationStructure2KHR(VkDevice device, const VkAccelerationStructureCreateInfo2KHR *pCreateInfo, const VkAllocationCallbacks *pAllocator, VkAccelerationStructureKHR *pAccelerationStructure) { struct vkCreateAccelerationStructure2KHR_params params; - NTSTATUS status; params.device = device; params.pCreateInfo = pCreateInfo; params.pAllocator = pAllocator; params.pAccelerationStructure = pAccelerationStructure; - status = UNIX_CALL(vkCreateAccelerationStructure2KHR, ¶ms); - assert(!status && "vkCreateAccelerationStructure2KHR"); + UNIX_CALL_CHECKED(vkCreateAccelerationStructure2KHR, ¶ms); return params.result; } VkResult WINAPI vkCreateAccelerationStructureKHR(VkDevice device, const VkAccelerationStructureCreateInfoKHR *pCreateInfo, const VkAllocationCallbacks *pAllocator, VkAccelerationStructureKHR *pAccelerationStructure) { struct vkCreateAccelerationStructureKHR_params params; - NTSTATUS status; params.device = device; params.pCreateInfo = pCreateInfo; params.pAllocator = pAllocator; params.pAccelerationStructure = pAccelerationStructure; - status = UNIX_CALL(vkCreateAccelerationStructureKHR, ¶ms); - assert(!status && "vkCreateAccelerationStructureKHR"); + UNIX_CALL_CHECKED(vkCreateAccelerationStructureKHR, ¶ms); return params.result; } VkResult WINAPI vkCreateAccelerationStructureNV(VkDevice device, const VkAccelerationStructureCreateInfoNV *pCreateInfo, const VkAllocationCallbacks *pAllocator, VkAccelerationStructureNV *pAccelerationStructure) { struct vkCreateAccelerationStructureNV_params params; - NTSTATUS status; params.device = device; params.pCreateInfo = pCreateInfo; params.pAllocator = pAllocator; params.pAccelerationStructure = pAccelerationStructure; - status = UNIX_CALL(vkCreateAccelerationStructureNV, ¶ms); - assert(!status && "vkCreateAccelerationStructureNV"); + UNIX_CALL_CHECKED(vkCreateAccelerationStructureNV, ¶ms); return params.result; } VkResult WINAPI vkCreateBuffer(VkDevice device, const VkBufferCreateInfo *pCreateInfo, const VkAllocationCallbacks *pAllocator, VkBuffer *pBuffer) { struct vkCreateBuffer_params params; - NTSTATUS status; params.device = device; params.pCreateInfo = pCreateInfo; params.pAllocator = pAllocator; params.pBuffer = pBuffer; - status = UNIX_CALL(vkCreateBuffer, ¶ms); - assert(!status && "vkCreateBuffer"); + UNIX_CALL_CHECKED(vkCreateBuffer, ¶ms); return params.result; } VkResult WINAPI vkCreateBufferView(VkDevice device, const VkBufferViewCreateInfo *pCreateInfo, const VkAllocationCallbacks *pAllocator, VkBufferView *pView) { struct vkCreateBufferView_params params; - NTSTATUS status; params.device = device; params.pCreateInfo = pCreateInfo; params.pAllocator = pAllocator; params.pView = pView; - status = UNIX_CALL(vkCreateBufferView, ¶ms); - assert(!status && "vkCreateBufferView"); + UNIX_CALL_CHECKED(vkCreateBufferView, ¶ms); return params.result; } VkResult WINAPI vkCreateComputePipelines(VkDevice device, VkPipelineCache pipelineCache, uint32_t createInfoCount, const VkComputePipelineCreateInfo *pCreateInfos, const VkAllocationCallbacks *pAllocator, VkPipeline *pPipelines) { struct vkCreateComputePipelines_params params; - NTSTATUS status; params.device = device; params.pipelineCache = pipelineCache; params.createInfoCount = createInfoCount; params.pCreateInfos = pCreateInfos; params.pAllocator = pAllocator; params.pPipelines = pPipelines; - status = UNIX_CALL(vkCreateComputePipelines, ¶ms); - assert(!status && "vkCreateComputePipelines"); + UNIX_CALL_CHECKED(vkCreateComputePipelines, ¶ms); return params.result; } VkResult WINAPI vkCreateCuFunctionNVX(VkDevice device, const VkCuFunctionCreateInfoNVX *pCreateInfo, const VkAllocationCallbacks *pAllocator, VkCuFunctionNVX *pFunction) { struct vkCreateCuFunctionNVX_params params; - NTSTATUS status; params.device = device; params.pCreateInfo = pCreateInfo; params.pAllocator = pAllocator; params.pFunction = pFunction; - status = UNIX_CALL(vkCreateCuFunctionNVX, ¶ms); - assert(!status && "vkCreateCuFunctionNVX"); + UNIX_CALL_CHECKED(vkCreateCuFunctionNVX, ¶ms); return params.result; } VkResult WINAPI vkCreateCuModuleNVX(VkDevice device, const VkCuModuleCreateInfoNVX *pCreateInfo, const VkAllocationCallbacks *pAllocator, VkCuModuleNVX *pModule) { struct vkCreateCuModuleNVX_params params; - NTSTATUS status; params.device = device; params.pCreateInfo = pCreateInfo; params.pAllocator = pAllocator; params.pModule = pModule; - status = UNIX_CALL(vkCreateCuModuleNVX, ¶ms); - assert(!status && "vkCreateCuModuleNVX"); + UNIX_CALL_CHECKED(vkCreateCuModuleNVX, ¶ms); return params.result; } VkResult WINAPI vkCreateDataGraphPipelineSessionARM(VkDevice device, const VkDataGraphPipelineSessionCreateInfoARM *pCreateInfo, const VkAllocationCallbacks *pAllocator, VkDataGraphPipelineSessionARM *pSession) { struct vkCreateDataGraphPipelineSessionARM_params params; - NTSTATUS status; params.device = device; params.pCreateInfo = pCreateInfo; params.pAllocator = pAllocator; params.pSession = pSession; - status = UNIX_CALL(vkCreateDataGraphPipelineSessionARM, ¶ms); - assert(!status && "vkCreateDataGraphPipelineSessionARM"); + UNIX_CALL_CHECKED(vkCreateDataGraphPipelineSessionARM, ¶ms); return params.result; } VkResult WINAPI vkCreateDataGraphPipelinesARM(VkDevice device, VkDeferredOperationKHR deferredOperation, VkPipelineCache pipelineCache, uint32_t createInfoCount, const VkDataGraphPipelineCreateInfoARM *pCreateInfos, const VkAllocationCallbacks *pAllocator, VkPipeline *pPipelines) { struct vkCreateDataGraphPipelinesARM_params params; - NTSTATUS status; params.device = device; params.deferredOperation = deferredOperation; params.pipelineCache = pipelineCache; @@ -3497,341 +3394,289 @@ VkResult WINAPI vkCreateDataGraphPipelinesARM(VkDevice device, VkDeferredOperati params.pCreateInfos = pCreateInfos; params.pAllocator = pAllocator; params.pPipelines = pPipelines; - status = UNIX_CALL(vkCreateDataGraphPipelinesARM, ¶ms); - assert(!status && "vkCreateDataGraphPipelinesARM"); + UNIX_CALL_CHECKED(vkCreateDataGraphPipelinesARM, ¶ms); return params.result; } VkResult WINAPI vkCreateDebugReportCallbackEXT(VkInstance instance, const VkDebugReportCallbackCreateInfoEXT *pCreateInfo, const VkAllocationCallbacks *pAllocator, VkDebugReportCallbackEXT *pCallback) { struct vkCreateDebugReportCallbackEXT_params params; - NTSTATUS status; params.instance = instance; params.pCreateInfo = pCreateInfo; params.pAllocator = pAllocator; params.pCallback = pCallback; - status = UNIX_CALL(vkCreateDebugReportCallbackEXT, ¶ms); - assert(!status && "vkCreateDebugReportCallbackEXT"); + UNIX_CALL_CHECKED(vkCreateDebugReportCallbackEXT, ¶ms); return params.result; } VkResult WINAPI vkCreateDebugUtilsMessengerEXT(VkInstance instance, const VkDebugUtilsMessengerCreateInfoEXT *pCreateInfo, const VkAllocationCallbacks *pAllocator, VkDebugUtilsMessengerEXT *pMessenger) { struct vkCreateDebugUtilsMessengerEXT_params params; - NTSTATUS status; params.instance = instance; params.pCreateInfo = pCreateInfo; params.pAllocator = pAllocator; params.pMessenger = pMessenger; - status = UNIX_CALL(vkCreateDebugUtilsMessengerEXT, ¶ms); - assert(!status && "vkCreateDebugUtilsMessengerEXT"); + UNIX_CALL_CHECKED(vkCreateDebugUtilsMessengerEXT, ¶ms); return params.result; } VkResult WINAPI vkCreateDeferredOperationKHR(VkDevice device, const VkAllocationCallbacks *pAllocator, VkDeferredOperationKHR *pDeferredOperation) { struct vkCreateDeferredOperationKHR_params params; - NTSTATUS status; params.device = device; params.pAllocator = pAllocator; params.pDeferredOperation = pDeferredOperation; - status = UNIX_CALL(vkCreateDeferredOperationKHR, ¶ms); - assert(!status && "vkCreateDeferredOperationKHR"); + UNIX_CALL_CHECKED(vkCreateDeferredOperationKHR, ¶ms); return params.result; } VkResult WINAPI vkCreateDescriptorPool(VkDevice device, const VkDescriptorPoolCreateInfo *pCreateInfo, const VkAllocationCallbacks *pAllocator, VkDescriptorPool *pDescriptorPool) { struct vkCreateDescriptorPool_params params; - NTSTATUS status; params.device = device; params.pCreateInfo = pCreateInfo; params.pAllocator = pAllocator; params.pDescriptorPool = pDescriptorPool; - status = UNIX_CALL(vkCreateDescriptorPool, ¶ms); - assert(!status && "vkCreateDescriptorPool"); + UNIX_CALL_CHECKED(vkCreateDescriptorPool, ¶ms); return params.result; } VkResult WINAPI vkCreateDescriptorSetLayout(VkDevice device, const VkDescriptorSetLayoutCreateInfo *pCreateInfo, const VkAllocationCallbacks *pAllocator, VkDescriptorSetLayout *pSetLayout) { struct vkCreateDescriptorSetLayout_params params; - NTSTATUS status; params.device = device; params.pCreateInfo = pCreateInfo; params.pAllocator = pAllocator; params.pSetLayout = pSetLayout; - status = UNIX_CALL(vkCreateDescriptorSetLayout, ¶ms); - assert(!status && "vkCreateDescriptorSetLayout"); + UNIX_CALL_CHECKED(vkCreateDescriptorSetLayout, ¶ms); return params.result; } VkResult WINAPI vkCreateDescriptorUpdateTemplate(VkDevice device, const VkDescriptorUpdateTemplateCreateInfo *pCreateInfo, const VkAllocationCallbacks *pAllocator, VkDescriptorUpdateTemplate *pDescriptorUpdateTemplate) { struct vkCreateDescriptorUpdateTemplate_params params; - NTSTATUS status; params.device = device; params.pCreateInfo = pCreateInfo; params.pAllocator = pAllocator; params.pDescriptorUpdateTemplate = pDescriptorUpdateTemplate; - status = UNIX_CALL(vkCreateDescriptorUpdateTemplate, ¶ms); - assert(!status && "vkCreateDescriptorUpdateTemplate"); + UNIX_CALL_CHECKED(vkCreateDescriptorUpdateTemplate, ¶ms); return params.result; } VkResult WINAPI vkCreateDescriptorUpdateTemplateKHR(VkDevice device, const VkDescriptorUpdateTemplateCreateInfo *pCreateInfo, const VkAllocationCallbacks *pAllocator, VkDescriptorUpdateTemplate *pDescriptorUpdateTemplate) { struct vkCreateDescriptorUpdateTemplateKHR_params params; - NTSTATUS status; params.device = device; params.pCreateInfo = pCreateInfo; params.pAllocator = pAllocator; params.pDescriptorUpdateTemplate = pDescriptorUpdateTemplate; - status = UNIX_CALL(vkCreateDescriptorUpdateTemplateKHR, ¶ms); - assert(!status && "vkCreateDescriptorUpdateTemplateKHR"); + UNIX_CALL_CHECKED(vkCreateDescriptorUpdateTemplateKHR, ¶ms); return params.result; } VkResult WINAPI vkCreateEvent(VkDevice device, const VkEventCreateInfo *pCreateInfo, const VkAllocationCallbacks *pAllocator, VkEvent *pEvent) { struct vkCreateEvent_params params; - NTSTATUS status; params.device = device; params.pCreateInfo = pCreateInfo; params.pAllocator = pAllocator; params.pEvent = pEvent; - status = UNIX_CALL(vkCreateEvent, ¶ms); - assert(!status && "vkCreateEvent"); + UNIX_CALL_CHECKED(vkCreateEvent, ¶ms); return params.result; } VkResult WINAPI vkCreateFence(VkDevice device, const VkFenceCreateInfo *pCreateInfo, const VkAllocationCallbacks *pAllocator, VkFence *pFence) { struct vkCreateFence_params params; - NTSTATUS status; params.device = device; params.pCreateInfo = pCreateInfo; params.pAllocator = pAllocator; params.pFence = pFence; - status = UNIX_CALL(vkCreateFence, ¶ms); - assert(!status && "vkCreateFence"); + UNIX_CALL_CHECKED(vkCreateFence, ¶ms); return params.result; } VkResult WINAPI vkCreateFramebuffer(VkDevice device, const VkFramebufferCreateInfo *pCreateInfo, const VkAllocationCallbacks *pAllocator, VkFramebuffer *pFramebuffer) { struct vkCreateFramebuffer_params params; - NTSTATUS status; params.device = device; params.pCreateInfo = pCreateInfo; params.pAllocator = pAllocator; params.pFramebuffer = pFramebuffer; - status = UNIX_CALL(vkCreateFramebuffer, ¶ms); - assert(!status && "vkCreateFramebuffer"); + UNIX_CALL_CHECKED(vkCreateFramebuffer, ¶ms); return params.result; } VkResult WINAPI vkCreateGpaSessionAMD(VkDevice device, const VkGpaSessionCreateInfoAMD *pCreateInfo, const VkAllocationCallbacks *pAllocator, VkGpaSessionAMD *pGpaSession) { struct vkCreateGpaSessionAMD_params params; - NTSTATUS status; params.device = device; params.pCreateInfo = pCreateInfo; params.pAllocator = pAllocator; params.pGpaSession = pGpaSession; - status = UNIX_CALL(vkCreateGpaSessionAMD, ¶ms); - assert(!status && "vkCreateGpaSessionAMD"); + UNIX_CALL_CHECKED(vkCreateGpaSessionAMD, ¶ms); return params.result; } VkResult WINAPI vkCreateGraphicsPipelines(VkDevice device, VkPipelineCache pipelineCache, uint32_t createInfoCount, const VkGraphicsPipelineCreateInfo *pCreateInfos, const VkAllocationCallbacks *pAllocator, VkPipeline *pPipelines) { struct vkCreateGraphicsPipelines_params params; - NTSTATUS status; params.device = device; params.pipelineCache = pipelineCache; params.createInfoCount = createInfoCount; params.pCreateInfos = pCreateInfos; params.pAllocator = pAllocator; params.pPipelines = pPipelines; - status = UNIX_CALL(vkCreateGraphicsPipelines, ¶ms); - assert(!status && "vkCreateGraphicsPipelines"); + UNIX_CALL_CHECKED(vkCreateGraphicsPipelines, ¶ms); return params.result; } VkResult WINAPI vkCreateImage(VkDevice device, const VkImageCreateInfo *pCreateInfo, const VkAllocationCallbacks *pAllocator, VkImage *pImage) { struct vkCreateImage_params params; - NTSTATUS status; params.device = device; params.pCreateInfo = pCreateInfo; params.pAllocator = pAllocator; params.pImage = pImage; - status = UNIX_CALL(vkCreateImage, ¶ms); - assert(!status && "vkCreateImage"); + UNIX_CALL_CHECKED(vkCreateImage, ¶ms); return params.result; } VkResult WINAPI vkCreateImageView(VkDevice device, const VkImageViewCreateInfo *pCreateInfo, const VkAllocationCallbacks *pAllocator, VkImageView *pView) { struct vkCreateImageView_params params; - NTSTATUS status; params.device = device; params.pCreateInfo = pCreateInfo; params.pAllocator = pAllocator; params.pView = pView; - status = UNIX_CALL(vkCreateImageView, ¶ms); - assert(!status && "vkCreateImageView"); + UNIX_CALL_CHECKED(vkCreateImageView, ¶ms); return params.result; } VkResult WINAPI vkCreateIndirectCommandsLayoutEXT(VkDevice device, const VkIndirectCommandsLayoutCreateInfoEXT *pCreateInfo, const VkAllocationCallbacks *pAllocator, VkIndirectCommandsLayoutEXT *pIndirectCommandsLayout) { struct vkCreateIndirectCommandsLayoutEXT_params params; - NTSTATUS status; params.device = device; params.pCreateInfo = pCreateInfo; params.pAllocator = pAllocator; params.pIndirectCommandsLayout = pIndirectCommandsLayout; - status = UNIX_CALL(vkCreateIndirectCommandsLayoutEXT, ¶ms); - assert(!status && "vkCreateIndirectCommandsLayoutEXT"); + UNIX_CALL_CHECKED(vkCreateIndirectCommandsLayoutEXT, ¶ms); return params.result; } VkResult WINAPI vkCreateIndirectCommandsLayoutNV(VkDevice device, const VkIndirectCommandsLayoutCreateInfoNV *pCreateInfo, const VkAllocationCallbacks *pAllocator, VkIndirectCommandsLayoutNV *pIndirectCommandsLayout) { struct vkCreateIndirectCommandsLayoutNV_params params; - NTSTATUS status; params.device = device; params.pCreateInfo = pCreateInfo; params.pAllocator = pAllocator; params.pIndirectCommandsLayout = pIndirectCommandsLayout; - status = UNIX_CALL(vkCreateIndirectCommandsLayoutNV, ¶ms); - assert(!status && "vkCreateIndirectCommandsLayoutNV"); + UNIX_CALL_CHECKED(vkCreateIndirectCommandsLayoutNV, ¶ms); return params.result; } VkResult WINAPI vkCreateIndirectExecutionSetEXT(VkDevice device, const VkIndirectExecutionSetCreateInfoEXT *pCreateInfo, const VkAllocationCallbacks *pAllocator, VkIndirectExecutionSetEXT *pIndirectExecutionSet) { struct vkCreateIndirectExecutionSetEXT_params params; - NTSTATUS status; params.device = device; params.pCreateInfo = pCreateInfo; params.pAllocator = pAllocator; params.pIndirectExecutionSet = pIndirectExecutionSet; - status = UNIX_CALL(vkCreateIndirectExecutionSetEXT, ¶ms); - assert(!status && "vkCreateIndirectExecutionSetEXT"); + UNIX_CALL_CHECKED(vkCreateIndirectExecutionSetEXT, ¶ms); return params.result; } VkResult WINAPI vkCreateMicromapEXT(VkDevice device, const VkMicromapCreateInfoEXT *pCreateInfo, const VkAllocationCallbacks *pAllocator, VkMicromapEXT *pMicromap) { struct vkCreateMicromapEXT_params params; - NTSTATUS status; params.device = device; params.pCreateInfo = pCreateInfo; params.pAllocator = pAllocator; params.pMicromap = pMicromap; - status = UNIX_CALL(vkCreateMicromapEXT, ¶ms); - assert(!status && "vkCreateMicromapEXT"); + UNIX_CALL_CHECKED(vkCreateMicromapEXT, ¶ms); return params.result; } VkResult WINAPI vkCreateOpticalFlowSessionNV(VkDevice device, const VkOpticalFlowSessionCreateInfoNV *pCreateInfo, const VkAllocationCallbacks *pAllocator, VkOpticalFlowSessionNV *pSession) { struct vkCreateOpticalFlowSessionNV_params params; - NTSTATUS status; params.device = device; params.pCreateInfo = pCreateInfo; params.pAllocator = pAllocator; params.pSession = pSession; - status = UNIX_CALL(vkCreateOpticalFlowSessionNV, ¶ms); - assert(!status && "vkCreateOpticalFlowSessionNV"); + UNIX_CALL_CHECKED(vkCreateOpticalFlowSessionNV, ¶ms); return params.result; } VkResult WINAPI vkCreatePipelineBinariesKHR(VkDevice device, const VkPipelineBinaryCreateInfoKHR *pCreateInfo, const VkAllocationCallbacks *pAllocator, VkPipelineBinaryHandlesInfoKHR *pBinaries) { struct vkCreatePipelineBinariesKHR_params params; - NTSTATUS status; params.device = device; params.pCreateInfo = pCreateInfo; params.pAllocator = pAllocator; params.pBinaries = pBinaries; - status = UNIX_CALL(vkCreatePipelineBinariesKHR, ¶ms); - assert(!status && "vkCreatePipelineBinariesKHR"); + UNIX_CALL_CHECKED(vkCreatePipelineBinariesKHR, ¶ms); return params.result; } VkResult WINAPI vkCreatePipelineCache(VkDevice device, const VkPipelineCacheCreateInfo *pCreateInfo, const VkAllocationCallbacks *pAllocator, VkPipelineCache *pPipelineCache) { struct vkCreatePipelineCache_params params; - NTSTATUS status; params.device = device; params.pCreateInfo = pCreateInfo; params.pAllocator = pAllocator; params.pPipelineCache = pPipelineCache; - status = UNIX_CALL(vkCreatePipelineCache, ¶ms); - assert(!status && "vkCreatePipelineCache"); + UNIX_CALL_CHECKED(vkCreatePipelineCache, ¶ms); return params.result; } VkResult WINAPI vkCreatePipelineLayout(VkDevice device, const VkPipelineLayoutCreateInfo *pCreateInfo, const VkAllocationCallbacks *pAllocator, VkPipelineLayout *pPipelineLayout) { struct vkCreatePipelineLayout_params params; - NTSTATUS status; params.device = device; params.pCreateInfo = pCreateInfo; params.pAllocator = pAllocator; params.pPipelineLayout = pPipelineLayout; - status = UNIX_CALL(vkCreatePipelineLayout, ¶ms); - assert(!status && "vkCreatePipelineLayout"); + UNIX_CALL_CHECKED(vkCreatePipelineLayout, ¶ms); return params.result; } VkResult WINAPI vkCreatePrivateDataSlot(VkDevice device, const VkPrivateDataSlotCreateInfo *pCreateInfo, const VkAllocationCallbacks *pAllocator, VkPrivateDataSlot *pPrivateDataSlot) { struct vkCreatePrivateDataSlot_params params; - NTSTATUS status; params.device = device; params.pCreateInfo = pCreateInfo; params.pAllocator = pAllocator; params.pPrivateDataSlot = pPrivateDataSlot; - status = UNIX_CALL(vkCreatePrivateDataSlot, ¶ms); - assert(!status && "vkCreatePrivateDataSlot"); + UNIX_CALL_CHECKED(vkCreatePrivateDataSlot, ¶ms); return params.result; } VkResult WINAPI vkCreatePrivateDataSlotEXT(VkDevice device, const VkPrivateDataSlotCreateInfo *pCreateInfo, const VkAllocationCallbacks *pAllocator, VkPrivateDataSlot *pPrivateDataSlot) { struct vkCreatePrivateDataSlotEXT_params params; - NTSTATUS status; params.device = device; params.pCreateInfo = pCreateInfo; params.pAllocator = pAllocator; params.pPrivateDataSlot = pPrivateDataSlot; - status = UNIX_CALL(vkCreatePrivateDataSlotEXT, ¶ms); - assert(!status && "vkCreatePrivateDataSlotEXT"); + UNIX_CALL_CHECKED(vkCreatePrivateDataSlotEXT, ¶ms); return params.result; } VkResult WINAPI vkCreateQueryPool(VkDevice device, const VkQueryPoolCreateInfo *pCreateInfo, const VkAllocationCallbacks *pAllocator, VkQueryPool *pQueryPool) { struct vkCreateQueryPool_params params; - NTSTATUS status; params.device = device; params.pCreateInfo = pCreateInfo; params.pAllocator = pAllocator; params.pQueryPool = pQueryPool; - status = UNIX_CALL(vkCreateQueryPool, ¶ms); - assert(!status && "vkCreateQueryPool"); + UNIX_CALL_CHECKED(vkCreateQueryPool, ¶ms); return params.result; } VkResult WINAPI vkCreateRayTracingPipelinesKHR(VkDevice device, VkDeferredOperationKHR deferredOperation, VkPipelineCache pipelineCache, uint32_t createInfoCount, const VkRayTracingPipelineCreateInfoKHR *pCreateInfos, const VkAllocationCallbacks *pAllocator, VkPipeline *pPipelines) { struct vkCreateRayTracingPipelinesKHR_params params; - NTSTATUS status; params.device = device; params.deferredOperation = deferredOperation; params.pipelineCache = pipelineCache; @@ -3839,274 +3684,232 @@ VkResult WINAPI vkCreateRayTracingPipelinesKHR(VkDevice device, VkDeferredOperat params.pCreateInfos = pCreateInfos; params.pAllocator = pAllocator; params.pPipelines = pPipelines; - status = UNIX_CALL(vkCreateRayTracingPipelinesKHR, ¶ms); - assert(!status && "vkCreateRayTracingPipelinesKHR"); + UNIX_CALL_CHECKED(vkCreateRayTracingPipelinesKHR, ¶ms); return params.result; } VkResult WINAPI vkCreateRayTracingPipelinesNV(VkDevice device, VkPipelineCache pipelineCache, uint32_t createInfoCount, const VkRayTracingPipelineCreateInfoNV *pCreateInfos, const VkAllocationCallbacks *pAllocator, VkPipeline *pPipelines) { struct vkCreateRayTracingPipelinesNV_params params; - NTSTATUS status; params.device = device; params.pipelineCache = pipelineCache; params.createInfoCount = createInfoCount; params.pCreateInfos = pCreateInfos; params.pAllocator = pAllocator; params.pPipelines = pPipelines; - status = UNIX_CALL(vkCreateRayTracingPipelinesNV, ¶ms); - assert(!status && "vkCreateRayTracingPipelinesNV"); + UNIX_CALL_CHECKED(vkCreateRayTracingPipelinesNV, ¶ms); return params.result; } VkResult WINAPI vkCreateRenderPass(VkDevice device, const VkRenderPassCreateInfo *pCreateInfo, const VkAllocationCallbacks *pAllocator, VkRenderPass *pRenderPass) { struct vkCreateRenderPass_params params; - NTSTATUS status; params.device = device; params.pCreateInfo = pCreateInfo; params.pAllocator = pAllocator; params.pRenderPass = pRenderPass; - status = UNIX_CALL(vkCreateRenderPass, ¶ms); - assert(!status && "vkCreateRenderPass"); + UNIX_CALL_CHECKED(vkCreateRenderPass, ¶ms); return params.result; } VkResult WINAPI vkCreateRenderPass2(VkDevice device, const VkRenderPassCreateInfo2 *pCreateInfo, const VkAllocationCallbacks *pAllocator, VkRenderPass *pRenderPass) { struct vkCreateRenderPass2_params params; - NTSTATUS status; params.device = device; params.pCreateInfo = pCreateInfo; params.pAllocator = pAllocator; params.pRenderPass = pRenderPass; - status = UNIX_CALL(vkCreateRenderPass2, ¶ms); - assert(!status && "vkCreateRenderPass2"); + UNIX_CALL_CHECKED(vkCreateRenderPass2, ¶ms); return params.result; } VkResult WINAPI vkCreateRenderPass2KHR(VkDevice device, const VkRenderPassCreateInfo2 *pCreateInfo, const VkAllocationCallbacks *pAllocator, VkRenderPass *pRenderPass) { struct vkCreateRenderPass2KHR_params params; - NTSTATUS status; params.device = device; params.pCreateInfo = pCreateInfo; params.pAllocator = pAllocator; params.pRenderPass = pRenderPass; - status = UNIX_CALL(vkCreateRenderPass2KHR, ¶ms); - assert(!status && "vkCreateRenderPass2KHR"); + UNIX_CALL_CHECKED(vkCreateRenderPass2KHR, ¶ms); return params.result; } VkResult WINAPI vkCreateSampler(VkDevice device, const VkSamplerCreateInfo *pCreateInfo, const VkAllocationCallbacks *pAllocator, VkSampler *pSampler) { struct vkCreateSampler_params params; - NTSTATUS status; params.device = device; params.pCreateInfo = pCreateInfo; params.pAllocator = pAllocator; params.pSampler = pSampler; - status = UNIX_CALL(vkCreateSampler, ¶ms); - assert(!status && "vkCreateSampler"); + UNIX_CALL_CHECKED(vkCreateSampler, ¶ms); return params.result; } VkResult WINAPI vkCreateSamplerYcbcrConversion(VkDevice device, const VkSamplerYcbcrConversionCreateInfo *pCreateInfo, const VkAllocationCallbacks *pAllocator, VkSamplerYcbcrConversion *pYcbcrConversion) { struct vkCreateSamplerYcbcrConversion_params params; - NTSTATUS status; params.device = device; params.pCreateInfo = pCreateInfo; params.pAllocator = pAllocator; params.pYcbcrConversion = pYcbcrConversion; - status = UNIX_CALL(vkCreateSamplerYcbcrConversion, ¶ms); - assert(!status && "vkCreateSamplerYcbcrConversion"); + UNIX_CALL_CHECKED(vkCreateSamplerYcbcrConversion, ¶ms); return params.result; } VkResult WINAPI vkCreateSamplerYcbcrConversionKHR(VkDevice device, const VkSamplerYcbcrConversionCreateInfo *pCreateInfo, const VkAllocationCallbacks *pAllocator, VkSamplerYcbcrConversion *pYcbcrConversion) { struct vkCreateSamplerYcbcrConversionKHR_params params; - NTSTATUS status; params.device = device; params.pCreateInfo = pCreateInfo; params.pAllocator = pAllocator; params.pYcbcrConversion = pYcbcrConversion; - status = UNIX_CALL(vkCreateSamplerYcbcrConversionKHR, ¶ms); - assert(!status && "vkCreateSamplerYcbcrConversionKHR"); + UNIX_CALL_CHECKED(vkCreateSamplerYcbcrConversionKHR, ¶ms); return params.result; } VkResult WINAPI vkCreateSemaphore(VkDevice device, const VkSemaphoreCreateInfo *pCreateInfo, const VkAllocationCallbacks *pAllocator, VkSemaphore *pSemaphore) { struct vkCreateSemaphore_params params; - NTSTATUS status; params.device = device; params.pCreateInfo = pCreateInfo; params.pAllocator = pAllocator; params.pSemaphore = pSemaphore; - status = UNIX_CALL(vkCreateSemaphore, ¶ms); - assert(!status && "vkCreateSemaphore"); + UNIX_CALL_CHECKED(vkCreateSemaphore, ¶ms); return params.result; } VkResult WINAPI vkCreateShaderInstrumentationARM(VkDevice device, const VkShaderInstrumentationCreateInfoARM *pCreateInfo, const VkAllocationCallbacks *pAllocator, VkShaderInstrumentationARM *pInstrumentation) { struct vkCreateShaderInstrumentationARM_params params; - NTSTATUS status; params.device = device; params.pCreateInfo = pCreateInfo; params.pAllocator = pAllocator; params.pInstrumentation = pInstrumentation; - status = UNIX_CALL(vkCreateShaderInstrumentationARM, ¶ms); - assert(!status && "vkCreateShaderInstrumentationARM"); + UNIX_CALL_CHECKED(vkCreateShaderInstrumentationARM, ¶ms); return params.result; } VkResult WINAPI vkCreateShaderModule(VkDevice device, const VkShaderModuleCreateInfo *pCreateInfo, const VkAllocationCallbacks *pAllocator, VkShaderModule *pShaderModule) { struct vkCreateShaderModule_params params; - NTSTATUS status; params.device = device; params.pCreateInfo = pCreateInfo; params.pAllocator = pAllocator; params.pShaderModule = pShaderModule; - status = UNIX_CALL(vkCreateShaderModule, ¶ms); - assert(!status && "vkCreateShaderModule"); + UNIX_CALL_CHECKED(vkCreateShaderModule, ¶ms); return params.result; } VkResult WINAPI vkCreateShadersEXT(VkDevice device, uint32_t createInfoCount, const VkShaderCreateInfoEXT *pCreateInfos, const VkAllocationCallbacks *pAllocator, VkShaderEXT *pShaders) { struct vkCreateShadersEXT_params params; - NTSTATUS status; params.device = device; params.createInfoCount = createInfoCount; params.pCreateInfos = pCreateInfos; params.pAllocator = pAllocator; params.pShaders = pShaders; - status = UNIX_CALL(vkCreateShadersEXT, ¶ms); - assert(!status && "vkCreateShadersEXT"); + UNIX_CALL_CHECKED(vkCreateShadersEXT, ¶ms); return params.result; } VkResult WINAPI vkCreateSwapchainKHR(VkDevice device, const VkSwapchainCreateInfoKHR *pCreateInfo, const VkAllocationCallbacks *pAllocator, VkSwapchainKHR *pSwapchain) { struct vkCreateSwapchainKHR_params params; - NTSTATUS status; params.device = device; params.pCreateInfo = pCreateInfo; params.pAllocator = pAllocator; params.pSwapchain = pSwapchain; - status = UNIX_CALL(vkCreateSwapchainKHR, ¶ms); - assert(!status && "vkCreateSwapchainKHR"); + UNIX_CALL_CHECKED(vkCreateSwapchainKHR, ¶ms); return params.result; } VkResult WINAPI vkCreateTensorARM(VkDevice device, const VkTensorCreateInfoARM *pCreateInfo, const VkAllocationCallbacks *pAllocator, VkTensorARM *pTensor) { struct vkCreateTensorARM_params params; - NTSTATUS status; params.device = device; params.pCreateInfo = pCreateInfo; params.pAllocator = pAllocator; params.pTensor = pTensor; - status = UNIX_CALL(vkCreateTensorARM, ¶ms); - assert(!status && "vkCreateTensorARM"); + UNIX_CALL_CHECKED(vkCreateTensorARM, ¶ms); return params.result; } VkResult WINAPI vkCreateTensorViewARM(VkDevice device, const VkTensorViewCreateInfoARM *pCreateInfo, const VkAllocationCallbacks *pAllocator, VkTensorViewARM *pView) { struct vkCreateTensorViewARM_params params; - NTSTATUS status; params.device = device; params.pCreateInfo = pCreateInfo; params.pAllocator = pAllocator; params.pView = pView; - status = UNIX_CALL(vkCreateTensorViewARM, ¶ms); - assert(!status && "vkCreateTensorViewARM"); + UNIX_CALL_CHECKED(vkCreateTensorViewARM, ¶ms); return params.result; } VkResult WINAPI vkCreateValidationCacheEXT(VkDevice device, const VkValidationCacheCreateInfoEXT *pCreateInfo, const VkAllocationCallbacks *pAllocator, VkValidationCacheEXT *pValidationCache) { struct vkCreateValidationCacheEXT_params params; - NTSTATUS status; params.device = device; params.pCreateInfo = pCreateInfo; params.pAllocator = pAllocator; params.pValidationCache = pValidationCache; - status = UNIX_CALL(vkCreateValidationCacheEXT, ¶ms); - assert(!status && "vkCreateValidationCacheEXT"); + UNIX_CALL_CHECKED(vkCreateValidationCacheEXT, ¶ms); return params.result; } VkResult WINAPI vkCreateVideoSessionKHR(VkDevice device, const VkVideoSessionCreateInfoKHR *pCreateInfo, const VkAllocationCallbacks *pAllocator, VkVideoSessionKHR *pVideoSession) { struct vkCreateVideoSessionKHR_params params; - NTSTATUS status; params.device = device; params.pCreateInfo = pCreateInfo; params.pAllocator = pAllocator; params.pVideoSession = pVideoSession; - status = UNIX_CALL(vkCreateVideoSessionKHR, ¶ms); - assert(!status && "vkCreateVideoSessionKHR"); + UNIX_CALL_CHECKED(vkCreateVideoSessionKHR, ¶ms); return params.result; } VkResult WINAPI vkCreateVideoSessionParametersKHR(VkDevice device, const VkVideoSessionParametersCreateInfoKHR *pCreateInfo, const VkAllocationCallbacks *pAllocator, VkVideoSessionParametersKHR *pVideoSessionParameters) { struct vkCreateVideoSessionParametersKHR_params params; - NTSTATUS status; params.device = device; params.pCreateInfo = pCreateInfo; params.pAllocator = pAllocator; params.pVideoSessionParameters = pVideoSessionParameters; - status = UNIX_CALL(vkCreateVideoSessionParametersKHR, ¶ms); - assert(!status && "vkCreateVideoSessionParametersKHR"); + UNIX_CALL_CHECKED(vkCreateVideoSessionParametersKHR, ¶ms); return params.result; } VkResult WINAPI vkCreateWin32SurfaceKHR(VkInstance instance, const VkWin32SurfaceCreateInfoKHR *pCreateInfo, const VkAllocationCallbacks *pAllocator, VkSurfaceKHR *pSurface) { struct vkCreateWin32SurfaceKHR_params params; - NTSTATUS status; params.instance = instance; params.pCreateInfo = pCreateInfo; params.pAllocator = pAllocator; params.pSurface = pSurface; - status = UNIX_CALL(vkCreateWin32SurfaceKHR, ¶ms); - assert(!status && "vkCreateWin32SurfaceKHR"); + UNIX_CALL_CHECKED(vkCreateWin32SurfaceKHR, ¶ms); return params.result; } VkResult WINAPI vkDebugMarkerSetObjectNameEXT(VkDevice device, const VkDebugMarkerObjectNameInfoEXT *pNameInfo) { struct vkDebugMarkerSetObjectNameEXT_params params; - NTSTATUS status; params.device = device; params.pNameInfo = pNameInfo; - status = UNIX_CALL(vkDebugMarkerSetObjectNameEXT, ¶ms); - assert(!status && "vkDebugMarkerSetObjectNameEXT"); + UNIX_CALL_CHECKED(vkDebugMarkerSetObjectNameEXT, ¶ms); return params.result; } VkResult WINAPI vkDebugMarkerSetObjectTagEXT(VkDevice device, const VkDebugMarkerObjectTagInfoEXT *pTagInfo) { struct vkDebugMarkerSetObjectTagEXT_params params; - NTSTATUS status; params.device = device; params.pTagInfo = pTagInfo; - status = UNIX_CALL(vkDebugMarkerSetObjectTagEXT, ¶ms); - assert(!status && "vkDebugMarkerSetObjectTagEXT"); + UNIX_CALL_CHECKED(vkDebugMarkerSetObjectTagEXT, ¶ms); return params.result; } void WINAPI vkDebugReportMessageEXT(VkInstance instance, VkDebugReportFlagsEXT flags, VkDebugReportObjectTypeEXT objectType, uint64_t object, size_t location, int32_t messageCode, const char *pLayerPrefix, const char *pMessage) { struct vkDebugReportMessageEXT_params params; - NTSTATUS status; params.instance = instance; params.flags = flags; params.objectType = objectType; @@ -4115,950 +3918,783 @@ void WINAPI vkDebugReportMessageEXT(VkInstance instance, VkDebugReportFlagsEXT f params.messageCode = messageCode; params.pLayerPrefix = pLayerPrefix; params.pMessage = pMessage; - status = UNIX_CALL(vkDebugReportMessageEXT, ¶ms); - assert(!status && "vkDebugReportMessageEXT"); + UNIX_CALL_CHECKED(vkDebugReportMessageEXT, ¶ms); } VkResult WINAPI vkDeferredOperationJoinKHR(VkDevice device, VkDeferredOperationKHR operation) { struct vkDeferredOperationJoinKHR_params params; - NTSTATUS status; params.device = device; params.operation = operation; - status = UNIX_CALL(vkDeferredOperationJoinKHR, ¶ms); - assert(!status && "vkDeferredOperationJoinKHR"); + UNIX_CALL_CHECKED(vkDeferredOperationJoinKHR, ¶ms); return params.result; } void WINAPI vkDestroyAccelerationStructureKHR(VkDevice device, VkAccelerationStructureKHR accelerationStructure, const VkAllocationCallbacks *pAllocator) { struct vkDestroyAccelerationStructureKHR_params params; - NTSTATUS status; params.device = device; params.accelerationStructure = accelerationStructure; params.pAllocator = pAllocator; - status = UNIX_CALL(vkDestroyAccelerationStructureKHR, ¶ms); - assert(!status && "vkDestroyAccelerationStructureKHR"); + UNIX_CALL_CHECKED(vkDestroyAccelerationStructureKHR, ¶ms); } void WINAPI vkDestroyAccelerationStructureNV(VkDevice device, VkAccelerationStructureNV accelerationStructure, const VkAllocationCallbacks *pAllocator) { struct vkDestroyAccelerationStructureNV_params params; - NTSTATUS status; params.device = device; params.accelerationStructure = accelerationStructure; params.pAllocator = pAllocator; - status = UNIX_CALL(vkDestroyAccelerationStructureNV, ¶ms); - assert(!status && "vkDestroyAccelerationStructureNV"); + UNIX_CALL_CHECKED(vkDestroyAccelerationStructureNV, ¶ms); } void WINAPI vkDestroyBuffer(VkDevice device, VkBuffer buffer, const VkAllocationCallbacks *pAllocator) { struct vkDestroyBuffer_params params; - NTSTATUS status; params.device = device; params.buffer = buffer; params.pAllocator = pAllocator; - status = UNIX_CALL(vkDestroyBuffer, ¶ms); - assert(!status && "vkDestroyBuffer"); + UNIX_CALL_CHECKED(vkDestroyBuffer, ¶ms); } void WINAPI vkDestroyBufferView(VkDevice device, VkBufferView bufferView, const VkAllocationCallbacks *pAllocator) { struct vkDestroyBufferView_params params; - NTSTATUS status; params.device = device; params.bufferView = bufferView; params.pAllocator = pAllocator; - status = UNIX_CALL(vkDestroyBufferView, ¶ms); - assert(!status && "vkDestroyBufferView"); + UNIX_CALL_CHECKED(vkDestroyBufferView, ¶ms); } void WINAPI vkDestroyCuFunctionNVX(VkDevice device, VkCuFunctionNVX function, const VkAllocationCallbacks *pAllocator) { struct vkDestroyCuFunctionNVX_params params; - NTSTATUS status; params.device = device; params.function = function; params.pAllocator = pAllocator; - status = UNIX_CALL(vkDestroyCuFunctionNVX, ¶ms); - assert(!status && "vkDestroyCuFunctionNVX"); + UNIX_CALL_CHECKED(vkDestroyCuFunctionNVX, ¶ms); } void WINAPI vkDestroyCuModuleNVX(VkDevice device, VkCuModuleNVX module, const VkAllocationCallbacks *pAllocator) { struct vkDestroyCuModuleNVX_params params; - NTSTATUS status; params.device = device; params.module = module; params.pAllocator = pAllocator; - status = UNIX_CALL(vkDestroyCuModuleNVX, ¶ms); - assert(!status && "vkDestroyCuModuleNVX"); + UNIX_CALL_CHECKED(vkDestroyCuModuleNVX, ¶ms); } void WINAPI vkDestroyDataGraphPipelineSessionARM(VkDevice device, VkDataGraphPipelineSessionARM session, const VkAllocationCallbacks *pAllocator) { struct vkDestroyDataGraphPipelineSessionARM_params params; - NTSTATUS status; params.device = device; params.session = session; params.pAllocator = pAllocator; - status = UNIX_CALL(vkDestroyDataGraphPipelineSessionARM, ¶ms); - assert(!status && "vkDestroyDataGraphPipelineSessionARM"); + UNIX_CALL_CHECKED(vkDestroyDataGraphPipelineSessionARM, ¶ms); } void WINAPI vkDestroyDebugReportCallbackEXT(VkInstance instance, VkDebugReportCallbackEXT callback, const VkAllocationCallbacks *pAllocator) { struct vkDestroyDebugReportCallbackEXT_params params; - NTSTATUS status; params.instance = instance; params.callback = callback; params.pAllocator = pAllocator; - status = UNIX_CALL(vkDestroyDebugReportCallbackEXT, ¶ms); - assert(!status && "vkDestroyDebugReportCallbackEXT"); + UNIX_CALL_CHECKED(vkDestroyDebugReportCallbackEXT, ¶ms); } void WINAPI vkDestroyDebugUtilsMessengerEXT(VkInstance instance, VkDebugUtilsMessengerEXT messenger, const VkAllocationCallbacks *pAllocator) { struct vkDestroyDebugUtilsMessengerEXT_params params; - NTSTATUS status; params.instance = instance; params.messenger = messenger; params.pAllocator = pAllocator; - status = UNIX_CALL(vkDestroyDebugUtilsMessengerEXT, ¶ms); - assert(!status && "vkDestroyDebugUtilsMessengerEXT"); + UNIX_CALL_CHECKED(vkDestroyDebugUtilsMessengerEXT, ¶ms); } void WINAPI vkDestroyDeferredOperationKHR(VkDevice device, VkDeferredOperationKHR operation, const VkAllocationCallbacks *pAllocator) { struct vkDestroyDeferredOperationKHR_params params; - NTSTATUS status; params.device = device; params.operation = operation; params.pAllocator = pAllocator; - status = UNIX_CALL(vkDestroyDeferredOperationKHR, ¶ms); - assert(!status && "vkDestroyDeferredOperationKHR"); + UNIX_CALL_CHECKED(vkDestroyDeferredOperationKHR, ¶ms); } void WINAPI vkDestroyDescriptorPool(VkDevice device, VkDescriptorPool descriptorPool, const VkAllocationCallbacks *pAllocator) { struct vkDestroyDescriptorPool_params params; - NTSTATUS status; params.device = device; params.descriptorPool = descriptorPool; params.pAllocator = pAllocator; - status = UNIX_CALL(vkDestroyDescriptorPool, ¶ms); - assert(!status && "vkDestroyDescriptorPool"); + UNIX_CALL_CHECKED(vkDestroyDescriptorPool, ¶ms); } void WINAPI vkDestroyDescriptorSetLayout(VkDevice device, VkDescriptorSetLayout descriptorSetLayout, const VkAllocationCallbacks *pAllocator) { struct vkDestroyDescriptorSetLayout_params params; - NTSTATUS status; params.device = device; params.descriptorSetLayout = descriptorSetLayout; params.pAllocator = pAllocator; - status = UNIX_CALL(vkDestroyDescriptorSetLayout, ¶ms); - assert(!status && "vkDestroyDescriptorSetLayout"); + UNIX_CALL_CHECKED(vkDestroyDescriptorSetLayout, ¶ms); } void WINAPI vkDestroyDescriptorUpdateTemplate(VkDevice device, VkDescriptorUpdateTemplate descriptorUpdateTemplate, const VkAllocationCallbacks *pAllocator) { struct vkDestroyDescriptorUpdateTemplate_params params; - NTSTATUS status; params.device = device; params.descriptorUpdateTemplate = descriptorUpdateTemplate; params.pAllocator = pAllocator; - status = UNIX_CALL(vkDestroyDescriptorUpdateTemplate, ¶ms); - assert(!status && "vkDestroyDescriptorUpdateTemplate"); + UNIX_CALL_CHECKED(vkDestroyDescriptorUpdateTemplate, ¶ms); } void WINAPI vkDestroyDescriptorUpdateTemplateKHR(VkDevice device, VkDescriptorUpdateTemplate descriptorUpdateTemplate, const VkAllocationCallbacks *pAllocator) { struct vkDestroyDescriptorUpdateTemplateKHR_params params; - NTSTATUS status; params.device = device; params.descriptorUpdateTemplate = descriptorUpdateTemplate; params.pAllocator = pAllocator; - status = UNIX_CALL(vkDestroyDescriptorUpdateTemplateKHR, ¶ms); - assert(!status && "vkDestroyDescriptorUpdateTemplateKHR"); + UNIX_CALL_CHECKED(vkDestroyDescriptorUpdateTemplateKHR, ¶ms); } void WINAPI vkDestroyEvent(VkDevice device, VkEvent event, const VkAllocationCallbacks *pAllocator) { struct vkDestroyEvent_params params; - NTSTATUS status; params.device = device; params.event = event; params.pAllocator = pAllocator; - status = UNIX_CALL(vkDestroyEvent, ¶ms); - assert(!status && "vkDestroyEvent"); + UNIX_CALL_CHECKED(vkDestroyEvent, ¶ms); } void WINAPI vkDestroyFence(VkDevice device, VkFence fence, const VkAllocationCallbacks *pAllocator) { struct vkDestroyFence_params params; - NTSTATUS status; params.device = device; params.fence = fence; params.pAllocator = pAllocator; - status = UNIX_CALL(vkDestroyFence, ¶ms); - assert(!status && "vkDestroyFence"); + UNIX_CALL_CHECKED(vkDestroyFence, ¶ms); } void WINAPI vkDestroyFramebuffer(VkDevice device, VkFramebuffer framebuffer, const VkAllocationCallbacks *pAllocator) { struct vkDestroyFramebuffer_params params; - NTSTATUS status; params.device = device; params.framebuffer = framebuffer; params.pAllocator = pAllocator; - status = UNIX_CALL(vkDestroyFramebuffer, ¶ms); - assert(!status && "vkDestroyFramebuffer"); + UNIX_CALL_CHECKED(vkDestroyFramebuffer, ¶ms); } void WINAPI vkDestroyGpaSessionAMD(VkDevice device, VkGpaSessionAMD gpaSession, const VkAllocationCallbacks *pAllocator) { struct vkDestroyGpaSessionAMD_params params; - NTSTATUS status; params.device = device; params.gpaSession = gpaSession; params.pAllocator = pAllocator; - status = UNIX_CALL(vkDestroyGpaSessionAMD, ¶ms); - assert(!status && "vkDestroyGpaSessionAMD"); + UNIX_CALL_CHECKED(vkDestroyGpaSessionAMD, ¶ms); } void WINAPI vkDestroyImage(VkDevice device, VkImage image, const VkAllocationCallbacks *pAllocator) { struct vkDestroyImage_params params; - NTSTATUS status; params.device = device; params.image = image; params.pAllocator = pAllocator; - status = UNIX_CALL(vkDestroyImage, ¶ms); - assert(!status && "vkDestroyImage"); + UNIX_CALL_CHECKED(vkDestroyImage, ¶ms); } void WINAPI vkDestroyImageView(VkDevice device, VkImageView imageView, const VkAllocationCallbacks *pAllocator) { struct vkDestroyImageView_params params; - NTSTATUS status; params.device = device; params.imageView = imageView; params.pAllocator = pAllocator; - status = UNIX_CALL(vkDestroyImageView, ¶ms); - assert(!status && "vkDestroyImageView"); + UNIX_CALL_CHECKED(vkDestroyImageView, ¶ms); } void WINAPI vkDestroyIndirectCommandsLayoutEXT(VkDevice device, VkIndirectCommandsLayoutEXT indirectCommandsLayout, const VkAllocationCallbacks *pAllocator) { struct vkDestroyIndirectCommandsLayoutEXT_params params; - NTSTATUS status; params.device = device; params.indirectCommandsLayout = indirectCommandsLayout; params.pAllocator = pAllocator; - status = UNIX_CALL(vkDestroyIndirectCommandsLayoutEXT, ¶ms); - assert(!status && "vkDestroyIndirectCommandsLayoutEXT"); + UNIX_CALL_CHECKED(vkDestroyIndirectCommandsLayoutEXT, ¶ms); } void WINAPI vkDestroyIndirectCommandsLayoutNV(VkDevice device, VkIndirectCommandsLayoutNV indirectCommandsLayout, const VkAllocationCallbacks *pAllocator) { struct vkDestroyIndirectCommandsLayoutNV_params params; - NTSTATUS status; params.device = device; params.indirectCommandsLayout = indirectCommandsLayout; params.pAllocator = pAllocator; - status = UNIX_CALL(vkDestroyIndirectCommandsLayoutNV, ¶ms); - assert(!status && "vkDestroyIndirectCommandsLayoutNV"); + UNIX_CALL_CHECKED(vkDestroyIndirectCommandsLayoutNV, ¶ms); } void WINAPI vkDestroyIndirectExecutionSetEXT(VkDevice device, VkIndirectExecutionSetEXT indirectExecutionSet, const VkAllocationCallbacks *pAllocator) { struct vkDestroyIndirectExecutionSetEXT_params params; - NTSTATUS status; params.device = device; params.indirectExecutionSet = indirectExecutionSet; params.pAllocator = pAllocator; - status = UNIX_CALL(vkDestroyIndirectExecutionSetEXT, ¶ms); - assert(!status && "vkDestroyIndirectExecutionSetEXT"); + UNIX_CALL_CHECKED(vkDestroyIndirectExecutionSetEXT, ¶ms); } void WINAPI vkDestroyMicromapEXT(VkDevice device, VkMicromapEXT micromap, const VkAllocationCallbacks *pAllocator) { struct vkDestroyMicromapEXT_params params; - NTSTATUS status; params.device = device; params.micromap = micromap; params.pAllocator = pAllocator; - status = UNIX_CALL(vkDestroyMicromapEXT, ¶ms); - assert(!status && "vkDestroyMicromapEXT"); + UNIX_CALL_CHECKED(vkDestroyMicromapEXT, ¶ms); } void WINAPI vkDestroyOpticalFlowSessionNV(VkDevice device, VkOpticalFlowSessionNV session, const VkAllocationCallbacks *pAllocator) { struct vkDestroyOpticalFlowSessionNV_params params; - NTSTATUS status; params.device = device; params.session = session; params.pAllocator = pAllocator; - status = UNIX_CALL(vkDestroyOpticalFlowSessionNV, ¶ms); - assert(!status && "vkDestroyOpticalFlowSessionNV"); + UNIX_CALL_CHECKED(vkDestroyOpticalFlowSessionNV, ¶ms); } void WINAPI vkDestroyPipeline(VkDevice device, VkPipeline pipeline, const VkAllocationCallbacks *pAllocator) { struct vkDestroyPipeline_params params; - NTSTATUS status; params.device = device; params.pipeline = pipeline; params.pAllocator = pAllocator; - status = UNIX_CALL(vkDestroyPipeline, ¶ms); - assert(!status && "vkDestroyPipeline"); + UNIX_CALL_CHECKED(vkDestroyPipeline, ¶ms); } void WINAPI vkDestroyPipelineBinaryKHR(VkDevice device, VkPipelineBinaryKHR pipelineBinary, const VkAllocationCallbacks *pAllocator) { struct vkDestroyPipelineBinaryKHR_params params; - NTSTATUS status; params.device = device; params.pipelineBinary = pipelineBinary; params.pAllocator = pAllocator; - status = UNIX_CALL(vkDestroyPipelineBinaryKHR, ¶ms); - assert(!status && "vkDestroyPipelineBinaryKHR"); + UNIX_CALL_CHECKED(vkDestroyPipelineBinaryKHR, ¶ms); } void WINAPI vkDestroyPipelineCache(VkDevice device, VkPipelineCache pipelineCache, const VkAllocationCallbacks *pAllocator) { struct vkDestroyPipelineCache_params params; - NTSTATUS status; params.device = device; params.pipelineCache = pipelineCache; params.pAllocator = pAllocator; - status = UNIX_CALL(vkDestroyPipelineCache, ¶ms); - assert(!status && "vkDestroyPipelineCache"); + UNIX_CALL_CHECKED(vkDestroyPipelineCache, ¶ms); } void WINAPI vkDestroyPipelineLayout(VkDevice device, VkPipelineLayout pipelineLayout, const VkAllocationCallbacks *pAllocator) { struct vkDestroyPipelineLayout_params params; - NTSTATUS status; params.device = device; params.pipelineLayout = pipelineLayout; params.pAllocator = pAllocator; - status = UNIX_CALL(vkDestroyPipelineLayout, ¶ms); - assert(!status && "vkDestroyPipelineLayout"); + UNIX_CALL_CHECKED(vkDestroyPipelineLayout, ¶ms); } void WINAPI vkDestroyPrivateDataSlot(VkDevice device, VkPrivateDataSlot privateDataSlot, const VkAllocationCallbacks *pAllocator) { struct vkDestroyPrivateDataSlot_params params; - NTSTATUS status; params.device = device; params.privateDataSlot = privateDataSlot; params.pAllocator = pAllocator; - status = UNIX_CALL(vkDestroyPrivateDataSlot, ¶ms); - assert(!status && "vkDestroyPrivateDataSlot"); + UNIX_CALL_CHECKED(vkDestroyPrivateDataSlot, ¶ms); } void WINAPI vkDestroyPrivateDataSlotEXT(VkDevice device, VkPrivateDataSlot privateDataSlot, const VkAllocationCallbacks *pAllocator) { struct vkDestroyPrivateDataSlotEXT_params params; - NTSTATUS status; params.device = device; params.privateDataSlot = privateDataSlot; params.pAllocator = pAllocator; - status = UNIX_CALL(vkDestroyPrivateDataSlotEXT, ¶ms); - assert(!status && "vkDestroyPrivateDataSlotEXT"); + UNIX_CALL_CHECKED(vkDestroyPrivateDataSlotEXT, ¶ms); } void WINAPI vkDestroyQueryPool(VkDevice device, VkQueryPool queryPool, const VkAllocationCallbacks *pAllocator) { struct vkDestroyQueryPool_params params; - NTSTATUS status; params.device = device; params.queryPool = queryPool; params.pAllocator = pAllocator; - status = UNIX_CALL(vkDestroyQueryPool, ¶ms); - assert(!status && "vkDestroyQueryPool"); + UNIX_CALL_CHECKED(vkDestroyQueryPool, ¶ms); } void WINAPI vkDestroyRenderPass(VkDevice device, VkRenderPass renderPass, const VkAllocationCallbacks *pAllocator) { struct vkDestroyRenderPass_params params; - NTSTATUS status; params.device = device; params.renderPass = renderPass; params.pAllocator = pAllocator; - status = UNIX_CALL(vkDestroyRenderPass, ¶ms); - assert(!status && "vkDestroyRenderPass"); + UNIX_CALL_CHECKED(vkDestroyRenderPass, ¶ms); } void WINAPI vkDestroySampler(VkDevice device, VkSampler sampler, const VkAllocationCallbacks *pAllocator) { struct vkDestroySampler_params params; - NTSTATUS status; params.device = device; params.sampler = sampler; params.pAllocator = pAllocator; - status = UNIX_CALL(vkDestroySampler, ¶ms); - assert(!status && "vkDestroySampler"); + UNIX_CALL_CHECKED(vkDestroySampler, ¶ms); } void WINAPI vkDestroySamplerYcbcrConversion(VkDevice device, VkSamplerYcbcrConversion ycbcrConversion, const VkAllocationCallbacks *pAllocator) { struct vkDestroySamplerYcbcrConversion_params params; - NTSTATUS status; params.device = device; params.ycbcrConversion = ycbcrConversion; params.pAllocator = pAllocator; - status = UNIX_CALL(vkDestroySamplerYcbcrConversion, ¶ms); - assert(!status && "vkDestroySamplerYcbcrConversion"); + UNIX_CALL_CHECKED(vkDestroySamplerYcbcrConversion, ¶ms); } void WINAPI vkDestroySamplerYcbcrConversionKHR(VkDevice device, VkSamplerYcbcrConversion ycbcrConversion, const VkAllocationCallbacks *pAllocator) { struct vkDestroySamplerYcbcrConversionKHR_params params; - NTSTATUS status; params.device = device; params.ycbcrConversion = ycbcrConversion; params.pAllocator = pAllocator; - status = UNIX_CALL(vkDestroySamplerYcbcrConversionKHR, ¶ms); - assert(!status && "vkDestroySamplerYcbcrConversionKHR"); + UNIX_CALL_CHECKED(vkDestroySamplerYcbcrConversionKHR, ¶ms); } void WINAPI vkDestroySemaphore(VkDevice device, VkSemaphore semaphore, const VkAllocationCallbacks *pAllocator) { struct vkDestroySemaphore_params params; - NTSTATUS status; params.device = device; params.semaphore = semaphore; params.pAllocator = pAllocator; - status = UNIX_CALL(vkDestroySemaphore, ¶ms); - assert(!status && "vkDestroySemaphore"); + UNIX_CALL_CHECKED(vkDestroySemaphore, ¶ms); } void WINAPI vkDestroyShaderEXT(VkDevice device, VkShaderEXT shader, const VkAllocationCallbacks *pAllocator) { struct vkDestroyShaderEXT_params params; - NTSTATUS status; params.device = device; params.shader = shader; params.pAllocator = pAllocator; - status = UNIX_CALL(vkDestroyShaderEXT, ¶ms); - assert(!status && "vkDestroyShaderEXT"); + UNIX_CALL_CHECKED(vkDestroyShaderEXT, ¶ms); } void WINAPI vkDestroyShaderInstrumentationARM(VkDevice device, VkShaderInstrumentationARM instrumentation, const VkAllocationCallbacks *pAllocator) { struct vkDestroyShaderInstrumentationARM_params params; - NTSTATUS status; params.device = device; params.instrumentation = instrumentation; params.pAllocator = pAllocator; - status = UNIX_CALL(vkDestroyShaderInstrumentationARM, ¶ms); - assert(!status && "vkDestroyShaderInstrumentationARM"); + UNIX_CALL_CHECKED(vkDestroyShaderInstrumentationARM, ¶ms); } void WINAPI vkDestroyShaderModule(VkDevice device, VkShaderModule shaderModule, const VkAllocationCallbacks *pAllocator) { struct vkDestroyShaderModule_params params; - NTSTATUS status; params.device = device; params.shaderModule = shaderModule; params.pAllocator = pAllocator; - status = UNIX_CALL(vkDestroyShaderModule, ¶ms); - assert(!status && "vkDestroyShaderModule"); + UNIX_CALL_CHECKED(vkDestroyShaderModule, ¶ms); } void WINAPI vkDestroySurfaceKHR(VkInstance instance, VkSurfaceKHR surface, const VkAllocationCallbacks *pAllocator) { struct vkDestroySurfaceKHR_params params; - NTSTATUS status; params.instance = instance; params.surface = surface; params.pAllocator = pAllocator; - status = UNIX_CALL(vkDestroySurfaceKHR, ¶ms); - assert(!status && "vkDestroySurfaceKHR"); + UNIX_CALL_CHECKED(vkDestroySurfaceKHR, ¶ms); } void WINAPI vkDestroySwapchainKHR(VkDevice device, VkSwapchainKHR swapchain, const VkAllocationCallbacks *pAllocator) { struct vkDestroySwapchainKHR_params params; - NTSTATUS status; params.device = device; params.swapchain = swapchain; params.pAllocator = pAllocator; - status = UNIX_CALL(vkDestroySwapchainKHR, ¶ms); - assert(!status && "vkDestroySwapchainKHR"); + UNIX_CALL_CHECKED(vkDestroySwapchainKHR, ¶ms); } void WINAPI vkDestroyTensorARM(VkDevice device, VkTensorARM tensor, const VkAllocationCallbacks *pAllocator) { struct vkDestroyTensorARM_params params; - NTSTATUS status; params.device = device; params.tensor = tensor; params.pAllocator = pAllocator; - status = UNIX_CALL(vkDestroyTensorARM, ¶ms); - assert(!status && "vkDestroyTensorARM"); + UNIX_CALL_CHECKED(vkDestroyTensorARM, ¶ms); } void WINAPI vkDestroyTensorViewARM(VkDevice device, VkTensorViewARM tensorView, const VkAllocationCallbacks *pAllocator) { struct vkDestroyTensorViewARM_params params; - NTSTATUS status; params.device = device; params.tensorView = tensorView; params.pAllocator = pAllocator; - status = UNIX_CALL(vkDestroyTensorViewARM, ¶ms); - assert(!status && "vkDestroyTensorViewARM"); + UNIX_CALL_CHECKED(vkDestroyTensorViewARM, ¶ms); } void WINAPI vkDestroyValidationCacheEXT(VkDevice device, VkValidationCacheEXT validationCache, const VkAllocationCallbacks *pAllocator) { struct vkDestroyValidationCacheEXT_params params; - NTSTATUS status; params.device = device; params.validationCache = validationCache; params.pAllocator = pAllocator; - status = UNIX_CALL(vkDestroyValidationCacheEXT, ¶ms); - assert(!status && "vkDestroyValidationCacheEXT"); + UNIX_CALL_CHECKED(vkDestroyValidationCacheEXT, ¶ms); } void WINAPI vkDestroyVideoSessionKHR(VkDevice device, VkVideoSessionKHR videoSession, const VkAllocationCallbacks *pAllocator) { struct vkDestroyVideoSessionKHR_params params; - NTSTATUS status; params.device = device; params.videoSession = videoSession; params.pAllocator = pAllocator; - status = UNIX_CALL(vkDestroyVideoSessionKHR, ¶ms); - assert(!status && "vkDestroyVideoSessionKHR"); + UNIX_CALL_CHECKED(vkDestroyVideoSessionKHR, ¶ms); } void WINAPI vkDestroyVideoSessionParametersKHR(VkDevice device, VkVideoSessionParametersKHR videoSessionParameters, const VkAllocationCallbacks *pAllocator) { struct vkDestroyVideoSessionParametersKHR_params params; - NTSTATUS status; params.device = device; params.videoSessionParameters = videoSessionParameters; params.pAllocator = pAllocator; - status = UNIX_CALL(vkDestroyVideoSessionParametersKHR, ¶ms); - assert(!status && "vkDestroyVideoSessionParametersKHR"); + UNIX_CALL_CHECKED(vkDestroyVideoSessionParametersKHR, ¶ms); } VkResult WINAPI vkDeviceWaitIdle(VkDevice device) { struct vkDeviceWaitIdle_params params; - NTSTATUS status; params.device = device; - status = UNIX_CALL(vkDeviceWaitIdle, ¶ms); - assert(!status && "vkDeviceWaitIdle"); + UNIX_CALL_CHECKED(vkDeviceWaitIdle, ¶ms); return params.result; } VkResult WINAPI vkEndCommandBuffer(VkCommandBuffer commandBuffer) { struct vkEndCommandBuffer_params params; - NTSTATUS status; params.commandBuffer = commandBuffer; - status = UNIX_CALL(vkEndCommandBuffer, ¶ms); - assert(!status && "vkEndCommandBuffer"); + UNIX_CALL_CHECKED(vkEndCommandBuffer, ¶ms); return params.result; } VkResult WINAPI vkEnumerateDeviceLayerProperties(VkPhysicalDevice physicalDevice, uint32_t *pPropertyCount, VkLayerProperties *pProperties) { struct vkEnumerateDeviceLayerProperties_params params; - NTSTATUS status; params.physicalDevice = physicalDevice; params.pPropertyCount = pPropertyCount; params.pProperties = pProperties; - status = UNIX_CALL(vkEnumerateDeviceLayerProperties, ¶ms); - assert(!status && "vkEnumerateDeviceLayerProperties"); + UNIX_CALL_CHECKED(vkEnumerateDeviceLayerProperties, ¶ms); return params.result; } VkResult WINAPI vkEnumeratePhysicalDeviceGroups(VkInstance instance, uint32_t *pPhysicalDeviceGroupCount, VkPhysicalDeviceGroupProperties *pPhysicalDeviceGroupProperties) { struct vkEnumeratePhysicalDeviceGroups_params params; - NTSTATUS status; params.instance = instance; params.pPhysicalDeviceGroupCount = pPhysicalDeviceGroupCount; params.pPhysicalDeviceGroupProperties = pPhysicalDeviceGroupProperties; - status = UNIX_CALL(vkEnumeratePhysicalDeviceGroups, ¶ms); - assert(!status && "vkEnumeratePhysicalDeviceGroups"); + UNIX_CALL_CHECKED(vkEnumeratePhysicalDeviceGroups, ¶ms); return params.result; } VkResult WINAPI vkEnumeratePhysicalDeviceGroupsKHR(VkInstance instance, uint32_t *pPhysicalDeviceGroupCount, VkPhysicalDeviceGroupProperties *pPhysicalDeviceGroupProperties) { struct vkEnumeratePhysicalDeviceGroupsKHR_params params; - NTSTATUS status; params.instance = instance; params.pPhysicalDeviceGroupCount = pPhysicalDeviceGroupCount; params.pPhysicalDeviceGroupProperties = pPhysicalDeviceGroupProperties; - status = UNIX_CALL(vkEnumeratePhysicalDeviceGroupsKHR, ¶ms); - assert(!status && "vkEnumeratePhysicalDeviceGroupsKHR"); + UNIX_CALL_CHECKED(vkEnumeratePhysicalDeviceGroupsKHR, ¶ms); return params.result; } VkResult WINAPI vkEnumeratePhysicalDeviceQueueFamilyPerformanceCountersByRegionARM(VkPhysicalDevice physicalDevice, uint32_t queueFamilyIndex, uint32_t *pCounterCount, VkPerformanceCounterARM *pCounters, VkPerformanceCounterDescriptionARM *pCounterDescriptions) { struct vkEnumeratePhysicalDeviceQueueFamilyPerformanceCountersByRegionARM_params params; - NTSTATUS status; params.physicalDevice = physicalDevice; params.queueFamilyIndex = queueFamilyIndex; params.pCounterCount = pCounterCount; params.pCounters = pCounters; params.pCounterDescriptions = pCounterDescriptions; - status = UNIX_CALL(vkEnumeratePhysicalDeviceQueueFamilyPerformanceCountersByRegionARM, ¶ms); - assert(!status && "vkEnumeratePhysicalDeviceQueueFamilyPerformanceCountersByRegionARM"); + UNIX_CALL_CHECKED(vkEnumeratePhysicalDeviceQueueFamilyPerformanceCountersByRegionARM, ¶ms); return params.result; } VkResult WINAPI vkEnumeratePhysicalDeviceQueueFamilyPerformanceQueryCountersKHR(VkPhysicalDevice physicalDevice, uint32_t queueFamilyIndex, uint32_t *pCounterCount, VkPerformanceCounterKHR *pCounters, VkPerformanceCounterDescriptionKHR *pCounterDescriptions) { struct vkEnumeratePhysicalDeviceQueueFamilyPerformanceQueryCountersKHR_params params; - NTSTATUS status; params.physicalDevice = physicalDevice; params.queueFamilyIndex = queueFamilyIndex; params.pCounterCount = pCounterCount; params.pCounters = pCounters; params.pCounterDescriptions = pCounterDescriptions; - status = UNIX_CALL(vkEnumeratePhysicalDeviceQueueFamilyPerformanceQueryCountersKHR, ¶ms); - assert(!status && "vkEnumeratePhysicalDeviceQueueFamilyPerformanceQueryCountersKHR"); + UNIX_CALL_CHECKED(vkEnumeratePhysicalDeviceQueueFamilyPerformanceQueryCountersKHR, ¶ms); return params.result; } VkResult WINAPI vkEnumeratePhysicalDeviceShaderInstrumentationMetricsARM(VkPhysicalDevice physicalDevice, uint32_t *pDescriptionCount, VkShaderInstrumentationMetricDescriptionARM *pDescriptions) { struct vkEnumeratePhysicalDeviceShaderInstrumentationMetricsARM_params params; - NTSTATUS status; params.physicalDevice = physicalDevice; params.pDescriptionCount = pDescriptionCount; params.pDescriptions = pDescriptions; - status = UNIX_CALL(vkEnumeratePhysicalDeviceShaderInstrumentationMetricsARM, ¶ms); - assert(!status && "vkEnumeratePhysicalDeviceShaderInstrumentationMetricsARM"); + UNIX_CALL_CHECKED(vkEnumeratePhysicalDeviceShaderInstrumentationMetricsARM, ¶ms); return params.result; } VkResult WINAPI vkEnumeratePhysicalDevices(VkInstance instance, uint32_t *pPhysicalDeviceCount, VkPhysicalDevice *pPhysicalDevices) { struct vkEnumeratePhysicalDevices_params params; - NTSTATUS status; params.instance = instance; params.pPhysicalDeviceCount = pPhysicalDeviceCount; params.pPhysicalDevices = pPhysicalDevices; - status = UNIX_CALL(vkEnumeratePhysicalDevices, ¶ms); - assert(!status && "vkEnumeratePhysicalDevices"); + UNIX_CALL_CHECKED(vkEnumeratePhysicalDevices, ¶ms); return params.result; } VkResult WINAPI vkFlushMappedMemoryRanges(VkDevice device, uint32_t memoryRangeCount, const VkMappedMemoryRange *pMemoryRanges) { struct vkFlushMappedMemoryRanges_params params; - NTSTATUS status; params.device = device; params.memoryRangeCount = memoryRangeCount; params.pMemoryRanges = pMemoryRanges; - status = UNIX_CALL(vkFlushMappedMemoryRanges, ¶ms); - assert(!status && "vkFlushMappedMemoryRanges"); + UNIX_CALL_CHECKED(vkFlushMappedMemoryRanges, ¶ms); return params.result; } VkResult WINAPI vkFreeDescriptorSets(VkDevice device, VkDescriptorPool descriptorPool, uint32_t descriptorSetCount, const VkDescriptorSet *pDescriptorSets) { struct vkFreeDescriptorSets_params params; - NTSTATUS status; params.device = device; params.descriptorPool = descriptorPool; params.descriptorSetCount = descriptorSetCount; params.pDescriptorSets = pDescriptorSets; - status = UNIX_CALL(vkFreeDescriptorSets, ¶ms); - assert(!status && "vkFreeDescriptorSets"); + UNIX_CALL_CHECKED(vkFreeDescriptorSets, ¶ms); return params.result; } void WINAPI vkFreeMemory(VkDevice device, VkDeviceMemory memory, const VkAllocationCallbacks *pAllocator) { struct vkFreeMemory_params params; - NTSTATUS status; params.device = device; params.memory = memory; params.pAllocator = pAllocator; - status = UNIX_CALL(vkFreeMemory, ¶ms); - assert(!status && "vkFreeMemory"); + UNIX_CALL_CHECKED(vkFreeMemory, ¶ms); } void WINAPI vkGetAccelerationStructureBuildSizesKHR(VkDevice device, VkAccelerationStructureBuildTypeKHR buildType, const VkAccelerationStructureBuildGeometryInfoKHR *pBuildInfo, const uint32_t *pMaxPrimitiveCounts, VkAccelerationStructureBuildSizesInfoKHR *pSizeInfo) { struct vkGetAccelerationStructureBuildSizesKHR_params params; - NTSTATUS status; params.device = device; params.buildType = buildType; params.pBuildInfo = pBuildInfo; params.pMaxPrimitiveCounts = pMaxPrimitiveCounts; params.pSizeInfo = pSizeInfo; - status = UNIX_CALL(vkGetAccelerationStructureBuildSizesKHR, ¶ms); - assert(!status && "vkGetAccelerationStructureBuildSizesKHR"); + UNIX_CALL_CHECKED(vkGetAccelerationStructureBuildSizesKHR, ¶ms); } VkDeviceAddress WINAPI vkGetAccelerationStructureDeviceAddressKHR(VkDevice device, const VkAccelerationStructureDeviceAddressInfoKHR *pInfo) { struct vkGetAccelerationStructureDeviceAddressKHR_params params; - NTSTATUS status; params.device = device; params.pInfo = pInfo; - status = UNIX_CALL(vkGetAccelerationStructureDeviceAddressKHR, ¶ms); - assert(!status && "vkGetAccelerationStructureDeviceAddressKHR"); + UNIX_CALL_CHECKED(vkGetAccelerationStructureDeviceAddressKHR, ¶ms); return params.result; } VkResult WINAPI vkGetAccelerationStructureHandleNV(VkDevice device, VkAccelerationStructureNV accelerationStructure, size_t dataSize, void *pData) { struct vkGetAccelerationStructureHandleNV_params params; - NTSTATUS status; params.device = device; params.accelerationStructure = accelerationStructure; params.dataSize = dataSize; params.pData = pData; - status = UNIX_CALL(vkGetAccelerationStructureHandleNV, ¶ms); - assert(!status && "vkGetAccelerationStructureHandleNV"); + UNIX_CALL_CHECKED(vkGetAccelerationStructureHandleNV, ¶ms); return params.result; } void WINAPI vkGetAccelerationStructureMemoryRequirementsNV(VkDevice device, const VkAccelerationStructureMemoryRequirementsInfoNV *pInfo, VkMemoryRequirements2 *pMemoryRequirements) { struct vkGetAccelerationStructureMemoryRequirementsNV_params params; - NTSTATUS status; params.device = device; params.pInfo = pInfo; params.pMemoryRequirements = pMemoryRequirements; - status = UNIX_CALL(vkGetAccelerationStructureMemoryRequirementsNV, ¶ms); - assert(!status && "vkGetAccelerationStructureMemoryRequirementsNV"); + UNIX_CALL_CHECKED(vkGetAccelerationStructureMemoryRequirementsNV, ¶ms); } VkResult WINAPI vkGetAccelerationStructureOpaqueCaptureDescriptorDataEXT(VkDevice device, const VkAccelerationStructureCaptureDescriptorDataInfoEXT *pInfo, void *pData) { struct vkGetAccelerationStructureOpaqueCaptureDescriptorDataEXT_params params; - NTSTATUS status; params.device = device; params.pInfo = pInfo; params.pData = pData; - status = UNIX_CALL(vkGetAccelerationStructureOpaqueCaptureDescriptorDataEXT, ¶ms); - assert(!status && "vkGetAccelerationStructureOpaqueCaptureDescriptorDataEXT"); + UNIX_CALL_CHECKED(vkGetAccelerationStructureOpaqueCaptureDescriptorDataEXT, ¶ms); return params.result; } VkDeviceAddress WINAPI vkGetBufferDeviceAddress(VkDevice device, const VkBufferDeviceAddressInfo *pInfo) { struct vkGetBufferDeviceAddress_params params; - NTSTATUS status; params.device = device; params.pInfo = pInfo; - status = UNIX_CALL(vkGetBufferDeviceAddress, ¶ms); - assert(!status && "vkGetBufferDeviceAddress"); + UNIX_CALL_CHECKED(vkGetBufferDeviceAddress, ¶ms); return params.result; } VkDeviceAddress WINAPI vkGetBufferDeviceAddressEXT(VkDevice device, const VkBufferDeviceAddressInfo *pInfo) { struct vkGetBufferDeviceAddressEXT_params params; - NTSTATUS status; params.device = device; params.pInfo = pInfo; - status = UNIX_CALL(vkGetBufferDeviceAddressEXT, ¶ms); - assert(!status && "vkGetBufferDeviceAddressEXT"); + UNIX_CALL_CHECKED(vkGetBufferDeviceAddressEXT, ¶ms); return params.result; } VkDeviceAddress WINAPI vkGetBufferDeviceAddressKHR(VkDevice device, const VkBufferDeviceAddressInfo *pInfo) { struct vkGetBufferDeviceAddressKHR_params params; - NTSTATUS status; params.device = device; params.pInfo = pInfo; - status = UNIX_CALL(vkGetBufferDeviceAddressKHR, ¶ms); - assert(!status && "vkGetBufferDeviceAddressKHR"); + UNIX_CALL_CHECKED(vkGetBufferDeviceAddressKHR, ¶ms); return params.result; } void WINAPI vkGetBufferMemoryRequirements(VkDevice device, VkBuffer buffer, VkMemoryRequirements *pMemoryRequirements) { struct vkGetBufferMemoryRequirements_params params; - NTSTATUS status; params.device = device; params.buffer = buffer; params.pMemoryRequirements = pMemoryRequirements; - status = UNIX_CALL(vkGetBufferMemoryRequirements, ¶ms); - assert(!status && "vkGetBufferMemoryRequirements"); + UNIX_CALL_CHECKED(vkGetBufferMemoryRequirements, ¶ms); } void WINAPI vkGetBufferMemoryRequirements2(VkDevice device, const VkBufferMemoryRequirementsInfo2 *pInfo, VkMemoryRequirements2 *pMemoryRequirements) { struct vkGetBufferMemoryRequirements2_params params; - NTSTATUS status; params.device = device; params.pInfo = pInfo; params.pMemoryRequirements = pMemoryRequirements; - status = UNIX_CALL(vkGetBufferMemoryRequirements2, ¶ms); - assert(!status && "vkGetBufferMemoryRequirements2"); + UNIX_CALL_CHECKED(vkGetBufferMemoryRequirements2, ¶ms); } void WINAPI vkGetBufferMemoryRequirements2KHR(VkDevice device, const VkBufferMemoryRequirementsInfo2 *pInfo, VkMemoryRequirements2 *pMemoryRequirements) { struct vkGetBufferMemoryRequirements2KHR_params params; - NTSTATUS status; params.device = device; params.pInfo = pInfo; params.pMemoryRequirements = pMemoryRequirements; - status = UNIX_CALL(vkGetBufferMemoryRequirements2KHR, ¶ms); - assert(!status && "vkGetBufferMemoryRequirements2KHR"); + UNIX_CALL_CHECKED(vkGetBufferMemoryRequirements2KHR, ¶ms); } uint64_t WINAPI vkGetBufferOpaqueCaptureAddress(VkDevice device, const VkBufferDeviceAddressInfo *pInfo) { struct vkGetBufferOpaqueCaptureAddress_params params; - NTSTATUS status; params.device = device; params.pInfo = pInfo; - status = UNIX_CALL(vkGetBufferOpaqueCaptureAddress, ¶ms); - assert(!status && "vkGetBufferOpaqueCaptureAddress"); + UNIX_CALL_CHECKED(vkGetBufferOpaqueCaptureAddress, ¶ms); return params.result; } uint64_t WINAPI vkGetBufferOpaqueCaptureAddressKHR(VkDevice device, const VkBufferDeviceAddressInfo *pInfo) { struct vkGetBufferOpaqueCaptureAddressKHR_params params; - NTSTATUS status; params.device = device; params.pInfo = pInfo; - status = UNIX_CALL(vkGetBufferOpaqueCaptureAddressKHR, ¶ms); - assert(!status && "vkGetBufferOpaqueCaptureAddressKHR"); + UNIX_CALL_CHECKED(vkGetBufferOpaqueCaptureAddressKHR, ¶ms); return params.result; } VkResult WINAPI vkGetBufferOpaqueCaptureDescriptorDataEXT(VkDevice device, const VkBufferCaptureDescriptorDataInfoEXT *pInfo, void *pData) { struct vkGetBufferOpaqueCaptureDescriptorDataEXT_params params; - NTSTATUS status; params.device = device; params.pInfo = pInfo; params.pData = pData; - status = UNIX_CALL(vkGetBufferOpaqueCaptureDescriptorDataEXT, ¶ms); - assert(!status && "vkGetBufferOpaqueCaptureDescriptorDataEXT"); + UNIX_CALL_CHECKED(vkGetBufferOpaqueCaptureDescriptorDataEXT, ¶ms); return params.result; } VkResult WINAPI vkGetCalibratedTimestampsEXT(VkDevice device, uint32_t timestampCount, const VkCalibratedTimestampInfoKHR *pTimestampInfos, uint64_t *pTimestamps, uint64_t *pMaxDeviation) { struct vkGetCalibratedTimestampsEXT_params params; - NTSTATUS status; params.device = device; params.timestampCount = timestampCount; params.pTimestampInfos = pTimestampInfos; params.pTimestamps = pTimestamps; params.pMaxDeviation = pMaxDeviation; - status = UNIX_CALL(vkGetCalibratedTimestampsEXT, ¶ms); - assert(!status && "vkGetCalibratedTimestampsEXT"); + UNIX_CALL_CHECKED(vkGetCalibratedTimestampsEXT, ¶ms); return params.result; } VkResult WINAPI vkGetCalibratedTimestampsKHR(VkDevice device, uint32_t timestampCount, const VkCalibratedTimestampInfoKHR *pTimestampInfos, uint64_t *pTimestamps, uint64_t *pMaxDeviation) { struct vkGetCalibratedTimestampsKHR_params params; - NTSTATUS status; params.device = device; params.timestampCount = timestampCount; params.pTimestampInfos = pTimestampInfos; params.pTimestamps = pTimestamps; params.pMaxDeviation = pMaxDeviation; - status = UNIX_CALL(vkGetCalibratedTimestampsKHR, ¶ms); - assert(!status && "vkGetCalibratedTimestampsKHR"); + UNIX_CALL_CHECKED(vkGetCalibratedTimestampsKHR, ¶ms); return params.result; } void WINAPI vkGetClusterAccelerationStructureBuildSizesNV(VkDevice device, const VkClusterAccelerationStructureInputInfoNV *pInfo, VkAccelerationStructureBuildSizesInfoKHR *pSizeInfo) { struct vkGetClusterAccelerationStructureBuildSizesNV_params params; - NTSTATUS status; params.device = device; params.pInfo = pInfo; params.pSizeInfo = pSizeInfo; - status = UNIX_CALL(vkGetClusterAccelerationStructureBuildSizesNV, ¶ms); - assert(!status && "vkGetClusterAccelerationStructureBuildSizesNV"); + UNIX_CALL_CHECKED(vkGetClusterAccelerationStructureBuildSizesNV, ¶ms); } VkResult WINAPI vkGetDataGraphPipelineAvailablePropertiesARM(VkDevice device, const VkDataGraphPipelineInfoARM *pPipelineInfo, uint32_t *pPropertiesCount, VkDataGraphPipelinePropertyARM *pProperties) { struct vkGetDataGraphPipelineAvailablePropertiesARM_params params; - NTSTATUS status; params.device = device; params.pPipelineInfo = pPipelineInfo; params.pPropertiesCount = pPropertiesCount; params.pProperties = pProperties; - status = UNIX_CALL(vkGetDataGraphPipelineAvailablePropertiesARM, ¶ms); - assert(!status && "vkGetDataGraphPipelineAvailablePropertiesARM"); + UNIX_CALL_CHECKED(vkGetDataGraphPipelineAvailablePropertiesARM, ¶ms); return params.result; } VkResult WINAPI vkGetDataGraphPipelinePropertiesARM(VkDevice device, const VkDataGraphPipelineInfoARM *pPipelineInfo, uint32_t propertiesCount, VkDataGraphPipelinePropertyQueryResultARM *pProperties) { struct vkGetDataGraphPipelinePropertiesARM_params params; - NTSTATUS status; params.device = device; params.pPipelineInfo = pPipelineInfo; params.propertiesCount = propertiesCount; params.pProperties = pProperties; - status = UNIX_CALL(vkGetDataGraphPipelinePropertiesARM, ¶ms); - assert(!status && "vkGetDataGraphPipelinePropertiesARM"); + UNIX_CALL_CHECKED(vkGetDataGraphPipelinePropertiesARM, ¶ms); return params.result; } VkResult WINAPI vkGetDataGraphPipelineSessionBindPointRequirementsARM(VkDevice device, const VkDataGraphPipelineSessionBindPointRequirementsInfoARM *pInfo, uint32_t *pBindPointRequirementCount, VkDataGraphPipelineSessionBindPointRequirementARM *pBindPointRequirements) { struct vkGetDataGraphPipelineSessionBindPointRequirementsARM_params params; - NTSTATUS status; params.device = device; params.pInfo = pInfo; params.pBindPointRequirementCount = pBindPointRequirementCount; params.pBindPointRequirements = pBindPointRequirements; - status = UNIX_CALL(vkGetDataGraphPipelineSessionBindPointRequirementsARM, ¶ms); - assert(!status && "vkGetDataGraphPipelineSessionBindPointRequirementsARM"); + UNIX_CALL_CHECKED(vkGetDataGraphPipelineSessionBindPointRequirementsARM, ¶ms); return params.result; } void WINAPI vkGetDataGraphPipelineSessionMemoryRequirementsARM(VkDevice device, const VkDataGraphPipelineSessionMemoryRequirementsInfoARM *pInfo, VkMemoryRequirements2 *pMemoryRequirements) { struct vkGetDataGraphPipelineSessionMemoryRequirementsARM_params params; - NTSTATUS status; params.device = device; params.pInfo = pInfo; params.pMemoryRequirements = pMemoryRequirements; - status = UNIX_CALL(vkGetDataGraphPipelineSessionMemoryRequirementsARM, ¶ms); - assert(!status && "vkGetDataGraphPipelineSessionMemoryRequirementsARM"); + UNIX_CALL_CHECKED(vkGetDataGraphPipelineSessionMemoryRequirementsARM, ¶ms); } uint32_t WINAPI vkGetDeferredOperationMaxConcurrencyKHR(VkDevice device, VkDeferredOperationKHR operation) { struct vkGetDeferredOperationMaxConcurrencyKHR_params params; - NTSTATUS status; params.device = device; params.operation = operation; - status = UNIX_CALL(vkGetDeferredOperationMaxConcurrencyKHR, ¶ms); - assert(!status && "vkGetDeferredOperationMaxConcurrencyKHR"); + UNIX_CALL_CHECKED(vkGetDeferredOperationMaxConcurrencyKHR, ¶ms); return params.result; } VkResult WINAPI vkGetDeferredOperationResultKHR(VkDevice device, VkDeferredOperationKHR operation) { struct vkGetDeferredOperationResultKHR_params params; - NTSTATUS status; params.device = device; params.operation = operation; - status = UNIX_CALL(vkGetDeferredOperationResultKHR, ¶ms); - assert(!status && "vkGetDeferredOperationResultKHR"); + UNIX_CALL_CHECKED(vkGetDeferredOperationResultKHR, ¶ms); return params.result; } @@ -5075,1012 +4711,837 @@ void WINAPI vkGetDescriptorEXT(VkDevice device, const VkDescriptorGetInfoEXT *pD void WINAPI vkGetDescriptorSetHostMappingVALVE(VkDevice device, VkDescriptorSet descriptorSet, void **ppData) { struct vkGetDescriptorSetHostMappingVALVE_params params; - NTSTATUS status; params.device = device; params.descriptorSet = descriptorSet; params.ppData = ppData; - status = UNIX_CALL(vkGetDescriptorSetHostMappingVALVE, ¶ms); - assert(!status && "vkGetDescriptorSetHostMappingVALVE"); + UNIX_CALL_CHECKED(vkGetDescriptorSetHostMappingVALVE, ¶ms); } void WINAPI vkGetDescriptorSetLayoutBindingOffsetEXT(VkDevice device, VkDescriptorSetLayout layout, uint32_t binding, VkDeviceSize *pOffset) { struct vkGetDescriptorSetLayoutBindingOffsetEXT_params params; - NTSTATUS status; params.device = device; params.layout = layout; params.binding = binding; params.pOffset = pOffset; - status = UNIX_CALL(vkGetDescriptorSetLayoutBindingOffsetEXT, ¶ms); - assert(!status && "vkGetDescriptorSetLayoutBindingOffsetEXT"); + UNIX_CALL_CHECKED(vkGetDescriptorSetLayoutBindingOffsetEXT, ¶ms); } void WINAPI vkGetDescriptorSetLayoutHostMappingInfoVALVE(VkDevice device, const VkDescriptorSetBindingReferenceVALVE *pBindingReference, VkDescriptorSetLayoutHostMappingInfoVALVE *pHostMapping) { struct vkGetDescriptorSetLayoutHostMappingInfoVALVE_params params; - NTSTATUS status; params.device = device; params.pBindingReference = pBindingReference; params.pHostMapping = pHostMapping; - status = UNIX_CALL(vkGetDescriptorSetLayoutHostMappingInfoVALVE, ¶ms); - assert(!status && "vkGetDescriptorSetLayoutHostMappingInfoVALVE"); + UNIX_CALL_CHECKED(vkGetDescriptorSetLayoutHostMappingInfoVALVE, ¶ms); } void WINAPI vkGetDescriptorSetLayoutSizeEXT(VkDevice device, VkDescriptorSetLayout layout, VkDeviceSize *pLayoutSizeInBytes) { struct vkGetDescriptorSetLayoutSizeEXT_params params; - NTSTATUS status; params.device = device; params.layout = layout; params.pLayoutSizeInBytes = pLayoutSizeInBytes; - status = UNIX_CALL(vkGetDescriptorSetLayoutSizeEXT, ¶ms); - assert(!status && "vkGetDescriptorSetLayoutSizeEXT"); + UNIX_CALL_CHECKED(vkGetDescriptorSetLayoutSizeEXT, ¶ms); } void WINAPI vkGetDescriptorSetLayoutSupport(VkDevice device, const VkDescriptorSetLayoutCreateInfo *pCreateInfo, VkDescriptorSetLayoutSupport *pSupport) { struct vkGetDescriptorSetLayoutSupport_params params; - NTSTATUS status; params.device = device; params.pCreateInfo = pCreateInfo; params.pSupport = pSupport; - status = UNIX_CALL(vkGetDescriptorSetLayoutSupport, ¶ms); - assert(!status && "vkGetDescriptorSetLayoutSupport"); + UNIX_CALL_CHECKED(vkGetDescriptorSetLayoutSupport, ¶ms); } void WINAPI vkGetDescriptorSetLayoutSupportKHR(VkDevice device, const VkDescriptorSetLayoutCreateInfo *pCreateInfo, VkDescriptorSetLayoutSupport *pSupport) { struct vkGetDescriptorSetLayoutSupportKHR_params params; - NTSTATUS status; params.device = device; params.pCreateInfo = pCreateInfo; params.pSupport = pSupport; - status = UNIX_CALL(vkGetDescriptorSetLayoutSupportKHR, ¶ms); - assert(!status && "vkGetDescriptorSetLayoutSupportKHR"); + UNIX_CALL_CHECKED(vkGetDescriptorSetLayoutSupportKHR, ¶ms); } void WINAPI vkGetDeviceAccelerationStructureCompatibilityKHR(VkDevice device, const VkAccelerationStructureVersionInfoKHR *pVersionInfo, VkAccelerationStructureCompatibilityKHR *pCompatibility) { struct vkGetDeviceAccelerationStructureCompatibilityKHR_params params; - NTSTATUS status; params.device = device; params.pVersionInfo = pVersionInfo; params.pCompatibility = pCompatibility; - status = UNIX_CALL(vkGetDeviceAccelerationStructureCompatibilityKHR, ¶ms); - assert(!status && "vkGetDeviceAccelerationStructureCompatibilityKHR"); + UNIX_CALL_CHECKED(vkGetDeviceAccelerationStructureCompatibilityKHR, ¶ms); } void WINAPI vkGetDeviceBufferMemoryRequirements(VkDevice device, const VkDeviceBufferMemoryRequirements *pInfo, VkMemoryRequirements2 *pMemoryRequirements) { struct vkGetDeviceBufferMemoryRequirements_params params; - NTSTATUS status; params.device = device; params.pInfo = pInfo; params.pMemoryRequirements = pMemoryRequirements; - status = UNIX_CALL(vkGetDeviceBufferMemoryRequirements, ¶ms); - assert(!status && "vkGetDeviceBufferMemoryRequirements"); + UNIX_CALL_CHECKED(vkGetDeviceBufferMemoryRequirements, ¶ms); } void WINAPI vkGetDeviceBufferMemoryRequirementsKHR(VkDevice device, const VkDeviceBufferMemoryRequirements *pInfo, VkMemoryRequirements2 *pMemoryRequirements) { struct vkGetDeviceBufferMemoryRequirementsKHR_params params; - NTSTATUS status; params.device = device; params.pInfo = pInfo; params.pMemoryRequirements = pMemoryRequirements; - status = UNIX_CALL(vkGetDeviceBufferMemoryRequirementsKHR, ¶ms); - assert(!status && "vkGetDeviceBufferMemoryRequirementsKHR"); + UNIX_CALL_CHECKED(vkGetDeviceBufferMemoryRequirementsKHR, ¶ms); } uint64_t WINAPI vkGetDeviceCombinedImageSamplerIndexNVX(VkDevice device, uint64_t imageViewIndex, uint64_t samplerIndex) { struct vkGetDeviceCombinedImageSamplerIndexNVX_params params; - NTSTATUS status; params.device = device; params.imageViewIndex = imageViewIndex; params.samplerIndex = samplerIndex; - status = UNIX_CALL(vkGetDeviceCombinedImageSamplerIndexNVX, ¶ms); - assert(!status && "vkGetDeviceCombinedImageSamplerIndexNVX"); + UNIX_CALL_CHECKED(vkGetDeviceCombinedImageSamplerIndexNVX, ¶ms); return params.result; } VkResult WINAPI vkGetDeviceFaultDebugInfoKHR(VkDevice device, VkDeviceFaultDebugInfoKHR *pDebugInfo) { struct vkGetDeviceFaultDebugInfoKHR_params params; - NTSTATUS status; params.device = device; params.pDebugInfo = pDebugInfo; - status = UNIX_CALL(vkGetDeviceFaultDebugInfoKHR, ¶ms); - assert(!status && "vkGetDeviceFaultDebugInfoKHR"); + UNIX_CALL_CHECKED(vkGetDeviceFaultDebugInfoKHR, ¶ms); return params.result; } VkResult WINAPI vkGetDeviceFaultInfoEXT(VkDevice device, VkDeviceFaultCountsEXT *pFaultCounts, VkDeviceFaultInfoEXT *pFaultInfo) { struct vkGetDeviceFaultInfoEXT_params params; - NTSTATUS status; params.device = device; params.pFaultCounts = pFaultCounts; params.pFaultInfo = pFaultInfo; - status = UNIX_CALL(vkGetDeviceFaultInfoEXT, ¶ms); - assert(!status && "vkGetDeviceFaultInfoEXT"); + UNIX_CALL_CHECKED(vkGetDeviceFaultInfoEXT, ¶ms); return params.result; } VkResult WINAPI vkGetDeviceFaultReportsKHR(VkDevice device, uint64_t timeout, uint32_t *pFaultCounts, VkDeviceFaultInfoKHR *pFaultInfo) { struct vkGetDeviceFaultReportsKHR_params params; - NTSTATUS status; params.device = device; params.timeout = timeout; params.pFaultCounts = pFaultCounts; params.pFaultInfo = pFaultInfo; - status = UNIX_CALL(vkGetDeviceFaultReportsKHR, ¶ms); - assert(!status && "vkGetDeviceFaultReportsKHR"); + UNIX_CALL_CHECKED(vkGetDeviceFaultReportsKHR, ¶ms); return params.result; } void WINAPI vkGetDeviceGroupPeerMemoryFeatures(VkDevice device, uint32_t heapIndex, uint32_t localDeviceIndex, uint32_t remoteDeviceIndex, VkPeerMemoryFeatureFlags *pPeerMemoryFeatures) { struct vkGetDeviceGroupPeerMemoryFeatures_params params; - NTSTATUS status; params.device = device; params.heapIndex = heapIndex; params.localDeviceIndex = localDeviceIndex; params.remoteDeviceIndex = remoteDeviceIndex; params.pPeerMemoryFeatures = pPeerMemoryFeatures; - status = UNIX_CALL(vkGetDeviceGroupPeerMemoryFeatures, ¶ms); - assert(!status && "vkGetDeviceGroupPeerMemoryFeatures"); + UNIX_CALL_CHECKED(vkGetDeviceGroupPeerMemoryFeatures, ¶ms); } void WINAPI vkGetDeviceGroupPeerMemoryFeaturesKHR(VkDevice device, uint32_t heapIndex, uint32_t localDeviceIndex, uint32_t remoteDeviceIndex, VkPeerMemoryFeatureFlags *pPeerMemoryFeatures) { struct vkGetDeviceGroupPeerMemoryFeaturesKHR_params params; - NTSTATUS status; params.device = device; params.heapIndex = heapIndex; params.localDeviceIndex = localDeviceIndex; params.remoteDeviceIndex = remoteDeviceIndex; params.pPeerMemoryFeatures = pPeerMemoryFeatures; - status = UNIX_CALL(vkGetDeviceGroupPeerMemoryFeaturesKHR, ¶ms); - assert(!status && "vkGetDeviceGroupPeerMemoryFeaturesKHR"); + UNIX_CALL_CHECKED(vkGetDeviceGroupPeerMemoryFeaturesKHR, ¶ms); } VkResult WINAPI vkGetDeviceGroupPresentCapabilitiesKHR(VkDevice device, VkDeviceGroupPresentCapabilitiesKHR *pDeviceGroupPresentCapabilities) { struct vkGetDeviceGroupPresentCapabilitiesKHR_params params; - NTSTATUS status; params.device = device; params.pDeviceGroupPresentCapabilities = pDeviceGroupPresentCapabilities; - status = UNIX_CALL(vkGetDeviceGroupPresentCapabilitiesKHR, ¶ms); - assert(!status && "vkGetDeviceGroupPresentCapabilitiesKHR"); + UNIX_CALL_CHECKED(vkGetDeviceGroupPresentCapabilitiesKHR, ¶ms); return params.result; } VkResult WINAPI vkGetDeviceGroupSurfacePresentModesKHR(VkDevice device, VkSurfaceKHR surface, VkDeviceGroupPresentModeFlagsKHR *pModes) { struct vkGetDeviceGroupSurfacePresentModesKHR_params params; - NTSTATUS status; params.device = device; params.surface = surface; params.pModes = pModes; - status = UNIX_CALL(vkGetDeviceGroupSurfacePresentModesKHR, ¶ms); - assert(!status && "vkGetDeviceGroupSurfacePresentModesKHR"); + UNIX_CALL_CHECKED(vkGetDeviceGroupSurfacePresentModesKHR, ¶ms); return params.result; } void WINAPI vkGetDeviceImageMemoryRequirements(VkDevice device, const VkDeviceImageMemoryRequirements *pInfo, VkMemoryRequirements2 *pMemoryRequirements) { struct vkGetDeviceImageMemoryRequirements_params params; - NTSTATUS status; params.device = device; params.pInfo = pInfo; params.pMemoryRequirements = pMemoryRequirements; - status = UNIX_CALL(vkGetDeviceImageMemoryRequirements, ¶ms); - assert(!status && "vkGetDeviceImageMemoryRequirements"); + UNIX_CALL_CHECKED(vkGetDeviceImageMemoryRequirements, ¶ms); } void WINAPI vkGetDeviceImageMemoryRequirementsKHR(VkDevice device, const VkDeviceImageMemoryRequirements *pInfo, VkMemoryRequirements2 *pMemoryRequirements) { struct vkGetDeviceImageMemoryRequirementsKHR_params params; - NTSTATUS status; params.device = device; params.pInfo = pInfo; params.pMemoryRequirements = pMemoryRequirements; - status = UNIX_CALL(vkGetDeviceImageMemoryRequirementsKHR, ¶ms); - assert(!status && "vkGetDeviceImageMemoryRequirementsKHR"); + UNIX_CALL_CHECKED(vkGetDeviceImageMemoryRequirementsKHR, ¶ms); } void WINAPI vkGetDeviceImageSparseMemoryRequirements(VkDevice device, const VkDeviceImageMemoryRequirements *pInfo, uint32_t *pSparseMemoryRequirementCount, VkSparseImageMemoryRequirements2 *pSparseMemoryRequirements) { struct vkGetDeviceImageSparseMemoryRequirements_params params; - NTSTATUS status; params.device = device; params.pInfo = pInfo; params.pSparseMemoryRequirementCount = pSparseMemoryRequirementCount; params.pSparseMemoryRequirements = pSparseMemoryRequirements; - status = UNIX_CALL(vkGetDeviceImageSparseMemoryRequirements, ¶ms); - assert(!status && "vkGetDeviceImageSparseMemoryRequirements"); + UNIX_CALL_CHECKED(vkGetDeviceImageSparseMemoryRequirements, ¶ms); } void WINAPI vkGetDeviceImageSparseMemoryRequirementsKHR(VkDevice device, const VkDeviceImageMemoryRequirements *pInfo, uint32_t *pSparseMemoryRequirementCount, VkSparseImageMemoryRequirements2 *pSparseMemoryRequirements) { struct vkGetDeviceImageSparseMemoryRequirementsKHR_params params; - NTSTATUS status; params.device = device; params.pInfo = pInfo; params.pSparseMemoryRequirementCount = pSparseMemoryRequirementCount; params.pSparseMemoryRequirements = pSparseMemoryRequirements; - status = UNIX_CALL(vkGetDeviceImageSparseMemoryRequirementsKHR, ¶ms); - assert(!status && "vkGetDeviceImageSparseMemoryRequirementsKHR"); + UNIX_CALL_CHECKED(vkGetDeviceImageSparseMemoryRequirementsKHR, ¶ms); } void WINAPI vkGetDeviceImageSubresourceLayout(VkDevice device, const VkDeviceImageSubresourceInfo *pInfo, VkSubresourceLayout2 *pLayout) { struct vkGetDeviceImageSubresourceLayout_params params; - NTSTATUS status; params.device = device; params.pInfo = pInfo; params.pLayout = pLayout; - status = UNIX_CALL(vkGetDeviceImageSubresourceLayout, ¶ms); - assert(!status && "vkGetDeviceImageSubresourceLayout"); + UNIX_CALL_CHECKED(vkGetDeviceImageSubresourceLayout, ¶ms); } void WINAPI vkGetDeviceImageSubresourceLayoutKHR(VkDevice device, const VkDeviceImageSubresourceInfo *pInfo, VkSubresourceLayout2 *pLayout) { struct vkGetDeviceImageSubresourceLayoutKHR_params params; - NTSTATUS status; params.device = device; params.pInfo = pInfo; params.pLayout = pLayout; - status = UNIX_CALL(vkGetDeviceImageSubresourceLayoutKHR, ¶ms); - assert(!status && "vkGetDeviceImageSubresourceLayoutKHR"); + UNIX_CALL_CHECKED(vkGetDeviceImageSubresourceLayoutKHR, ¶ms); } void WINAPI vkGetDeviceMemoryCommitment(VkDevice device, VkDeviceMemory memory, VkDeviceSize *pCommittedMemoryInBytes) { struct vkGetDeviceMemoryCommitment_params params; - NTSTATUS status; params.device = device; params.memory = memory; params.pCommittedMemoryInBytes = pCommittedMemoryInBytes; - status = UNIX_CALL(vkGetDeviceMemoryCommitment, ¶ms); - assert(!status && "vkGetDeviceMemoryCommitment"); + UNIX_CALL_CHECKED(vkGetDeviceMemoryCommitment, ¶ms); } uint64_t WINAPI vkGetDeviceMemoryOpaqueCaptureAddress(VkDevice device, const VkDeviceMemoryOpaqueCaptureAddressInfo *pInfo) { struct vkGetDeviceMemoryOpaqueCaptureAddress_params params; - NTSTATUS status; params.device = device; params.pInfo = pInfo; - status = UNIX_CALL(vkGetDeviceMemoryOpaqueCaptureAddress, ¶ms); - assert(!status && "vkGetDeviceMemoryOpaqueCaptureAddress"); + UNIX_CALL_CHECKED(vkGetDeviceMemoryOpaqueCaptureAddress, ¶ms); return params.result; } uint64_t WINAPI vkGetDeviceMemoryOpaqueCaptureAddressKHR(VkDevice device, const VkDeviceMemoryOpaqueCaptureAddressInfo *pInfo) { struct vkGetDeviceMemoryOpaqueCaptureAddressKHR_params params; - NTSTATUS status; params.device = device; params.pInfo = pInfo; - status = UNIX_CALL(vkGetDeviceMemoryOpaqueCaptureAddressKHR, ¶ms); - assert(!status && "vkGetDeviceMemoryOpaqueCaptureAddressKHR"); + UNIX_CALL_CHECKED(vkGetDeviceMemoryOpaqueCaptureAddressKHR, ¶ms); return params.result; } void WINAPI vkGetDeviceMicromapCompatibilityEXT(VkDevice device, const VkMicromapVersionInfoEXT *pVersionInfo, VkAccelerationStructureCompatibilityKHR *pCompatibility) { struct vkGetDeviceMicromapCompatibilityEXT_params params; - NTSTATUS status; params.device = device; params.pVersionInfo = pVersionInfo; params.pCompatibility = pCompatibility; - status = UNIX_CALL(vkGetDeviceMicromapCompatibilityEXT, ¶ms); - assert(!status && "vkGetDeviceMicromapCompatibilityEXT"); + UNIX_CALL_CHECKED(vkGetDeviceMicromapCompatibilityEXT, ¶ms); } void WINAPI vkGetDeviceQueue(VkDevice device, uint32_t queueFamilyIndex, uint32_t queueIndex, VkQueue *pQueue) { struct vkGetDeviceQueue_params params; - NTSTATUS status; params.device = device; params.queueFamilyIndex = queueFamilyIndex; params.queueIndex = queueIndex; params.pQueue = pQueue; - status = UNIX_CALL(vkGetDeviceQueue, ¶ms); - assert(!status && "vkGetDeviceQueue"); + UNIX_CALL_CHECKED(vkGetDeviceQueue, ¶ms); } void WINAPI vkGetDeviceQueue2(VkDevice device, const VkDeviceQueueInfo2 *pQueueInfo, VkQueue *pQueue) { struct vkGetDeviceQueue2_params params; - NTSTATUS status; params.device = device; params.pQueueInfo = pQueueInfo; params.pQueue = pQueue; - status = UNIX_CALL(vkGetDeviceQueue2, ¶ms); - assert(!status && "vkGetDeviceQueue2"); + UNIX_CALL_CHECKED(vkGetDeviceQueue2, ¶ms); } VkResult WINAPI vkGetDeviceSubpassShadingMaxWorkgroupSizeHUAWEI(VkDevice device, VkRenderPass renderpass, VkExtent2D *pMaxWorkgroupSize) { struct vkGetDeviceSubpassShadingMaxWorkgroupSizeHUAWEI_params params; - NTSTATUS status; params.device = device; params.renderpass = renderpass; params.pMaxWorkgroupSize = pMaxWorkgroupSize; - status = UNIX_CALL(vkGetDeviceSubpassShadingMaxWorkgroupSizeHUAWEI, ¶ms); - assert(!status && "vkGetDeviceSubpassShadingMaxWorkgroupSizeHUAWEI"); + UNIX_CALL_CHECKED(vkGetDeviceSubpassShadingMaxWorkgroupSizeHUAWEI, ¶ms); return params.result; } void WINAPI vkGetDeviceTensorMemoryRequirementsARM(VkDevice device, const VkDeviceTensorMemoryRequirementsARM *pInfo, VkMemoryRequirements2 *pMemoryRequirements) { struct vkGetDeviceTensorMemoryRequirementsARM_params params; - NTSTATUS status; params.device = device; params.pInfo = pInfo; params.pMemoryRequirements = pMemoryRequirements; - status = UNIX_CALL(vkGetDeviceTensorMemoryRequirementsARM, ¶ms); - assert(!status && "vkGetDeviceTensorMemoryRequirementsARM"); + UNIX_CALL_CHECKED(vkGetDeviceTensorMemoryRequirementsARM, ¶ms); } VkResult WINAPI vkGetDynamicRenderingTilePropertiesQCOM(VkDevice device, const VkRenderingInfo *pRenderingInfo, VkTilePropertiesQCOM *pProperties) { struct vkGetDynamicRenderingTilePropertiesQCOM_params params; - NTSTATUS status; params.device = device; params.pRenderingInfo = pRenderingInfo; params.pProperties = pProperties; - status = UNIX_CALL(vkGetDynamicRenderingTilePropertiesQCOM, ¶ms); - assert(!status && "vkGetDynamicRenderingTilePropertiesQCOM"); + UNIX_CALL_CHECKED(vkGetDynamicRenderingTilePropertiesQCOM, ¶ms); return params.result; } VkResult WINAPI vkGetEncodedVideoSessionParametersKHR(VkDevice device, const VkVideoEncodeSessionParametersGetInfoKHR *pVideoSessionParametersInfo, VkVideoEncodeSessionParametersFeedbackInfoKHR *pFeedbackInfo, size_t *pDataSize, void *pData) { struct vkGetEncodedVideoSessionParametersKHR_params params; - NTSTATUS status; params.device = device; params.pVideoSessionParametersInfo = pVideoSessionParametersInfo; params.pFeedbackInfo = pFeedbackInfo; params.pDataSize = pDataSize; params.pData = pData; - status = UNIX_CALL(vkGetEncodedVideoSessionParametersKHR, ¶ms); - assert(!status && "vkGetEncodedVideoSessionParametersKHR"); + UNIX_CALL_CHECKED(vkGetEncodedVideoSessionParametersKHR, ¶ms); return params.result; } VkResult WINAPI vkGetEventStatus(VkDevice device, VkEvent event) { struct vkGetEventStatus_params params; - NTSTATUS status; params.device = device; params.event = event; - status = UNIX_CALL(vkGetEventStatus, ¶ms); - assert(!status && "vkGetEventStatus"); + UNIX_CALL_CHECKED(vkGetEventStatus, ¶ms); return params.result; } VkResult WINAPI vkGetFenceStatus(VkDevice device, VkFence fence) { struct vkGetFenceStatus_params params; - NTSTATUS status; params.device = device; params.fence = fence; - status = UNIX_CALL(vkGetFenceStatus, ¶ms); - assert(!status && "vkGetFenceStatus"); + UNIX_CALL_CHECKED(vkGetFenceStatus, ¶ms); return params.result; } VkResult WINAPI vkGetFenceWin32HandleKHR(VkDevice device, const VkFenceGetWin32HandleInfoKHR *pGetWin32HandleInfo, HANDLE *pHandle) { struct vkGetFenceWin32HandleKHR_params params; - NTSTATUS status; params.device = device; params.pGetWin32HandleInfo = pGetWin32HandleInfo; params.pHandle = pHandle; - status = UNIX_CALL(vkGetFenceWin32HandleKHR, ¶ms); - assert(!status && "vkGetFenceWin32HandleKHR"); + UNIX_CALL_CHECKED(vkGetFenceWin32HandleKHR, ¶ms); return params.result; } VkResult WINAPI vkGetFramebufferTilePropertiesQCOM(VkDevice device, VkFramebuffer framebuffer, uint32_t *pPropertiesCount, VkTilePropertiesQCOM *pProperties) { struct vkGetFramebufferTilePropertiesQCOM_params params; - NTSTATUS status; params.device = device; params.framebuffer = framebuffer; params.pPropertiesCount = pPropertiesCount; params.pProperties = pProperties; - status = UNIX_CALL(vkGetFramebufferTilePropertiesQCOM, ¶ms); - assert(!status && "vkGetFramebufferTilePropertiesQCOM"); + UNIX_CALL_CHECKED(vkGetFramebufferTilePropertiesQCOM, ¶ms); return params.result; } void WINAPI vkGetGeneratedCommandsMemoryRequirementsEXT(VkDevice device, const VkGeneratedCommandsMemoryRequirementsInfoEXT *pInfo, VkMemoryRequirements2 *pMemoryRequirements) { struct vkGetGeneratedCommandsMemoryRequirementsEXT_params params; - NTSTATUS status; params.device = device; params.pInfo = pInfo; params.pMemoryRequirements = pMemoryRequirements; - status = UNIX_CALL(vkGetGeneratedCommandsMemoryRequirementsEXT, ¶ms); - assert(!status && "vkGetGeneratedCommandsMemoryRequirementsEXT"); + UNIX_CALL_CHECKED(vkGetGeneratedCommandsMemoryRequirementsEXT, ¶ms); } void WINAPI vkGetGeneratedCommandsMemoryRequirementsNV(VkDevice device, const VkGeneratedCommandsMemoryRequirementsInfoNV *pInfo, VkMemoryRequirements2 *pMemoryRequirements) { struct vkGetGeneratedCommandsMemoryRequirementsNV_params params; - NTSTATUS status; params.device = device; params.pInfo = pInfo; params.pMemoryRequirements = pMemoryRequirements; - status = UNIX_CALL(vkGetGeneratedCommandsMemoryRequirementsNV, ¶ms); - assert(!status && "vkGetGeneratedCommandsMemoryRequirementsNV"); + UNIX_CALL_CHECKED(vkGetGeneratedCommandsMemoryRequirementsNV, ¶ms); } VkResult WINAPI vkGetGpaDeviceClockInfoAMD(VkDevice device, VkGpaDeviceGetClockInfoAMD *pInfo) { struct vkGetGpaDeviceClockInfoAMD_params params; - NTSTATUS status; params.device = device; params.pInfo = pInfo; - status = UNIX_CALL(vkGetGpaDeviceClockInfoAMD, ¶ms); - assert(!status && "vkGetGpaDeviceClockInfoAMD"); + UNIX_CALL_CHECKED(vkGetGpaDeviceClockInfoAMD, ¶ms); return params.result; } VkResult WINAPI vkGetGpaSessionResultsAMD(VkDevice device, VkGpaSessionAMD gpaSession, uint32_t sampleID, size_t *pSizeInBytes, void *pData) { struct vkGetGpaSessionResultsAMD_params params; - NTSTATUS status; params.device = device; params.gpaSession = gpaSession; params.sampleID = sampleID; params.pSizeInBytes = pSizeInBytes; params.pData = pData; - status = UNIX_CALL(vkGetGpaSessionResultsAMD, ¶ms); - assert(!status && "vkGetGpaSessionResultsAMD"); + UNIX_CALL_CHECKED(vkGetGpaSessionResultsAMD, ¶ms); return params.result; } VkResult WINAPI vkGetGpaSessionStatusAMD(VkDevice device, VkGpaSessionAMD gpaSession) { struct vkGetGpaSessionStatusAMD_params params; - NTSTATUS status; params.device = device; params.gpaSession = gpaSession; - status = UNIX_CALL(vkGetGpaSessionStatusAMD, ¶ms); - assert(!status && "vkGetGpaSessionStatusAMD"); + UNIX_CALL_CHECKED(vkGetGpaSessionStatusAMD, ¶ms); return params.result; } void WINAPI vkGetImageMemoryRequirements(VkDevice device, VkImage image, VkMemoryRequirements *pMemoryRequirements) { struct vkGetImageMemoryRequirements_params params; - NTSTATUS status; params.device = device; params.image = image; params.pMemoryRequirements = pMemoryRequirements; - status = UNIX_CALL(vkGetImageMemoryRequirements, ¶ms); - assert(!status && "vkGetImageMemoryRequirements"); + UNIX_CALL_CHECKED(vkGetImageMemoryRequirements, ¶ms); } void WINAPI vkGetImageMemoryRequirements2(VkDevice device, const VkImageMemoryRequirementsInfo2 *pInfo, VkMemoryRequirements2 *pMemoryRequirements) { struct vkGetImageMemoryRequirements2_params params; - NTSTATUS status; params.device = device; params.pInfo = pInfo; params.pMemoryRequirements = pMemoryRequirements; - status = UNIX_CALL(vkGetImageMemoryRequirements2, ¶ms); - assert(!status && "vkGetImageMemoryRequirements2"); + UNIX_CALL_CHECKED(vkGetImageMemoryRequirements2, ¶ms); } void WINAPI vkGetImageMemoryRequirements2KHR(VkDevice device, const VkImageMemoryRequirementsInfo2 *pInfo, VkMemoryRequirements2 *pMemoryRequirements) { struct vkGetImageMemoryRequirements2KHR_params params; - NTSTATUS status; params.device = device; params.pInfo = pInfo; params.pMemoryRequirements = pMemoryRequirements; - status = UNIX_CALL(vkGetImageMemoryRequirements2KHR, ¶ms); - assert(!status && "vkGetImageMemoryRequirements2KHR"); + UNIX_CALL_CHECKED(vkGetImageMemoryRequirements2KHR, ¶ms); } VkResult WINAPI vkGetImageOpaqueCaptureDataEXT(VkDevice device, uint32_t imageCount, const VkImage *pImages, VkHostAddressRangeEXT *pDatas) { struct vkGetImageOpaqueCaptureDataEXT_params params; - NTSTATUS status; params.device = device; params.imageCount = imageCount; params.pImages = pImages; params.pDatas = pDatas; - status = UNIX_CALL(vkGetImageOpaqueCaptureDataEXT, ¶ms); - assert(!status && "vkGetImageOpaqueCaptureDataEXT"); + UNIX_CALL_CHECKED(vkGetImageOpaqueCaptureDataEXT, ¶ms); return params.result; } VkResult WINAPI vkGetImageOpaqueCaptureDescriptorDataEXT(VkDevice device, const VkImageCaptureDescriptorDataInfoEXT *pInfo, void *pData) { struct vkGetImageOpaqueCaptureDescriptorDataEXT_params params; - NTSTATUS status; params.device = device; params.pInfo = pInfo; params.pData = pData; - status = UNIX_CALL(vkGetImageOpaqueCaptureDescriptorDataEXT, ¶ms); - assert(!status && "vkGetImageOpaqueCaptureDescriptorDataEXT"); + UNIX_CALL_CHECKED(vkGetImageOpaqueCaptureDescriptorDataEXT, ¶ms); return params.result; } void WINAPI vkGetImageSparseMemoryRequirements(VkDevice device, VkImage image, uint32_t *pSparseMemoryRequirementCount, VkSparseImageMemoryRequirements *pSparseMemoryRequirements) { struct vkGetImageSparseMemoryRequirements_params params; - NTSTATUS status; params.device = device; params.image = image; params.pSparseMemoryRequirementCount = pSparseMemoryRequirementCount; params.pSparseMemoryRequirements = pSparseMemoryRequirements; - status = UNIX_CALL(vkGetImageSparseMemoryRequirements, ¶ms); - assert(!status && "vkGetImageSparseMemoryRequirements"); + UNIX_CALL_CHECKED(vkGetImageSparseMemoryRequirements, ¶ms); } void WINAPI vkGetImageSparseMemoryRequirements2(VkDevice device, const VkImageSparseMemoryRequirementsInfo2 *pInfo, uint32_t *pSparseMemoryRequirementCount, VkSparseImageMemoryRequirements2 *pSparseMemoryRequirements) { struct vkGetImageSparseMemoryRequirements2_params params; - NTSTATUS status; params.device = device; params.pInfo = pInfo; params.pSparseMemoryRequirementCount = pSparseMemoryRequirementCount; params.pSparseMemoryRequirements = pSparseMemoryRequirements; - status = UNIX_CALL(vkGetImageSparseMemoryRequirements2, ¶ms); - assert(!status && "vkGetImageSparseMemoryRequirements2"); + UNIX_CALL_CHECKED(vkGetImageSparseMemoryRequirements2, ¶ms); } void WINAPI vkGetImageSparseMemoryRequirements2KHR(VkDevice device, const VkImageSparseMemoryRequirementsInfo2 *pInfo, uint32_t *pSparseMemoryRequirementCount, VkSparseImageMemoryRequirements2 *pSparseMemoryRequirements) { struct vkGetImageSparseMemoryRequirements2KHR_params params; - NTSTATUS status; params.device = device; params.pInfo = pInfo; params.pSparseMemoryRequirementCount = pSparseMemoryRequirementCount; params.pSparseMemoryRequirements = pSparseMemoryRequirements; - status = UNIX_CALL(vkGetImageSparseMemoryRequirements2KHR, ¶ms); - assert(!status && "vkGetImageSparseMemoryRequirements2KHR"); + UNIX_CALL_CHECKED(vkGetImageSparseMemoryRequirements2KHR, ¶ms); } void WINAPI vkGetImageSubresourceLayout(VkDevice device, VkImage image, const VkImageSubresource *pSubresource, VkSubresourceLayout *pLayout) { struct vkGetImageSubresourceLayout_params params; - NTSTATUS status; params.device = device; params.image = image; params.pSubresource = pSubresource; params.pLayout = pLayout; - status = UNIX_CALL(vkGetImageSubresourceLayout, ¶ms); - assert(!status && "vkGetImageSubresourceLayout"); + UNIX_CALL_CHECKED(vkGetImageSubresourceLayout, ¶ms); } void WINAPI vkGetImageSubresourceLayout2(VkDevice device, VkImage image, const VkImageSubresource2 *pSubresource, VkSubresourceLayout2 *pLayout) { struct vkGetImageSubresourceLayout2_params params; - NTSTATUS status; params.device = device; params.image = image; params.pSubresource = pSubresource; params.pLayout = pLayout; - status = UNIX_CALL(vkGetImageSubresourceLayout2, ¶ms); - assert(!status && "vkGetImageSubresourceLayout2"); + UNIX_CALL_CHECKED(vkGetImageSubresourceLayout2, ¶ms); } void WINAPI vkGetImageSubresourceLayout2EXT(VkDevice device, VkImage image, const VkImageSubresource2 *pSubresource, VkSubresourceLayout2 *pLayout) { struct vkGetImageSubresourceLayout2EXT_params params; - NTSTATUS status; params.device = device; params.image = image; params.pSubresource = pSubresource; params.pLayout = pLayout; - status = UNIX_CALL(vkGetImageSubresourceLayout2EXT, ¶ms); - assert(!status && "vkGetImageSubresourceLayout2EXT"); + UNIX_CALL_CHECKED(vkGetImageSubresourceLayout2EXT, ¶ms); } void WINAPI vkGetImageSubresourceLayout2KHR(VkDevice device, VkImage image, const VkImageSubresource2 *pSubresource, VkSubresourceLayout2 *pLayout) { struct vkGetImageSubresourceLayout2KHR_params params; - NTSTATUS status; params.device = device; params.image = image; params.pSubresource = pSubresource; params.pLayout = pLayout; - status = UNIX_CALL(vkGetImageSubresourceLayout2KHR, ¶ms); - assert(!status && "vkGetImageSubresourceLayout2KHR"); + UNIX_CALL_CHECKED(vkGetImageSubresourceLayout2KHR, ¶ms); } VkResult WINAPI vkGetImageViewAddressNVX(VkDevice device, VkImageView imageView, VkImageViewAddressPropertiesNVX *pProperties) { struct vkGetImageViewAddressNVX_params params; - NTSTATUS status; params.device = device; params.imageView = imageView; params.pProperties = pProperties; - status = UNIX_CALL(vkGetImageViewAddressNVX, ¶ms); - assert(!status && "vkGetImageViewAddressNVX"); + UNIX_CALL_CHECKED(vkGetImageViewAddressNVX, ¶ms); return params.result; } uint64_t WINAPI vkGetImageViewHandle64NVX(VkDevice device, const VkImageViewHandleInfoNVX *pInfo) { struct vkGetImageViewHandle64NVX_params params; - NTSTATUS status; params.device = device; params.pInfo = pInfo; - status = UNIX_CALL(vkGetImageViewHandle64NVX, ¶ms); - assert(!status && "vkGetImageViewHandle64NVX"); + UNIX_CALL_CHECKED(vkGetImageViewHandle64NVX, ¶ms); return params.result; } uint32_t WINAPI vkGetImageViewHandleNVX(VkDevice device, const VkImageViewHandleInfoNVX *pInfo) { struct vkGetImageViewHandleNVX_params params; - NTSTATUS status; params.device = device; params.pInfo = pInfo; - status = UNIX_CALL(vkGetImageViewHandleNVX, ¶ms); - assert(!status && "vkGetImageViewHandleNVX"); + UNIX_CALL_CHECKED(vkGetImageViewHandleNVX, ¶ms); return params.result; } VkResult WINAPI vkGetImageViewOpaqueCaptureDescriptorDataEXT(VkDevice device, const VkImageViewCaptureDescriptorDataInfoEXT *pInfo, void *pData) { struct vkGetImageViewOpaqueCaptureDescriptorDataEXT_params params; - NTSTATUS status; params.device = device; params.pInfo = pInfo; params.pData = pData; - status = UNIX_CALL(vkGetImageViewOpaqueCaptureDescriptorDataEXT, ¶ms); - assert(!status && "vkGetImageViewOpaqueCaptureDescriptorDataEXT"); + UNIX_CALL_CHECKED(vkGetImageViewOpaqueCaptureDescriptorDataEXT, ¶ms); return params.result; } void WINAPI vkGetLatencyTimingsNV(VkDevice device, VkSwapchainKHR swapchain, VkGetLatencyMarkerInfoNV *pLatencyMarkerInfo) { struct vkGetLatencyTimingsNV_params params; - NTSTATUS status; params.device = device; params.swapchain = swapchain; params.pLatencyMarkerInfo = pLatencyMarkerInfo; - status = UNIX_CALL(vkGetLatencyTimingsNV, ¶ms); - assert(!status && "vkGetLatencyTimingsNV"); + UNIX_CALL_CHECKED(vkGetLatencyTimingsNV, ¶ms); } VkResult WINAPI vkGetMemoryHostPointerPropertiesEXT(VkDevice device, VkExternalMemoryHandleTypeFlagBits handleType, const void *pHostPointer, VkMemoryHostPointerPropertiesEXT *pMemoryHostPointerProperties) { struct vkGetMemoryHostPointerPropertiesEXT_params params; - NTSTATUS status; params.device = device; params.handleType = handleType; params.pHostPointer = pHostPointer; params.pMemoryHostPointerProperties = pMemoryHostPointerProperties; - status = UNIX_CALL(vkGetMemoryHostPointerPropertiesEXT, ¶ms); - assert(!status && "vkGetMemoryHostPointerPropertiesEXT"); + UNIX_CALL_CHECKED(vkGetMemoryHostPointerPropertiesEXT, ¶ms); return params.result; } VkResult WINAPI vkGetMemoryWin32HandleKHR(VkDevice device, const VkMemoryGetWin32HandleInfoKHR *pGetWin32HandleInfo, HANDLE *pHandle) { struct vkGetMemoryWin32HandleKHR_params params; - NTSTATUS status; params.device = device; params.pGetWin32HandleInfo = pGetWin32HandleInfo; params.pHandle = pHandle; - status = UNIX_CALL(vkGetMemoryWin32HandleKHR, ¶ms); - assert(!status && "vkGetMemoryWin32HandleKHR"); + UNIX_CALL_CHECKED(vkGetMemoryWin32HandleKHR, ¶ms); return params.result; } VkResult WINAPI vkGetMemoryWin32HandlePropertiesKHR(VkDevice device, VkExternalMemoryHandleTypeFlagBits handleType, HANDLE handle, VkMemoryWin32HandlePropertiesKHR *pMemoryWin32HandleProperties) { struct vkGetMemoryWin32HandlePropertiesKHR_params params; - NTSTATUS status; params.device = device; params.handleType = handleType; params.handle = handle; params.pMemoryWin32HandleProperties = pMemoryWin32HandleProperties; - status = UNIX_CALL(vkGetMemoryWin32HandlePropertiesKHR, ¶ms); - assert(!status && "vkGetMemoryWin32HandlePropertiesKHR"); + UNIX_CALL_CHECKED(vkGetMemoryWin32HandlePropertiesKHR, ¶ms); return params.result; } void WINAPI vkGetMicromapBuildSizesEXT(VkDevice device, VkAccelerationStructureBuildTypeKHR buildType, const VkMicromapBuildInfoEXT *pBuildInfo, VkMicromapBuildSizesInfoEXT *pSizeInfo) { struct vkGetMicromapBuildSizesEXT_params params; - NTSTATUS status; params.device = device; params.buildType = buildType; params.pBuildInfo = pBuildInfo; params.pSizeInfo = pSizeInfo; - status = UNIX_CALL(vkGetMicromapBuildSizesEXT, ¶ms); - assert(!status && "vkGetMicromapBuildSizesEXT"); + UNIX_CALL_CHECKED(vkGetMicromapBuildSizesEXT, ¶ms); } void WINAPI vkGetPartitionedAccelerationStructuresBuildSizesNV(VkDevice device, const VkPartitionedAccelerationStructureInstancesInputNV *pInfo, VkAccelerationStructureBuildSizesInfoKHR *pSizeInfo) { struct vkGetPartitionedAccelerationStructuresBuildSizesNV_params params; - NTSTATUS status; params.device = device; params.pInfo = pInfo; params.pSizeInfo = pSizeInfo; - status = UNIX_CALL(vkGetPartitionedAccelerationStructuresBuildSizesNV, ¶ms); - assert(!status && "vkGetPartitionedAccelerationStructuresBuildSizesNV"); + UNIX_CALL_CHECKED(vkGetPartitionedAccelerationStructuresBuildSizesNV, ¶ms); } VkResult WINAPI vkGetPastPresentationTimingEXT(VkDevice device, const VkPastPresentationTimingInfoEXT *pPastPresentationTimingInfo, VkPastPresentationTimingPropertiesEXT *pPastPresentationTimingProperties) { struct vkGetPastPresentationTimingEXT_params params; - NTSTATUS status; params.device = device; params.pPastPresentationTimingInfo = pPastPresentationTimingInfo; params.pPastPresentationTimingProperties = pPastPresentationTimingProperties; - status = UNIX_CALL(vkGetPastPresentationTimingEXT, ¶ms); - assert(!status && "vkGetPastPresentationTimingEXT"); + UNIX_CALL_CHECKED(vkGetPastPresentationTimingEXT, ¶ms); return params.result; } VkResult WINAPI vkGetPerformanceParameterINTEL(VkDevice device, VkPerformanceParameterTypeINTEL parameter, VkPerformanceValueINTEL *pValue) { struct vkGetPerformanceParameterINTEL_params params; - NTSTATUS status; params.device = device; params.parameter = parameter; params.pValue = pValue; - status = UNIX_CALL(vkGetPerformanceParameterINTEL, ¶ms); - assert(!status && "vkGetPerformanceParameterINTEL"); + UNIX_CALL_CHECKED(vkGetPerformanceParameterINTEL, ¶ms); return params.result; } VkResult WINAPI vkGetPhysicalDeviceCalibrateableTimeDomainsEXT(VkPhysicalDevice physicalDevice, uint32_t *pTimeDomainCount, VkTimeDomainKHR *pTimeDomains) { struct vkGetPhysicalDeviceCalibrateableTimeDomainsEXT_params params; - NTSTATUS status; params.physicalDevice = physicalDevice; params.pTimeDomainCount = pTimeDomainCount; params.pTimeDomains = pTimeDomains; - status = UNIX_CALL(vkGetPhysicalDeviceCalibrateableTimeDomainsEXT, ¶ms); - assert(!status && "vkGetPhysicalDeviceCalibrateableTimeDomainsEXT"); + UNIX_CALL_CHECKED(vkGetPhysicalDeviceCalibrateableTimeDomainsEXT, ¶ms); return params.result; } VkResult WINAPI vkGetPhysicalDeviceCalibrateableTimeDomainsKHR(VkPhysicalDevice physicalDevice, uint32_t *pTimeDomainCount, VkTimeDomainKHR *pTimeDomains) { struct vkGetPhysicalDeviceCalibrateableTimeDomainsKHR_params params; - NTSTATUS status; params.physicalDevice = physicalDevice; params.pTimeDomainCount = pTimeDomainCount; params.pTimeDomains = pTimeDomains; - status = UNIX_CALL(vkGetPhysicalDeviceCalibrateableTimeDomainsKHR, ¶ms); - assert(!status && "vkGetPhysicalDeviceCalibrateableTimeDomainsKHR"); + UNIX_CALL_CHECKED(vkGetPhysicalDeviceCalibrateableTimeDomainsKHR, ¶ms); return params.result; } VkResult WINAPI vkGetPhysicalDeviceCooperativeMatrixFlexibleDimensionsPropertiesNV(VkPhysicalDevice physicalDevice, uint32_t *pPropertyCount, VkCooperativeMatrixFlexibleDimensionsPropertiesNV *pProperties) { struct vkGetPhysicalDeviceCooperativeMatrixFlexibleDimensionsPropertiesNV_params params; - NTSTATUS status; params.physicalDevice = physicalDevice; params.pPropertyCount = pPropertyCount; params.pProperties = pProperties; - status = UNIX_CALL(vkGetPhysicalDeviceCooperativeMatrixFlexibleDimensionsPropertiesNV, ¶ms); - assert(!status && "vkGetPhysicalDeviceCooperativeMatrixFlexibleDimensionsPropertiesNV"); + UNIX_CALL_CHECKED(vkGetPhysicalDeviceCooperativeMatrixFlexibleDimensionsPropertiesNV, ¶ms); return params.result; } VkResult WINAPI vkGetPhysicalDeviceCooperativeMatrixPropertiesKHR(VkPhysicalDevice physicalDevice, uint32_t *pPropertyCount, VkCooperativeMatrixPropertiesKHR *pProperties) { struct vkGetPhysicalDeviceCooperativeMatrixPropertiesKHR_params params; - NTSTATUS status; params.physicalDevice = physicalDevice; params.pPropertyCount = pPropertyCount; params.pProperties = pProperties; - status = UNIX_CALL(vkGetPhysicalDeviceCooperativeMatrixPropertiesKHR, ¶ms); - assert(!status && "vkGetPhysicalDeviceCooperativeMatrixPropertiesKHR"); + UNIX_CALL_CHECKED(vkGetPhysicalDeviceCooperativeMatrixPropertiesKHR, ¶ms); return params.result; } VkResult WINAPI vkGetPhysicalDeviceCooperativeMatrixPropertiesNV(VkPhysicalDevice physicalDevice, uint32_t *pPropertyCount, VkCooperativeMatrixPropertiesNV *pProperties) { struct vkGetPhysicalDeviceCooperativeMatrixPropertiesNV_params params; - NTSTATUS status; params.physicalDevice = physicalDevice; params.pPropertyCount = pPropertyCount; params.pProperties = pProperties; - status = UNIX_CALL(vkGetPhysicalDeviceCooperativeMatrixPropertiesNV, ¶ms); - assert(!status && "vkGetPhysicalDeviceCooperativeMatrixPropertiesNV"); + UNIX_CALL_CHECKED(vkGetPhysicalDeviceCooperativeMatrixPropertiesNV, ¶ms); return params.result; } VkResult WINAPI vkGetPhysicalDeviceCooperativeVectorPropertiesNV(VkPhysicalDevice physicalDevice, uint32_t *pPropertyCount, VkCooperativeVectorPropertiesNV *pProperties) { struct vkGetPhysicalDeviceCooperativeVectorPropertiesNV_params params; - NTSTATUS status; params.physicalDevice = physicalDevice; params.pPropertyCount = pPropertyCount; params.pProperties = pProperties; - status = UNIX_CALL(vkGetPhysicalDeviceCooperativeVectorPropertiesNV, ¶ms); - assert(!status && "vkGetPhysicalDeviceCooperativeVectorPropertiesNV"); + UNIX_CALL_CHECKED(vkGetPhysicalDeviceCooperativeVectorPropertiesNV, ¶ms); return params.result; } VkDeviceSize WINAPI vkGetPhysicalDeviceDescriptorSizeEXT(VkPhysicalDevice physicalDevice, VkDescriptorType descriptorType) { struct vkGetPhysicalDeviceDescriptorSizeEXT_params params; - NTSTATUS status; params.physicalDevice = physicalDevice; params.descriptorType = descriptorType; - status = UNIX_CALL(vkGetPhysicalDeviceDescriptorSizeEXT, ¶ms); - assert(!status && "vkGetPhysicalDeviceDescriptorSizeEXT"); + UNIX_CALL_CHECKED(vkGetPhysicalDeviceDescriptorSizeEXT, ¶ms); return params.result; } void WINAPI vkGetPhysicalDeviceExternalBufferProperties(VkPhysicalDevice physicalDevice, const VkPhysicalDeviceExternalBufferInfo *pExternalBufferInfo, VkExternalBufferProperties *pExternalBufferProperties) { struct vkGetPhysicalDeviceExternalBufferProperties_params params; - NTSTATUS status; params.physicalDevice = physicalDevice; params.pExternalBufferInfo = pExternalBufferInfo; params.pExternalBufferProperties = pExternalBufferProperties; - status = UNIX_CALL(vkGetPhysicalDeviceExternalBufferProperties, ¶ms); - assert(!status && "vkGetPhysicalDeviceExternalBufferProperties"); + UNIX_CALL_CHECKED(vkGetPhysicalDeviceExternalBufferProperties, ¶ms); } void WINAPI vkGetPhysicalDeviceExternalBufferPropertiesKHR(VkPhysicalDevice physicalDevice, const VkPhysicalDeviceExternalBufferInfo *pExternalBufferInfo, VkExternalBufferProperties *pExternalBufferProperties) { struct vkGetPhysicalDeviceExternalBufferPropertiesKHR_params params; - NTSTATUS status; params.physicalDevice = physicalDevice; params.pExternalBufferInfo = pExternalBufferInfo; params.pExternalBufferProperties = pExternalBufferProperties; - status = UNIX_CALL(vkGetPhysicalDeviceExternalBufferPropertiesKHR, ¶ms); - assert(!status && "vkGetPhysicalDeviceExternalBufferPropertiesKHR"); + UNIX_CALL_CHECKED(vkGetPhysicalDeviceExternalBufferPropertiesKHR, ¶ms); } void WINAPI vkGetPhysicalDeviceExternalFenceProperties(VkPhysicalDevice physicalDevice, const VkPhysicalDeviceExternalFenceInfo *pExternalFenceInfo, VkExternalFenceProperties *pExternalFenceProperties) { struct vkGetPhysicalDeviceExternalFenceProperties_params params; - NTSTATUS status; params.physicalDevice = physicalDevice; params.pExternalFenceInfo = pExternalFenceInfo; params.pExternalFenceProperties = pExternalFenceProperties; - status = UNIX_CALL(vkGetPhysicalDeviceExternalFenceProperties, ¶ms); - assert(!status && "vkGetPhysicalDeviceExternalFenceProperties"); + UNIX_CALL_CHECKED(vkGetPhysicalDeviceExternalFenceProperties, ¶ms); } void WINAPI vkGetPhysicalDeviceExternalFencePropertiesKHR(VkPhysicalDevice physicalDevice, const VkPhysicalDeviceExternalFenceInfo *pExternalFenceInfo, VkExternalFenceProperties *pExternalFenceProperties) { struct vkGetPhysicalDeviceExternalFencePropertiesKHR_params params; - NTSTATUS status; params.physicalDevice = physicalDevice; params.pExternalFenceInfo = pExternalFenceInfo; params.pExternalFenceProperties = pExternalFenceProperties; - status = UNIX_CALL(vkGetPhysicalDeviceExternalFencePropertiesKHR, ¶ms); - assert(!status && "vkGetPhysicalDeviceExternalFencePropertiesKHR"); + UNIX_CALL_CHECKED(vkGetPhysicalDeviceExternalFencePropertiesKHR, ¶ms); } void WINAPI vkGetPhysicalDeviceExternalSemaphoreProperties(VkPhysicalDevice physicalDevice, const VkPhysicalDeviceExternalSemaphoreInfo *pExternalSemaphoreInfo, VkExternalSemaphoreProperties *pExternalSemaphoreProperties) { struct vkGetPhysicalDeviceExternalSemaphoreProperties_params params; - NTSTATUS status; params.physicalDevice = physicalDevice; params.pExternalSemaphoreInfo = pExternalSemaphoreInfo; params.pExternalSemaphoreProperties = pExternalSemaphoreProperties; - status = UNIX_CALL(vkGetPhysicalDeviceExternalSemaphoreProperties, ¶ms); - assert(!status && "vkGetPhysicalDeviceExternalSemaphoreProperties"); + UNIX_CALL_CHECKED(vkGetPhysicalDeviceExternalSemaphoreProperties, ¶ms); } void WINAPI vkGetPhysicalDeviceExternalSemaphorePropertiesKHR(VkPhysicalDevice physicalDevice, const VkPhysicalDeviceExternalSemaphoreInfo *pExternalSemaphoreInfo, VkExternalSemaphoreProperties *pExternalSemaphoreProperties) { struct vkGetPhysicalDeviceExternalSemaphorePropertiesKHR_params params; - NTSTATUS status; params.physicalDevice = physicalDevice; params.pExternalSemaphoreInfo = pExternalSemaphoreInfo; params.pExternalSemaphoreProperties = pExternalSemaphoreProperties; - status = UNIX_CALL(vkGetPhysicalDeviceExternalSemaphorePropertiesKHR, ¶ms); - assert(!status && "vkGetPhysicalDeviceExternalSemaphorePropertiesKHR"); + UNIX_CALL_CHECKED(vkGetPhysicalDeviceExternalSemaphorePropertiesKHR, ¶ms); } void WINAPI vkGetPhysicalDeviceExternalTensorPropertiesARM(VkPhysicalDevice physicalDevice, const VkPhysicalDeviceExternalTensorInfoARM *pExternalTensorInfo, VkExternalTensorPropertiesARM *pExternalTensorProperties) { struct vkGetPhysicalDeviceExternalTensorPropertiesARM_params params; - NTSTATUS status; params.physicalDevice = physicalDevice; params.pExternalTensorInfo = pExternalTensorInfo; params.pExternalTensorProperties = pExternalTensorProperties; - status = UNIX_CALL(vkGetPhysicalDeviceExternalTensorPropertiesARM, ¶ms); - assert(!status && "vkGetPhysicalDeviceExternalTensorPropertiesARM"); + UNIX_CALL_CHECKED(vkGetPhysicalDeviceExternalTensorPropertiesARM, ¶ms); } void WINAPI vkGetPhysicalDeviceFeatures(VkPhysicalDevice physicalDevice, VkPhysicalDeviceFeatures *pFeatures) { struct vkGetPhysicalDeviceFeatures_params params; - NTSTATUS status; params.physicalDevice = physicalDevice; params.pFeatures = pFeatures; - status = UNIX_CALL(vkGetPhysicalDeviceFeatures, ¶ms); - assert(!status && "vkGetPhysicalDeviceFeatures"); + UNIX_CALL_CHECKED(vkGetPhysicalDeviceFeatures, ¶ms); } void WINAPI vkGetPhysicalDeviceFeatures2(VkPhysicalDevice physicalDevice, VkPhysicalDeviceFeatures2 *pFeatures) { struct vkGetPhysicalDeviceFeatures2_params params; - NTSTATUS status; params.physicalDevice = physicalDevice; params.pFeatures = pFeatures; - status = UNIX_CALL(vkGetPhysicalDeviceFeatures2, ¶ms); - assert(!status && "vkGetPhysicalDeviceFeatures2"); + UNIX_CALL_CHECKED(vkGetPhysicalDeviceFeatures2, ¶ms); } void WINAPI vkGetPhysicalDeviceFeatures2KHR(VkPhysicalDevice physicalDevice, VkPhysicalDeviceFeatures2 *pFeatures) { struct vkGetPhysicalDeviceFeatures2KHR_params params; - NTSTATUS status; params.physicalDevice = physicalDevice; params.pFeatures = pFeatures; - status = UNIX_CALL(vkGetPhysicalDeviceFeatures2KHR, ¶ms); - assert(!status && "vkGetPhysicalDeviceFeatures2KHR"); + UNIX_CALL_CHECKED(vkGetPhysicalDeviceFeatures2KHR, ¶ms); } void WINAPI vkGetPhysicalDeviceFormatProperties(VkPhysicalDevice physicalDevice, VkFormat format, VkFormatProperties *pFormatProperties) { struct vkGetPhysicalDeviceFormatProperties_params params; - NTSTATUS status; params.physicalDevice = physicalDevice; params.format = format; params.pFormatProperties = pFormatProperties; - status = UNIX_CALL(vkGetPhysicalDeviceFormatProperties, ¶ms); - assert(!status && "vkGetPhysicalDeviceFormatProperties"); + UNIX_CALL_CHECKED(vkGetPhysicalDeviceFormatProperties, ¶ms); } void WINAPI vkGetPhysicalDeviceFormatProperties2(VkPhysicalDevice physicalDevice, VkFormat format, VkFormatProperties2 *pFormatProperties) { struct vkGetPhysicalDeviceFormatProperties2_params params; - NTSTATUS status; params.physicalDevice = physicalDevice; params.format = format; params.pFormatProperties = pFormatProperties; - status = UNIX_CALL(vkGetPhysicalDeviceFormatProperties2, ¶ms); - assert(!status && "vkGetPhysicalDeviceFormatProperties2"); + UNIX_CALL_CHECKED(vkGetPhysicalDeviceFormatProperties2, ¶ms); } void WINAPI vkGetPhysicalDeviceFormatProperties2KHR(VkPhysicalDevice physicalDevice, VkFormat format, VkFormatProperties2 *pFormatProperties) { struct vkGetPhysicalDeviceFormatProperties2KHR_params params; - NTSTATUS status; params.physicalDevice = physicalDevice; params.format = format; params.pFormatProperties = pFormatProperties; - status = UNIX_CALL(vkGetPhysicalDeviceFormatProperties2KHR, ¶ms); - assert(!status && "vkGetPhysicalDeviceFormatProperties2KHR"); + UNIX_CALL_CHECKED(vkGetPhysicalDeviceFormatProperties2KHR, ¶ms); } VkResult WINAPI vkGetPhysicalDeviceFragmentShadingRatesKHR(VkPhysicalDevice physicalDevice, uint32_t *pFragmentShadingRateCount, VkPhysicalDeviceFragmentShadingRateKHR *pFragmentShadingRates) { struct vkGetPhysicalDeviceFragmentShadingRatesKHR_params params; - NTSTATUS status; params.physicalDevice = physicalDevice; params.pFragmentShadingRateCount = pFragmentShadingRateCount; params.pFragmentShadingRates = pFragmentShadingRates; - status = UNIX_CALL(vkGetPhysicalDeviceFragmentShadingRatesKHR, ¶ms); - assert(!status && "vkGetPhysicalDeviceFragmentShadingRatesKHR"); + UNIX_CALL_CHECKED(vkGetPhysicalDeviceFragmentShadingRatesKHR, ¶ms); return params.result; } VkResult WINAPI vkGetPhysicalDeviceImageFormatProperties(VkPhysicalDevice physicalDevice, VkFormat format, VkImageType type, VkImageTiling tiling, VkImageUsageFlags usage, VkImageCreateFlags flags, VkImageFormatProperties *pImageFormatProperties) { struct vkGetPhysicalDeviceImageFormatProperties_params params; - NTSTATUS status; params.physicalDevice = physicalDevice; params.format = format; params.type = type; @@ -6088,232 +5549,192 @@ VkResult WINAPI vkGetPhysicalDeviceImageFormatProperties(VkPhysicalDevice physic params.usage = usage; params.flags = flags; params.pImageFormatProperties = pImageFormatProperties; - status = UNIX_CALL(vkGetPhysicalDeviceImageFormatProperties, ¶ms); - assert(!status && "vkGetPhysicalDeviceImageFormatProperties"); + UNIX_CALL_CHECKED(vkGetPhysicalDeviceImageFormatProperties, ¶ms); return params.result; } VkResult WINAPI vkGetPhysicalDeviceImageFormatProperties2(VkPhysicalDevice physicalDevice, const VkPhysicalDeviceImageFormatInfo2 *pImageFormatInfo, VkImageFormatProperties2 *pImageFormatProperties) { struct vkGetPhysicalDeviceImageFormatProperties2_params params; - NTSTATUS status; params.physicalDevice = physicalDevice; params.pImageFormatInfo = pImageFormatInfo; params.pImageFormatProperties = pImageFormatProperties; - status = UNIX_CALL(vkGetPhysicalDeviceImageFormatProperties2, ¶ms); - assert(!status && "vkGetPhysicalDeviceImageFormatProperties2"); + UNIX_CALL_CHECKED(vkGetPhysicalDeviceImageFormatProperties2, ¶ms); return params.result; } VkResult WINAPI vkGetPhysicalDeviceImageFormatProperties2KHR(VkPhysicalDevice physicalDevice, const VkPhysicalDeviceImageFormatInfo2 *pImageFormatInfo, VkImageFormatProperties2 *pImageFormatProperties) { struct vkGetPhysicalDeviceImageFormatProperties2KHR_params params; - NTSTATUS status; params.physicalDevice = physicalDevice; params.pImageFormatInfo = pImageFormatInfo; params.pImageFormatProperties = pImageFormatProperties; - status = UNIX_CALL(vkGetPhysicalDeviceImageFormatProperties2KHR, ¶ms); - assert(!status && "vkGetPhysicalDeviceImageFormatProperties2KHR"); + UNIX_CALL_CHECKED(vkGetPhysicalDeviceImageFormatProperties2KHR, ¶ms); return params.result; } void WINAPI vkGetPhysicalDeviceMemoryProperties(VkPhysicalDevice physicalDevice, VkPhysicalDeviceMemoryProperties *pMemoryProperties) { struct vkGetPhysicalDeviceMemoryProperties_params params; - NTSTATUS status; params.physicalDevice = physicalDevice; params.pMemoryProperties = pMemoryProperties; - status = UNIX_CALL(vkGetPhysicalDeviceMemoryProperties, ¶ms); - assert(!status && "vkGetPhysicalDeviceMemoryProperties"); + UNIX_CALL_CHECKED(vkGetPhysicalDeviceMemoryProperties, ¶ms); } void WINAPI vkGetPhysicalDeviceMemoryProperties2(VkPhysicalDevice physicalDevice, VkPhysicalDeviceMemoryProperties2 *pMemoryProperties) { struct vkGetPhysicalDeviceMemoryProperties2_params params; - NTSTATUS status; params.physicalDevice = physicalDevice; params.pMemoryProperties = pMemoryProperties; - status = UNIX_CALL(vkGetPhysicalDeviceMemoryProperties2, ¶ms); - assert(!status && "vkGetPhysicalDeviceMemoryProperties2"); + UNIX_CALL_CHECKED(vkGetPhysicalDeviceMemoryProperties2, ¶ms); } void WINAPI vkGetPhysicalDeviceMemoryProperties2KHR(VkPhysicalDevice physicalDevice, VkPhysicalDeviceMemoryProperties2 *pMemoryProperties) { struct vkGetPhysicalDeviceMemoryProperties2KHR_params params; - NTSTATUS status; params.physicalDevice = physicalDevice; params.pMemoryProperties = pMemoryProperties; - status = UNIX_CALL(vkGetPhysicalDeviceMemoryProperties2KHR, ¶ms); - assert(!status && "vkGetPhysicalDeviceMemoryProperties2KHR"); + UNIX_CALL_CHECKED(vkGetPhysicalDeviceMemoryProperties2KHR, ¶ms); } void WINAPI vkGetPhysicalDeviceMultisamplePropertiesEXT(VkPhysicalDevice physicalDevice, VkSampleCountFlagBits samples, VkMultisamplePropertiesEXT *pMultisampleProperties) { struct vkGetPhysicalDeviceMultisamplePropertiesEXT_params params; - NTSTATUS status; params.physicalDevice = physicalDevice; params.samples = samples; params.pMultisampleProperties = pMultisampleProperties; - status = UNIX_CALL(vkGetPhysicalDeviceMultisamplePropertiesEXT, ¶ms); - assert(!status && "vkGetPhysicalDeviceMultisamplePropertiesEXT"); + UNIX_CALL_CHECKED(vkGetPhysicalDeviceMultisamplePropertiesEXT, ¶ms); } VkResult WINAPI vkGetPhysicalDeviceOpticalFlowImageFormatsNV(VkPhysicalDevice physicalDevice, const VkOpticalFlowImageFormatInfoNV *pOpticalFlowImageFormatInfo, uint32_t *pFormatCount, VkOpticalFlowImageFormatPropertiesNV *pImageFormatProperties) { struct vkGetPhysicalDeviceOpticalFlowImageFormatsNV_params params; - NTSTATUS status; params.physicalDevice = physicalDevice; params.pOpticalFlowImageFormatInfo = pOpticalFlowImageFormatInfo; params.pFormatCount = pFormatCount; params.pImageFormatProperties = pImageFormatProperties; - status = UNIX_CALL(vkGetPhysicalDeviceOpticalFlowImageFormatsNV, ¶ms); - assert(!status && "vkGetPhysicalDeviceOpticalFlowImageFormatsNV"); + UNIX_CALL_CHECKED(vkGetPhysicalDeviceOpticalFlowImageFormatsNV, ¶ms); return params.result; } VkResult WINAPI vkGetPhysicalDevicePresentRectanglesKHR(VkPhysicalDevice physicalDevice, VkSurfaceKHR surface, uint32_t *pRectCount, VkRect2D *pRects) { struct vkGetPhysicalDevicePresentRectanglesKHR_params params; - NTSTATUS status; params.physicalDevice = physicalDevice; params.surface = surface; params.pRectCount = pRectCount; params.pRects = pRects; - status = UNIX_CALL(vkGetPhysicalDevicePresentRectanglesKHR, ¶ms); - assert(!status && "vkGetPhysicalDevicePresentRectanglesKHR"); + UNIX_CALL_CHECKED(vkGetPhysicalDevicePresentRectanglesKHR, ¶ms); return params.result; } void WINAPI vkGetPhysicalDeviceProperties(VkPhysicalDevice physicalDevice, VkPhysicalDeviceProperties *pProperties) { struct vkGetPhysicalDeviceProperties_params params; - NTSTATUS status; params.physicalDevice = physicalDevice; params.pProperties = pProperties; - status = UNIX_CALL(vkGetPhysicalDeviceProperties, ¶ms); - assert(!status && "vkGetPhysicalDeviceProperties"); + UNIX_CALL_CHECKED(vkGetPhysicalDeviceProperties, ¶ms); } void WINAPI vkGetPhysicalDeviceProperties2(VkPhysicalDevice physicalDevice, VkPhysicalDeviceProperties2 *pProperties) { struct vkGetPhysicalDeviceProperties2_params params; - NTSTATUS status; params.physicalDevice = physicalDevice; params.pProperties = pProperties; - status = UNIX_CALL(vkGetPhysicalDeviceProperties2, ¶ms); - assert(!status && "vkGetPhysicalDeviceProperties2"); + UNIX_CALL_CHECKED(vkGetPhysicalDeviceProperties2, ¶ms); } void WINAPI vkGetPhysicalDeviceProperties2KHR(VkPhysicalDevice physicalDevice, VkPhysicalDeviceProperties2 *pProperties) { struct vkGetPhysicalDeviceProperties2KHR_params params; - NTSTATUS status; params.physicalDevice = physicalDevice; params.pProperties = pProperties; - status = UNIX_CALL(vkGetPhysicalDeviceProperties2KHR, ¶ms); - assert(!status && "vkGetPhysicalDeviceProperties2KHR"); + UNIX_CALL_CHECKED(vkGetPhysicalDeviceProperties2KHR, ¶ms); } VkResult WINAPI vkGetPhysicalDeviceQueueFamilyDataGraphEngineOperationPropertiesARM(VkPhysicalDevice physicalDevice, uint32_t queueFamilyIndex, const VkQueueFamilyDataGraphPropertiesARM *pQueueFamilyDataGraphProperties, VkBaseOutStructure *pProperties) { struct vkGetPhysicalDeviceQueueFamilyDataGraphEngineOperationPropertiesARM_params params; - NTSTATUS status; params.physicalDevice = physicalDevice; params.queueFamilyIndex = queueFamilyIndex; params.pQueueFamilyDataGraphProperties = pQueueFamilyDataGraphProperties; params.pProperties = pProperties; - status = UNIX_CALL(vkGetPhysicalDeviceQueueFamilyDataGraphEngineOperationPropertiesARM, ¶ms); - assert(!status && "vkGetPhysicalDeviceQueueFamilyDataGraphEngineOperationPropertiesARM"); + UNIX_CALL_CHECKED(vkGetPhysicalDeviceQueueFamilyDataGraphEngineOperationPropertiesARM, ¶ms); return params.result; } VkResult WINAPI vkGetPhysicalDeviceQueueFamilyDataGraphOpticalFlowImageFormatsARM(VkPhysicalDevice physicalDevice, uint32_t queueFamilyIndex, const VkQueueFamilyDataGraphPropertiesARM *pQueueFamilyDataGraphProperties, const VkDataGraphOpticalFlowImageFormatInfoARM *pOpticalFlowImageFormatInfo, uint32_t *pFormatCount, VkDataGraphOpticalFlowImageFormatPropertiesARM *pImageFormatProperties) { struct vkGetPhysicalDeviceQueueFamilyDataGraphOpticalFlowImageFormatsARM_params params; - NTSTATUS status; params.physicalDevice = physicalDevice; params.queueFamilyIndex = queueFamilyIndex; params.pQueueFamilyDataGraphProperties = pQueueFamilyDataGraphProperties; params.pOpticalFlowImageFormatInfo = pOpticalFlowImageFormatInfo; params.pFormatCount = pFormatCount; params.pImageFormatProperties = pImageFormatProperties; - status = UNIX_CALL(vkGetPhysicalDeviceQueueFamilyDataGraphOpticalFlowImageFormatsARM, ¶ms); - assert(!status && "vkGetPhysicalDeviceQueueFamilyDataGraphOpticalFlowImageFormatsARM"); + UNIX_CALL_CHECKED(vkGetPhysicalDeviceQueueFamilyDataGraphOpticalFlowImageFormatsARM, ¶ms); return params.result; } void WINAPI vkGetPhysicalDeviceQueueFamilyDataGraphProcessingEnginePropertiesARM(VkPhysicalDevice physicalDevice, const VkPhysicalDeviceQueueFamilyDataGraphProcessingEngineInfoARM *pQueueFamilyDataGraphProcessingEngineInfo, VkQueueFamilyDataGraphProcessingEnginePropertiesARM *pQueueFamilyDataGraphProcessingEngineProperties) { struct vkGetPhysicalDeviceQueueFamilyDataGraphProcessingEnginePropertiesARM_params params; - NTSTATUS status; params.physicalDevice = physicalDevice; params.pQueueFamilyDataGraphProcessingEngineInfo = pQueueFamilyDataGraphProcessingEngineInfo; params.pQueueFamilyDataGraphProcessingEngineProperties = pQueueFamilyDataGraphProcessingEngineProperties; - status = UNIX_CALL(vkGetPhysicalDeviceQueueFamilyDataGraphProcessingEnginePropertiesARM, ¶ms); - assert(!status && "vkGetPhysicalDeviceQueueFamilyDataGraphProcessingEnginePropertiesARM"); + UNIX_CALL_CHECKED(vkGetPhysicalDeviceQueueFamilyDataGraphProcessingEnginePropertiesARM, ¶ms); } VkResult WINAPI vkGetPhysicalDeviceQueueFamilyDataGraphPropertiesARM(VkPhysicalDevice physicalDevice, uint32_t queueFamilyIndex, uint32_t *pQueueFamilyDataGraphPropertyCount, VkQueueFamilyDataGraphPropertiesARM *pQueueFamilyDataGraphProperties) { struct vkGetPhysicalDeviceQueueFamilyDataGraphPropertiesARM_params params; - NTSTATUS status; params.physicalDevice = physicalDevice; params.queueFamilyIndex = queueFamilyIndex; params.pQueueFamilyDataGraphPropertyCount = pQueueFamilyDataGraphPropertyCount; params.pQueueFamilyDataGraphProperties = pQueueFamilyDataGraphProperties; - status = UNIX_CALL(vkGetPhysicalDeviceQueueFamilyDataGraphPropertiesARM, ¶ms); - assert(!status && "vkGetPhysicalDeviceQueueFamilyDataGraphPropertiesARM"); + UNIX_CALL_CHECKED(vkGetPhysicalDeviceQueueFamilyDataGraphPropertiesARM, ¶ms); return params.result; } void WINAPI vkGetPhysicalDeviceQueueFamilyPerformanceQueryPassesKHR(VkPhysicalDevice physicalDevice, const VkQueryPoolPerformanceCreateInfoKHR *pPerformanceQueryCreateInfo, uint32_t *pNumPasses) { struct vkGetPhysicalDeviceQueueFamilyPerformanceQueryPassesKHR_params params; - NTSTATUS status; params.physicalDevice = physicalDevice; params.pPerformanceQueryCreateInfo = pPerformanceQueryCreateInfo; params.pNumPasses = pNumPasses; - status = UNIX_CALL(vkGetPhysicalDeviceQueueFamilyPerformanceQueryPassesKHR, ¶ms); - assert(!status && "vkGetPhysicalDeviceQueueFamilyPerformanceQueryPassesKHR"); + UNIX_CALL_CHECKED(vkGetPhysicalDeviceQueueFamilyPerformanceQueryPassesKHR, ¶ms); } void WINAPI vkGetPhysicalDeviceQueueFamilyProperties(VkPhysicalDevice physicalDevice, uint32_t *pQueueFamilyPropertyCount, VkQueueFamilyProperties *pQueueFamilyProperties) { struct vkGetPhysicalDeviceQueueFamilyProperties_params params; - NTSTATUS status; params.physicalDevice = physicalDevice; params.pQueueFamilyPropertyCount = pQueueFamilyPropertyCount; params.pQueueFamilyProperties = pQueueFamilyProperties; - status = UNIX_CALL(vkGetPhysicalDeviceQueueFamilyProperties, ¶ms); - assert(!status && "vkGetPhysicalDeviceQueueFamilyProperties"); + UNIX_CALL_CHECKED(vkGetPhysicalDeviceQueueFamilyProperties, ¶ms); } void WINAPI vkGetPhysicalDeviceQueueFamilyProperties2(VkPhysicalDevice physicalDevice, uint32_t *pQueueFamilyPropertyCount, VkQueueFamilyProperties2 *pQueueFamilyProperties) { struct vkGetPhysicalDeviceQueueFamilyProperties2_params params; - NTSTATUS status; params.physicalDevice = physicalDevice; params.pQueueFamilyPropertyCount = pQueueFamilyPropertyCount; params.pQueueFamilyProperties = pQueueFamilyProperties; - status = UNIX_CALL(vkGetPhysicalDeviceQueueFamilyProperties2, ¶ms); - assert(!status && "vkGetPhysicalDeviceQueueFamilyProperties2"); + UNIX_CALL_CHECKED(vkGetPhysicalDeviceQueueFamilyProperties2, ¶ms); } void WINAPI vkGetPhysicalDeviceQueueFamilyProperties2KHR(VkPhysicalDevice physicalDevice, uint32_t *pQueueFamilyPropertyCount, VkQueueFamilyProperties2 *pQueueFamilyProperties) { struct vkGetPhysicalDeviceQueueFamilyProperties2KHR_params params; - NTSTATUS status; params.physicalDevice = physicalDevice; params.pQueueFamilyPropertyCount = pQueueFamilyPropertyCount; params.pQueueFamilyProperties = pQueueFamilyProperties; - status = UNIX_CALL(vkGetPhysicalDeviceQueueFamilyProperties2KHR, ¶ms); - assert(!status && "vkGetPhysicalDeviceQueueFamilyProperties2KHR"); + UNIX_CALL_CHECKED(vkGetPhysicalDeviceQueueFamilyProperties2KHR, ¶ms); } void WINAPI vkGetPhysicalDeviceSparseImageFormatProperties(VkPhysicalDevice physicalDevice, VkFormat format, VkImageType type, VkSampleCountFlagBits samples, VkImageUsageFlags usage, VkImageTiling tiling, uint32_t *pPropertyCount, VkSparseImageFormatProperties *pProperties) { struct vkGetPhysicalDeviceSparseImageFormatProperties_params params; - NTSTATUS status; params.physicalDevice = physicalDevice; params.format = format; params.type = type; @@ -6322,336 +5743,282 @@ void WINAPI vkGetPhysicalDeviceSparseImageFormatProperties(VkPhysicalDevice phys params.tiling = tiling; params.pPropertyCount = pPropertyCount; params.pProperties = pProperties; - status = UNIX_CALL(vkGetPhysicalDeviceSparseImageFormatProperties, ¶ms); - assert(!status && "vkGetPhysicalDeviceSparseImageFormatProperties"); + UNIX_CALL_CHECKED(vkGetPhysicalDeviceSparseImageFormatProperties, ¶ms); } void WINAPI vkGetPhysicalDeviceSparseImageFormatProperties2(VkPhysicalDevice physicalDevice, const VkPhysicalDeviceSparseImageFormatInfo2 *pFormatInfo, uint32_t *pPropertyCount, VkSparseImageFormatProperties2 *pProperties) { struct vkGetPhysicalDeviceSparseImageFormatProperties2_params params; - NTSTATUS status; params.physicalDevice = physicalDevice; params.pFormatInfo = pFormatInfo; params.pPropertyCount = pPropertyCount; params.pProperties = pProperties; - status = UNIX_CALL(vkGetPhysicalDeviceSparseImageFormatProperties2, ¶ms); - assert(!status && "vkGetPhysicalDeviceSparseImageFormatProperties2"); + UNIX_CALL_CHECKED(vkGetPhysicalDeviceSparseImageFormatProperties2, ¶ms); } void WINAPI vkGetPhysicalDeviceSparseImageFormatProperties2KHR(VkPhysicalDevice physicalDevice, const VkPhysicalDeviceSparseImageFormatInfo2 *pFormatInfo, uint32_t *pPropertyCount, VkSparseImageFormatProperties2 *pProperties) { struct vkGetPhysicalDeviceSparseImageFormatProperties2KHR_params params; - NTSTATUS status; params.physicalDevice = physicalDevice; params.pFormatInfo = pFormatInfo; params.pPropertyCount = pPropertyCount; params.pProperties = pProperties; - status = UNIX_CALL(vkGetPhysicalDeviceSparseImageFormatProperties2KHR, ¶ms); - assert(!status && "vkGetPhysicalDeviceSparseImageFormatProperties2KHR"); + UNIX_CALL_CHECKED(vkGetPhysicalDeviceSparseImageFormatProperties2KHR, ¶ms); } VkResult WINAPI vkGetPhysicalDeviceSupportedFramebufferMixedSamplesCombinationsNV(VkPhysicalDevice physicalDevice, uint32_t *pCombinationCount, VkFramebufferMixedSamplesCombinationNV *pCombinations) { struct vkGetPhysicalDeviceSupportedFramebufferMixedSamplesCombinationsNV_params params; - NTSTATUS status; params.physicalDevice = physicalDevice; params.pCombinationCount = pCombinationCount; params.pCombinations = pCombinations; - status = UNIX_CALL(vkGetPhysicalDeviceSupportedFramebufferMixedSamplesCombinationsNV, ¶ms); - assert(!status && "vkGetPhysicalDeviceSupportedFramebufferMixedSamplesCombinationsNV"); + UNIX_CALL_CHECKED(vkGetPhysicalDeviceSupportedFramebufferMixedSamplesCombinationsNV, ¶ms); return params.result; } VkResult WINAPI vkGetPhysicalDeviceSurfaceCapabilities2KHR(VkPhysicalDevice physicalDevice, const VkPhysicalDeviceSurfaceInfo2KHR *pSurfaceInfo, VkSurfaceCapabilities2KHR *pSurfaceCapabilities) { struct vkGetPhysicalDeviceSurfaceCapabilities2KHR_params params; - NTSTATUS status; params.physicalDevice = physicalDevice; params.pSurfaceInfo = pSurfaceInfo; params.pSurfaceCapabilities = pSurfaceCapabilities; - status = UNIX_CALL(vkGetPhysicalDeviceSurfaceCapabilities2KHR, ¶ms); - assert(!status && "vkGetPhysicalDeviceSurfaceCapabilities2KHR"); + UNIX_CALL_CHECKED(vkGetPhysicalDeviceSurfaceCapabilities2KHR, ¶ms); return params.result; } VkResult WINAPI vkGetPhysicalDeviceSurfaceCapabilitiesKHR(VkPhysicalDevice physicalDevice, VkSurfaceKHR surface, VkSurfaceCapabilitiesKHR *pSurfaceCapabilities) { struct vkGetPhysicalDeviceSurfaceCapabilitiesKHR_params params; - NTSTATUS status; params.physicalDevice = physicalDevice; params.surface = surface; params.pSurfaceCapabilities = pSurfaceCapabilities; - status = UNIX_CALL(vkGetPhysicalDeviceSurfaceCapabilitiesKHR, ¶ms); - assert(!status && "vkGetPhysicalDeviceSurfaceCapabilitiesKHR"); + UNIX_CALL_CHECKED(vkGetPhysicalDeviceSurfaceCapabilitiesKHR, ¶ms); return params.result; } VkResult WINAPI vkGetPhysicalDeviceSurfaceFormats2KHR(VkPhysicalDevice physicalDevice, const VkPhysicalDeviceSurfaceInfo2KHR *pSurfaceInfo, uint32_t *pSurfaceFormatCount, VkSurfaceFormat2KHR *pSurfaceFormats) { struct vkGetPhysicalDeviceSurfaceFormats2KHR_params params; - NTSTATUS status; params.physicalDevice = physicalDevice; params.pSurfaceInfo = pSurfaceInfo; params.pSurfaceFormatCount = pSurfaceFormatCount; params.pSurfaceFormats = pSurfaceFormats; - status = UNIX_CALL(vkGetPhysicalDeviceSurfaceFormats2KHR, ¶ms); - assert(!status && "vkGetPhysicalDeviceSurfaceFormats2KHR"); + UNIX_CALL_CHECKED(vkGetPhysicalDeviceSurfaceFormats2KHR, ¶ms); return params.result; } VkResult WINAPI vkGetPhysicalDeviceSurfaceFormatsKHR(VkPhysicalDevice physicalDevice, VkSurfaceKHR surface, uint32_t *pSurfaceFormatCount, VkSurfaceFormatKHR *pSurfaceFormats) { struct vkGetPhysicalDeviceSurfaceFormatsKHR_params params; - NTSTATUS status; params.physicalDevice = physicalDevice; params.surface = surface; params.pSurfaceFormatCount = pSurfaceFormatCount; params.pSurfaceFormats = pSurfaceFormats; - status = UNIX_CALL(vkGetPhysicalDeviceSurfaceFormatsKHR, ¶ms); - assert(!status && "vkGetPhysicalDeviceSurfaceFormatsKHR"); + UNIX_CALL_CHECKED(vkGetPhysicalDeviceSurfaceFormatsKHR, ¶ms); return params.result; } VkResult WINAPI vkGetPhysicalDeviceSurfacePresentModesKHR(VkPhysicalDevice physicalDevice, VkSurfaceKHR surface, uint32_t *pPresentModeCount, VkPresentModeKHR *pPresentModes) { struct vkGetPhysicalDeviceSurfacePresentModesKHR_params params; - NTSTATUS status; params.physicalDevice = physicalDevice; params.surface = surface; params.pPresentModeCount = pPresentModeCount; params.pPresentModes = pPresentModes; - status = UNIX_CALL(vkGetPhysicalDeviceSurfacePresentModesKHR, ¶ms); - assert(!status && "vkGetPhysicalDeviceSurfacePresentModesKHR"); + UNIX_CALL_CHECKED(vkGetPhysicalDeviceSurfacePresentModesKHR, ¶ms); return params.result; } VkResult WINAPI vkGetPhysicalDeviceSurfaceSupportKHR(VkPhysicalDevice physicalDevice, uint32_t queueFamilyIndex, VkSurfaceKHR surface, VkBool32 *pSupported) { struct vkGetPhysicalDeviceSurfaceSupportKHR_params params; - NTSTATUS status; params.physicalDevice = physicalDevice; params.queueFamilyIndex = queueFamilyIndex; params.surface = surface; params.pSupported = pSupported; - status = UNIX_CALL(vkGetPhysicalDeviceSurfaceSupportKHR, ¶ms); - assert(!status && "vkGetPhysicalDeviceSurfaceSupportKHR"); + UNIX_CALL_CHECKED(vkGetPhysicalDeviceSurfaceSupportKHR, ¶ms); return params.result; } VkResult WINAPI vkGetPhysicalDeviceToolProperties(VkPhysicalDevice physicalDevice, uint32_t *pToolCount, VkPhysicalDeviceToolProperties *pToolProperties) { struct vkGetPhysicalDeviceToolProperties_params params; - NTSTATUS status; params.physicalDevice = physicalDevice; params.pToolCount = pToolCount; params.pToolProperties = pToolProperties; - status = UNIX_CALL(vkGetPhysicalDeviceToolProperties, ¶ms); - assert(!status && "vkGetPhysicalDeviceToolProperties"); + UNIX_CALL_CHECKED(vkGetPhysicalDeviceToolProperties, ¶ms); return params.result; } VkResult WINAPI vkGetPhysicalDeviceToolPropertiesEXT(VkPhysicalDevice physicalDevice, uint32_t *pToolCount, VkPhysicalDeviceToolProperties *pToolProperties) { struct vkGetPhysicalDeviceToolPropertiesEXT_params params; - NTSTATUS status; params.physicalDevice = physicalDevice; params.pToolCount = pToolCount; params.pToolProperties = pToolProperties; - status = UNIX_CALL(vkGetPhysicalDeviceToolPropertiesEXT, ¶ms); - assert(!status && "vkGetPhysicalDeviceToolPropertiesEXT"); + UNIX_CALL_CHECKED(vkGetPhysicalDeviceToolPropertiesEXT, ¶ms); return params.result; } VkResult WINAPI vkGetPhysicalDeviceVideoCapabilitiesKHR(VkPhysicalDevice physicalDevice, const VkVideoProfileInfoKHR *pVideoProfile, VkVideoCapabilitiesKHR *pCapabilities) { struct vkGetPhysicalDeviceVideoCapabilitiesKHR_params params; - NTSTATUS status; params.physicalDevice = physicalDevice; params.pVideoProfile = pVideoProfile; params.pCapabilities = pCapabilities; - status = UNIX_CALL(vkGetPhysicalDeviceVideoCapabilitiesKHR, ¶ms); - assert(!status && "vkGetPhysicalDeviceVideoCapabilitiesKHR"); + UNIX_CALL_CHECKED(vkGetPhysicalDeviceVideoCapabilitiesKHR, ¶ms); return params.result; } VkResult WINAPI vkGetPhysicalDeviceVideoEncodeQualityLevelPropertiesKHR(VkPhysicalDevice physicalDevice, const VkPhysicalDeviceVideoEncodeQualityLevelInfoKHR *pQualityLevelInfo, VkVideoEncodeQualityLevelPropertiesKHR *pQualityLevelProperties) { struct vkGetPhysicalDeviceVideoEncodeQualityLevelPropertiesKHR_params params; - NTSTATUS status; params.physicalDevice = physicalDevice; params.pQualityLevelInfo = pQualityLevelInfo; params.pQualityLevelProperties = pQualityLevelProperties; - status = UNIX_CALL(vkGetPhysicalDeviceVideoEncodeQualityLevelPropertiesKHR, ¶ms); - assert(!status && "vkGetPhysicalDeviceVideoEncodeQualityLevelPropertiesKHR"); + UNIX_CALL_CHECKED(vkGetPhysicalDeviceVideoEncodeQualityLevelPropertiesKHR, ¶ms); return params.result; } VkResult WINAPI vkGetPhysicalDeviceVideoFormatPropertiesKHR(VkPhysicalDevice physicalDevice, const VkPhysicalDeviceVideoFormatInfoKHR *pVideoFormatInfo, uint32_t *pVideoFormatPropertyCount, VkVideoFormatPropertiesKHR *pVideoFormatProperties) { struct vkGetPhysicalDeviceVideoFormatPropertiesKHR_params params; - NTSTATUS status; params.physicalDevice = physicalDevice; params.pVideoFormatInfo = pVideoFormatInfo; params.pVideoFormatPropertyCount = pVideoFormatPropertyCount; params.pVideoFormatProperties = pVideoFormatProperties; - status = UNIX_CALL(vkGetPhysicalDeviceVideoFormatPropertiesKHR, ¶ms); - assert(!status && "vkGetPhysicalDeviceVideoFormatPropertiesKHR"); + UNIX_CALL_CHECKED(vkGetPhysicalDeviceVideoFormatPropertiesKHR, ¶ms); return params.result; } VkBool32 WINAPI vkGetPhysicalDeviceWin32PresentationSupportKHR(VkPhysicalDevice physicalDevice, uint32_t queueFamilyIndex) { struct vkGetPhysicalDeviceWin32PresentationSupportKHR_params params; - NTSTATUS status; params.physicalDevice = physicalDevice; params.queueFamilyIndex = queueFamilyIndex; - status = UNIX_CALL(vkGetPhysicalDeviceWin32PresentationSupportKHR, ¶ms); - assert(!status && "vkGetPhysicalDeviceWin32PresentationSupportKHR"); + UNIX_CALL_CHECKED(vkGetPhysicalDeviceWin32PresentationSupportKHR, ¶ms); return params.result; } VkResult WINAPI vkGetPipelineBinaryDataKHR(VkDevice device, const VkPipelineBinaryDataInfoKHR *pInfo, VkPipelineBinaryKeyKHR *pPipelineBinaryKey, size_t *pPipelineBinaryDataSize, void *pPipelineBinaryData) { struct vkGetPipelineBinaryDataKHR_params params; - NTSTATUS status; params.device = device; params.pInfo = pInfo; params.pPipelineBinaryKey = pPipelineBinaryKey; params.pPipelineBinaryDataSize = pPipelineBinaryDataSize; params.pPipelineBinaryData = pPipelineBinaryData; - status = UNIX_CALL(vkGetPipelineBinaryDataKHR, ¶ms); - assert(!status && "vkGetPipelineBinaryDataKHR"); + UNIX_CALL_CHECKED(vkGetPipelineBinaryDataKHR, ¶ms); return params.result; } VkResult WINAPI vkGetPipelineCacheData(VkDevice device, VkPipelineCache pipelineCache, size_t *pDataSize, void *pData) { struct vkGetPipelineCacheData_params params; - NTSTATUS status; params.device = device; params.pipelineCache = pipelineCache; params.pDataSize = pDataSize; params.pData = pData; - status = UNIX_CALL(vkGetPipelineCacheData, ¶ms); - assert(!status && "vkGetPipelineCacheData"); + UNIX_CALL_CHECKED(vkGetPipelineCacheData, ¶ms); return params.result; } VkResult WINAPI vkGetPipelineExecutableInternalRepresentationsKHR(VkDevice device, const VkPipelineExecutableInfoKHR *pExecutableInfo, uint32_t *pInternalRepresentationCount, VkPipelineExecutableInternalRepresentationKHR *pInternalRepresentations) { struct vkGetPipelineExecutableInternalRepresentationsKHR_params params; - NTSTATUS status; params.device = device; params.pExecutableInfo = pExecutableInfo; params.pInternalRepresentationCount = pInternalRepresentationCount; params.pInternalRepresentations = pInternalRepresentations; - status = UNIX_CALL(vkGetPipelineExecutableInternalRepresentationsKHR, ¶ms); - assert(!status && "vkGetPipelineExecutableInternalRepresentationsKHR"); + UNIX_CALL_CHECKED(vkGetPipelineExecutableInternalRepresentationsKHR, ¶ms); return params.result; } VkResult WINAPI vkGetPipelineExecutablePropertiesKHR(VkDevice device, const VkPipelineInfoKHR *pPipelineInfo, uint32_t *pExecutableCount, VkPipelineExecutablePropertiesKHR *pProperties) { struct vkGetPipelineExecutablePropertiesKHR_params params; - NTSTATUS status; params.device = device; params.pPipelineInfo = pPipelineInfo; params.pExecutableCount = pExecutableCount; params.pProperties = pProperties; - status = UNIX_CALL(vkGetPipelineExecutablePropertiesKHR, ¶ms); - assert(!status && "vkGetPipelineExecutablePropertiesKHR"); + UNIX_CALL_CHECKED(vkGetPipelineExecutablePropertiesKHR, ¶ms); return params.result; } VkResult WINAPI vkGetPipelineExecutableStatisticsKHR(VkDevice device, const VkPipelineExecutableInfoKHR *pExecutableInfo, uint32_t *pStatisticCount, VkPipelineExecutableStatisticKHR *pStatistics) { struct vkGetPipelineExecutableStatisticsKHR_params params; - NTSTATUS status; params.device = device; params.pExecutableInfo = pExecutableInfo; params.pStatisticCount = pStatisticCount; params.pStatistics = pStatistics; - status = UNIX_CALL(vkGetPipelineExecutableStatisticsKHR, ¶ms); - assert(!status && "vkGetPipelineExecutableStatisticsKHR"); + UNIX_CALL_CHECKED(vkGetPipelineExecutableStatisticsKHR, ¶ms); return params.result; } VkDeviceAddress WINAPI vkGetPipelineIndirectDeviceAddressNV(VkDevice device, const VkPipelineIndirectDeviceAddressInfoNV *pInfo) { struct vkGetPipelineIndirectDeviceAddressNV_params params; - NTSTATUS status; params.device = device; params.pInfo = pInfo; - status = UNIX_CALL(vkGetPipelineIndirectDeviceAddressNV, ¶ms); - assert(!status && "vkGetPipelineIndirectDeviceAddressNV"); + UNIX_CALL_CHECKED(vkGetPipelineIndirectDeviceAddressNV, ¶ms); return params.result; } void WINAPI vkGetPipelineIndirectMemoryRequirementsNV(VkDevice device, const VkComputePipelineCreateInfo *pCreateInfo, VkMemoryRequirements2 *pMemoryRequirements) { struct vkGetPipelineIndirectMemoryRequirementsNV_params params; - NTSTATUS status; params.device = device; params.pCreateInfo = pCreateInfo; params.pMemoryRequirements = pMemoryRequirements; - status = UNIX_CALL(vkGetPipelineIndirectMemoryRequirementsNV, ¶ms); - assert(!status && "vkGetPipelineIndirectMemoryRequirementsNV"); + UNIX_CALL_CHECKED(vkGetPipelineIndirectMemoryRequirementsNV, ¶ms); } VkResult WINAPI vkGetPipelineKeyKHR(VkDevice device, const VkPipelineCreateInfoKHR *pPipelineCreateInfo, VkPipelineBinaryKeyKHR *pPipelineKey) { struct vkGetPipelineKeyKHR_params params; - NTSTATUS status; params.device = device; params.pPipelineCreateInfo = pPipelineCreateInfo; params.pPipelineKey = pPipelineKey; - status = UNIX_CALL(vkGetPipelineKeyKHR, ¶ms); - assert(!status && "vkGetPipelineKeyKHR"); + UNIX_CALL_CHECKED(vkGetPipelineKeyKHR, ¶ms); return params.result; } VkResult WINAPI vkGetPipelinePropertiesEXT(VkDevice device, const VkPipelineInfoKHR *pPipelineInfo, VkBaseOutStructure *pPipelineProperties) { struct vkGetPipelinePropertiesEXT_params params; - NTSTATUS status; params.device = device; params.pPipelineInfo = pPipelineInfo; params.pPipelineProperties = pPipelineProperties; - status = UNIX_CALL(vkGetPipelinePropertiesEXT, ¶ms); - assert(!status && "vkGetPipelinePropertiesEXT"); + UNIX_CALL_CHECKED(vkGetPipelinePropertiesEXT, ¶ms); return params.result; } void WINAPI vkGetPrivateData(VkDevice device, VkObjectType objectType, uint64_t objectHandle, VkPrivateDataSlot privateDataSlot, uint64_t *pData) { struct vkGetPrivateData_params params; - NTSTATUS status; params.device = device; params.objectType = objectType; params.objectHandle = objectHandle; params.privateDataSlot = privateDataSlot; params.pData = pData; - status = UNIX_CALL(vkGetPrivateData, ¶ms); - assert(!status && "vkGetPrivateData"); + UNIX_CALL_CHECKED(vkGetPrivateData, ¶ms); } void WINAPI vkGetPrivateDataEXT(VkDevice device, VkObjectType objectType, uint64_t objectHandle, VkPrivateDataSlot privateDataSlot, uint64_t *pData) { struct vkGetPrivateDataEXT_params params; - NTSTATUS status; params.device = device; params.objectType = objectType; params.objectHandle = objectHandle; params.privateDataSlot = privateDataSlot; params.pData = pData; - status = UNIX_CALL(vkGetPrivateDataEXT, ¶ms); - assert(!status && "vkGetPrivateDataEXT"); + UNIX_CALL_CHECKED(vkGetPrivateDataEXT, ¶ms); } VkResult WINAPI vkGetQueryPoolResults(VkDevice device, VkQueryPool queryPool, uint32_t firstQuery, uint32_t queryCount, size_t dataSize, void *pData, VkDeviceSize stride, VkQueryResultFlags flags) { struct vkGetQueryPoolResults_params params; - NTSTATUS status; params.device = device; params.queryPool = queryPool; params.firstQuery = firstQuery; @@ -6660,1024 +6027,851 @@ VkResult WINAPI vkGetQueryPoolResults(VkDevice device, VkQueryPool queryPool, ui params.pData = pData; params.stride = stride; params.flags = flags; - status = UNIX_CALL(vkGetQueryPoolResults, ¶ms); - assert(!status && "vkGetQueryPoolResults"); + UNIX_CALL_CHECKED(vkGetQueryPoolResults, ¶ms); return params.result; } void WINAPI vkGetQueueCheckpointData2NV(VkQueue queue, uint32_t *pCheckpointDataCount, VkCheckpointData2NV *pCheckpointData) { struct vkGetQueueCheckpointData2NV_params params; - NTSTATUS status; params.queue = queue; params.pCheckpointDataCount = pCheckpointDataCount; params.pCheckpointData = pCheckpointData; - status = UNIX_CALL(vkGetQueueCheckpointData2NV, ¶ms); - assert(!status && "vkGetQueueCheckpointData2NV"); + UNIX_CALL_CHECKED(vkGetQueueCheckpointData2NV, ¶ms); } void WINAPI vkGetQueueCheckpointDataNV(VkQueue queue, uint32_t *pCheckpointDataCount, VkCheckpointDataNV *pCheckpointData) { struct vkGetQueueCheckpointDataNV_params params; - NTSTATUS status; params.queue = queue; params.pCheckpointDataCount = pCheckpointDataCount; params.pCheckpointData = pCheckpointData; - status = UNIX_CALL(vkGetQueueCheckpointDataNV, ¶ms); - assert(!status && "vkGetQueueCheckpointDataNV"); + UNIX_CALL_CHECKED(vkGetQueueCheckpointDataNV, ¶ms); } VkResult WINAPI vkGetRayTracingCaptureReplayShaderGroupHandlesKHR(VkDevice device, VkPipeline pipeline, uint32_t firstGroup, uint32_t groupCount, size_t dataSize, void *pData) { struct vkGetRayTracingCaptureReplayShaderGroupHandlesKHR_params params; - NTSTATUS status; params.device = device; params.pipeline = pipeline; params.firstGroup = firstGroup; params.groupCount = groupCount; params.dataSize = dataSize; params.pData = pData; - status = UNIX_CALL(vkGetRayTracingCaptureReplayShaderGroupHandlesKHR, ¶ms); - assert(!status && "vkGetRayTracingCaptureReplayShaderGroupHandlesKHR"); + UNIX_CALL_CHECKED(vkGetRayTracingCaptureReplayShaderGroupHandlesKHR, ¶ms); return params.result; } VkResult WINAPI vkGetRayTracingShaderGroupHandlesKHR(VkDevice device, VkPipeline pipeline, uint32_t firstGroup, uint32_t groupCount, size_t dataSize, void *pData) { struct vkGetRayTracingShaderGroupHandlesKHR_params params; - NTSTATUS status; params.device = device; params.pipeline = pipeline; params.firstGroup = firstGroup; params.groupCount = groupCount; params.dataSize = dataSize; params.pData = pData; - status = UNIX_CALL(vkGetRayTracingShaderGroupHandlesKHR, ¶ms); - assert(!status && "vkGetRayTracingShaderGroupHandlesKHR"); + UNIX_CALL_CHECKED(vkGetRayTracingShaderGroupHandlesKHR, ¶ms); return params.result; } VkResult WINAPI vkGetRayTracingShaderGroupHandlesNV(VkDevice device, VkPipeline pipeline, uint32_t firstGroup, uint32_t groupCount, size_t dataSize, void *pData) { struct vkGetRayTracingShaderGroupHandlesNV_params params; - NTSTATUS status; params.device = device; params.pipeline = pipeline; params.firstGroup = firstGroup; params.groupCount = groupCount; params.dataSize = dataSize; params.pData = pData; - status = UNIX_CALL(vkGetRayTracingShaderGroupHandlesNV, ¶ms); - assert(!status && "vkGetRayTracingShaderGroupHandlesNV"); + UNIX_CALL_CHECKED(vkGetRayTracingShaderGroupHandlesNV, ¶ms); return params.result; } VkDeviceSize WINAPI vkGetRayTracingShaderGroupStackSizeKHR(VkDevice device, VkPipeline pipeline, uint32_t group, VkShaderGroupShaderKHR groupShader) { struct vkGetRayTracingShaderGroupStackSizeKHR_params params; - NTSTATUS status; params.device = device; params.pipeline = pipeline; params.group = group; params.groupShader = groupShader; - status = UNIX_CALL(vkGetRayTracingShaderGroupStackSizeKHR, ¶ms); - assert(!status && "vkGetRayTracingShaderGroupStackSizeKHR"); + UNIX_CALL_CHECKED(vkGetRayTracingShaderGroupStackSizeKHR, ¶ms); return params.result; } void WINAPI vkGetRenderAreaGranularity(VkDevice device, VkRenderPass renderPass, VkExtent2D *pGranularity) { struct vkGetRenderAreaGranularity_params params; - NTSTATUS status; params.device = device; params.renderPass = renderPass; params.pGranularity = pGranularity; - status = UNIX_CALL(vkGetRenderAreaGranularity, ¶ms); - assert(!status && "vkGetRenderAreaGranularity"); + UNIX_CALL_CHECKED(vkGetRenderAreaGranularity, ¶ms); } void WINAPI vkGetRenderingAreaGranularity(VkDevice device, const VkRenderingAreaInfo *pRenderingAreaInfo, VkExtent2D *pGranularity) { struct vkGetRenderingAreaGranularity_params params; - NTSTATUS status; params.device = device; params.pRenderingAreaInfo = pRenderingAreaInfo; params.pGranularity = pGranularity; - status = UNIX_CALL(vkGetRenderingAreaGranularity, ¶ms); - assert(!status && "vkGetRenderingAreaGranularity"); + UNIX_CALL_CHECKED(vkGetRenderingAreaGranularity, ¶ms); } void WINAPI vkGetRenderingAreaGranularityKHR(VkDevice device, const VkRenderingAreaInfo *pRenderingAreaInfo, VkExtent2D *pGranularity) { struct vkGetRenderingAreaGranularityKHR_params params; - NTSTATUS status; params.device = device; params.pRenderingAreaInfo = pRenderingAreaInfo; params.pGranularity = pGranularity; - status = UNIX_CALL(vkGetRenderingAreaGranularityKHR, ¶ms); - assert(!status && "vkGetRenderingAreaGranularityKHR"); + UNIX_CALL_CHECKED(vkGetRenderingAreaGranularityKHR, ¶ms); } VkResult WINAPI vkGetSamplerOpaqueCaptureDescriptorDataEXT(VkDevice device, const VkSamplerCaptureDescriptorDataInfoEXT *pInfo, void *pData) { struct vkGetSamplerOpaqueCaptureDescriptorDataEXT_params params; - NTSTATUS status; params.device = device; params.pInfo = pInfo; params.pData = pData; - status = UNIX_CALL(vkGetSamplerOpaqueCaptureDescriptorDataEXT, ¶ms); - assert(!status && "vkGetSamplerOpaqueCaptureDescriptorDataEXT"); + UNIX_CALL_CHECKED(vkGetSamplerOpaqueCaptureDescriptorDataEXT, ¶ms); return params.result; } VkResult WINAPI vkGetSemaphoreCounterValue(VkDevice device, VkSemaphore semaphore, uint64_t *pValue) { struct vkGetSemaphoreCounterValue_params params; - NTSTATUS status; params.device = device; params.semaphore = semaphore; params.pValue = pValue; - status = UNIX_CALL(vkGetSemaphoreCounterValue, ¶ms); - assert(!status && "vkGetSemaphoreCounterValue"); + UNIX_CALL_CHECKED(vkGetSemaphoreCounterValue, ¶ms); return params.result; } VkResult WINAPI vkGetSemaphoreCounterValueKHR(VkDevice device, VkSemaphore semaphore, uint64_t *pValue) { struct vkGetSemaphoreCounterValueKHR_params params; - NTSTATUS status; params.device = device; params.semaphore = semaphore; params.pValue = pValue; - status = UNIX_CALL(vkGetSemaphoreCounterValueKHR, ¶ms); - assert(!status && "vkGetSemaphoreCounterValueKHR"); + UNIX_CALL_CHECKED(vkGetSemaphoreCounterValueKHR, ¶ms); return params.result; } VkResult WINAPI vkGetSemaphoreWin32HandleKHR(VkDevice device, const VkSemaphoreGetWin32HandleInfoKHR *pGetWin32HandleInfo, HANDLE *pHandle) { struct vkGetSemaphoreWin32HandleKHR_params params; - NTSTATUS status; params.device = device; params.pGetWin32HandleInfo = pGetWin32HandleInfo; params.pHandle = pHandle; - status = UNIX_CALL(vkGetSemaphoreWin32HandleKHR, ¶ms); - assert(!status && "vkGetSemaphoreWin32HandleKHR"); + UNIX_CALL_CHECKED(vkGetSemaphoreWin32HandleKHR, ¶ms); return params.result; } VkResult WINAPI vkGetShaderBinaryDataEXT(VkDevice device, VkShaderEXT shader, size_t *pDataSize, void *pData) { struct vkGetShaderBinaryDataEXT_params params; - NTSTATUS status; params.device = device; params.shader = shader; params.pDataSize = pDataSize; params.pData = pData; - status = UNIX_CALL(vkGetShaderBinaryDataEXT, ¶ms); - assert(!status && "vkGetShaderBinaryDataEXT"); + UNIX_CALL_CHECKED(vkGetShaderBinaryDataEXT, ¶ms); return params.result; } VkResult WINAPI vkGetShaderInfoAMD(VkDevice device, VkPipeline pipeline, VkShaderStageFlagBits shaderStage, VkShaderInfoTypeAMD infoType, size_t *pInfoSize, void *pInfo) { struct vkGetShaderInfoAMD_params params; - NTSTATUS status; params.device = device; params.pipeline = pipeline; params.shaderStage = shaderStage; params.infoType = infoType; params.pInfoSize = pInfoSize; params.pInfo = pInfo; - status = UNIX_CALL(vkGetShaderInfoAMD, ¶ms); - assert(!status && "vkGetShaderInfoAMD"); + UNIX_CALL_CHECKED(vkGetShaderInfoAMD, ¶ms); return params.result; } VkResult WINAPI vkGetShaderInstrumentationValuesARM(VkDevice device, VkShaderInstrumentationARM instrumentation, uint32_t *pMetricBlockCount, void *pMetricValues, VkShaderInstrumentationValuesFlagsARM flags) { struct vkGetShaderInstrumentationValuesARM_params params; - NTSTATUS status; params.device = device; params.instrumentation = instrumentation; params.pMetricBlockCount = pMetricBlockCount; params.pMetricValues = pMetricValues; params.flags = flags; - status = UNIX_CALL(vkGetShaderInstrumentationValuesARM, ¶ms); - assert(!status && "vkGetShaderInstrumentationValuesARM"); + UNIX_CALL_CHECKED(vkGetShaderInstrumentationValuesARM, ¶ms); return params.result; } void WINAPI vkGetShaderModuleCreateInfoIdentifierEXT(VkDevice device, const VkShaderModuleCreateInfo *pCreateInfo, VkShaderModuleIdentifierEXT *pIdentifier) { struct vkGetShaderModuleCreateInfoIdentifierEXT_params params; - NTSTATUS status; params.device = device; params.pCreateInfo = pCreateInfo; params.pIdentifier = pIdentifier; - status = UNIX_CALL(vkGetShaderModuleCreateInfoIdentifierEXT, ¶ms); - assert(!status && "vkGetShaderModuleCreateInfoIdentifierEXT"); + UNIX_CALL_CHECKED(vkGetShaderModuleCreateInfoIdentifierEXT, ¶ms); } void WINAPI vkGetShaderModuleIdentifierEXT(VkDevice device, VkShaderModule shaderModule, VkShaderModuleIdentifierEXT *pIdentifier) { struct vkGetShaderModuleIdentifierEXT_params params; - NTSTATUS status; params.device = device; params.shaderModule = shaderModule; params.pIdentifier = pIdentifier; - status = UNIX_CALL(vkGetShaderModuleIdentifierEXT, ¶ms); - assert(!status && "vkGetShaderModuleIdentifierEXT"); + UNIX_CALL_CHECKED(vkGetShaderModuleIdentifierEXT, ¶ms); } VkResult WINAPI vkGetSwapchainImagesKHR(VkDevice device, VkSwapchainKHR swapchain, uint32_t *pSwapchainImageCount, VkImage *pSwapchainImages) { struct vkGetSwapchainImagesKHR_params params; - NTSTATUS status; params.device = device; params.swapchain = swapchain; params.pSwapchainImageCount = pSwapchainImageCount; params.pSwapchainImages = pSwapchainImages; - status = UNIX_CALL(vkGetSwapchainImagesKHR, ¶ms); - assert(!status && "vkGetSwapchainImagesKHR"); + UNIX_CALL_CHECKED(vkGetSwapchainImagesKHR, ¶ms); return params.result; } VkResult WINAPI vkGetSwapchainTimeDomainPropertiesEXT(VkDevice device, VkSwapchainKHR swapchain, VkSwapchainTimeDomainPropertiesEXT *pSwapchainTimeDomainProperties, uint64_t *pTimeDomainsCounter) { struct vkGetSwapchainTimeDomainPropertiesEXT_params params; - NTSTATUS status; params.device = device; params.swapchain = swapchain; params.pSwapchainTimeDomainProperties = pSwapchainTimeDomainProperties; params.pTimeDomainsCounter = pTimeDomainsCounter; - status = UNIX_CALL(vkGetSwapchainTimeDomainPropertiesEXT, ¶ms); - assert(!status && "vkGetSwapchainTimeDomainPropertiesEXT"); + UNIX_CALL_CHECKED(vkGetSwapchainTimeDomainPropertiesEXT, ¶ms); return params.result; } VkResult WINAPI vkGetSwapchainTimingPropertiesEXT(VkDevice device, VkSwapchainKHR swapchain, VkSwapchainTimingPropertiesEXT *pSwapchainTimingProperties, uint64_t *pSwapchainTimingPropertiesCounter) { struct vkGetSwapchainTimingPropertiesEXT_params params; - NTSTATUS status; params.device = device; params.swapchain = swapchain; params.pSwapchainTimingProperties = pSwapchainTimingProperties; params.pSwapchainTimingPropertiesCounter = pSwapchainTimingPropertiesCounter; - status = UNIX_CALL(vkGetSwapchainTimingPropertiesEXT, ¶ms); - assert(!status && "vkGetSwapchainTimingPropertiesEXT"); + UNIX_CALL_CHECKED(vkGetSwapchainTimingPropertiesEXT, ¶ms); return params.result; } void WINAPI vkGetTensorMemoryRequirementsARM(VkDevice device, const VkTensorMemoryRequirementsInfoARM *pInfo, VkMemoryRequirements2 *pMemoryRequirements) { struct vkGetTensorMemoryRequirementsARM_params params; - NTSTATUS status; params.device = device; params.pInfo = pInfo; params.pMemoryRequirements = pMemoryRequirements; - status = UNIX_CALL(vkGetTensorMemoryRequirementsARM, ¶ms); - assert(!status && "vkGetTensorMemoryRequirementsARM"); + UNIX_CALL_CHECKED(vkGetTensorMemoryRequirementsARM, ¶ms); } VkResult WINAPI vkGetTensorOpaqueCaptureDataARM(VkDevice device, uint32_t tensorCount, const VkTensorARM *pTensors, VkHostAddressRangeEXT *pDatas) { struct vkGetTensorOpaqueCaptureDataARM_params params; - NTSTATUS status; params.device = device; params.tensorCount = tensorCount; params.pTensors = pTensors; params.pDatas = pDatas; - status = UNIX_CALL(vkGetTensorOpaqueCaptureDataARM, ¶ms); - assert(!status && "vkGetTensorOpaqueCaptureDataARM"); + UNIX_CALL_CHECKED(vkGetTensorOpaqueCaptureDataARM, ¶ms); return params.result; } VkResult WINAPI vkGetTensorOpaqueCaptureDescriptorDataARM(VkDevice device, const VkTensorCaptureDescriptorDataInfoARM *pInfo, void *pData) { struct vkGetTensorOpaqueCaptureDescriptorDataARM_params params; - NTSTATUS status; params.device = device; params.pInfo = pInfo; params.pData = pData; - status = UNIX_CALL(vkGetTensorOpaqueCaptureDescriptorDataARM, ¶ms); - assert(!status && "vkGetTensorOpaqueCaptureDescriptorDataARM"); + UNIX_CALL_CHECKED(vkGetTensorOpaqueCaptureDescriptorDataARM, ¶ms); return params.result; } VkResult WINAPI vkGetTensorViewOpaqueCaptureDescriptorDataARM(VkDevice device, const VkTensorViewCaptureDescriptorDataInfoARM *pInfo, void *pData) { struct vkGetTensorViewOpaqueCaptureDescriptorDataARM_params params; - NTSTATUS status; params.device = device; params.pInfo = pInfo; params.pData = pData; - status = UNIX_CALL(vkGetTensorViewOpaqueCaptureDescriptorDataARM, ¶ms); - assert(!status && "vkGetTensorViewOpaqueCaptureDescriptorDataARM"); + UNIX_CALL_CHECKED(vkGetTensorViewOpaqueCaptureDescriptorDataARM, ¶ms); return params.result; } VkResult WINAPI vkGetValidationCacheDataEXT(VkDevice device, VkValidationCacheEXT validationCache, size_t *pDataSize, void *pData) { struct vkGetValidationCacheDataEXT_params params; - NTSTATUS status; params.device = device; params.validationCache = validationCache; params.pDataSize = pDataSize; params.pData = pData; - status = UNIX_CALL(vkGetValidationCacheDataEXT, ¶ms); - assert(!status && "vkGetValidationCacheDataEXT"); + UNIX_CALL_CHECKED(vkGetValidationCacheDataEXT, ¶ms); return params.result; } VkResult WINAPI vkGetVideoSessionMemoryRequirementsKHR(VkDevice device, VkVideoSessionKHR videoSession, uint32_t *pMemoryRequirementsCount, VkVideoSessionMemoryRequirementsKHR *pMemoryRequirements) { struct vkGetVideoSessionMemoryRequirementsKHR_params params; - NTSTATUS status; params.device = device; params.videoSession = videoSession; params.pMemoryRequirementsCount = pMemoryRequirementsCount; params.pMemoryRequirements = pMemoryRequirements; - status = UNIX_CALL(vkGetVideoSessionMemoryRequirementsKHR, ¶ms); - assert(!status && "vkGetVideoSessionMemoryRequirementsKHR"); + UNIX_CALL_CHECKED(vkGetVideoSessionMemoryRequirementsKHR, ¶ms); return params.result; } VkResult WINAPI vkImportFenceWin32HandleKHR(VkDevice device, const VkImportFenceWin32HandleInfoKHR *pImportFenceWin32HandleInfo) { struct vkImportFenceWin32HandleKHR_params params; - NTSTATUS status; params.device = device; params.pImportFenceWin32HandleInfo = pImportFenceWin32HandleInfo; - status = UNIX_CALL(vkImportFenceWin32HandleKHR, ¶ms); - assert(!status && "vkImportFenceWin32HandleKHR"); + UNIX_CALL_CHECKED(vkImportFenceWin32HandleKHR, ¶ms); return params.result; } VkResult WINAPI vkImportSemaphoreWin32HandleKHR(VkDevice device, const VkImportSemaphoreWin32HandleInfoKHR *pImportSemaphoreWin32HandleInfo) { struct vkImportSemaphoreWin32HandleKHR_params params; - NTSTATUS status; params.device = device; params.pImportSemaphoreWin32HandleInfo = pImportSemaphoreWin32HandleInfo; - status = UNIX_CALL(vkImportSemaphoreWin32HandleKHR, ¶ms); - assert(!status && "vkImportSemaphoreWin32HandleKHR"); + UNIX_CALL_CHECKED(vkImportSemaphoreWin32HandleKHR, ¶ms); return params.result; } VkResult WINAPI vkInitializePerformanceApiINTEL(VkDevice device, const VkInitializePerformanceApiInfoINTEL *pInitializeInfo) { struct vkInitializePerformanceApiINTEL_params params; - NTSTATUS status; params.device = device; params.pInitializeInfo = pInitializeInfo; - status = UNIX_CALL(vkInitializePerformanceApiINTEL, ¶ms); - assert(!status && "vkInitializePerformanceApiINTEL"); + UNIX_CALL_CHECKED(vkInitializePerformanceApiINTEL, ¶ms); return params.result; } VkResult WINAPI vkInvalidateMappedMemoryRanges(VkDevice device, uint32_t memoryRangeCount, const VkMappedMemoryRange *pMemoryRanges) { struct vkInvalidateMappedMemoryRanges_params params; - NTSTATUS status; params.device = device; params.memoryRangeCount = memoryRangeCount; params.pMemoryRanges = pMemoryRanges; - status = UNIX_CALL(vkInvalidateMappedMemoryRanges, ¶ms); - assert(!status && "vkInvalidateMappedMemoryRanges"); + UNIX_CALL_CHECKED(vkInvalidateMappedMemoryRanges, ¶ms); return params.result; } VkResult WINAPI vkLatencySleepNV(VkDevice device, VkSwapchainKHR swapchain, const VkLatencySleepInfoNV *pSleepInfo) { struct vkLatencySleepNV_params params; - NTSTATUS status; params.device = device; params.swapchain = swapchain; params.pSleepInfo = pSleepInfo; - status = UNIX_CALL(vkLatencySleepNV, ¶ms); - assert(!status && "vkLatencySleepNV"); + UNIX_CALL_CHECKED(vkLatencySleepNV, ¶ms); return params.result; } VkResult WINAPI vkMapMemory(VkDevice device, VkDeviceMemory memory, VkDeviceSize offset, VkDeviceSize size, VkMemoryMapFlags flags, void **ppData) { struct vkMapMemory_params params; - NTSTATUS status; params.device = device; params.memory = memory; params.offset = offset; params.size = size; params.flags = flags; params.ppData = ppData; - status = UNIX_CALL(vkMapMemory, ¶ms); - assert(!status && "vkMapMemory"); + UNIX_CALL_CHECKED(vkMapMemory, ¶ms); return params.result; } VkResult WINAPI vkMapMemory2(VkDevice device, const VkMemoryMapInfo *pMemoryMapInfo, void **ppData) { struct vkMapMemory2_params params; - NTSTATUS status; params.device = device; params.pMemoryMapInfo = pMemoryMapInfo; params.ppData = ppData; - status = UNIX_CALL(vkMapMemory2, ¶ms); - assert(!status && "vkMapMemory2"); + UNIX_CALL_CHECKED(vkMapMemory2, ¶ms); return params.result; } VkResult WINAPI vkMapMemory2KHR(VkDevice device, const VkMemoryMapInfo *pMemoryMapInfo, void **ppData) { struct vkMapMemory2KHR_params params; - NTSTATUS status; params.device = device; params.pMemoryMapInfo = pMemoryMapInfo; params.ppData = ppData; - status = UNIX_CALL(vkMapMemory2KHR, ¶ms); - assert(!status && "vkMapMemory2KHR"); + UNIX_CALL_CHECKED(vkMapMemory2KHR, ¶ms); return params.result; } VkResult WINAPI vkMergePipelineCaches(VkDevice device, VkPipelineCache dstCache, uint32_t srcCacheCount, const VkPipelineCache *pSrcCaches) { struct vkMergePipelineCaches_params params; - NTSTATUS status; params.device = device; params.dstCache = dstCache; params.srcCacheCount = srcCacheCount; params.pSrcCaches = pSrcCaches; - status = UNIX_CALL(vkMergePipelineCaches, ¶ms); - assert(!status && "vkMergePipelineCaches"); + UNIX_CALL_CHECKED(vkMergePipelineCaches, ¶ms); return params.result; } VkResult WINAPI vkMergeValidationCachesEXT(VkDevice device, VkValidationCacheEXT dstCache, uint32_t srcCacheCount, const VkValidationCacheEXT *pSrcCaches) { struct vkMergeValidationCachesEXT_params params; - NTSTATUS status; params.device = device; params.dstCache = dstCache; params.srcCacheCount = srcCacheCount; params.pSrcCaches = pSrcCaches; - status = UNIX_CALL(vkMergeValidationCachesEXT, ¶ms); - assert(!status && "vkMergeValidationCachesEXT"); + UNIX_CALL_CHECKED(vkMergeValidationCachesEXT, ¶ms); return params.result; } void WINAPI vkQueueBeginDebugUtilsLabelEXT(VkQueue queue, const VkDebugUtilsLabelEXT *pLabelInfo) { struct vkQueueBeginDebugUtilsLabelEXT_params params; - NTSTATUS status; params.queue = queue; params.pLabelInfo = pLabelInfo; - status = UNIX_CALL(vkQueueBeginDebugUtilsLabelEXT, ¶ms); - assert(!status && "vkQueueBeginDebugUtilsLabelEXT"); + UNIX_CALL_CHECKED(vkQueueBeginDebugUtilsLabelEXT, ¶ms); } VkResult WINAPI vkQueueBindSparse(VkQueue queue, uint32_t bindInfoCount, const VkBindSparseInfo *pBindInfo, VkFence fence) { struct vkQueueBindSparse_params params; - NTSTATUS status; params.queue = queue; params.bindInfoCount = bindInfoCount; params.pBindInfo = pBindInfo; params.fence = fence; - status = UNIX_CALL(vkQueueBindSparse, ¶ms); - assert(!status && "vkQueueBindSparse"); + UNIX_CALL_CHECKED(vkQueueBindSparse, ¶ms); return params.result; } void WINAPI vkQueueEndDebugUtilsLabelEXT(VkQueue queue) { struct vkQueueEndDebugUtilsLabelEXT_params params; - NTSTATUS status; params.queue = queue; - status = UNIX_CALL(vkQueueEndDebugUtilsLabelEXT, ¶ms); - assert(!status && "vkQueueEndDebugUtilsLabelEXT"); + UNIX_CALL_CHECKED(vkQueueEndDebugUtilsLabelEXT, ¶ms); } void WINAPI vkQueueInsertDebugUtilsLabelEXT(VkQueue queue, const VkDebugUtilsLabelEXT *pLabelInfo) { struct vkQueueInsertDebugUtilsLabelEXT_params params; - NTSTATUS status; params.queue = queue; params.pLabelInfo = pLabelInfo; - status = UNIX_CALL(vkQueueInsertDebugUtilsLabelEXT, ¶ms); - assert(!status && "vkQueueInsertDebugUtilsLabelEXT"); + UNIX_CALL_CHECKED(vkQueueInsertDebugUtilsLabelEXT, ¶ms); } void WINAPI vkQueueNotifyOutOfBandNV(VkQueue queue, const VkOutOfBandQueueTypeInfoNV *pQueueTypeInfo) { struct vkQueueNotifyOutOfBandNV_params params; - NTSTATUS status; params.queue = queue; params.pQueueTypeInfo = pQueueTypeInfo; - status = UNIX_CALL(vkQueueNotifyOutOfBandNV, ¶ms); - assert(!status && "vkQueueNotifyOutOfBandNV"); + UNIX_CALL_CHECKED(vkQueueNotifyOutOfBandNV, ¶ms); } VkResult WINAPI vkQueuePresentKHR(VkQueue queue, const VkPresentInfoKHR *pPresentInfo) { struct vkQueuePresentKHR_params params; - NTSTATUS status; params.queue = queue; params.pPresentInfo = pPresentInfo; - status = UNIX_CALL(vkQueuePresentKHR, ¶ms); - assert(!status && "vkQueuePresentKHR"); + UNIX_CALL_CHECKED(vkQueuePresentKHR, ¶ms); return params.result; } VkResult WINAPI vkQueueSetPerfHintQCOM(VkQueue queue, const VkPerfHintInfoQCOM *pPerfHintInfo) { struct vkQueueSetPerfHintQCOM_params params; - NTSTATUS status; params.queue = queue; params.pPerfHintInfo = pPerfHintInfo; - status = UNIX_CALL(vkQueueSetPerfHintQCOM, ¶ms); - assert(!status && "vkQueueSetPerfHintQCOM"); + UNIX_CALL_CHECKED(vkQueueSetPerfHintQCOM, ¶ms); return params.result; } VkResult WINAPI vkQueueSetPerformanceConfigurationINTEL(VkQueue queue, VkPerformanceConfigurationINTEL configuration) { struct vkQueueSetPerformanceConfigurationINTEL_params params; - NTSTATUS status; params.queue = queue; params.configuration = configuration; - status = UNIX_CALL(vkQueueSetPerformanceConfigurationINTEL, ¶ms); - assert(!status && "vkQueueSetPerformanceConfigurationINTEL"); + UNIX_CALL_CHECKED(vkQueueSetPerformanceConfigurationINTEL, ¶ms); return params.result; } VkResult WINAPI vkQueueSubmit(VkQueue queue, uint32_t submitCount, const VkSubmitInfo *pSubmits, VkFence fence) { struct vkQueueSubmit_params params; - NTSTATUS status; params.queue = queue; params.submitCount = submitCount; params.pSubmits = pSubmits; params.fence = fence; - status = UNIX_CALL(vkQueueSubmit, ¶ms); - assert(!status && "vkQueueSubmit"); + UNIX_CALL_CHECKED(vkQueueSubmit, ¶ms); return params.result; } VkResult WINAPI vkQueueSubmit2(VkQueue queue, uint32_t submitCount, const VkSubmitInfo2 *pSubmits, VkFence fence) { struct vkQueueSubmit2_params params; - NTSTATUS status; params.queue = queue; params.submitCount = submitCount; params.pSubmits = pSubmits; params.fence = fence; - status = UNIX_CALL(vkQueueSubmit2, ¶ms); - assert(!status && "vkQueueSubmit2"); + UNIX_CALL_CHECKED(vkQueueSubmit2, ¶ms); return params.result; } VkResult WINAPI vkQueueSubmit2KHR(VkQueue queue, uint32_t submitCount, const VkSubmitInfo2 *pSubmits, VkFence fence) { struct vkQueueSubmit2KHR_params params; - NTSTATUS status; params.queue = queue; params.submitCount = submitCount; params.pSubmits = pSubmits; params.fence = fence; - status = UNIX_CALL(vkQueueSubmit2KHR, ¶ms); - assert(!status && "vkQueueSubmit2KHR"); + UNIX_CALL_CHECKED(vkQueueSubmit2KHR, ¶ms); return params.result; } VkResult WINAPI vkQueueWaitIdle(VkQueue queue) { struct vkQueueWaitIdle_params params; - NTSTATUS status; params.queue = queue; - status = UNIX_CALL(vkQueueWaitIdle, ¶ms); - assert(!status && "vkQueueWaitIdle"); + UNIX_CALL_CHECKED(vkQueueWaitIdle, ¶ms); return params.result; } VkResult WINAPI vkRegisterCustomBorderColorEXT(VkDevice device, const VkSamplerCustomBorderColorCreateInfoEXT *pBorderColor, VkBool32 requestIndex, uint32_t *pIndex) { struct vkRegisterCustomBorderColorEXT_params params; - NTSTATUS status; params.device = device; params.pBorderColor = pBorderColor; params.requestIndex = requestIndex; params.pIndex = pIndex; - status = UNIX_CALL(vkRegisterCustomBorderColorEXT, ¶ms); - assert(!status && "vkRegisterCustomBorderColorEXT"); + UNIX_CALL_CHECKED(vkRegisterCustomBorderColorEXT, ¶ms); return params.result; } VkResult WINAPI vkReleaseCapturedPipelineDataKHR(VkDevice device, const VkReleaseCapturedPipelineDataInfoKHR *pInfo, const VkAllocationCallbacks *pAllocator) { struct vkReleaseCapturedPipelineDataKHR_params params; - NTSTATUS status; params.device = device; params.pInfo = pInfo; params.pAllocator = pAllocator; - status = UNIX_CALL(vkReleaseCapturedPipelineDataKHR, ¶ms); - assert(!status && "vkReleaseCapturedPipelineDataKHR"); + UNIX_CALL_CHECKED(vkReleaseCapturedPipelineDataKHR, ¶ms); return params.result; } VkResult WINAPI vkReleasePerformanceConfigurationINTEL(VkDevice device, VkPerformanceConfigurationINTEL configuration) { struct vkReleasePerformanceConfigurationINTEL_params params; - NTSTATUS status; params.device = device; params.configuration = configuration; - status = UNIX_CALL(vkReleasePerformanceConfigurationINTEL, ¶ms); - assert(!status && "vkReleasePerformanceConfigurationINTEL"); + UNIX_CALL_CHECKED(vkReleasePerformanceConfigurationINTEL, ¶ms); return params.result; } void WINAPI vkReleaseProfilingLockKHR(VkDevice device) { struct vkReleaseProfilingLockKHR_params params; - NTSTATUS status; params.device = device; - status = UNIX_CALL(vkReleaseProfilingLockKHR, ¶ms); - assert(!status && "vkReleaseProfilingLockKHR"); + UNIX_CALL_CHECKED(vkReleaseProfilingLockKHR, ¶ms); } VkResult WINAPI vkReleaseSwapchainImagesEXT(VkDevice device, const VkReleaseSwapchainImagesInfoKHR *pReleaseInfo) { struct vkReleaseSwapchainImagesEXT_params params; - NTSTATUS status; params.device = device; params.pReleaseInfo = pReleaseInfo; - status = UNIX_CALL(vkReleaseSwapchainImagesEXT, ¶ms); - assert(!status && "vkReleaseSwapchainImagesEXT"); + UNIX_CALL_CHECKED(vkReleaseSwapchainImagesEXT, ¶ms); return params.result; } VkResult WINAPI vkReleaseSwapchainImagesKHR(VkDevice device, const VkReleaseSwapchainImagesInfoKHR *pReleaseInfo) { struct vkReleaseSwapchainImagesKHR_params params; - NTSTATUS status; params.device = device; params.pReleaseInfo = pReleaseInfo; - status = UNIX_CALL(vkReleaseSwapchainImagesKHR, ¶ms); - assert(!status && "vkReleaseSwapchainImagesKHR"); + UNIX_CALL_CHECKED(vkReleaseSwapchainImagesKHR, ¶ms); return params.result; } VkResult WINAPI vkResetCommandBuffer(VkCommandBuffer commandBuffer, VkCommandBufferResetFlags flags) { struct vkResetCommandBuffer_params params; - NTSTATUS status; params.commandBuffer = commandBuffer; params.flags = flags; - status = UNIX_CALL(vkResetCommandBuffer, ¶ms); - assert(!status && "vkResetCommandBuffer"); + UNIX_CALL_CHECKED(vkResetCommandBuffer, ¶ms); return params.result; } VkResult WINAPI vkResetCommandPool(VkDevice device, VkCommandPool commandPool, VkCommandPoolResetFlags flags) { struct vkResetCommandPool_params params; - NTSTATUS status; params.device = device; params.commandPool = commandPool; params.flags = flags; - status = UNIX_CALL(vkResetCommandPool, ¶ms); - assert(!status && "vkResetCommandPool"); + UNIX_CALL_CHECKED(vkResetCommandPool, ¶ms); return params.result; } VkResult WINAPI vkResetDescriptorPool(VkDevice device, VkDescriptorPool descriptorPool, VkDescriptorPoolResetFlags flags) { struct vkResetDescriptorPool_params params; - NTSTATUS status; params.device = device; params.descriptorPool = descriptorPool; params.flags = flags; - status = UNIX_CALL(vkResetDescriptorPool, ¶ms); - assert(!status && "vkResetDescriptorPool"); + UNIX_CALL_CHECKED(vkResetDescriptorPool, ¶ms); return params.result; } VkResult WINAPI vkResetEvent(VkDevice device, VkEvent event) { struct vkResetEvent_params params; - NTSTATUS status; params.device = device; params.event = event; - status = UNIX_CALL(vkResetEvent, ¶ms); - assert(!status && "vkResetEvent"); + UNIX_CALL_CHECKED(vkResetEvent, ¶ms); return params.result; } VkResult WINAPI vkResetFences(VkDevice device, uint32_t fenceCount, const VkFence *pFences) { struct vkResetFences_params params; - NTSTATUS status; params.device = device; params.fenceCount = fenceCount; params.pFences = pFences; - status = UNIX_CALL(vkResetFences, ¶ms); - assert(!status && "vkResetFences"); + UNIX_CALL_CHECKED(vkResetFences, ¶ms); return params.result; } VkResult WINAPI vkResetGpaSessionAMD(VkDevice device, VkGpaSessionAMD gpaSession) { struct vkResetGpaSessionAMD_params params; - NTSTATUS status; params.device = device; params.gpaSession = gpaSession; - status = UNIX_CALL(vkResetGpaSessionAMD, ¶ms); - assert(!status && "vkResetGpaSessionAMD"); + UNIX_CALL_CHECKED(vkResetGpaSessionAMD, ¶ms); return params.result; } void WINAPI vkResetQueryPool(VkDevice device, VkQueryPool queryPool, uint32_t firstQuery, uint32_t queryCount) { struct vkResetQueryPool_params params; - NTSTATUS status; params.device = device; params.queryPool = queryPool; params.firstQuery = firstQuery; params.queryCount = queryCount; - status = UNIX_CALL(vkResetQueryPool, ¶ms); - assert(!status && "vkResetQueryPool"); + UNIX_CALL_CHECKED(vkResetQueryPool, ¶ms); } void WINAPI vkResetQueryPoolEXT(VkDevice device, VkQueryPool queryPool, uint32_t firstQuery, uint32_t queryCount) { struct vkResetQueryPoolEXT_params params; - NTSTATUS status; params.device = device; params.queryPool = queryPool; params.firstQuery = firstQuery; params.queryCount = queryCount; - status = UNIX_CALL(vkResetQueryPoolEXT, ¶ms); - assert(!status && "vkResetQueryPoolEXT"); + UNIX_CALL_CHECKED(vkResetQueryPoolEXT, ¶ms); } VkResult WINAPI vkSetDebugUtilsObjectNameEXT(VkDevice device, const VkDebugUtilsObjectNameInfoEXT *pNameInfo) { struct vkSetDebugUtilsObjectNameEXT_params params; - NTSTATUS status; params.device = device; params.pNameInfo = pNameInfo; - status = UNIX_CALL(vkSetDebugUtilsObjectNameEXT, ¶ms); - assert(!status && "vkSetDebugUtilsObjectNameEXT"); + UNIX_CALL_CHECKED(vkSetDebugUtilsObjectNameEXT, ¶ms); return params.result; } VkResult WINAPI vkSetDebugUtilsObjectTagEXT(VkDevice device, const VkDebugUtilsObjectTagInfoEXT *pTagInfo) { struct vkSetDebugUtilsObjectTagEXT_params params; - NTSTATUS status; params.device = device; params.pTagInfo = pTagInfo; - status = UNIX_CALL(vkSetDebugUtilsObjectTagEXT, ¶ms); - assert(!status && "vkSetDebugUtilsObjectTagEXT"); + UNIX_CALL_CHECKED(vkSetDebugUtilsObjectTagEXT, ¶ms); return params.result; } void WINAPI vkSetDeviceMemoryPriorityEXT(VkDevice device, VkDeviceMemory memory, float priority) { struct vkSetDeviceMemoryPriorityEXT_params params; - NTSTATUS status; params.device = device; params.memory = memory; params.priority = priority; - status = UNIX_CALL(vkSetDeviceMemoryPriorityEXT, ¶ms); - assert(!status && "vkSetDeviceMemoryPriorityEXT"); + UNIX_CALL_CHECKED(vkSetDeviceMemoryPriorityEXT, ¶ms); } VkResult WINAPI vkSetEvent(VkDevice device, VkEvent event) { struct vkSetEvent_params params; - NTSTATUS status; params.device = device; params.event = event; - status = UNIX_CALL(vkSetEvent, ¶ms); - assert(!status && "vkSetEvent"); + UNIX_CALL_CHECKED(vkSetEvent, ¶ms); return params.result; } VkResult WINAPI vkSetGpaDeviceClockModeAMD(VkDevice device, VkGpaDeviceClockModeInfoAMD *pInfo) { struct vkSetGpaDeviceClockModeAMD_params params; - NTSTATUS status; params.device = device; params.pInfo = pInfo; - status = UNIX_CALL(vkSetGpaDeviceClockModeAMD, ¶ms); - assert(!status && "vkSetGpaDeviceClockModeAMD"); + UNIX_CALL_CHECKED(vkSetGpaDeviceClockModeAMD, ¶ms); return params.result; } void WINAPI vkSetHdrMetadataEXT(VkDevice device, uint32_t swapchainCount, const VkSwapchainKHR *pSwapchains, const VkHdrMetadataEXT *pMetadata) { struct vkSetHdrMetadataEXT_params params; - NTSTATUS status; params.device = device; params.swapchainCount = swapchainCount; params.pSwapchains = pSwapchains; params.pMetadata = pMetadata; - status = UNIX_CALL(vkSetHdrMetadataEXT, ¶ms); - assert(!status && "vkSetHdrMetadataEXT"); + UNIX_CALL_CHECKED(vkSetHdrMetadataEXT, ¶ms); } void WINAPI vkSetLatencyMarkerNV(VkDevice device, VkSwapchainKHR swapchain, const VkSetLatencyMarkerInfoNV *pLatencyMarkerInfo) { struct vkSetLatencyMarkerNV_params params; - NTSTATUS status; params.device = device; params.swapchain = swapchain; params.pLatencyMarkerInfo = pLatencyMarkerInfo; - status = UNIX_CALL(vkSetLatencyMarkerNV, ¶ms); - assert(!status && "vkSetLatencyMarkerNV"); + UNIX_CALL_CHECKED(vkSetLatencyMarkerNV, ¶ms); } VkResult WINAPI vkSetLatencySleepModeNV(VkDevice device, VkSwapchainKHR swapchain, const VkLatencySleepModeInfoNV *pSleepModeInfo) { struct vkSetLatencySleepModeNV_params params; - NTSTATUS status; params.device = device; params.swapchain = swapchain; params.pSleepModeInfo = pSleepModeInfo; - status = UNIX_CALL(vkSetLatencySleepModeNV, ¶ms); - assert(!status && "vkSetLatencySleepModeNV"); + UNIX_CALL_CHECKED(vkSetLatencySleepModeNV, ¶ms); return params.result; } VkResult WINAPI vkSetPrivateData(VkDevice device, VkObjectType objectType, uint64_t objectHandle, VkPrivateDataSlot privateDataSlot, uint64_t data) { struct vkSetPrivateData_params params; - NTSTATUS status; params.device = device; params.objectType = objectType; params.objectHandle = objectHandle; params.privateDataSlot = privateDataSlot; params.data = data; - status = UNIX_CALL(vkSetPrivateData, ¶ms); - assert(!status && "vkSetPrivateData"); + UNIX_CALL_CHECKED(vkSetPrivateData, ¶ms); return params.result; } VkResult WINAPI vkSetPrivateDataEXT(VkDevice device, VkObjectType objectType, uint64_t objectHandle, VkPrivateDataSlot privateDataSlot, uint64_t data) { struct vkSetPrivateDataEXT_params params; - NTSTATUS status; params.device = device; params.objectType = objectType; params.objectHandle = objectHandle; params.privateDataSlot = privateDataSlot; params.data = data; - status = UNIX_CALL(vkSetPrivateDataEXT, ¶ms); - assert(!status && "vkSetPrivateDataEXT"); + UNIX_CALL_CHECKED(vkSetPrivateDataEXT, ¶ms); return params.result; } VkResult WINAPI vkSetSwapchainPresentTimingQueueSizeEXT(VkDevice device, VkSwapchainKHR swapchain, uint32_t size) { struct vkSetSwapchainPresentTimingQueueSizeEXT_params params; - NTSTATUS status; params.device = device; params.swapchain = swapchain; params.size = size; - status = UNIX_CALL(vkSetSwapchainPresentTimingQueueSizeEXT, ¶ms); - assert(!status && "vkSetSwapchainPresentTimingQueueSizeEXT"); + UNIX_CALL_CHECKED(vkSetSwapchainPresentTimingQueueSizeEXT, ¶ms); return params.result; } VkResult WINAPI vkSignalSemaphore(VkDevice device, const VkSemaphoreSignalInfo *pSignalInfo) { struct vkSignalSemaphore_params params; - NTSTATUS status; params.device = device; params.pSignalInfo = pSignalInfo; - status = UNIX_CALL(vkSignalSemaphore, ¶ms); - assert(!status && "vkSignalSemaphore"); + UNIX_CALL_CHECKED(vkSignalSemaphore, ¶ms); return params.result; } VkResult WINAPI vkSignalSemaphoreKHR(VkDevice device, const VkSemaphoreSignalInfo *pSignalInfo) { struct vkSignalSemaphoreKHR_params params; - NTSTATUS status; params.device = device; params.pSignalInfo = pSignalInfo; - status = UNIX_CALL(vkSignalSemaphoreKHR, ¶ms); - assert(!status && "vkSignalSemaphoreKHR"); + UNIX_CALL_CHECKED(vkSignalSemaphoreKHR, ¶ms); return params.result; } void WINAPI vkSubmitDebugUtilsMessageEXT(VkInstance instance, VkDebugUtilsMessageSeverityFlagBitsEXT messageSeverity, VkDebugUtilsMessageTypeFlagsEXT messageTypes, const VkDebugUtilsMessengerCallbackDataEXT *pCallbackData) { struct vkSubmitDebugUtilsMessageEXT_params params; - NTSTATUS status; params.instance = instance; params.messageSeverity = messageSeverity; params.messageTypes = messageTypes; params.pCallbackData = pCallbackData; - status = UNIX_CALL(vkSubmitDebugUtilsMessageEXT, ¶ms); - assert(!status && "vkSubmitDebugUtilsMessageEXT"); + UNIX_CALL_CHECKED(vkSubmitDebugUtilsMessageEXT, ¶ms); } VkResult WINAPI vkTransitionImageLayout(VkDevice device, uint32_t transitionCount, const VkHostImageLayoutTransitionInfo *pTransitions) { struct vkTransitionImageLayout_params params; - NTSTATUS status; params.device = device; params.transitionCount = transitionCount; params.pTransitions = pTransitions; - status = UNIX_CALL(vkTransitionImageLayout, ¶ms); - assert(!status && "vkTransitionImageLayout"); + UNIX_CALL_CHECKED(vkTransitionImageLayout, ¶ms); return params.result; } VkResult WINAPI vkTransitionImageLayoutEXT(VkDevice device, uint32_t transitionCount, const VkHostImageLayoutTransitionInfo *pTransitions) { struct vkTransitionImageLayoutEXT_params params; - NTSTATUS status; params.device = device; params.transitionCount = transitionCount; params.pTransitions = pTransitions; - status = UNIX_CALL(vkTransitionImageLayoutEXT, ¶ms); - assert(!status && "vkTransitionImageLayoutEXT"); + UNIX_CALL_CHECKED(vkTransitionImageLayoutEXT, ¶ms); return params.result; } void WINAPI vkTrimCommandPool(VkDevice device, VkCommandPool commandPool, VkCommandPoolTrimFlags flags) { struct vkTrimCommandPool_params params; - NTSTATUS status; params.device = device; params.commandPool = commandPool; params.flags = flags; - status = UNIX_CALL(vkTrimCommandPool, ¶ms); - assert(!status && "vkTrimCommandPool"); + UNIX_CALL_CHECKED(vkTrimCommandPool, ¶ms); } void WINAPI vkTrimCommandPoolKHR(VkDevice device, VkCommandPool commandPool, VkCommandPoolTrimFlags flags) { struct vkTrimCommandPoolKHR_params params; - NTSTATUS status; params.device = device; params.commandPool = commandPool; params.flags = flags; - status = UNIX_CALL(vkTrimCommandPoolKHR, ¶ms); - assert(!status && "vkTrimCommandPoolKHR"); + UNIX_CALL_CHECKED(vkTrimCommandPoolKHR, ¶ms); } void WINAPI vkUninitializePerformanceApiINTEL(VkDevice device) { struct vkUninitializePerformanceApiINTEL_params params; - NTSTATUS status; params.device = device; - status = UNIX_CALL(vkUninitializePerformanceApiINTEL, ¶ms); - assert(!status && "vkUninitializePerformanceApiINTEL"); + UNIX_CALL_CHECKED(vkUninitializePerformanceApiINTEL, ¶ms); } void WINAPI vkUnmapMemory(VkDevice device, VkDeviceMemory memory) { struct vkUnmapMemory_params params; - NTSTATUS status; params.device = device; params.memory = memory; - status = UNIX_CALL(vkUnmapMemory, ¶ms); - assert(!status && "vkUnmapMemory"); + UNIX_CALL_CHECKED(vkUnmapMemory, ¶ms); } VkResult WINAPI vkUnmapMemory2(VkDevice device, const VkMemoryUnmapInfo *pMemoryUnmapInfo) { struct vkUnmapMemory2_params params; - NTSTATUS status; params.device = device; params.pMemoryUnmapInfo = pMemoryUnmapInfo; - status = UNIX_CALL(vkUnmapMemory2, ¶ms); - assert(!status && "vkUnmapMemory2"); + UNIX_CALL_CHECKED(vkUnmapMemory2, ¶ms); return params.result; } VkResult WINAPI vkUnmapMemory2KHR(VkDevice device, const VkMemoryUnmapInfo *pMemoryUnmapInfo) { struct vkUnmapMemory2KHR_params params; - NTSTATUS status; params.device = device; params.pMemoryUnmapInfo = pMemoryUnmapInfo; - status = UNIX_CALL(vkUnmapMemory2KHR, ¶ms); - assert(!status && "vkUnmapMemory2KHR"); + UNIX_CALL_CHECKED(vkUnmapMemory2KHR, ¶ms); return params.result; } void WINAPI vkUnregisterCustomBorderColorEXT(VkDevice device, uint32_t index) { struct vkUnregisterCustomBorderColorEXT_params params; - NTSTATUS status; params.device = device; params.index = index; - status = UNIX_CALL(vkUnregisterCustomBorderColorEXT, ¶ms); - assert(!status && "vkUnregisterCustomBorderColorEXT"); + UNIX_CALL_CHECKED(vkUnregisterCustomBorderColorEXT, ¶ms); } void WINAPI vkUpdateDescriptorSetWithTemplate(VkDevice device, VkDescriptorSet descriptorSet, VkDescriptorUpdateTemplate descriptorUpdateTemplate, const void *pData) @@ -7693,13 +6887,11 @@ void WINAPI vkUpdateDescriptorSetWithTemplate(VkDevice device, VkDescriptorSet d void WINAPI vkUpdateDescriptorSetWithTemplateKHR(VkDevice device, VkDescriptorSet descriptorSet, VkDescriptorUpdateTemplate descriptorUpdateTemplate, const void *pData) { struct vkUpdateDescriptorSetWithTemplateKHR_params params; - NTSTATUS status; params.device = device; params.descriptorSet = descriptorSet; params.descriptorUpdateTemplate = descriptorUpdateTemplate; params.pData = pData; - status = UNIX_CALL(vkUpdateDescriptorSetWithTemplateKHR, ¶ms); - assert(!status && "vkUpdateDescriptorSetWithTemplateKHR"); + UNIX_CALL_CHECKED(vkUpdateDescriptorSetWithTemplateKHR, ¶ms); } void WINAPI vkUpdateDescriptorSets(VkDevice device, uint32_t descriptorWriteCount, const VkWriteDescriptorSet *pDescriptorWrites, uint32_t descriptorCopyCount, const VkCopyDescriptorSet *pDescriptorCopies) @@ -7716,106 +6908,89 @@ void WINAPI vkUpdateDescriptorSets(VkDevice device, uint32_t descriptorWriteCoun void WINAPI vkUpdateIndirectExecutionSetPipelineEXT(VkDevice device, VkIndirectExecutionSetEXT indirectExecutionSet, uint32_t executionSetWriteCount, const VkWriteIndirectExecutionSetPipelineEXT *pExecutionSetWrites) { struct vkUpdateIndirectExecutionSetPipelineEXT_params params; - NTSTATUS status; params.device = device; params.indirectExecutionSet = indirectExecutionSet; params.executionSetWriteCount = executionSetWriteCount; params.pExecutionSetWrites = pExecutionSetWrites; - status = UNIX_CALL(vkUpdateIndirectExecutionSetPipelineEXT, ¶ms); - assert(!status && "vkUpdateIndirectExecutionSetPipelineEXT"); + UNIX_CALL_CHECKED(vkUpdateIndirectExecutionSetPipelineEXT, ¶ms); } void WINAPI vkUpdateIndirectExecutionSetShaderEXT(VkDevice device, VkIndirectExecutionSetEXT indirectExecutionSet, uint32_t executionSetWriteCount, const VkWriteIndirectExecutionSetShaderEXT *pExecutionSetWrites) { struct vkUpdateIndirectExecutionSetShaderEXT_params params; - NTSTATUS status; params.device = device; params.indirectExecutionSet = indirectExecutionSet; params.executionSetWriteCount = executionSetWriteCount; params.pExecutionSetWrites = pExecutionSetWrites; - status = UNIX_CALL(vkUpdateIndirectExecutionSetShaderEXT, ¶ms); - assert(!status && "vkUpdateIndirectExecutionSetShaderEXT"); + UNIX_CALL_CHECKED(vkUpdateIndirectExecutionSetShaderEXT, ¶ms); } VkResult WINAPI vkUpdateVideoSessionParametersKHR(VkDevice device, VkVideoSessionParametersKHR videoSessionParameters, const VkVideoSessionParametersUpdateInfoKHR *pUpdateInfo) { struct vkUpdateVideoSessionParametersKHR_params params; - NTSTATUS status; params.device = device; params.videoSessionParameters = videoSessionParameters; params.pUpdateInfo = pUpdateInfo; - status = UNIX_CALL(vkUpdateVideoSessionParametersKHR, ¶ms); - assert(!status && "vkUpdateVideoSessionParametersKHR"); + UNIX_CALL_CHECKED(vkUpdateVideoSessionParametersKHR, ¶ms); return params.result; } VkResult WINAPI vkWaitForFences(VkDevice device, uint32_t fenceCount, const VkFence *pFences, VkBool32 waitAll, uint64_t timeout) { struct vkWaitForFences_params params; - NTSTATUS status; params.device = device; params.fenceCount = fenceCount; params.pFences = pFences; params.waitAll = waitAll; params.timeout = timeout; - status = UNIX_CALL(vkWaitForFences, ¶ms); - assert(!status && "vkWaitForFences"); + UNIX_CALL_CHECKED(vkWaitForFences, ¶ms); return params.result; } VkResult WINAPI vkWaitForPresent2KHR(VkDevice device, VkSwapchainKHR swapchain, const VkPresentWait2InfoKHR *pPresentWait2Info) { struct vkWaitForPresent2KHR_params params; - NTSTATUS status; params.device = device; params.swapchain = swapchain; params.pPresentWait2Info = pPresentWait2Info; - status = UNIX_CALL(vkWaitForPresent2KHR, ¶ms); - assert(!status && "vkWaitForPresent2KHR"); + UNIX_CALL_CHECKED(vkWaitForPresent2KHR, ¶ms); return params.result; } VkResult WINAPI vkWaitForPresentKHR(VkDevice device, VkSwapchainKHR swapchain, uint64_t presentId, uint64_t timeout) { struct vkWaitForPresentKHR_params params; - NTSTATUS status; params.device = device; params.swapchain = swapchain; params.presentId = presentId; params.timeout = timeout; - status = UNIX_CALL(vkWaitForPresentKHR, ¶ms); - assert(!status && "vkWaitForPresentKHR"); + UNIX_CALL_CHECKED(vkWaitForPresentKHR, ¶ms); return params.result; } VkResult WINAPI vkWaitSemaphores(VkDevice device, const VkSemaphoreWaitInfo *pWaitInfo, uint64_t timeout) { struct vkWaitSemaphores_params params; - NTSTATUS status; params.device = device; params.pWaitInfo = pWaitInfo; params.timeout = timeout; - status = UNIX_CALL(vkWaitSemaphores, ¶ms); - assert(!status && "vkWaitSemaphores"); + UNIX_CALL_CHECKED(vkWaitSemaphores, ¶ms); return params.result; } VkResult WINAPI vkWaitSemaphoresKHR(VkDevice device, const VkSemaphoreWaitInfo *pWaitInfo, uint64_t timeout) { struct vkWaitSemaphoresKHR_params params; - NTSTATUS status; params.device = device; params.pWaitInfo = pWaitInfo; params.timeout = timeout; - status = UNIX_CALL(vkWaitSemaphoresKHR, ¶ms); - assert(!status && "vkWaitSemaphoresKHR"); + UNIX_CALL_CHECKED(vkWaitSemaphoresKHR, ¶ms); return params.result; } VkResult WINAPI vkWriteAccelerationStructuresPropertiesKHR(VkDevice device, uint32_t accelerationStructureCount, const VkAccelerationStructureKHR *pAccelerationStructures, VkQueryType queryType, size_t dataSize, void *pData, size_t stride) { struct vkWriteAccelerationStructuresPropertiesKHR_params params; - NTSTATUS status; params.device = device; params.accelerationStructureCount = accelerationStructureCount; params.pAccelerationStructures = pAccelerationStructures; @@ -7823,15 +6998,13 @@ VkResult WINAPI vkWriteAccelerationStructuresPropertiesKHR(VkDevice device, uint params.dataSize = dataSize; params.pData = pData; params.stride = stride; - status = UNIX_CALL(vkWriteAccelerationStructuresPropertiesKHR, ¶ms); - assert(!status && "vkWriteAccelerationStructuresPropertiesKHR"); + UNIX_CALL_CHECKED(vkWriteAccelerationStructuresPropertiesKHR, ¶ms); return params.result; } VkResult WINAPI vkWriteMicromapsPropertiesEXT(VkDevice device, uint32_t micromapCount, const VkMicromapEXT *pMicromaps, VkQueryType queryType, size_t dataSize, void *pData, size_t stride) { struct vkWriteMicromapsPropertiesEXT_params params; - NTSTATUS status; params.device = device; params.micromapCount = micromapCount; params.pMicromaps = pMicromaps; @@ -7839,8 +7012,7 @@ VkResult WINAPI vkWriteMicromapsPropertiesEXT(VkDevice device, uint32_t micromap params.dataSize = dataSize; params.pData = pData; params.stride = stride; - status = UNIX_CALL(vkWriteMicromapsPropertiesEXT, ¶ms); - assert(!status && "vkWriteMicromapsPropertiesEXT"); + UNIX_CALL_CHECKED(vkWriteMicromapsPropertiesEXT, ¶ms); return params.result; } diff --git a/dlls/winevulkan/make_vulkan b/dlls/winevulkan/make_vulkan index 70273a19223..71994e45788 100755 --- a/dlls/winevulkan/make_vulkan +++ b/dlls/winevulkan/make_vulkan @@ -884,8 +884,6 @@ class Function(Type): thunk += u"{\n" thunk += f" struct {self.name}_params params;\n" - if not self.is_perf_critical(): - thunk += u" NTSTATUS status;\n" for p in self.params: thunk += f" params.{p.name} = {p.name};\n" @@ -893,8 +891,7 @@ class Function(Type): if self.is_perf_critical(): thunk += f" UNIX_CALL({self.name}, ¶ms);\n" else: - thunk += f" status = UNIX_CALL({self.name}, ¶ms);\n" - thunk += f" assert(!status && \"{self.name}\");\n" + thunk += f" UNIX_CALL_CHECKED({self.name}, ¶ms);\n" if self.type != "void": thunk += u" return params.result;\n" diff --git a/dlls/winevulkan/vulkan_loader.h b/dlls/winevulkan/vulkan_loader.h index 9066e0329ef..94e52774b77 100644 --- a/dlls/winevulkan/vulkan_loader.h +++ b/dlls/winevulkan/vulkan_loader.h @@ -23,7 +23,6 @@ #include "ntstatus.h" #include <stdarg.h> #include <stdlib.h> -#include <assert.h> #include "windef.h" #include "winbase.h" #include "winternl.h" @@ -145,5 +144,14 @@ struct is_available_device_function_params }; #define UNIX_CALL(code, params) WINE_UNIX_CALL(unix_ ## code, params) +#define UNIX_CALL_CHECKED(code, params) \ + { \ + NTSTATUS status = UNIX_CALL(code, params); \ + if (status) \ + { \ + ERR("Exception %#lx in Unix call.\n", status); \ + ExitProcess(3); \ + } \ + } #endif /* __WINE_VULKAN_LOADER_H */ -- GitLab https://gitlab.winehq.org/wine/wine/-/merge_requests/11164