[PATCH 0/2] MR6571: winevulkan: Update to VK spec version 1.3.296.

List overview All Threads

newer

older

[PATCH 0/6] MR6575: dplayx: Open()...

Re: [PATCH v2 0/1] MR6579:...

Georg Lehmann (＠DadSchoorse)

26 Sep 2024 26 Sep '24

8:13 p.m.

-- https://gitlab.winehq.org/wine/wine/-/merge_requests/6571

Show replies by date

Georg Lehmann

26 Sep 26 Sep

8:13 p.m.

New subject: [PATCH 1/2] winevulkan: Avoid empty struct extension conversions.

From: Georg Lehmann dadschoorse@gmail.com

--- dlls/winevulkan/make_vulkan | 3 +++ 1 file changed, 3 insertions(+)

diff --git a/dlls/winevulkan/make_vulkan b/dlls/winevulkan/make_vulkan index 2b98893e0c1..288fa1fd11a 100755 --- a/dlls/winevulkan/make_vulkan +++ b/dlls/winevulkan/make_vulkan @@ -2412,6 +2412,9 @@ class StructConversionFunction(object):

needs_extensions = self.operand.needs_extensions_conversion(self.conv, self.direction)

+ if self.direction == Direction.OUTPUT and not any([any([self.member_needs_copy(ext, m) for m in ext]) for ext in self.operand.struct_extensions]): + needs_extensions = False + body += "{\n" if needs_extensions: if self.direction == Direction.INPUT:

-- GitLab https://gitlab.winehq.org/wine/wine/-/merge_requests/6571

Georg Lehmann

8:13 p.m.

New subject: [PATCH 2/2] winevulkan: Update to VK spec version 1.3.296.

From: Georg Lehmann dadschoorse@gmail.com

--- dlls/winevulkan/loader_thunks.c | 120 ++++ dlls/winevulkan/loader_thunks.h | 86 +++ dlls/winevulkan/make_vulkan | 2 +- dlls/winevulkan/vulkan_thunks.c | 983 ++++++++++++++++++++++++++++++++ dlls/winevulkan/vulkan_thunks.h | 20 + dlls/winevulkan/winevulkan.json | 2 +- include/wine/vulkan.h | 323 ++++++++++- 7 files changed, 1533 insertions(+), 3 deletions(-)

diff --git a/dlls/winevulkan/loader_thunks.c b/dlls/winevulkan/loader_thunks.c index 5b6e3d9339c..a427006cac1 100644 --- a/dlls/winevulkan/loader_thunks.c +++ b/dlls/winevulkan/loader_thunks.c @@ -1310,6 +1310,15 @@ void WINAPI vkCmdExecuteCommands(VkCommandBuffer commandBuffer, uint32_t command UNIX_CALL(vkCmdExecuteCommands, &params); }

+void WINAPI vkCmdExecuteGeneratedCommandsEXT(VkCommandBuffer commandBuffer, VkBool32 isPreprocessed, const VkGeneratedCommandsInfoEXT *pGeneratedCommandsInfo) +{ + struct vkCmdExecuteGeneratedCommandsEXT_params params; + params.commandBuffer = commandBuffer; + params.isPreprocessed = isPreprocessed; + params.pGeneratedCommandsInfo = pGeneratedCommandsInfo; + UNIX_CALL(vkCmdExecuteGeneratedCommandsEXT, &params); +} + void WINAPI vkCmdExecuteGeneratedCommandsNV(VkCommandBuffer commandBuffer, VkBool32 isPreprocessed, const VkGeneratedCommandsInfoNV *pGeneratedCommandsInfo) { struct vkCmdExecuteGeneratedCommandsNV_params params; @@ -1405,6 +1414,15 @@ void WINAPI vkCmdPipelineBarrier2KHR(VkCommandBuffer commandBuffer, const VkDepe UNIX_CALL(vkCmdPipelineBarrier2KHR, &params); }

+void WINAPI vkCmdPreprocessGeneratedCommandsEXT(VkCommandBuffer commandBuffer, const VkGeneratedCommandsInfoEXT *pGeneratedCommandsInfo, VkCommandBuffer stateCommandBuffer) +{ + struct vkCmdPreprocessGeneratedCommandsEXT_params params; + params.commandBuffer = commandBuffer; + params.pGeneratedCommandsInfo = pGeneratedCommandsInfo; + params.stateCommandBuffer = stateCommandBuffer; + UNIX_CALL(vkCmdPreprocessGeneratedCommandsEXT, &params); +} + void WINAPI vkCmdPreprocessGeneratedCommandsNV(VkCommandBuffer commandBuffer, const VkGeneratedCommandsInfoNV *pGeneratedCommandsInfo) { struct vkCmdPreprocessGeneratedCommandsNV_params params; @@ -1777,6 +1795,15 @@ void WINAPI vkCmdSetDepthClampEnableEXT(VkCommandBuffer commandBuffer, VkBool32 UNIX_CALL(vkCmdSetDepthClampEnableEXT, &params); }

+void WINAPI vkCmdSetDepthClampRangeEXT(VkCommandBuffer commandBuffer, VkDepthClampModeEXT depthClampMode, const VkDepthClampRangeEXT *pDepthClampRange) +{ + struct vkCmdSetDepthClampRangeEXT_params params; + params.commandBuffer = commandBuffer; + params.depthClampMode = depthClampMode; + params.pDepthClampRange = pDepthClampRange; + UNIX_CALL(vkCmdSetDepthClampRangeEXT, &params); +} + void WINAPI vkCmdSetDepthClipEnableEXT(VkCommandBuffer commandBuffer, VkBool32 depthClipEnable) { struct vkCmdSetDepthClipEnableEXT_params params; @@ -3030,6 +3057,19 @@ VkResult WINAPI vkCreateImageView(VkDevice device, const VkImageViewCreateInfo * 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, &params); + assert(!status && "vkCreateIndirectCommandsLayoutEXT"); + return params.result; +} + VkResult WINAPI vkCreateIndirectCommandsLayoutNV(VkDevice device, const VkIndirectCommandsLayoutCreateInfoNV *pCreateInfo, const VkAllocationCallbacks *pAllocator, VkIndirectCommandsLayoutNV *pIndirectCommandsLayout) { struct vkCreateIndirectCommandsLayoutNV_params params; @@ -3043,6 +3083,19 @@ VkResult WINAPI vkCreateIndirectCommandsLayoutNV(VkDevice device, const VkIndire 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, &params); + assert(!status && "vkCreateIndirectExecutionSetEXT"); + return params.result; +} + VkResult WINAPI vkCreateMicromapEXT(VkDevice device, const VkMicromapCreateInfoEXT *pCreateInfo, const VkAllocationCallbacks *pAllocator, VkMicromapEXT *pMicromap) { struct vkCreateMicromapEXT_params params; @@ -3630,6 +3683,17 @@ void WINAPI vkDestroyImageView(VkDevice device, VkImageView imageView, const VkA assert(!status && "vkDestroyImageView"); }

+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, &params); + assert(!status && "vkDestroyIndirectCommandsLayoutEXT"); +} + void WINAPI vkDestroyIndirectCommandsLayoutNV(VkDevice device, VkIndirectCommandsLayoutNV indirectCommandsLayout, const VkAllocationCallbacks *pAllocator) { struct vkDestroyIndirectCommandsLayoutNV_params params; @@ -3641,6 +3705,17 @@ void WINAPI vkDestroyIndirectCommandsLayoutNV(VkDevice device, VkIndirectCommand assert(!status && "vkDestroyIndirectCommandsLayoutNV"); }

+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, &params); + assert(!status && "vkDestroyIndirectExecutionSetEXT"); +} + void WINAPI vkDestroyMicromapEXT(VkDevice device, VkMicromapEXT micromap, const VkAllocationCallbacks *pAllocator) { struct vkDestroyMicromapEXT_params params; @@ -4594,6 +4669,17 @@ VkResult WINAPI vkGetFramebufferTilePropertiesQCOM(VkDevice device, VkFramebuffe 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, &params); + assert(!status && "vkGetGeneratedCommandsMemoryRequirementsEXT"); +} + void WINAPI vkGetGeneratedCommandsMemoryRequirementsNV(VkDevice device, const VkGeneratedCommandsMemoryRequirementsInfoNV *pInfo, VkMemoryRequirements2 *pMemoryRequirements) { struct vkGetGeneratedCommandsMemoryRequirementsNV_params params; @@ -6311,6 +6397,30 @@ void WINAPI vkUpdateDescriptorSets(VkDevice device, uint32_t descriptorWriteCoun UNIX_CALL(vkUpdateDescriptorSets, &params); }

+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, &params); + assert(!status && "vkUpdateIndirectExecutionSetPipelineEXT"); +} + +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, &params); + assert(!status && "vkUpdateIndirectExecutionSetShaderEXT"); +} + VkResult WINAPI vkUpdateVideoSessionParametersKHR(VkDevice device, VkVideoSessionParametersKHR videoSessionParameters, const VkVideoSessionParametersUpdateInfoKHR *pUpdateInfo) { struct vkUpdateVideoSessionParametersKHR_params params; @@ -6534,6 +6644,7 @@ static const struct vulkan_func vk_device_dispatch_table[] = {"vkCmdEndTransformFeedbackEXT", vkCmdEndTransformFeedbackEXT}, {"vkCmdEndVideoCodingKHR", vkCmdEndVideoCodingKHR}, {"vkCmdExecuteCommands", vkCmdExecuteCommands}, + {"vkCmdExecuteGeneratedCommandsEXT", vkCmdExecuteGeneratedCommandsEXT}, {"vkCmdExecuteGeneratedCommandsNV", vkCmdExecuteGeneratedCommandsNV}, {"vkCmdFillBuffer", vkCmdFillBuffer}, {"vkCmdInsertDebugUtilsLabelEXT", vkCmdInsertDebugUtilsLabelEXT}, @@ -6544,6 +6655,7 @@ static const struct vulkan_func vk_device_dispatch_table[] = {"vkCmdPipelineBarrier", vkCmdPipelineBarrier}, {"vkCmdPipelineBarrier2", vkCmdPipelineBarrier2}, {"vkCmdPipelineBarrier2KHR", vkCmdPipelineBarrier2KHR}, + {"vkCmdPreprocessGeneratedCommandsEXT", vkCmdPreprocessGeneratedCommandsEXT}, {"vkCmdPreprocessGeneratedCommandsNV", vkCmdPreprocessGeneratedCommandsNV}, {"vkCmdPushConstants", vkCmdPushConstants}, {"vkCmdPushConstants2KHR", vkCmdPushConstants2KHR}, @@ -6586,6 +6698,7 @@ static const struct vulkan_func vk_device_dispatch_table[] = {"vkCmdSetDepthBoundsTestEnable", vkCmdSetDepthBoundsTestEnable}, {"vkCmdSetDepthBoundsTestEnableEXT", vkCmdSetDepthBoundsTestEnableEXT}, {"vkCmdSetDepthClampEnableEXT", vkCmdSetDepthClampEnableEXT}, + {"vkCmdSetDepthClampRangeEXT", vkCmdSetDepthClampRangeEXT}, {"vkCmdSetDepthClipEnableEXT", vkCmdSetDepthClipEnableEXT}, {"vkCmdSetDepthClipNegativeOneToOneEXT", vkCmdSetDepthClipNegativeOneToOneEXT}, {"vkCmdSetDepthCompareOp", vkCmdSetDepthCompareOp}, @@ -6708,7 +6821,9 @@ static const struct vulkan_func vk_device_dispatch_table[] = {"vkCreateGraphicsPipelines", vkCreateGraphicsPipelines}, {"vkCreateImage", vkCreateImage}, {"vkCreateImageView", vkCreateImageView}, + {"vkCreateIndirectCommandsLayoutEXT", vkCreateIndirectCommandsLayoutEXT}, {"vkCreateIndirectCommandsLayoutNV", vkCreateIndirectCommandsLayoutNV}, + {"vkCreateIndirectExecutionSetEXT", vkCreateIndirectExecutionSetEXT}, {"vkCreateMicromapEXT", vkCreateMicromapEXT}, {"vkCreateOpticalFlowSessionNV", vkCreateOpticalFlowSessionNV}, {"vkCreatePipelineBinariesKHR", vkCreatePipelineBinariesKHR}, @@ -6755,7 +6870,9 @@ static const struct vulkan_func vk_device_dispatch_table[] = {"vkDestroyFramebuffer", vkDestroyFramebuffer}, {"vkDestroyImage", vkDestroyImage}, {"vkDestroyImageView", vkDestroyImageView}, + {"vkDestroyIndirectCommandsLayoutEXT", vkDestroyIndirectCommandsLayoutEXT}, {"vkDestroyIndirectCommandsLayoutNV", vkDestroyIndirectCommandsLayoutNV}, + {"vkDestroyIndirectExecutionSetEXT", vkDestroyIndirectExecutionSetEXT}, {"vkDestroyMicromapEXT", vkDestroyMicromapEXT}, {"vkDestroyOpticalFlowSessionNV", vkDestroyOpticalFlowSessionNV}, {"vkDestroyPipeline", vkDestroyPipeline}, @@ -6834,6 +6951,7 @@ static const struct vulkan_func vk_device_dispatch_table[] = {"vkGetEventStatus", vkGetEventStatus}, {"vkGetFenceStatus", vkGetFenceStatus}, {"vkGetFramebufferTilePropertiesQCOM", vkGetFramebufferTilePropertiesQCOM}, + {"vkGetGeneratedCommandsMemoryRequirementsEXT", vkGetGeneratedCommandsMemoryRequirementsEXT}, {"vkGetGeneratedCommandsMemoryRequirementsNV", vkGetGeneratedCommandsMemoryRequirementsNV}, {"vkGetImageMemoryRequirements", vkGetImageMemoryRequirements}, {"vkGetImageMemoryRequirements2", vkGetImageMemoryRequirements2}, @@ -6931,6 +7049,8 @@ static const struct vulkan_func vk_device_dispatch_table[] = {"vkUpdateDescriptorSetWithTemplate", vkUpdateDescriptorSetWithTemplate}, {"vkUpdateDescriptorSetWithTemplateKHR", vkUpdateDescriptorSetWithTemplateKHR}, {"vkUpdateDescriptorSets", vkUpdateDescriptorSets}, + {"vkUpdateIndirectExecutionSetPipelineEXT", vkUpdateIndirectExecutionSetPipelineEXT}, + {"vkUpdateIndirectExecutionSetShaderEXT", vkUpdateIndirectExecutionSetShaderEXT}, {"vkUpdateVideoSessionParametersKHR", vkUpdateVideoSessionParametersKHR}, {"vkWaitForFences", vkWaitForFences}, {"vkWaitForPresentKHR", vkWaitForPresentKHR}, diff --git a/dlls/winevulkan/loader_thunks.h b/dlls/winevulkan/loader_thunks.h index bf175374b5d..8ab16eebdf4 100644 --- a/dlls/winevulkan/loader_thunks.h +++ b/dlls/winevulkan/loader_thunks.h @@ -149,6 +149,7 @@ enum unix_call unix_vkCmdEndTransformFeedbackEXT, unix_vkCmdEndVideoCodingKHR, unix_vkCmdExecuteCommands, + unix_vkCmdExecuteGeneratedCommandsEXT, unix_vkCmdExecuteGeneratedCommandsNV, unix_vkCmdFillBuffer, unix_vkCmdInsertDebugUtilsLabelEXT, @@ -159,6 +160,7 @@ enum unix_call unix_vkCmdPipelineBarrier, unix_vkCmdPipelineBarrier2, unix_vkCmdPipelineBarrier2KHR, + unix_vkCmdPreprocessGeneratedCommandsEXT, unix_vkCmdPreprocessGeneratedCommandsNV, unix_vkCmdPushConstants, unix_vkCmdPushConstants2KHR, @@ -201,6 +203,7 @@ enum unix_call unix_vkCmdSetDepthBoundsTestEnable, unix_vkCmdSetDepthBoundsTestEnableEXT, unix_vkCmdSetDepthClampEnableEXT, + unix_vkCmdSetDepthClampRangeEXT, unix_vkCmdSetDepthClipEnableEXT, unix_vkCmdSetDepthClipNegativeOneToOneEXT, unix_vkCmdSetDepthCompareOp, @@ -326,7 +329,9 @@ enum unix_call unix_vkCreateGraphicsPipelines, unix_vkCreateImage, unix_vkCreateImageView, + unix_vkCreateIndirectCommandsLayoutEXT, unix_vkCreateIndirectCommandsLayoutNV, + unix_vkCreateIndirectExecutionSetEXT, unix_vkCreateInstance, unix_vkCreateMicromapEXT, unix_vkCreateOpticalFlowSessionNV, @@ -378,7 +383,9 @@ enum unix_call unix_vkDestroyFramebuffer, unix_vkDestroyImage, unix_vkDestroyImageView, + unix_vkDestroyIndirectCommandsLayoutEXT, unix_vkDestroyIndirectCommandsLayoutNV, + unix_vkDestroyIndirectExecutionSetEXT, unix_vkDestroyInstance, unix_vkDestroyMicromapEXT, unix_vkDestroyOpticalFlowSessionNV, @@ -466,6 +473,7 @@ enum unix_call unix_vkGetEventStatus, unix_vkGetFenceStatus, unix_vkGetFramebufferTilePropertiesQCOM, + unix_vkGetGeneratedCommandsMemoryRequirementsEXT, unix_vkGetGeneratedCommandsMemoryRequirementsNV, unix_vkGetImageMemoryRequirements, unix_vkGetImageMemoryRequirements2, @@ -613,6 +621,8 @@ enum unix_call unix_vkUpdateDescriptorSetWithTemplate, unix_vkUpdateDescriptorSetWithTemplateKHR, unix_vkUpdateDescriptorSets, + unix_vkUpdateIndirectExecutionSetPipelineEXT, + unix_vkUpdateIndirectExecutionSetShaderEXT, unix_vkUpdateVideoSessionParametersKHR, unix_vkWaitForFences, unix_vkWaitForPresentKHR, @@ -1634,6 +1644,13 @@ struct vkCmdExecuteCommands_params const VkCommandBuffer *pCommandBuffers; };

+struct vkCmdExecuteGeneratedCommandsEXT_params +{ + VkCommandBuffer commandBuffer; + VkBool32 isPreprocessed; + const VkGeneratedCommandsInfoEXT *pGeneratedCommandsInfo; +}; + struct vkCmdExecuteGeneratedCommandsNV_params { VkCommandBuffer commandBuffer; @@ -1709,6 +1726,13 @@ struct vkCmdPipelineBarrier2KHR_params const VkDependencyInfo *pDependencyInfo; };

+struct vkCmdPreprocessGeneratedCommandsEXT_params +{ + VkCommandBuffer commandBuffer; + const VkGeneratedCommandsInfoEXT *pGeneratedCommandsInfo; + VkCommandBuffer stateCommandBuffer; +}; + struct vkCmdPreprocessGeneratedCommandsNV_params { VkCommandBuffer commandBuffer; @@ -1997,6 +2021,13 @@ struct vkCmdSetDepthClampEnableEXT_params VkBool32 depthClampEnable; };

+struct vkCmdSetDepthClampRangeEXT_params +{ + VkCommandBuffer commandBuffer; + VkDepthClampModeEXT depthClampMode; + const VkDepthClampRangeEXT *pDepthClampRange; +}; + struct vkCmdSetDepthClipEnableEXT_params { VkCommandBuffer commandBuffer; @@ -2954,6 +2985,15 @@ struct vkCreateImageView_params VkResult result; };

+struct vkCreateIndirectCommandsLayoutEXT_params +{ + VkDevice device; + const VkIndirectCommandsLayoutCreateInfoEXT *pCreateInfo; + const VkAllocationCallbacks *pAllocator; + VkIndirectCommandsLayoutEXT *pIndirectCommandsLayout; + VkResult result; +}; + struct vkCreateIndirectCommandsLayoutNV_params { VkDevice device; @@ -2963,6 +3003,15 @@ struct vkCreateIndirectCommandsLayoutNV_params VkResult result; };

+struct vkCreateIndirectExecutionSetEXT_params +{ + VkDevice device; + const VkIndirectExecutionSetCreateInfoEXT *pCreateInfo; + const VkAllocationCallbacks *pAllocator; + VkIndirectExecutionSetEXT *pIndirectExecutionSet; + VkResult result; +}; + struct vkCreateInstance_params { const VkInstanceCreateInfo *pCreateInfo; @@ -3380,6 +3429,13 @@ struct vkDestroyImageView_params const VkAllocationCallbacks *pAllocator; };

+struct vkDestroyIndirectCommandsLayoutEXT_params +{ + VkDevice device; + VkIndirectCommandsLayoutEXT DECLSPEC_ALIGN(8) indirectCommandsLayout; + const VkAllocationCallbacks *pAllocator; +}; + struct vkDestroyIndirectCommandsLayoutNV_params { VkDevice device; @@ -3387,6 +3443,13 @@ struct vkDestroyIndirectCommandsLayoutNV_params const VkAllocationCallbacks *pAllocator; };

+struct vkDestroyIndirectExecutionSetEXT_params +{ + VkDevice device; + VkIndirectExecutionSetEXT DECLSPEC_ALIGN(8) indirectExecutionSet; + const VkAllocationCallbacks *pAllocator; +}; + struct vkDestroyInstance_params { VkInstance instance; @@ -4038,6 +4101,13 @@ struct vkGetFramebufferTilePropertiesQCOM_params VkResult result; };

+struct vkGetGeneratedCommandsMemoryRequirementsEXT_params +{ + VkDevice device; + const VkGeneratedCommandsMemoryRequirementsInfoEXT *pInfo; + VkMemoryRequirements2 *pMemoryRequirements; +}; + struct vkGetGeneratedCommandsMemoryRequirementsNV_params { VkDevice device; @@ -5191,6 +5261,22 @@ struct vkUpdateDescriptorSets_params const VkCopyDescriptorSet *pDescriptorCopies; };

+struct vkUpdateIndirectExecutionSetPipelineEXT_params +{ + VkDevice device; + VkIndirectExecutionSetEXT DECLSPEC_ALIGN(8) indirectExecutionSet; + uint32_t executionSetWriteCount; + const VkWriteIndirectExecutionSetPipelineEXT *pExecutionSetWrites; +}; + +struct vkUpdateIndirectExecutionSetShaderEXT_params +{ + VkDevice device; + VkIndirectExecutionSetEXT DECLSPEC_ALIGN(8) indirectExecutionSet; + uint32_t executionSetWriteCount; + const VkWriteIndirectExecutionSetShaderEXT *pExecutionSetWrites; +}; + struct vkUpdateVideoSessionParametersKHR_params { VkDevice device; diff --git a/dlls/winevulkan/make_vulkan b/dlls/winevulkan/make_vulkan index 288fa1fd11a..8978766189c 100755 --- a/dlls/winevulkan/make_vulkan +++ b/dlls/winevulkan/make_vulkan @@ -64,7 +64,7 @@ from enum import Enum LOGGER = logging.Logger("vulkan") LOGGER.addHandler(logging.StreamHandler())

-VK_XML_VERSION = "1.3.295" +VK_XML_VERSION = "1.3.296" WINE_VK_VERSION = (1, 3)

# Filenames to create. diff --git a/dlls/winevulkan/vulkan_thunks.c b/dlls/winevulkan/vulkan_thunks.c index 76bc26b53fd..1a2d2487a4c 100644 --- a/dlls/winevulkan/vulkan_thunks.c +++ b/dlls/winevulkan/vulkan_thunks.c @@ -1402,6 +1402,37 @@ typedef struct VkVideoEndCodingInfoKHR32 VkVideoEndCodingFlagsKHR flags; } VkVideoEndCodingInfoKHR32;

+typedef struct VkGeneratedCommandsPipelineInfoEXT32 +{ + VkStructureType sType; + PTR32 pNext; + VkPipeline DECLSPEC_ALIGN(8) pipeline; +} VkGeneratedCommandsPipelineInfoEXT32; + +typedef struct VkGeneratedCommandsShaderInfoEXT32 +{ + VkStructureType sType; + PTR32 pNext; + uint32_t shaderCount; + PTR32 pShaders; +} VkGeneratedCommandsShaderInfoEXT32; + +typedef struct VkGeneratedCommandsInfoEXT32 +{ + VkStructureType sType; + PTR32 pNext; + VkShaderStageFlags shaderStages; + VkIndirectExecutionSetEXT DECLSPEC_ALIGN(8) indirectExecutionSet; + VkIndirectCommandsLayoutEXT DECLSPEC_ALIGN(8) indirectCommandsLayout; + VkDeviceAddress DECLSPEC_ALIGN(8) indirectAddress; + VkDeviceSize DECLSPEC_ALIGN(8) indirectAddressSize; + VkDeviceAddress DECLSPEC_ALIGN(8) preprocessAddress; + VkDeviceSize DECLSPEC_ALIGN(8) preprocessSize; + uint32_t maxSequenceCount; + VkDeviceAddress DECLSPEC_ALIGN(8) sequenceCountAddress; + uint32_t maxDrawCount; +} VkGeneratedCommandsInfoEXT32; + typedef struct VkIndirectCommandsStreamNV32 { VkBuffer DECLSPEC_ALIGN(8) buffer; @@ -3311,6 +3342,21 @@ typedef struct VkPhysicalDeviceDepthClipControlFeaturesEXT32 VkBool32 depthClipControl; } VkPhysicalDeviceDepthClipControlFeaturesEXT32;

+typedef struct VkPhysicalDeviceDeviceGeneratedCommandsFeaturesEXT32 +{ + VkStructureType sType; + PTR32 pNext; + VkBool32 deviceGeneratedCommands; + VkBool32 dynamicGeneratedPipelineLayout; +} VkPhysicalDeviceDeviceGeneratedCommandsFeaturesEXT32; + +typedef struct VkPhysicalDeviceDepthClampControlFeaturesEXT32 +{ + VkStructureType sType; + PTR32 pNext; + VkBool32 depthClampControl; +} VkPhysicalDeviceDepthClampControlFeaturesEXT32; + typedef struct VkPhysicalDeviceVertexInputDynamicStateFeaturesEXT32 { VkStructureType sType; @@ -4087,6 +4133,14 @@ typedef struct VkPipelineViewportDepthClipControlCreateInfoEXT32 VkBool32 negativeOneToOne; } VkPipelineViewportDepthClipControlCreateInfoEXT32;

+typedef struct VkPipelineViewportDepthClampControlCreateInfoEXT32 +{ + VkStructureType sType; + PTR32 pNext; + VkDepthClampModeEXT depthClampMode; + PTR32 pDepthClampRange; +} VkPipelineViewportDepthClampControlCreateInfoEXT32; + typedef struct VkPipelineViewportStateCreateInfo32 { VkStructureType sType; @@ -4502,6 +4556,35 @@ typedef struct VkImageViewCreateInfo32 VkImageSubresourceRange subresourceRange; } VkImageViewCreateInfo32;

+typedef union VkIndirectCommandsTokenDataEXT32 +{ + PTR32 pPushConstant; + PTR32 pVertexBuffer; + PTR32 pIndexBuffer; + PTR32 pExecutionSet; +} VkIndirectCommandsTokenDataEXT32; + +typedef struct VkIndirectCommandsLayoutTokenEXT32 +{ + VkStructureType sType; + PTR32 pNext; + VkIndirectCommandsTokenTypeEXT type; + VkIndirectCommandsTokenDataEXT32 data; + uint32_t offset; +} VkIndirectCommandsLayoutTokenEXT32; + +typedef struct VkIndirectCommandsLayoutCreateInfoEXT32 +{ + VkStructureType sType; + PTR32 pNext; + VkIndirectCommandsLayoutUsageFlagsEXT flags; + VkShaderStageFlags shaderStages; + uint32_t indirectStride; + VkPipelineLayout DECLSPEC_ALIGN(8) pipelineLayout; + uint32_t tokenCount; + PTR32 pTokens; +} VkIndirectCommandsLayoutCreateInfoEXT32; + typedef struct VkIndirectCommandsLayoutTokenNV32 { VkStructureType sType; @@ -4533,6 +4616,48 @@ typedef struct VkIndirectCommandsLayoutCreateInfoNV32 PTR32 pStreamStrides; } VkIndirectCommandsLayoutCreateInfoNV32;

+typedef struct VkIndirectExecutionSetPipelineInfoEXT32 +{ + VkStructureType sType; + PTR32 pNext; + VkPipeline DECLSPEC_ALIGN(8) initialPipeline; + uint32_t maxPipelineCount; +} VkIndirectExecutionSetPipelineInfoEXT32; + +typedef struct VkIndirectExecutionSetShaderLayoutInfoEXT32 +{ + VkStructureType sType; + PTR32 pNext; + uint32_t setLayoutCount; + PTR32 pSetLayouts; +} VkIndirectExecutionSetShaderLayoutInfoEXT32; + +typedef struct VkIndirectExecutionSetShaderInfoEXT32 +{ + VkStructureType sType; + PTR32 pNext; + uint32_t shaderCount; + PTR32 pInitialShaders; + PTR32 pSetLayoutInfos; + uint32_t maxShaderCount; + uint32_t pushConstantRangeCount; + PTR32 pPushConstantRanges; +} VkIndirectExecutionSetShaderInfoEXT32; + +typedef union VkIndirectExecutionSetInfoEXT32 +{ + PTR32 pPipelineInfo; + PTR32 pShaderInfo; +} VkIndirectExecutionSetInfoEXT32; + +typedef struct VkIndirectExecutionSetCreateInfoEXT32 +{ + VkStructureType sType; + PTR32 pNext; + VkIndirectExecutionSetInfoTypeEXT type; + VkIndirectExecutionSetInfoEXT32 info; +} VkIndirectExecutionSetCreateInfoEXT32; + typedef struct VkLayerSettingEXT32 { PTR32 pLayerName; @@ -5970,6 +6095,16 @@ typedef struct VkVideoEncodeSessionParametersFeedbackInfoKHR32 VkBool32 hasOverrides; } VkVideoEncodeSessionParametersFeedbackInfoKHR32;

+typedef struct VkGeneratedCommandsMemoryRequirementsInfoEXT32 +{ + VkStructureType sType; + PTR32 pNext; + VkIndirectExecutionSetEXT DECLSPEC_ALIGN(8) indirectExecutionSet; + VkIndirectCommandsLayoutEXT DECLSPEC_ALIGN(8) indirectCommandsLayout; + uint32_t maxSequenceCount; + uint32_t maxDrawCount; +} VkGeneratedCommandsMemoryRequirementsInfoEXT32; + typedef struct VkGeneratedCommandsMemoryRequirementsInfoNV32 { VkStructureType sType; @@ -7209,6 +7344,24 @@ typedef struct VkPhysicalDeviceLegacyVertexAttributesPropertiesEXT32 VkBool32 nativeUnalignedPerformance; } VkPhysicalDeviceLegacyVertexAttributesPropertiesEXT32;

+typedef struct VkPhysicalDeviceDeviceGeneratedCommandsPropertiesEXT32 +{ + VkStructureType sType; + PTR32 pNext; + uint32_t maxIndirectPipelineCount; + uint32_t maxIndirectShaderObjectCount; + uint32_t maxIndirectSequenceCount; + uint32_t maxIndirectCommandsTokenCount; + uint32_t maxIndirectCommandsTokenOffset; + uint32_t maxIndirectCommandsIndirectStride; + VkIndirectCommandsInputModeFlagsEXT supportedIndirectCommandsInputModes; + VkShaderStageFlags supportedIndirectCommandsShaderStages; + VkShaderStageFlags supportedIndirectCommandsShaderStagesPipelineBinding; + VkShaderStageFlags supportedIndirectCommandsShaderStagesShaderBinding; + VkBool32 deviceGeneratedCommandsTransformFeedback; + VkBool32 deviceGeneratedCommandsMultiDrawIndirectCount; +} VkPhysicalDeviceDeviceGeneratedCommandsPropertiesEXT32; + typedef struct VkPhysicalDeviceHostImageCopyPropertiesEXT32 { VkStructureType sType; @@ -8348,6 +8501,22 @@ typedef struct VkCopyDescriptorSet32 uint32_t descriptorCount; } VkCopyDescriptorSet32;

+typedef struct VkWriteIndirectExecutionSetPipelineEXT32 +{ + VkStructureType sType; + PTR32 pNext; + uint32_t index; + VkPipeline DECLSPEC_ALIGN(8) pipeline; +} VkWriteIndirectExecutionSetPipelineEXT32; + +typedef struct VkWriteIndirectExecutionSetShaderEXT32 +{ + VkStructureType sType; + PTR32 pNext; + uint32_t index; + VkShaderEXT DECLSPEC_ALIGN(8) shader; +} VkWriteIndirectExecutionSetShaderEXT32; + typedef struct VkVideoSessionParametersUpdateInfoKHR32 { VkStructureType sType; @@ -11524,6 +11693,60 @@ static inline const VkCommandBuffer *convert_VkCommandBuffer_array_win32_to_host return out; }

+static inline void convert_VkGeneratedCommandsInfoEXT_win32_to_host(struct conversion_context *ctx, const VkGeneratedCommandsInfoEXT32 *in, VkGeneratedCommandsInfoEXT *out) +{ + const VkBaseInStructure32 *in_header; + VkBaseOutStructure *out_header = (void *)out; + + if (!in) return; + + out->sType = in->sType; + out->pNext = NULL; + out->shaderStages = in->shaderStages; + out->indirectExecutionSet = in->indirectExecutionSet; + out->indirectCommandsLayout = in->indirectCommandsLayout; + out->indirectAddress = in->indirectAddress; + out->indirectAddressSize = in->indirectAddressSize; + out->preprocessAddress = in->preprocessAddress; + out->preprocessSize = in->preprocessSize; + out->maxSequenceCount = in->maxSequenceCount; + out->sequenceCountAddress = in->sequenceCountAddress; + out->maxDrawCount = in->maxDrawCount; + + for (in_header = UlongToPtr(in->pNext); in_header; in_header = UlongToPtr(in_header->pNext)) + { + switch (in_header->sType) + { + case VK_STRUCTURE_TYPE_GENERATED_COMMANDS_PIPELINE_INFO_EXT: + { + VkGeneratedCommandsPipelineInfoEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext)); + const VkGeneratedCommandsPipelineInfoEXT32 *in_ext = (const VkGeneratedCommandsPipelineInfoEXT32 *)in_header; + out_ext->sType = VK_STRUCTURE_TYPE_GENERATED_COMMANDS_PIPELINE_INFO_EXT; + out_ext->pNext = NULL; + out_ext->pipeline = in_ext->pipeline; + out_header->pNext = (void *)out_ext; + out_header = (void *)out_ext; + break; + } + case VK_STRUCTURE_TYPE_GENERATED_COMMANDS_SHADER_INFO_EXT: + { + VkGeneratedCommandsShaderInfoEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext)); + const VkGeneratedCommandsShaderInfoEXT32 *in_ext = (const VkGeneratedCommandsShaderInfoEXT32 *)in_header; + out_ext->sType = VK_STRUCTURE_TYPE_GENERATED_COMMANDS_SHADER_INFO_EXT; + out_ext->pNext = NULL; + out_ext->shaderCount = in_ext->shaderCount; + out_ext->pShaders = UlongToPtr(in_ext->pShaders); + out_header->pNext = (void *)out_ext; + out_header = (void *)out_ext; + break; + } + default: + FIXME("Unhandled sType %u.\n", in_header->sType); + break; + } + } +} + static inline void convert_VkIndirectCommandsStreamNV_win32_to_host(const VkIndirectCommandsStreamNV32 *in, VkIndirectCommandsStreamNV *out) { if (!in) return; @@ -15293,6 +15516,29 @@ static inline void convert_VkDeviceCreateInfo_win64_to_host(struct conversion_co out_header = (void *)out_ext; break; } + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DEVICE_GENERATED_COMMANDS_FEATURES_EXT: + { + VkPhysicalDeviceDeviceGeneratedCommandsFeaturesEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext)); + const VkPhysicalDeviceDeviceGeneratedCommandsFeaturesEXT *in_ext = (const VkPhysicalDeviceDeviceGeneratedCommandsFeaturesEXT *)in_header; + out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DEVICE_GENERATED_COMMANDS_FEATURES_EXT; + out_ext->pNext = NULL; + out_ext->deviceGeneratedCommands = in_ext->deviceGeneratedCommands; + out_ext->dynamicGeneratedPipelineLayout = in_ext->dynamicGeneratedPipelineLayout; + out_header->pNext = (void *)out_ext; + out_header = (void *)out_ext; + break; + } + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DEPTH_CLAMP_CONTROL_FEATURES_EXT: + { + VkPhysicalDeviceDepthClampControlFeaturesEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext)); + const VkPhysicalDeviceDepthClampControlFeaturesEXT *in_ext = (const VkPhysicalDeviceDepthClampControlFeaturesEXT *)in_header; + out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DEPTH_CLAMP_CONTROL_FEATURES_EXT; + out_ext->pNext = NULL; + out_ext->depthClampControl = in_ext->depthClampControl; + out_header->pNext = (void *)out_ext; + out_header = (void *)out_ext; + break; + } case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VERTEX_INPUT_DYNAMIC_STATE_FEATURES_EXT: { VkPhysicalDeviceVertexInputDynamicStateFeaturesEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext)); @@ -17697,6 +17943,29 @@ static inline void convert_VkDeviceCreateInfo_win32_to_host(struct conversion_co out_header = (void *)out_ext; break; } + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DEVICE_GENERATED_COMMANDS_FEATURES_EXT: + { + VkPhysicalDeviceDeviceGeneratedCommandsFeaturesEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext)); + const VkPhysicalDeviceDeviceGeneratedCommandsFeaturesEXT32 *in_ext = (const VkPhysicalDeviceDeviceGeneratedCommandsFeaturesEXT32 *)in_header; + out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DEVICE_GENERATED_COMMANDS_FEATURES_EXT; + out_ext->pNext = NULL; + out_ext->deviceGeneratedCommands = in_ext->deviceGeneratedCommands; + out_ext->dynamicGeneratedPipelineLayout = in_ext->dynamicGeneratedPipelineLayout; + out_header->pNext = (void *)out_ext; + out_header = (void *)out_ext; + break; + } + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DEPTH_CLAMP_CONTROL_FEATURES_EXT: + { + VkPhysicalDeviceDepthClampControlFeaturesEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext)); + const VkPhysicalDeviceDepthClampControlFeaturesEXT32 *in_ext = (const VkPhysicalDeviceDepthClampControlFeaturesEXT32 *)in_header; + out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DEPTH_CLAMP_CONTROL_FEATURES_EXT; + out_ext->pNext = NULL; + out_ext->depthClampControl = in_ext->depthClampControl; + out_header->pNext = (void *)out_ext; + out_header = (void *)out_ext; + break; + } case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VERTEX_INPUT_DYNAMIC_STATE_FEATURES_EXT: { VkPhysicalDeviceVertexInputDynamicStateFeaturesEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext)); @@ -19072,6 +19341,18 @@ static inline void convert_VkPipelineViewportStateCreateInfo_win32_to_host(struc out_header = (void *)out_ext; break; } + case VK_STRUCTURE_TYPE_PIPELINE_VIEWPORT_DEPTH_CLAMP_CONTROL_CREATE_INFO_EXT: + { + VkPipelineViewportDepthClampControlCreateInfoEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext)); + const VkPipelineViewportDepthClampControlCreateInfoEXT32 *in_ext = (const VkPipelineViewportDepthClampControlCreateInfoEXT32 *)in_header; + out_ext->sType = VK_STRUCTURE_TYPE_PIPELINE_VIEWPORT_DEPTH_CLAMP_CONTROL_CREATE_INFO_EXT; + out_ext->pNext = NULL; + out_ext->depthClampMode = in_ext->depthClampMode; + out_ext->pDepthClampRange = UlongToPtr(in_ext->pDepthClampRange); + out_header->pNext = (void *)out_ext; + out_header = (void *)out_ext; + break; + } default: FIXME("Unhandled sType %u.\n", in_header->sType); break; @@ -20442,6 +20723,91 @@ static inline void convert_VkImageViewCreateInfo_win32_to_host(struct conversion } }

+static inline void convert_VkIndirectCommandsTokenDataEXT_win32_to_host(const VkIndirectCommandsTokenDataEXT32 *in, VkIndirectCommandsTokenDataEXT *out, VkFlags selector) +{ + if (!in) return; + + if (selector == VK_INDIRECT_COMMANDS_TOKEN_TYPE_PUSH_CONSTANT_EXT) + out->pPushConstant = UlongToPtr(in->pPushConstant); + if (selector == VK_INDIRECT_COMMANDS_TOKEN_TYPE_VERTEX_BUFFER_EXT) + out->pVertexBuffer = UlongToPtr(in->pVertexBuffer); + if (selector == VK_INDIRECT_COMMANDS_TOKEN_TYPE_INDEX_BUFFER_EXT) + out->pIndexBuffer = UlongToPtr(in->pIndexBuffer); + if (selector == VK_INDIRECT_COMMANDS_TOKEN_TYPE_EXECUTION_SET_EXT) + out->pExecutionSet = UlongToPtr(in->pExecutionSet); +} + +static inline void convert_VkIndirectCommandsLayoutTokenEXT_win32_to_host(const VkIndirectCommandsLayoutTokenEXT32 *in, VkIndirectCommandsLayoutTokenEXT *out) +{ + if (!in) return; + + out->sType = in->sType; + out->pNext = NULL; + out->type = in->type; + convert_VkIndirectCommandsTokenDataEXT_win32_to_host(&in->data, &out->data, in->type); + out->offset = in->offset; + if (in->pNext) + FIXME("Unexpected pNext\n"); +} + +static inline const VkIndirectCommandsLayoutTokenEXT *convert_VkIndirectCommandsLayoutTokenEXT_array_win32_to_host(struct conversion_context *ctx, const VkIndirectCommandsLayoutTokenEXT32 *in, uint32_t count) +{ + VkIndirectCommandsLayoutTokenEXT *out; + unsigned int i; + + if (!in || !count) return NULL; + + out = conversion_context_alloc(ctx, count * sizeof(*out)); + for (i = 0; i < count; i++) + { + convert_VkIndirectCommandsLayoutTokenEXT_win32_to_host(&in[i], &out[i]); + } + + return out; +} + +static inline void convert_VkIndirectCommandsLayoutCreateInfoEXT_win32_to_host(struct conversion_context *ctx, const VkIndirectCommandsLayoutCreateInfoEXT32 *in, VkIndirectCommandsLayoutCreateInfoEXT *out) +{ + const VkBaseInStructure32 *in_header; + VkBaseOutStructure *out_header = (void *)out; + + if (!in) return; + + out->sType = in->sType; + out->pNext = NULL; + out->flags = in->flags; + out->shaderStages = in->shaderStages; + out->indirectStride = in->indirectStride; + out->pipelineLayout = in->pipelineLayout; + out->tokenCount = in->tokenCount; + out->pTokens = convert_VkIndirectCommandsLayoutTokenEXT_array_win32_to_host(ctx, (const VkIndirectCommandsLayoutTokenEXT32 *)UlongToPtr(in->pTokens), in->tokenCount); + + for (in_header = UlongToPtr(in->pNext); in_header; in_header = UlongToPtr(in_header->pNext)) + { + switch (in_header->sType) + { + case VK_STRUCTURE_TYPE_PIPELINE_LAYOUT_CREATE_INFO: + { + VkPipelineLayoutCreateInfo *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext)); + const VkPipelineLayoutCreateInfo32 *in_ext = (const VkPipelineLayoutCreateInfo32 *)in_header; + out_ext->sType = VK_STRUCTURE_TYPE_PIPELINE_LAYOUT_CREATE_INFO; + out_ext->pNext = NULL; + out_ext->flags = in_ext->flags; + out_ext->setLayoutCount = in_ext->setLayoutCount; + out_ext->pSetLayouts = UlongToPtr(in_ext->pSetLayouts); + out_ext->pushConstantRangeCount = in_ext->pushConstantRangeCount; + out_ext->pPushConstantRanges = UlongToPtr(in_ext->pPushConstantRanges); + out_header->pNext = (void *)out_ext; + out_header = (void *)out_ext; + break; + } + default: + FIXME("Unhandled sType %u.\n", in_header->sType); + break; + } + } +} + static inline void convert_VkIndirectCommandsLayoutTokenNV_win32_to_host(const VkIndirectCommandsLayoutTokenNV32 *in, VkIndirectCommandsLayoutTokenNV *out) { if (!in) return; @@ -20497,6 +20863,116 @@ static inline void convert_VkIndirectCommandsLayoutCreateInfoNV_win32_to_host(st FIXME("Unexpected pNext\n"); }

+static inline void convert_VkIndirectExecutionSetPipelineInfoEXT_win32_to_host(const VkIndirectExecutionSetPipelineInfoEXT32 *in, VkIndirectExecutionSetPipelineInfoEXT *out) +{ + if (!in) return; + + out->sType = in->sType; + out->pNext = NULL; + out->initialPipeline = in->initialPipeline; + out->maxPipelineCount = in->maxPipelineCount; + if (in->pNext) + FIXME("Unexpected pNext\n"); +} + +static inline const VkIndirectExecutionSetPipelineInfoEXT *convert_VkIndirectExecutionSetPipelineInfoEXT_array_win32_to_host(struct conversion_context *ctx, const VkIndirectExecutionSetPipelineInfoEXT32 *in, uint32_t count) +{ + VkIndirectExecutionSetPipelineInfoEXT *out; + unsigned int i; + + if (!in || !count) return NULL; + + out = conversion_context_alloc(ctx, count * sizeof(*out)); + for (i = 0; i < count; i++) + { + convert_VkIndirectExecutionSetPipelineInfoEXT_win32_to_host(&in[i], &out[i]); + } + + return out; +} + +static inline void convert_VkIndirectExecutionSetShaderLayoutInfoEXT_win32_to_host(const VkIndirectExecutionSetShaderLayoutInfoEXT32 *in, VkIndirectExecutionSetShaderLayoutInfoEXT *out) +{ + if (!in) return; + + out->sType = in->sType; + out->pNext = NULL; + out->setLayoutCount = in->setLayoutCount; + out->pSetLayouts = UlongToPtr(in->pSetLayouts); + if (in->pNext) + FIXME("Unexpected pNext\n"); +} + +static inline const VkIndirectExecutionSetShaderLayoutInfoEXT *convert_VkIndirectExecutionSetShaderLayoutInfoEXT_array_win32_to_host(struct conversion_context *ctx, const VkIndirectExecutionSetShaderLayoutInfoEXT32 *in, uint32_t count) +{ + VkIndirectExecutionSetShaderLayoutInfoEXT *out; + unsigned int i; + + if (!in || !count) return NULL; + + out = conversion_context_alloc(ctx, count * sizeof(*out)); + for (i = 0; i < count; i++) + { + convert_VkIndirectExecutionSetShaderLayoutInfoEXT_win32_to_host(&in[i], &out[i]); + } + + return out; +} + +static inline void convert_VkIndirectExecutionSetShaderInfoEXT_win32_to_host(struct conversion_context *ctx, const VkIndirectExecutionSetShaderInfoEXT32 *in, VkIndirectExecutionSetShaderInfoEXT *out) +{ + if (!in) return; + + out->sType = in->sType; + out->pNext = NULL; + out->shaderCount = in->shaderCount; + out->pInitialShaders = UlongToPtr(in->pInitialShaders); + out->pSetLayoutInfos = convert_VkIndirectExecutionSetShaderLayoutInfoEXT_array_win32_to_host(ctx, (const VkIndirectExecutionSetShaderLayoutInfoEXT32 *)UlongToPtr(in->pSetLayoutInfos), in->shaderCount); + out->maxShaderCount = in->maxShaderCount; + out->pushConstantRangeCount = in->pushConstantRangeCount; + out->pPushConstantRanges = UlongToPtr(in->pPushConstantRanges); + if (in->pNext) + FIXME("Unexpected pNext\n"); +} + +static inline const VkIndirectExecutionSetShaderInfoEXT *convert_VkIndirectExecutionSetShaderInfoEXT_array_win32_to_host(struct conversion_context *ctx, const VkIndirectExecutionSetShaderInfoEXT32 *in, uint32_t count) +{ + VkIndirectExecutionSetShaderInfoEXT *out; + unsigned int i; + + if (!in || !count) return NULL; + + out = conversion_context_alloc(ctx, count * sizeof(*out)); + for (i = 0; i < count; i++) + { + convert_VkIndirectExecutionSetShaderInfoEXT_win32_to_host(ctx, &in[i], &out[i]); + } + + return out; +} + +static inline void convert_VkIndirectExecutionSetInfoEXT_win32_to_host(struct conversion_context *ctx, const VkIndirectExecutionSetInfoEXT32 *in, VkIndirectExecutionSetInfoEXT *out, VkFlags selector) +{ + if (!in) return; + + if (selector == VK_INDIRECT_EXECUTION_SET_INFO_TYPE_PIPELINES_EXT) + out->pPipelineInfo = convert_VkIndirectExecutionSetPipelineInfoEXT_array_win32_to_host(ctx, (const VkIndirectExecutionSetPipelineInfoEXT32 *)UlongToPtr(in->pPipelineInfo), 1); + if (selector == VK_INDIRECT_EXECUTION_SET_INFO_TYPE_SHADER_OBJECTS_EXT) + out->pShaderInfo = convert_VkIndirectExecutionSetShaderInfoEXT_array_win32_to_host(ctx, (const VkIndirectExecutionSetShaderInfoEXT32 *)UlongToPtr(in->pShaderInfo), 1); +} + +static inline void convert_VkIndirectExecutionSetCreateInfoEXT_win32_to_host(struct conversion_context *ctx, const VkIndirectExecutionSetCreateInfoEXT32 *in, VkIndirectExecutionSetCreateInfoEXT *out) +{ + if (!in) return; + + out->sType = in->sType; + out->pNext = NULL; + out->type = in->type; + convert_VkIndirectExecutionSetInfoEXT_win32_to_host(ctx, &in->info, &out->info, in->type); + if (in->pNext) + FIXME("Unexpected pNext\n"); +} + static inline void convert_VkLayerSettingEXT_win32_to_host(const VkLayerSettingEXT32 *in, VkLayerSettingEXT *out) { if (!in) return; @@ -24481,6 +24957,60 @@ static inline void convert_VkTilePropertiesQCOM_array_host_to_win32(const VkTile } }

+static inline void convert_VkGeneratedCommandsMemoryRequirementsInfoEXT_win32_to_host(struct conversion_context *ctx, const VkGeneratedCommandsMemoryRequirementsInfoEXT32 *in, VkGeneratedCommandsMemoryRequirementsInfoEXT *out) +{ + const VkBaseInStructure32 *in_header; + VkBaseOutStructure *out_header = (void *)out; + + if (!in) return; + + out->sType = in->sType; + out->pNext = NULL; + out->indirectExecutionSet = in->indirectExecutionSet; + out->indirectCommandsLayout = in->indirectCommandsLayout; + out->maxSequenceCount = in->maxSequenceCount; + out->maxDrawCount = in->maxDrawCount; + + for (in_header = UlongToPtr(in->pNext); in_header; in_header = UlongToPtr(in_header->pNext)) + { + switch (in_header->sType) + { + case VK_STRUCTURE_TYPE_GENERATED_COMMANDS_PIPELINE_INFO_EXT: + { + VkGeneratedCommandsPipelineInfoEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext)); + const VkGeneratedCommandsPipelineInfoEXT32 *in_ext = (const VkGeneratedCommandsPipelineInfoEXT32 *)in_header; + out_ext->sType = VK_STRUCTURE_TYPE_GENERATED_COMMANDS_PIPELINE_INFO_EXT; + out_ext->pNext = NULL; + out_ext->pipeline = in_ext->pipeline; + out_header->pNext = (void *)out_ext; + out_header = (void *)out_ext; + break; + } + case VK_STRUCTURE_TYPE_GENERATED_COMMANDS_SHADER_INFO_EXT: + { + VkGeneratedCommandsShaderInfoEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext)); + const VkGeneratedCommandsShaderInfoEXT32 *in_ext = (const VkGeneratedCommandsShaderInfoEXT32 *)in_header; + out_ext->sType = VK_STRUCTURE_TYPE_GENERATED_COMMANDS_SHADER_INFO_EXT; + out_ext->pNext = NULL; + out_ext->shaderCount = in_ext->shaderCount; + out_ext->pShaders = UlongToPtr(in_ext->pShaders); + out_header->pNext = (void *)out_ext; + out_header = (void *)out_ext; + break; + } + default: + FIXME("Unhandled sType %u.\n", in_header->sType); + break; + } + } +} + +static inline void convert_VkGeneratedCommandsMemoryRequirementsInfoEXT_host_to_win32(const VkGeneratedCommandsMemoryRequirementsInfoEXT *in, const VkGeneratedCommandsMemoryRequirementsInfoEXT32 *out) +{ + if (!in) return; + +} + static inline void convert_VkGeneratedCommandsMemoryRequirementsInfoNV_win32_to_host(const VkGeneratedCommandsMemoryRequirementsInfoNV32 *in, VkGeneratedCommandsMemoryRequirementsInfoNV *out) { if (!in) return; @@ -26391,6 +26921,29 @@ static inline void convert_VkPhysicalDeviceFeatures2_win32_to_host(struct conver out_header = (void *)out_ext; break; } + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DEVICE_GENERATED_COMMANDS_FEATURES_EXT: + { + VkPhysicalDeviceDeviceGeneratedCommandsFeaturesEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext)); + const VkPhysicalDeviceDeviceGeneratedCommandsFeaturesEXT32 *in_ext = (const VkPhysicalDeviceDeviceGeneratedCommandsFeaturesEXT32 *)in_header; + out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DEVICE_GENERATED_COMMANDS_FEATURES_EXT; + out_ext->pNext = NULL; + out_ext->deviceGeneratedCommands = in_ext->deviceGeneratedCommands; + out_ext->dynamicGeneratedPipelineLayout = in_ext->dynamicGeneratedPipelineLayout; + out_header->pNext = (void *)out_ext; + out_header = (void *)out_ext; + break; + } + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DEPTH_CLAMP_CONTROL_FEATURES_EXT: + { + VkPhysicalDeviceDepthClampControlFeaturesEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext)); + const VkPhysicalDeviceDepthClampControlFeaturesEXT32 *in_ext = (const VkPhysicalDeviceDepthClampControlFeaturesEXT32 *)in_header; + out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DEPTH_CLAMP_CONTROL_FEATURES_EXT; + out_ext->pNext = NULL; + out_ext->depthClampControl = in_ext->depthClampControl; + out_header->pNext = (void *)out_ext; + out_header = (void *)out_ext; + break; + } case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VERTEX_INPUT_DYNAMIC_STATE_FEATURES_EXT: { VkPhysicalDeviceVertexInputDynamicStateFeaturesEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext)); @@ -28482,6 +29035,25 @@ static inline void convert_VkPhysicalDeviceFeatures2_host_to_win32(const VkPhysi out_header = (void *)out_ext; break; } + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DEVICE_GENERATED_COMMANDS_FEATURES_EXT: + { + VkPhysicalDeviceDeviceGeneratedCommandsFeaturesEXT32 *out_ext = find_next_struct32(out_header, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DEVICE_GENERATED_COMMANDS_FEATURES_EXT); + const VkPhysicalDeviceDeviceGeneratedCommandsFeaturesEXT *in_ext = (const VkPhysicalDeviceDeviceGeneratedCommandsFeaturesEXT *)in_header; + out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DEVICE_GENERATED_COMMANDS_FEATURES_EXT; + out_ext->deviceGeneratedCommands = in_ext->deviceGeneratedCommands; + out_ext->dynamicGeneratedPipelineLayout = in_ext->dynamicGeneratedPipelineLayout; + out_header = (void *)out_ext; + break; + } + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DEPTH_CLAMP_CONTROL_FEATURES_EXT: + { + VkPhysicalDeviceDepthClampControlFeaturesEXT32 *out_ext = find_next_struct32(out_header, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DEPTH_CLAMP_CONTROL_FEATURES_EXT); + const VkPhysicalDeviceDepthClampControlFeaturesEXT *in_ext = (const VkPhysicalDeviceDepthClampControlFeaturesEXT *)in_header; + out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DEPTH_CLAMP_CONTROL_FEATURES_EXT; + out_ext->depthClampControl = in_ext->depthClampControl; + out_header = (void *)out_ext; + break; + } case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VERTEX_INPUT_DYNAMIC_STATE_FEATURES_EXT: { VkPhysicalDeviceVertexInputDynamicStateFeaturesEXT32 *out_ext = find_next_struct32(out_header, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VERTEX_INPUT_DYNAMIC_STATE_FEATURES_EXT); @@ -30467,6 +31039,15 @@ static inline void convert_VkPhysicalDeviceProperties2_win32_to_host(struct conv out_header = (void *)out_ext; break; } + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DEVICE_GENERATED_COMMANDS_PROPERTIES_EXT: + { + VkPhysicalDeviceDeviceGeneratedCommandsPropertiesEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext)); + out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DEVICE_GENERATED_COMMANDS_PROPERTIES_EXT; + out_ext->pNext = NULL; + out_header->pNext = (void *)out_ext; + out_header = (void *)out_ext; + break; + } case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_HOST_IMAGE_COPY_PROPERTIES_EXT: { VkPhysicalDeviceHostImageCopyPropertiesEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext)); @@ -31613,6 +32194,26 @@ static inline void convert_VkPhysicalDeviceProperties2_host_to_win32(const VkPhy out_header = (void *)out_ext; break; } + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DEVICE_GENERATED_COMMANDS_PROPERTIES_EXT: + { + VkPhysicalDeviceDeviceGeneratedCommandsPropertiesEXT32 *out_ext = find_next_struct32(out_header, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DEVICE_GENERATED_COMMANDS_PROPERTIES_EXT); + const VkPhysicalDeviceDeviceGeneratedCommandsPropertiesEXT *in_ext = (const VkPhysicalDeviceDeviceGeneratedCommandsPropertiesEXT *)in_header; + out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DEVICE_GENERATED_COMMANDS_PROPERTIES_EXT; + out_ext->maxIndirectPipelineCount = in_ext->maxIndirectPipelineCount; + out_ext->maxIndirectShaderObjectCount = in_ext->maxIndirectShaderObjectCount; + out_ext->maxIndirectSequenceCount = in_ext->maxIndirectSequenceCount; + out_ext->maxIndirectCommandsTokenCount = in_ext->maxIndirectCommandsTokenCount; + out_ext->maxIndirectCommandsTokenOffset = in_ext->maxIndirectCommandsTokenOffset; + out_ext->maxIndirectCommandsIndirectStride = in_ext->maxIndirectCommandsIndirectStride; + out_ext->supportedIndirectCommandsInputModes = in_ext->supportedIndirectCommandsInputModes; + out_ext->supportedIndirectCommandsShaderStages = in_ext->supportedIndirectCommandsShaderStages; + out_ext->supportedIndirectCommandsShaderStagesPipelineBinding = in_ext->supportedIndirectCommandsShaderStagesPipelineBinding; + out_ext->supportedIndirectCommandsShaderStagesShaderBinding = in_ext->supportedIndirectCommandsShaderStagesShaderBinding; + out_ext->deviceGeneratedCommandsTransformFeedback = in_ext->deviceGeneratedCommandsTransformFeedback; + out_ext->deviceGeneratedCommandsMultiDrawIndirectCount = in_ext->deviceGeneratedCommandsMultiDrawIndirectCount; + out_header = (void *)out_ext; + break; + } case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_HOST_IMAGE_COPY_PROPERTIES_EXT: { VkPhysicalDeviceHostImageCopyPropertiesEXT32 *out_ext = find_next_struct32(out_header, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_HOST_IMAGE_COPY_PROPERTIES_EXT); @@ -34737,6 +35338,62 @@ static inline const VkCopyDescriptorSet *convert_VkCopyDescriptorSet_array_win32 return out; }

+static inline void convert_VkWriteIndirectExecutionSetPipelineEXT_win32_to_host(const VkWriteIndirectExecutionSetPipelineEXT32 *in, VkWriteIndirectExecutionSetPipelineEXT *out) +{ + if (!in) return; + + out->sType = in->sType; + out->pNext = NULL; + out->index = in->index; + out->pipeline = in->pipeline; + if (in->pNext) + FIXME("Unexpected pNext\n"); +} + +static inline const VkWriteIndirectExecutionSetPipelineEXT *convert_VkWriteIndirectExecutionSetPipelineEXT_array_win32_to_host(struct conversion_context *ctx, const VkWriteIndirectExecutionSetPipelineEXT32 *in, uint32_t count) +{ + VkWriteIndirectExecutionSetPipelineEXT *out; + unsigned int i; + + if (!in || !count) return NULL; + + out = conversion_context_alloc(ctx, count * sizeof(*out)); + for (i = 0; i < count; i++) + { + convert_VkWriteIndirectExecutionSetPipelineEXT_win32_to_host(&in[i], &out[i]); + } + + return out; +} + +static inline void convert_VkWriteIndirectExecutionSetShaderEXT_win32_to_host(const VkWriteIndirectExecutionSetShaderEXT32 *in, VkWriteIndirectExecutionSetShaderEXT *out) +{ + if (!in) return; + + out->sType = in->sType; + out->pNext = NULL; + out->index = in->index; + out->shader = in->shader; + if (in->pNext) + FIXME("Unexpected pNext\n"); +} + +static inline const VkWriteIndirectExecutionSetShaderEXT *convert_VkWriteIndirectExecutionSetShaderEXT_array_win32_to_host(struct conversion_context *ctx, const VkWriteIndirectExecutionSetShaderEXT32 *in, uint32_t count) +{ + VkWriteIndirectExecutionSetShaderEXT *out; + unsigned int i; + + if (!in || !count) return NULL; + + out = conversion_context_alloc(ctx, count * sizeof(*out)); + for (i = 0; i < count; i++) + { + convert_VkWriteIndirectExecutionSetShaderEXT_win32_to_host(&in[i], &out[i]); + } + + return out; +} + static inline void convert_VkVideoSessionParametersUpdateInfoKHR_win32_to_host(struct conversion_context *ctx, const VkVideoSessionParametersUpdateInfoKHR32 *in, VkVideoSessionParametersUpdateInfoKHR *out) { const VkBaseInStructure32 *in_header; @@ -38099,6 +38756,33 @@ static void thunk32_vkCmdExecuteCommands(void *args) free_conversion_context(ctx); }

+#ifdef _WIN64 +static void thunk64_vkCmdExecuteGeneratedCommandsEXT(void *args) +{ + struct vkCmdExecuteGeneratedCommandsEXT_params *params = args; + + wine_cmd_buffer_from_handle(params->commandBuffer)->device->funcs.p_vkCmdExecuteGeneratedCommandsEXT(wine_cmd_buffer_from_handle(params->commandBuffer)->host_command_buffer, params->isPreprocessed, params->pGeneratedCommandsInfo); +} +#endif /* _WIN64 */ + +static void thunk32_vkCmdExecuteGeneratedCommandsEXT(void *args) +{ + struct + { + PTR32 commandBuffer; + VkBool32 isPreprocessed; + PTR32 pGeneratedCommandsInfo; + } *params = args; + VkGeneratedCommandsInfoEXT pGeneratedCommandsInfo_host; + struct conversion_context local_ctx; + struct conversion_context *ctx = &local_ctx; + + init_conversion_context(ctx); + convert_VkGeneratedCommandsInfoEXT_win32_to_host(ctx, (const VkGeneratedCommandsInfoEXT32 *)UlongToPtr(params->pGeneratedCommandsInfo), &pGeneratedCommandsInfo_host); + wine_cmd_buffer_from_handle((VkCommandBuffer)UlongToPtr(params->commandBuffer))->device->funcs.p_vkCmdExecuteGeneratedCommandsEXT(wine_cmd_buffer_from_handle((VkCommandBuffer)UlongToPtr(params->commandBuffer))->host_command_buffer, params->isPreprocessed, &pGeneratedCommandsInfo_host); + free_conversion_context(ctx); +} + #ifdef _WIN64 static void thunk64_vkCmdExecuteGeneratedCommandsNV(void *args) { @@ -38362,6 +39046,33 @@ static void thunk32_vkCmdPipelineBarrier2KHR(void *args) free_conversion_context(ctx); }

+#ifdef _WIN64 +static void thunk64_vkCmdPreprocessGeneratedCommandsEXT(void *args) +{ + struct vkCmdPreprocessGeneratedCommandsEXT_params *params = args; + + wine_cmd_buffer_from_handle(params->commandBuffer)->device->funcs.p_vkCmdPreprocessGeneratedCommandsEXT(wine_cmd_buffer_from_handle(params->commandBuffer)->host_command_buffer, params->pGeneratedCommandsInfo, wine_cmd_buffer_from_handle(params->stateCommandBuffer)->host_command_buffer); +} +#endif /* _WIN64 */ + +static void thunk32_vkCmdPreprocessGeneratedCommandsEXT(void *args) +{ + struct + { + PTR32 commandBuffer; + PTR32 pGeneratedCommandsInfo; + PTR32 stateCommandBuffer; + } *params = args; + VkGeneratedCommandsInfoEXT pGeneratedCommandsInfo_host; + struct conversion_context local_ctx; + struct conversion_context *ctx = &local_ctx; + + init_conversion_context(ctx); + convert_VkGeneratedCommandsInfoEXT_win32_to_host(ctx, (const VkGeneratedCommandsInfoEXT32 *)UlongToPtr(params->pGeneratedCommandsInfo), &pGeneratedCommandsInfo_host); + wine_cmd_buffer_from_handle((VkCommandBuffer)UlongToPtr(params->commandBuffer))->device->funcs.p_vkCmdPreprocessGeneratedCommandsEXT(wine_cmd_buffer_from_handle((VkCommandBuffer)UlongToPtr(params->commandBuffer))->host_command_buffer, &pGeneratedCommandsInfo_host, wine_cmd_buffer_from_handle((VkCommandBuffer)UlongToPtr(params->stateCommandBuffer))->host_command_buffer); + free_conversion_context(ctx); +} + #ifdef _WIN64 static void thunk64_vkCmdPreprocessGeneratedCommandsNV(void *args) { @@ -39292,6 +40003,27 @@ static void thunk32_vkCmdSetDepthClampEnableEXT(void *args) wine_cmd_buffer_from_handle((VkCommandBuffer)UlongToPtr(params->commandBuffer))->device->funcs.p_vkCmdSetDepthClampEnableEXT(wine_cmd_buffer_from_handle((VkCommandBuffer)UlongToPtr(params->commandBuffer))->host_command_buffer, params->depthClampEnable); }

+#ifdef _WIN64 +static void thunk64_vkCmdSetDepthClampRangeEXT(void *args) +{ + struct vkCmdSetDepthClampRangeEXT_params *params = args; + + wine_cmd_buffer_from_handle(params->commandBuffer)->device->funcs.p_vkCmdSetDepthClampRangeEXT(wine_cmd_buffer_from_handle(params->commandBuffer)->host_command_buffer, params->depthClampMode, params->pDepthClampRange); +} +#endif /* _WIN64 */ + +static void thunk32_vkCmdSetDepthClampRangeEXT(void *args) +{ + struct + { + PTR32 commandBuffer; + VkDepthClampModeEXT depthClampMode; + PTR32 pDepthClampRange; + } *params = args; + + wine_cmd_buffer_from_handle((VkCommandBuffer)UlongToPtr(params->commandBuffer))->device->funcs.p_vkCmdSetDepthClampRangeEXT(wine_cmd_buffer_from_handle((VkCommandBuffer)UlongToPtr(params->commandBuffer))->host_command_buffer, params->depthClampMode, (const VkDepthClampRangeEXT *)UlongToPtr(params->pDepthClampRange)); +} + #ifdef _WIN64 static void thunk64_vkCmdSetDepthClipEnableEXT(void *args) { @@ -42468,6 +43200,41 @@ static NTSTATUS thunk32_vkCreateImageView(void *args) return STATUS_SUCCESS; }

+#ifdef _WIN64 +static NTSTATUS thunk64_vkCreateIndirectCommandsLayoutEXT(void *args) +{ + struct vkCreateIndirectCommandsLayoutEXT_params *params = args; + + TRACE("%p, %p, %p, %p\n", params->device, params->pCreateInfo, params->pAllocator, params->pIndirectCommandsLayout); + + params->result = wine_device_from_handle(params->device)->funcs.p_vkCreateIndirectCommandsLayoutEXT(wine_device_from_handle(params->device)->host_device, params->pCreateInfo, NULL, params->pIndirectCommandsLayout); + return STATUS_SUCCESS; +} +#endif /* _WIN64 */ + +static NTSTATUS thunk32_vkCreateIndirectCommandsLayoutEXT(void *args) +{ + struct + { + PTR32 device; + PTR32 pCreateInfo; + PTR32 pAllocator; + PTR32 pIndirectCommandsLayout; + VkResult result; + } *params = args; + VkIndirectCommandsLayoutCreateInfoEXT pCreateInfo_host; + struct conversion_context local_ctx; + struct conversion_context *ctx = &local_ctx; + + TRACE("%#x, %#x, %#x, %#x\n", params->device, params->pCreateInfo, params->pAllocator, params->pIndirectCommandsLayout); + + init_conversion_context(ctx); + convert_VkIndirectCommandsLayoutCreateInfoEXT_win32_to_host(ctx, (const VkIndirectCommandsLayoutCreateInfoEXT32 *)UlongToPtr(params->pCreateInfo), &pCreateInfo_host); + params->result = wine_device_from_handle((VkDevice)UlongToPtr(params->device))->funcs.p_vkCreateIndirectCommandsLayoutEXT(wine_device_from_handle((VkDevice)UlongToPtr(params->device))->host_device, &pCreateInfo_host, NULL, (VkIndirectCommandsLayoutEXT *)UlongToPtr(params->pIndirectCommandsLayout)); + free_conversion_context(ctx); + return STATUS_SUCCESS; +} + #ifdef _WIN64 static NTSTATUS thunk64_vkCreateIndirectCommandsLayoutNV(void *args) { @@ -42503,6 +43270,41 @@ static NTSTATUS thunk32_vkCreateIndirectCommandsLayoutNV(void *args) return STATUS_SUCCESS; }

+#ifdef _WIN64 +static NTSTATUS thunk64_vkCreateIndirectExecutionSetEXT(void *args) +{ + struct vkCreateIndirectExecutionSetEXT_params *params = args; + + TRACE("%p, %p, %p, %p\n", params->device, params->pCreateInfo, params->pAllocator, params->pIndirectExecutionSet); + + params->result = wine_device_from_handle(params->device)->funcs.p_vkCreateIndirectExecutionSetEXT(wine_device_from_handle(params->device)->host_device, params->pCreateInfo, NULL, params->pIndirectExecutionSet); + return STATUS_SUCCESS; +} +#endif /* _WIN64 */ + +static NTSTATUS thunk32_vkCreateIndirectExecutionSetEXT(void *args) +{ + struct + { + PTR32 device; + PTR32 pCreateInfo; + PTR32 pAllocator; + PTR32 pIndirectExecutionSet; + VkResult result; + } *params = args; + VkIndirectExecutionSetCreateInfoEXT pCreateInfo_host; + struct conversion_context local_ctx; + struct conversion_context *ctx = &local_ctx; + + TRACE("%#x, %#x, %#x, %#x\n", params->device, params->pCreateInfo, params->pAllocator, params->pIndirectExecutionSet); + + init_conversion_context(ctx); + convert_VkIndirectExecutionSetCreateInfoEXT_win32_to_host(ctx, (const VkIndirectExecutionSetCreateInfoEXT32 *)UlongToPtr(params->pCreateInfo), &pCreateInfo_host); + params->result = wine_device_from_handle((VkDevice)UlongToPtr(params->device))->funcs.p_vkCreateIndirectExecutionSetEXT(wine_device_from_handle((VkDevice)UlongToPtr(params->device))->host_device, &pCreateInfo_host, NULL, (VkIndirectExecutionSetEXT *)UlongToPtr(params->pIndirectExecutionSet)); + free_conversion_context(ctx); + return STATUS_SUCCESS; +} + #ifdef _WIN64 static NTSTATUS thunk64_vkCreateInstance(void *args) { @@ -44110,6 +44912,33 @@ static NTSTATUS thunk32_vkDestroyImageView(void *args) return STATUS_SUCCESS; }

+#ifdef _WIN64 +static NTSTATUS thunk64_vkDestroyIndirectCommandsLayoutEXT(void *args) +{ + struct vkDestroyIndirectCommandsLayoutEXT_params *params = args; + + TRACE("%p, 0x%s, %p\n", params->device, wine_dbgstr_longlong(params->indirectCommandsLayout), params->pAllocator); + + wine_device_from_handle(params->device)->funcs.p_vkDestroyIndirectCommandsLayoutEXT(wine_device_from_handle(params->device)->host_device, params->indirectCommandsLayout, NULL); + return STATUS_SUCCESS; +} +#endif /* _WIN64 */ + +static NTSTATUS thunk32_vkDestroyIndirectCommandsLayoutEXT(void *args) +{ + struct + { + PTR32 device; + VkIndirectCommandsLayoutEXT DECLSPEC_ALIGN(8) indirectCommandsLayout; + PTR32 pAllocator; + } *params = args; + + TRACE("%#x, 0x%s, %#x\n", params->device, wine_dbgstr_longlong(params->indirectCommandsLayout), params->pAllocator); + + wine_device_from_handle((VkDevice)UlongToPtr(params->device))->funcs.p_vkDestroyIndirectCommandsLayoutEXT(wine_device_from_handle((VkDevice)UlongToPtr(params->device))->host_device, params->indirectCommandsLayout, NULL); + return STATUS_SUCCESS; +} + #ifdef _WIN64 static NTSTATUS thunk64_vkDestroyIndirectCommandsLayoutNV(void *args) { @@ -44137,6 +44966,33 @@ static NTSTATUS thunk32_vkDestroyIndirectCommandsLayoutNV(void *args) return STATUS_SUCCESS; }

+#ifdef _WIN64 +static NTSTATUS thunk64_vkDestroyIndirectExecutionSetEXT(void *args) +{ + struct vkDestroyIndirectExecutionSetEXT_params *params = args; + + TRACE("%p, 0x%s, %p\n", params->device, wine_dbgstr_longlong(params->indirectExecutionSet), params->pAllocator); + + wine_device_from_handle(params->device)->funcs.p_vkDestroyIndirectExecutionSetEXT(wine_device_from_handle(params->device)->host_device, params->indirectExecutionSet, NULL); + return STATUS_SUCCESS; +} +#endif /* _WIN64 */ + +static NTSTATUS thunk32_vkDestroyIndirectExecutionSetEXT(void *args) +{ + struct + { + PTR32 device; + VkIndirectExecutionSetEXT DECLSPEC_ALIGN(8) indirectExecutionSet; + PTR32 pAllocator; + } *params = args; + + TRACE("%#x, 0x%s, %#x\n", params->device, wine_dbgstr_longlong(params->indirectExecutionSet), params->pAllocator); + + wine_device_from_handle((VkDevice)UlongToPtr(params->device))->funcs.p_vkDestroyIndirectExecutionSetEXT(wine_device_from_handle((VkDevice)UlongToPtr(params->device))->host_device, params->indirectExecutionSet, NULL); + return STATUS_SUCCESS; +} + #ifdef _WIN64 static NTSTATUS thunk64_vkDestroyInstance(void *args) { @@ -46836,6 +47692,43 @@ static NTSTATUS thunk32_vkGetFramebufferTilePropertiesQCOM(void *args) return STATUS_SUCCESS; }

+#ifdef _WIN64 +static NTSTATUS thunk64_vkGetGeneratedCommandsMemoryRequirementsEXT(void *args) +{ + struct vkGetGeneratedCommandsMemoryRequirementsEXT_params *params = args; + + TRACE("%p, %p, %p\n", params->device, params->pInfo, params->pMemoryRequirements); + + wine_device_from_handle(params->device)->funcs.p_vkGetGeneratedCommandsMemoryRequirementsEXT(wine_device_from_handle(params->device)->host_device, params->pInfo, params->pMemoryRequirements); + return STATUS_SUCCESS; +} +#endif /* _WIN64 */ + +static NTSTATUS thunk32_vkGetGeneratedCommandsMemoryRequirementsEXT(void *args) +{ + struct + { + PTR32 device; + PTR32 pInfo; + PTR32 pMemoryRequirements; + } *params = args; + VkGeneratedCommandsMemoryRequirementsInfoEXT pInfo_host; + VkMemoryRequirements2 pMemoryRequirements_host; + struct conversion_context local_ctx; + struct conversion_context *ctx = &local_ctx; + + TRACE("%#x, %#x, %#x\n", params->device, params->pInfo, params->pMemoryRequirements); + + init_conversion_context(ctx); + convert_VkGeneratedCommandsMemoryRequirementsInfoEXT_win32_to_host(ctx, (const VkGeneratedCommandsMemoryRequirementsInfoEXT32 *)UlongToPtr(params->pInfo), &pInfo_host); + convert_VkMemoryRequirements2_win32_to_host(ctx, (VkMemoryRequirements232 *)UlongToPtr(params->pMemoryRequirements), &pMemoryRequirements_host); + wine_device_from_handle((VkDevice)UlongToPtr(params->device))->funcs.p_vkGetGeneratedCommandsMemoryRequirementsEXT(wine_device_from_handle((VkDevice)UlongToPtr(params->device))->host_device, &pInfo_host, &pMemoryRequirements_host); + convert_VkGeneratedCommandsMemoryRequirementsInfoEXT_host_to_win32(&pInfo_host, (const VkGeneratedCommandsMemoryRequirementsInfoEXT32 *)UlongToPtr(params->pInfo)); + convert_VkMemoryRequirements2_host_to_win32(&pMemoryRequirements_host, (VkMemoryRequirements232 *)UlongToPtr(params->pMemoryRequirements)); + free_conversion_context(ctx); + return STATUS_SUCCESS; +} + #ifdef _WIN64 static NTSTATUS thunk64_vkGetGeneratedCommandsMemoryRequirementsNV(void *args) { @@ -51550,6 +52443,74 @@ static void thunk32_vkUpdateDescriptorSets(void *args) free_conversion_context(ctx); }

+#ifdef _WIN64 +static NTSTATUS thunk64_vkUpdateIndirectExecutionSetPipelineEXT(void *args) +{ + struct vkUpdateIndirectExecutionSetPipelineEXT_params *params = args; + + TRACE("%p, 0x%s, %u, %p\n", params->device, wine_dbgstr_longlong(params->indirectExecutionSet), params->executionSetWriteCount, params->pExecutionSetWrites); + + wine_device_from_handle(params->device)->funcs.p_vkUpdateIndirectExecutionSetPipelineEXT(wine_device_from_handle(params->device)->host_device, params->indirectExecutionSet, params->executionSetWriteCount, params->pExecutionSetWrites); + return STATUS_SUCCESS; +} +#endif /* _WIN64 */ + +static NTSTATUS thunk32_vkUpdateIndirectExecutionSetPipelineEXT(void *args) +{ + struct + { + PTR32 device; + VkIndirectExecutionSetEXT DECLSPEC_ALIGN(8) indirectExecutionSet; + uint32_t executionSetWriteCount; + PTR32 pExecutionSetWrites; + } *params = args; + const VkWriteIndirectExecutionSetPipelineEXT *pExecutionSetWrites_host; + struct conversion_context local_ctx; + struct conversion_context *ctx = &local_ctx; + + TRACE("%#x, 0x%s, %u, %#x\n", params->device, wine_dbgstr_longlong(params->indirectExecutionSet), params->executionSetWriteCount, params->pExecutionSetWrites); + + init_conversion_context(ctx); + pExecutionSetWrites_host = convert_VkWriteIndirectExecutionSetPipelineEXT_array_win32_to_host(ctx, (const VkWriteIndirectExecutionSetPipelineEXT32 *)UlongToPtr(params->pExecutionSetWrites), params->executionSetWriteCount); + wine_device_from_handle((VkDevice)UlongToPtr(params->device))->funcs.p_vkUpdateIndirectExecutionSetPipelineEXT(wine_device_from_handle((VkDevice)UlongToPtr(params->device))->host_device, params->indirectExecutionSet, params->executionSetWriteCount, pExecutionSetWrites_host); + free_conversion_context(ctx); + return STATUS_SUCCESS; +} + +#ifdef _WIN64 +static NTSTATUS thunk64_vkUpdateIndirectExecutionSetShaderEXT(void *args) +{ + struct vkUpdateIndirectExecutionSetShaderEXT_params *params = args; + + TRACE("%p, 0x%s, %u, %p\n", params->device, wine_dbgstr_longlong(params->indirectExecutionSet), params->executionSetWriteCount, params->pExecutionSetWrites); + + wine_device_from_handle(params->device)->funcs.p_vkUpdateIndirectExecutionSetShaderEXT(wine_device_from_handle(params->device)->host_device, params->indirectExecutionSet, params->executionSetWriteCount, params->pExecutionSetWrites); + return STATUS_SUCCESS; +} +#endif /* _WIN64 */ + +static NTSTATUS thunk32_vkUpdateIndirectExecutionSetShaderEXT(void *args) +{ + struct + { + PTR32 device; + VkIndirectExecutionSetEXT DECLSPEC_ALIGN(8) indirectExecutionSet; + uint32_t executionSetWriteCount; + PTR32 pExecutionSetWrites; + } *params = args; + const VkWriteIndirectExecutionSetShaderEXT *pExecutionSetWrites_host; + struct conversion_context local_ctx; + struct conversion_context *ctx = &local_ctx; + + TRACE("%#x, 0x%s, %u, %#x\n", params->device, wine_dbgstr_longlong(params->indirectExecutionSet), params->executionSetWriteCount, params->pExecutionSetWrites); + + init_conversion_context(ctx); + pExecutionSetWrites_host = convert_VkWriteIndirectExecutionSetShaderEXT_array_win32_to_host(ctx, (const VkWriteIndirectExecutionSetShaderEXT32 *)UlongToPtr(params->pExecutionSetWrites), params->executionSetWriteCount); + wine_device_from_handle((VkDevice)UlongToPtr(params->device))->funcs.p_vkUpdateIndirectExecutionSetShaderEXT(wine_device_from_handle((VkDevice)UlongToPtr(params->device))->host_device, params->indirectExecutionSet, params->executionSetWriteCount, pExecutionSetWrites_host); + free_conversion_context(ctx); + return STATUS_SUCCESS; +} + #ifdef _WIN64 static NTSTATUS thunk64_vkUpdateVideoSessionParametersKHR(void *args) { @@ -51810,6 +52771,7 @@ static const char * const vk_device_extensions[] = "VK_EXT_custom_border_color", "VK_EXT_debug_marker", "VK_EXT_depth_bias_control", + "VK_EXT_depth_clamp_control", "VK_EXT_depth_clamp_zero_one", "VK_EXT_depth_clip_control", "VK_EXT_depth_clip_enable", @@ -51818,6 +52780,7 @@ static const char * const vk_device_extensions[] = "VK_EXT_descriptor_indexing", "VK_EXT_device_address_binding_report", "VK_EXT_device_fault", + "VK_EXT_device_generated_commands", "VK_EXT_discard_rectangles", "VK_EXT_dynamic_rendering_unused_attachments", "VK_EXT_extended_dynamic_state", @@ -52294,6 +53257,7 @@ const unixlib_entry_t __wine_unix_call_funcs[] = (void *)thunk64_vkCmdEndTransformFeedbackEXT, (void *)thunk64_vkCmdEndVideoCodingKHR, (void *)thunk64_vkCmdExecuteCommands, + (void *)thunk64_vkCmdExecuteGeneratedCommandsEXT, (void *)thunk64_vkCmdExecuteGeneratedCommandsNV, (void *)thunk64_vkCmdFillBuffer, (void *)thunk64_vkCmdInsertDebugUtilsLabelEXT, @@ -52304,6 +53268,7 @@ const unixlib_entry_t __wine_unix_call_funcs[] = (void *)thunk64_vkCmdPipelineBarrier, (void *)thunk64_vkCmdPipelineBarrier2, (void *)thunk64_vkCmdPipelineBarrier2KHR, + (void *)thunk64_vkCmdPreprocessGeneratedCommandsEXT, (void *)thunk64_vkCmdPreprocessGeneratedCommandsNV, (void *)thunk64_vkCmdPushConstants, (void *)thunk64_vkCmdPushConstants2KHR, @@ -52346,6 +53311,7 @@ const unixlib_entry_t __wine_unix_call_funcs[] = (void *)thunk64_vkCmdSetDepthBoundsTestEnable, (void *)thunk64_vkCmdSetDepthBoundsTestEnableEXT, (void *)thunk64_vkCmdSetDepthClampEnableEXT, + (void *)thunk64_vkCmdSetDepthClampRangeEXT, (void *)thunk64_vkCmdSetDepthClipEnableEXT, (void *)thunk64_vkCmdSetDepthClipNegativeOneToOneEXT, (void *)thunk64_vkCmdSetDepthCompareOp, @@ -52471,7 +53437,9 @@ const unixlib_entry_t __wine_unix_call_funcs[] = thunk64_vkCreateGraphicsPipelines, thunk64_vkCreateImage, thunk64_vkCreateImageView, + thunk64_vkCreateIndirectCommandsLayoutEXT, thunk64_vkCreateIndirectCommandsLayoutNV, + thunk64_vkCreateIndirectExecutionSetEXT, thunk64_vkCreateInstance, thunk64_vkCreateMicromapEXT, thunk64_vkCreateOpticalFlowSessionNV, @@ -52523,7 +53491,9 @@ const unixlib_entry_t __wine_unix_call_funcs[] = thunk64_vkDestroyFramebuffer, thunk64_vkDestroyImage, thunk64_vkDestroyImageView, + thunk64_vkDestroyIndirectCommandsLayoutEXT, thunk64_vkDestroyIndirectCommandsLayoutNV, + thunk64_vkDestroyIndirectExecutionSetEXT, thunk64_vkDestroyInstance, thunk64_vkDestroyMicromapEXT, thunk64_vkDestroyOpticalFlowSessionNV, @@ -52611,6 +53581,7 @@ const unixlib_entry_t __wine_unix_call_funcs[] = thunk64_vkGetEventStatus, thunk64_vkGetFenceStatus, thunk64_vkGetFramebufferTilePropertiesQCOM, + thunk64_vkGetGeneratedCommandsMemoryRequirementsEXT, thunk64_vkGetGeneratedCommandsMemoryRequirementsNV, thunk64_vkGetImageMemoryRequirements, thunk64_vkGetImageMemoryRequirements2, @@ -52758,6 +53729,8 @@ const unixlib_entry_t __wine_unix_call_funcs[] = (void *)thunk64_vkUpdateDescriptorSetWithTemplate, thunk64_vkUpdateDescriptorSetWithTemplateKHR, (void *)thunk64_vkUpdateDescriptorSets, + thunk64_vkUpdateIndirectExecutionSetPipelineEXT, + thunk64_vkUpdateIndirectExecutionSetShaderEXT, thunk64_vkUpdateVideoSessionParametersKHR, thunk64_vkWaitForFences, thunk64_vkWaitForPresentKHR, @@ -52905,6 +53878,7 @@ const unixlib_entry_t __wine_unix_call_funcs[] = (void *)thunk32_vkCmdEndTransformFeedbackEXT, (void *)thunk32_vkCmdEndVideoCodingKHR, (void *)thunk32_vkCmdExecuteCommands, + (void *)thunk32_vkCmdExecuteGeneratedCommandsEXT, (void *)thunk32_vkCmdExecuteGeneratedCommandsNV, (void *)thunk32_vkCmdFillBuffer, (void *)thunk32_vkCmdInsertDebugUtilsLabelEXT, @@ -52915,6 +53889,7 @@ const unixlib_entry_t __wine_unix_call_funcs[] = (void *)thunk32_vkCmdPipelineBarrier, (void *)thunk32_vkCmdPipelineBarrier2, (void *)thunk32_vkCmdPipelineBarrier2KHR, + (void *)thunk32_vkCmdPreprocessGeneratedCommandsEXT, (void *)thunk32_vkCmdPreprocessGeneratedCommandsNV, (void *)thunk32_vkCmdPushConstants, (void *)thunk32_vkCmdPushConstants2KHR, @@ -52957,6 +53932,7 @@ const unixlib_entry_t __wine_unix_call_funcs[] = (void *)thunk32_vkCmdSetDepthBoundsTestEnable, (void *)thunk32_vkCmdSetDepthBoundsTestEnableEXT, (void *)thunk32_vkCmdSetDepthClampEnableEXT, + (void *)thunk32_vkCmdSetDepthClampRangeEXT, (void *)thunk32_vkCmdSetDepthClipEnableEXT, (void *)thunk32_vkCmdSetDepthClipNegativeOneToOneEXT, (void *)thunk32_vkCmdSetDepthCompareOp, @@ -53082,7 +54058,9 @@ const unixlib_entry_t __wine_unix_call_funcs[] = thunk32_vkCreateGraphicsPipelines, thunk32_vkCreateImage, thunk32_vkCreateImageView, + thunk32_vkCreateIndirectCommandsLayoutEXT, thunk32_vkCreateIndirectCommandsLayoutNV, + thunk32_vkCreateIndirectExecutionSetEXT, thunk32_vkCreateInstance, thunk32_vkCreateMicromapEXT, thunk32_vkCreateOpticalFlowSessionNV, @@ -53134,7 +54112,9 @@ const unixlib_entry_t __wine_unix_call_funcs[] = thunk32_vkDestroyFramebuffer, thunk32_vkDestroyImage, thunk32_vkDestroyImageView, + thunk32_vkDestroyIndirectCommandsLayoutEXT, thunk32_vkDestroyIndirectCommandsLayoutNV, + thunk32_vkDestroyIndirectExecutionSetEXT, thunk32_vkDestroyInstance, thunk32_vkDestroyMicromapEXT, thunk32_vkDestroyOpticalFlowSessionNV, @@ -53222,6 +54202,7 @@ const unixlib_entry_t __wine_unix_call_funcs[] = thunk32_vkGetEventStatus, thunk32_vkGetFenceStatus, thunk32_vkGetFramebufferTilePropertiesQCOM, + thunk32_vkGetGeneratedCommandsMemoryRequirementsEXT, thunk32_vkGetGeneratedCommandsMemoryRequirementsNV, thunk32_vkGetImageMemoryRequirements, thunk32_vkGetImageMemoryRequirements2, @@ -53369,6 +54350,8 @@ const unixlib_entry_t __wine_unix_call_funcs[] = (void *)thunk32_vkUpdateDescriptorSetWithTemplate, thunk32_vkUpdateDescriptorSetWithTemplateKHR, (void *)thunk32_vkUpdateDescriptorSets, + thunk32_vkUpdateIndirectExecutionSetPipelineEXT, + thunk32_vkUpdateIndirectExecutionSetShaderEXT, thunk32_vkUpdateVideoSessionParametersKHR, thunk32_vkWaitForFences, thunk32_vkWaitForPresentKHR, diff --git a/dlls/winevulkan/vulkan_thunks.h b/dlls/winevulkan/vulkan_thunks.h index 547da66da80..82c23d3dde4 100644 --- a/dlls/winevulkan/vulkan_thunks.h +++ b/dlls/winevulkan/vulkan_thunks.h @@ -205,6 +205,7 @@ struct vulkan_device_funcs void (*p_vkCmdEndTransformFeedbackEXT)(VkCommandBuffer, uint32_t, uint32_t, const VkBuffer *, const VkDeviceSize *); void (*p_vkCmdEndVideoCodingKHR)(VkCommandBuffer, const VkVideoEndCodingInfoKHR *); void (*p_vkCmdExecuteCommands)(VkCommandBuffer, uint32_t, const VkCommandBuffer *); + void (*p_vkCmdExecuteGeneratedCommandsEXT)(VkCommandBuffer, VkBool32, const VkGeneratedCommandsInfoEXT *); void (*p_vkCmdExecuteGeneratedCommandsNV)(VkCommandBuffer, VkBool32, const VkGeneratedCommandsInfoNV *); void (*p_vkCmdFillBuffer)(VkCommandBuffer, VkBuffer, VkDeviceSize, VkDeviceSize, uint32_t); void (*p_vkCmdInsertDebugUtilsLabelEXT)(VkCommandBuffer, const VkDebugUtilsLabelEXT *); @@ -215,6 +216,7 @@ struct vulkan_device_funcs void (*p_vkCmdPipelineBarrier)(VkCommandBuffer, VkPipelineStageFlags, VkPipelineStageFlags, VkDependencyFlags, uint32_t, const VkMemoryBarrier *, uint32_t, const VkBufferMemoryBarrier *, uint32_t, const VkImageMemoryBarrier *); void (*p_vkCmdPipelineBarrier2)(VkCommandBuffer, const VkDependencyInfo *); void (*p_vkCmdPipelineBarrier2KHR)(VkCommandBuffer, const VkDependencyInfo *); + void (*p_vkCmdPreprocessGeneratedCommandsEXT)(VkCommandBuffer, const VkGeneratedCommandsInfoEXT *, VkCommandBuffer); void (*p_vkCmdPreprocessGeneratedCommandsNV)(VkCommandBuffer, const VkGeneratedCommandsInfoNV *); void (*p_vkCmdPushConstants)(VkCommandBuffer, VkPipelineLayout, VkShaderStageFlags, uint32_t, uint32_t, const void *); void (*p_vkCmdPushConstants2KHR)(VkCommandBuffer, const VkPushConstantsInfoKHR *); @@ -257,6 +259,7 @@ struct vulkan_device_funcs void (*p_vkCmdSetDepthBoundsTestEnable)(VkCommandBuffer, VkBool32); void (*p_vkCmdSetDepthBoundsTestEnableEXT)(VkCommandBuffer, VkBool32); void (*p_vkCmdSetDepthClampEnableEXT)(VkCommandBuffer, VkBool32); + void (*p_vkCmdSetDepthClampRangeEXT)(VkCommandBuffer, VkDepthClampModeEXT, const VkDepthClampRangeEXT *); void (*p_vkCmdSetDepthClipEnableEXT)(VkCommandBuffer, VkBool32); void (*p_vkCmdSetDepthClipNegativeOneToOneEXT)(VkCommandBuffer, VkBool32); void (*p_vkCmdSetDepthCompareOp)(VkCommandBuffer, VkCompareOp); @@ -379,7 +382,9 @@ struct vulkan_device_funcs VkResult (*p_vkCreateGraphicsPipelines)(VkDevice, VkPipelineCache, uint32_t, const VkGraphicsPipelineCreateInfo *, const VkAllocationCallbacks *, VkPipeline *); VkResult (*p_vkCreateImage)(VkDevice, const VkImageCreateInfo *, const VkAllocationCallbacks *, VkImage *); VkResult (*p_vkCreateImageView)(VkDevice, const VkImageViewCreateInfo *, const VkAllocationCallbacks *, VkImageView *); + VkResult (*p_vkCreateIndirectCommandsLayoutEXT)(VkDevice, const VkIndirectCommandsLayoutCreateInfoEXT *, const VkAllocationCallbacks *, VkIndirectCommandsLayoutEXT *); VkResult (*p_vkCreateIndirectCommandsLayoutNV)(VkDevice, const VkIndirectCommandsLayoutCreateInfoNV *, const VkAllocationCallbacks *, VkIndirectCommandsLayoutNV *); + VkResult (*p_vkCreateIndirectExecutionSetEXT)(VkDevice, const VkIndirectExecutionSetCreateInfoEXT *, const VkAllocationCallbacks *, VkIndirectExecutionSetEXT *); VkResult (*p_vkCreateMicromapEXT)(VkDevice, const VkMicromapCreateInfoEXT *, const VkAllocationCallbacks *, VkMicromapEXT *); VkResult (*p_vkCreateOpticalFlowSessionNV)(VkDevice, const VkOpticalFlowSessionCreateInfoNV *, const VkAllocationCallbacks *, VkOpticalFlowSessionNV *); VkResult (*p_vkCreatePipelineBinariesKHR)(VkDevice, const VkPipelineBinaryCreateInfoKHR *, const VkAllocationCallbacks *, VkPipelineBinaryHandlesInfoKHR *); @@ -426,7 +431,9 @@ struct vulkan_device_funcs void (*p_vkDestroyFramebuffer)(VkDevice, VkFramebuffer, const VkAllocationCallbacks *); void (*p_vkDestroyImage)(VkDevice, VkImage, const VkAllocationCallbacks *); void (*p_vkDestroyImageView)(VkDevice, VkImageView, const VkAllocationCallbacks *); + void (*p_vkDestroyIndirectCommandsLayoutEXT)(VkDevice, VkIndirectCommandsLayoutEXT, const VkAllocationCallbacks *); void (*p_vkDestroyIndirectCommandsLayoutNV)(VkDevice, VkIndirectCommandsLayoutNV, const VkAllocationCallbacks *); + void (*p_vkDestroyIndirectExecutionSetEXT)(VkDevice, VkIndirectExecutionSetEXT, const VkAllocationCallbacks *); void (*p_vkDestroyMicromapEXT)(VkDevice, VkMicromapEXT, const VkAllocationCallbacks *); void (*p_vkDestroyOpticalFlowSessionNV)(VkDevice, VkOpticalFlowSessionNV, const VkAllocationCallbacks *); void (*p_vkDestroyPipeline)(VkDevice, VkPipeline, const VkAllocationCallbacks *); @@ -504,6 +511,7 @@ struct vulkan_device_funcs VkResult (*p_vkGetEventStatus)(VkDevice, VkEvent); VkResult (*p_vkGetFenceStatus)(VkDevice, VkFence); VkResult (*p_vkGetFramebufferTilePropertiesQCOM)(VkDevice, VkFramebuffer, uint32_t *, VkTilePropertiesQCOM *); + void (*p_vkGetGeneratedCommandsMemoryRequirementsEXT)(VkDevice, const VkGeneratedCommandsMemoryRequirementsInfoEXT *, VkMemoryRequirements2 *); void (*p_vkGetGeneratedCommandsMemoryRequirementsNV)(VkDevice, const VkGeneratedCommandsMemoryRequirementsInfoNV *, VkMemoryRequirements2 *); void (*p_vkGetImageMemoryRequirements)(VkDevice, VkImage, VkMemoryRequirements *); void (*p_vkGetImageMemoryRequirements2)(VkDevice, const VkImageMemoryRequirementsInfo2 *, VkMemoryRequirements2 *); @@ -601,6 +609,8 @@ struct vulkan_device_funcs void (*p_vkUpdateDescriptorSetWithTemplate)(VkDevice, VkDescriptorSet, VkDescriptorUpdateTemplate, const void *); void (*p_vkUpdateDescriptorSetWithTemplateKHR)(VkDevice, VkDescriptorSet, VkDescriptorUpdateTemplate, const void *); void (*p_vkUpdateDescriptorSets)(VkDevice, uint32_t, const VkWriteDescriptorSet *, uint32_t, const VkCopyDescriptorSet *); + void (*p_vkUpdateIndirectExecutionSetPipelineEXT)(VkDevice, VkIndirectExecutionSetEXT, uint32_t, const VkWriteIndirectExecutionSetPipelineEXT *); + void (*p_vkUpdateIndirectExecutionSetShaderEXT)(VkDevice, VkIndirectExecutionSetEXT, uint32_t, const VkWriteIndirectExecutionSetShaderEXT *); VkResult (*p_vkUpdateVideoSessionParametersKHR)(VkDevice, VkVideoSessionParametersKHR, const VkVideoSessionParametersUpdateInfoKHR *); VkResult (*p_vkWaitForFences)(VkDevice, uint32_t, const VkFence *, VkBool32, uint64_t); VkResult (*p_vkWaitForPresentKHR)(VkDevice, VkSwapchainKHR, uint64_t, uint64_t); @@ -801,6 +811,7 @@ struct vulkan_instance_funcs USE_VK_FUNC(vkCmdEndTransformFeedbackEXT) \ USE_VK_FUNC(vkCmdEndVideoCodingKHR) \ USE_VK_FUNC(vkCmdExecuteCommands) \ + USE_VK_FUNC(vkCmdExecuteGeneratedCommandsEXT) \ USE_VK_FUNC(vkCmdExecuteGeneratedCommandsNV) \ USE_VK_FUNC(vkCmdFillBuffer) \ USE_VK_FUNC(vkCmdInsertDebugUtilsLabelEXT) \ @@ -811,6 +822,7 @@ struct vulkan_instance_funcs USE_VK_FUNC(vkCmdPipelineBarrier) \ USE_VK_FUNC(vkCmdPipelineBarrier2) \ USE_VK_FUNC(vkCmdPipelineBarrier2KHR) \ + USE_VK_FUNC(vkCmdPreprocessGeneratedCommandsEXT) \ USE_VK_FUNC(vkCmdPreprocessGeneratedCommandsNV) \ USE_VK_FUNC(vkCmdPushConstants) \ USE_VK_FUNC(vkCmdPushConstants2KHR) \ @@ -853,6 +865,7 @@ struct vulkan_instance_funcs USE_VK_FUNC(vkCmdSetDepthBoundsTestEnable) \ USE_VK_FUNC(vkCmdSetDepthBoundsTestEnableEXT) \ USE_VK_FUNC(vkCmdSetDepthClampEnableEXT) \ + USE_VK_FUNC(vkCmdSetDepthClampRangeEXT) \ USE_VK_FUNC(vkCmdSetDepthClipEnableEXT) \ USE_VK_FUNC(vkCmdSetDepthClipNegativeOneToOneEXT) \ USE_VK_FUNC(vkCmdSetDepthCompareOp) \ @@ -975,7 +988,9 @@ struct vulkan_instance_funcs USE_VK_FUNC(vkCreateGraphicsPipelines) \ USE_VK_FUNC(vkCreateImage) \ USE_VK_FUNC(vkCreateImageView) \ + USE_VK_FUNC(vkCreateIndirectCommandsLayoutEXT) \ USE_VK_FUNC(vkCreateIndirectCommandsLayoutNV) \ + USE_VK_FUNC(vkCreateIndirectExecutionSetEXT) \ USE_VK_FUNC(vkCreateMicromapEXT) \ USE_VK_FUNC(vkCreateOpticalFlowSessionNV) \ USE_VK_FUNC(vkCreatePipelineBinariesKHR) \ @@ -1022,7 +1037,9 @@ struct vulkan_instance_funcs USE_VK_FUNC(vkDestroyFramebuffer) \ USE_VK_FUNC(vkDestroyImage) \ USE_VK_FUNC(vkDestroyImageView) \ + USE_VK_FUNC(vkDestroyIndirectCommandsLayoutEXT) \ USE_VK_FUNC(vkDestroyIndirectCommandsLayoutNV) \ + USE_VK_FUNC(vkDestroyIndirectExecutionSetEXT) \ USE_VK_FUNC(vkDestroyMicromapEXT) \ USE_VK_FUNC(vkDestroyOpticalFlowSessionNV) \ USE_VK_FUNC(vkDestroyPipeline) \ @@ -1100,6 +1117,7 @@ struct vulkan_instance_funcs USE_VK_FUNC(vkGetEventStatus) \ USE_VK_FUNC(vkGetFenceStatus) \ USE_VK_FUNC(vkGetFramebufferTilePropertiesQCOM) \ + USE_VK_FUNC(vkGetGeneratedCommandsMemoryRequirementsEXT) \ USE_VK_FUNC(vkGetGeneratedCommandsMemoryRequirementsNV) \ USE_VK_FUNC(vkGetImageMemoryRequirements) \ USE_VK_FUNC(vkGetImageMemoryRequirements2) \ @@ -1197,6 +1215,8 @@ struct vulkan_instance_funcs USE_VK_FUNC(vkUpdateDescriptorSetWithTemplate) \ USE_VK_FUNC(vkUpdateDescriptorSetWithTemplateKHR) \ USE_VK_FUNC(vkUpdateDescriptorSets) \ + USE_VK_FUNC(vkUpdateIndirectExecutionSetPipelineEXT) \ + USE_VK_FUNC(vkUpdateIndirectExecutionSetShaderEXT) \ USE_VK_FUNC(vkUpdateVideoSessionParametersKHR) \ USE_VK_FUNC(vkWaitForFences) \ USE_VK_FUNC(vkWaitForPresentKHR) \ diff --git a/dlls/winevulkan/winevulkan.json b/dlls/winevulkan/winevulkan.json index 67cee901fd9..2e77e6f042e 100644 --- a/dlls/winevulkan/winevulkan.json +++ b/dlls/winevulkan/winevulkan.json @@ -2,6 +2,6 @@ "file_format_version": "1.0.0", "ICD": { "library_path": ".\winevulkan.dll", - "api_version": "1.3.295" + "api_version": "1.3.296" } } diff --git a/include/wine/vulkan.h b/include/wine/vulkan.h index d07d780a7dc..8f1afc519ca 100644 --- a/include/wine/vulkan.h +++ b/include/wine/vulkan.h @@ -716,8 +716,12 @@ #define VK_EXT_SHADER_REPLICATED_COMPOSITES_EXTENSION_NAME "VK_EXT_shader_replicated_composites" #define VK_NV_RAY_TRACING_VALIDATION_SPEC_VERSION 1 #define VK_NV_RAY_TRACING_VALIDATION_EXTENSION_NAME "VK_NV_ray_tracing_validation" +#define VK_EXT_DEVICE_GENERATED_COMMANDS_SPEC_VERSION 1 +#define VK_EXT_DEVICE_GENERATED_COMMANDS_EXTENSION_NAME "VK_EXT_device_generated_commands" #define VK_MESA_IMAGE_ALIGNMENT_CONTROL_SPEC_VERSION 1 #define VK_MESA_IMAGE_ALIGNMENT_CONTROL_EXTENSION_NAME "VK_MESA_image_alignment_control" +#define VK_EXT_DEPTH_CLAMP_CONTROL_SPEC_VERSION 1 +#define VK_EXT_DEPTH_CLAMP_CONTROL_EXTENSION_NAME "VK_EXT_depth_clamp_control" #define STD_VIDEO_H264_CPB_CNT_LIST_SIZE 32 #define STD_VIDEO_H264_SCALING_LIST_4X4_NUM_LISTS 6 #define STD_VIDEO_H264_SCALING_LIST_4X4_NUM_ELEMENTS 16 @@ -808,7 +812,7 @@ #define VK_API_VERSION_1_2 VK_MAKE_API_VERSION(0, 1, 2, 0) #define VK_API_VERSION_1_3 VK_MAKE_API_VERSION(0, 1, 3, 0) #define VKSC_API_VERSION_1_0 VK_MAKE_API_VERSION(VKSC_API_VARIANT, 1, 0, 0) -#define VK_HEADER_VERSION 295 +#define VK_HEADER_VERSION 296 #define VK_HEADER_VERSION_COMPLETE VK_MAKE_API_VERSION(0, 1, 3, VK_HEADER_VERSION) #define VK_DEFINE_HANDLE(object) typedef struct object##_T* object; #define VK_USE_64_BIT_PTR_DEFINES 0 @@ -867,7 +871,9 @@ VK_DEFINE_NON_DISPATCHABLE_HANDLE(VkFence) VK_DEFINE_NON_DISPATCHABLE_HANDLE(VkFramebuffer) VK_DEFINE_NON_DISPATCHABLE_HANDLE(VkImage) VK_DEFINE_NON_DISPATCHABLE_HANDLE(VkImageView) +VK_DEFINE_NON_DISPATCHABLE_HANDLE(VkIndirectCommandsLayoutEXT) VK_DEFINE_NON_DISPATCHABLE_HANDLE(VkIndirectCommandsLayoutNV) +VK_DEFINE_NON_DISPATCHABLE_HANDLE(VkIndirectExecutionSetEXT) VK_DEFINE_HANDLE(VkInstance) VK_DEFINE_NON_DISPATCHABLE_HANDLE(VkMicromapEXT) VK_DEFINE_NON_DISPATCHABLE_HANDLE(VkOpticalFlowSessionNV) @@ -1002,6 +1008,8 @@ typedef VkFlags VkImageFormatConstraintsFlagsFUCHSIA; typedef VkFlags VkImagePipeSurfaceCreateFlagsFUCHSIA; typedef VkFlags VkImageUsageFlags; typedef VkFlags VkImageViewCreateFlags; +typedef VkFlags VkIndirectCommandsInputModeFlagsEXT; +typedef VkFlags VkIndirectCommandsLayoutUsageFlagsEXT; typedef VkFlags VkIndirectCommandsLayoutUsageFlagsNV; typedef VkFlags VkIndirectStateFlagsNV; typedef VkFlags VkInstanceCreateFlags; @@ -1601,6 +1609,8 @@ typedef enum VkAccessFlagBits VK_ACCESS_ACCELERATION_STRUCTURE_READ_BIT_NV = VK_ACCESS_ACCELERATION_STRUCTURE_READ_BIT_KHR, VK_ACCESS_ACCELERATION_STRUCTURE_WRITE_BIT_NV = VK_ACCESS_ACCELERATION_STRUCTURE_WRITE_BIT_KHR, VK_ACCESS_NONE_KHR = VK_ACCESS_NONE, + VK_ACCESS_COMMAND_PREPROCESS_READ_BIT_EXT = VK_ACCESS_COMMAND_PREPROCESS_READ_BIT_NV, + VK_ACCESS_COMMAND_PREPROCESS_WRITE_BIT_EXT = VK_ACCESS_COMMAND_PREPROCESS_WRITE_BIT_NV, VK_ACCESS_FLAG_BITS_MAX_ENUM = 0x7fffffff, } VkAccessFlagBits;

@@ -1643,7 +1653,9 @@ static const VkAccessFlagBits2 VK_ACCESS_2_MEMORY_READ_BIT_KHR = 0x00008000ull; static const VkAccessFlagBits2 VK_ACCESS_2_MEMORY_WRITE_BIT = 0x00010000ull; static const VkAccessFlagBits2 VK_ACCESS_2_MEMORY_WRITE_BIT_KHR = 0x00010000ull; static const VkAccessFlagBits2 VK_ACCESS_2_COMMAND_PREPROCESS_READ_BIT_NV = 0x00020000ull; +static const VkAccessFlagBits2 VK_ACCESS_2_COMMAND_PREPROCESS_READ_BIT_EXT = 0x00020000ull; static const VkAccessFlagBits2 VK_ACCESS_2_COMMAND_PREPROCESS_WRITE_BIT_NV = 0x00040000ull; +static const VkAccessFlagBits2 VK_ACCESS_2_COMMAND_PREPROCESS_WRITE_BIT_EXT = 0x00040000ull; static const VkAccessFlagBits2 VK_ACCESS_2_COLOR_ATTACHMENT_READ_NONCOHERENT_BIT_EXT = 0x00080000ull; static const VkAccessFlagBits2 VK_ACCESS_2_CONDITIONAL_RENDERING_READ_BIT_EXT = 0x00100000ull; static const VkAccessFlagBits2 VK_ACCESS_2_ACCELERATION_STRUCTURE_READ_BIT_KHR = 0x00200000ull; @@ -1905,6 +1917,7 @@ static const VkBufferUsageFlagBits2KHR VK_BUFFER_USAGE_2_RESOURCE_DESCRIPTOR_BUF static const VkBufferUsageFlagBits2KHR VK_BUFFER_USAGE_2_MICROMAP_BUILD_INPUT_READ_ONLY_BIT_EXT = 0x00800000ull; static const VkBufferUsageFlagBits2KHR VK_BUFFER_USAGE_2_MICROMAP_STORAGE_BIT_EXT = 0x01000000ull; static const VkBufferUsageFlagBits2KHR VK_BUFFER_USAGE_2_PUSH_DESCRIPTORS_DESCRIPTOR_BUFFER_BIT_EXT = 0x04000000ull; +static const VkBufferUsageFlagBits2KHR VK_BUFFER_USAGE_2_PREPROCESS_BUFFER_BIT_EXT = 0x80000000ull;

typedef enum VkBuildAccelerationStructureFlagBitsKHR { @@ -2260,6 +2273,13 @@ typedef enum VkDepthBiasRepresentationEXT VK_DEPTH_BIAS_REPRESENTATION_EXT_MAX_ENUM = 0x7fffffff, } VkDepthBiasRepresentationEXT;

+typedef enum VkDepthClampModeEXT +{ + VK_DEPTH_CLAMP_MODE_VIEWPORT_RANGE_EXT = 0, + VK_DEPTH_CLAMP_MODE_USER_DEFINED_RANGE_EXT = 1, + VK_DEPTH_CLAMP_MODE_EXT_MAX_ENUM = 0x7fffffff, +} VkDepthClampModeEXT; + typedef enum VkDescriptorBindingFlagBits { VK_DESCRIPTOR_BINDING_UPDATE_AFTER_BIND_BIT = 0x00000001, @@ -2514,6 +2534,7 @@ typedef enum VkDynamicState VK_DYNAMIC_STATE_REPRESENTATIVE_FRAGMENT_TEST_ENABLE_NV = 1000455031, VK_DYNAMIC_STATE_COVERAGE_REDUCTION_MODE_NV = 1000455032, VK_DYNAMIC_STATE_ATTACHMENT_FEEDBACK_LOOP_ENABLE_EXT = 1000524000, + VK_DYNAMIC_STATE_DEPTH_CLAMP_RANGE_EXT = 1000582000, VK_DYNAMIC_STATE_LINE_STIPPLE_EXT = VK_DYNAMIC_STATE_LINE_STIPPLE_KHR, VK_DYNAMIC_STATE_CULL_MODE_EXT = VK_DYNAMIC_STATE_CULL_MODE, VK_DYNAMIC_STATE_FRONT_FACE_EXT = VK_DYNAMIC_STATE_FRONT_FACE, @@ -3388,6 +3409,20 @@ typedef enum VkIndexType VK_INDEX_TYPE_MAX_ENUM = 0x7fffffff, } VkIndexType;

+typedef enum VkIndirectCommandsInputModeFlagBitsEXT +{ + VK_INDIRECT_COMMANDS_INPUT_MODE_VULKAN_INDEX_BUFFER_EXT = 0x00000001, + VK_INDIRECT_COMMANDS_INPUT_MODE_DXGI_INDEX_BUFFER_EXT = 0x00000002, + VK_INDIRECT_COMMANDS_INPUT_MODE_FLAG_BITS_EXT_MAX_ENUM = 0x7fffffff, +} VkIndirectCommandsInputModeFlagBitsEXT; + +typedef enum VkIndirectCommandsLayoutUsageFlagBitsEXT +{ + VK_INDIRECT_COMMANDS_LAYOUT_USAGE_EXPLICIT_PREPROCESS_BIT_EXT = 0x00000001, + VK_INDIRECT_COMMANDS_LAYOUT_USAGE_UNORDERED_SEQUENCES_BIT_EXT = 0x00000002, + VK_INDIRECT_COMMANDS_LAYOUT_USAGE_FLAG_BITS_EXT_MAX_ENUM = 0x7fffffff, +} VkIndirectCommandsLayoutUsageFlagBitsEXT; + typedef enum VkIndirectCommandsLayoutUsageFlagBitsNV { VK_INDIRECT_COMMANDS_LAYOUT_USAGE_EXPLICIT_PREPROCESS_BIT_NV = 0x00000001, @@ -3396,6 +3431,26 @@ typedef enum VkIndirectCommandsLayoutUsageFlagBitsNV VK_INDIRECT_COMMANDS_LAYOUT_USAGE_FLAG_BITS_NV_MAX_ENUM = 0x7fffffff, } VkIndirectCommandsLayoutUsageFlagBitsNV;

+typedef enum VkIndirectCommandsTokenTypeEXT +{ + VK_INDIRECT_COMMANDS_TOKEN_TYPE_EXECUTION_SET_EXT = 0, + VK_INDIRECT_COMMANDS_TOKEN_TYPE_PUSH_CONSTANT_EXT = 1, + VK_INDIRECT_COMMANDS_TOKEN_TYPE_SEQUENCE_INDEX_EXT = 2, + VK_INDIRECT_COMMANDS_TOKEN_TYPE_INDEX_BUFFER_EXT = 3, + VK_INDIRECT_COMMANDS_TOKEN_TYPE_VERTEX_BUFFER_EXT = 4, + VK_INDIRECT_COMMANDS_TOKEN_TYPE_DRAW_INDEXED_EXT = 5, + VK_INDIRECT_COMMANDS_TOKEN_TYPE_DRAW_EXT = 6, + VK_INDIRECT_COMMANDS_TOKEN_TYPE_DRAW_INDEXED_COUNT_EXT = 7, + VK_INDIRECT_COMMANDS_TOKEN_TYPE_DRAW_COUNT_EXT = 8, + VK_INDIRECT_COMMANDS_TOKEN_TYPE_DISPATCH_EXT = 9, + VK_INDIRECT_COMMANDS_TOKEN_TYPE_DRAW_MESH_TASKS_NV_EXT = 1000202002, + VK_INDIRECT_COMMANDS_TOKEN_TYPE_DRAW_MESH_TASKS_COUNT_NV_EXT = 1000202003, + VK_INDIRECT_COMMANDS_TOKEN_TYPE_DRAW_MESH_TASKS_EXT = 1000328000, + VK_INDIRECT_COMMANDS_TOKEN_TYPE_DRAW_MESH_TASKS_COUNT_EXT = 1000328001, + VK_INDIRECT_COMMANDS_TOKEN_TYPE_TRACE_RAYS2_EXT = 1000386004, + VK_INDIRECT_COMMANDS_TOKEN_TYPE_EXT_MAX_ENUM = 0x7fffffff, +} VkIndirectCommandsTokenTypeEXT; + typedef enum VkIndirectCommandsTokenTypeNV { VK_INDIRECT_COMMANDS_TOKEN_TYPE_SHADER_GROUP_NV = 0, @@ -3412,6 +3467,13 @@ typedef enum VkIndirectCommandsTokenTypeNV VK_INDIRECT_COMMANDS_TOKEN_TYPE_NV_MAX_ENUM = 0x7fffffff, } VkIndirectCommandsTokenTypeNV;

+typedef enum VkIndirectExecutionSetInfoTypeEXT +{ + VK_INDIRECT_EXECUTION_SET_INFO_TYPE_PIPELINES_EXT = 0, + VK_INDIRECT_EXECUTION_SET_INFO_TYPE_SHADER_OBJECTS_EXT = 1, + VK_INDIRECT_EXECUTION_SET_INFO_TYPE_EXT_MAX_ENUM = 0x7fffffff, +} VkIndirectExecutionSetInfoTypeEXT; + typedef enum VkIndirectStateFlagBitsNV { VK_INDIRECT_STATE_FLAG_FRONTFACE_BIT_NV = 0x00000001, @@ -3622,6 +3684,8 @@ typedef enum VkObjectType VK_OBJECT_TYPE_OPTICAL_FLOW_SESSION_NV = 1000464000, VK_OBJECT_TYPE_SHADER_EXT = 1000482000, VK_OBJECT_TYPE_PIPELINE_BINARY_KHR = 1000483000, + VK_OBJECT_TYPE_INDIRECT_COMMANDS_LAYOUT_EXT = 1000572000, + VK_OBJECT_TYPE_INDIRECT_EXECUTION_SET_EXT = 1000572001, VK_OBJECT_TYPE_DESCRIPTOR_UPDATE_TEMPLATE_KHR = VK_OBJECT_TYPE_DESCRIPTOR_UPDATE_TEMPLATE, VK_OBJECT_TYPE_SAMPLER_YCBCR_CONVERSION_KHR = VK_OBJECT_TYPE_SAMPLER_YCBCR_CONVERSION, VK_OBJECT_TYPE_PRIVATE_DATA_SLOT_EXT = VK_OBJECT_TYPE_PRIVATE_DATA_SLOT, @@ -3928,6 +3992,7 @@ static const VkPipelineCreateFlagBits2KHR VK_PIPELINE_CREATE_2_DESCRIPTOR_BUFFER static const VkPipelineCreateFlagBits2KHR VK_PIPELINE_CREATE_2_PROTECTED_ACCESS_ONLY_BIT_EXT = 0x40000000ull; static const VkPipelineCreateFlagBits2KHR VK_PIPELINE_CREATE_2_CAPTURE_DATA_BIT_KHR = 0x80000000ull; static const VkPipelineCreateFlagBits2KHR VK_PIPELINE_CREATE_2_ENABLE_LEGACY_DITHERING_BIT_EXT = 0x400000000ull; +static const VkPipelineCreateFlagBits2KHR VK_PIPELINE_CREATE_2_INDIRECT_BINDABLE_BIT_EXT = 0x4000000000ull;

typedef enum VkPipelineCreationFeedbackFlagBits { @@ -4027,6 +4092,7 @@ typedef enum VkPipelineStageFlagBits VK_PIPELINE_STAGE_TASK_SHADER_BIT_NV = VK_PIPELINE_STAGE_TASK_SHADER_BIT_EXT, VK_PIPELINE_STAGE_MESH_SHADER_BIT_NV = VK_PIPELINE_STAGE_MESH_SHADER_BIT_EXT, VK_PIPELINE_STAGE_NONE_KHR = VK_PIPELINE_STAGE_NONE, + VK_PIPELINE_STAGE_COMMAND_PREPROCESS_BIT_EXT = VK_PIPELINE_STAGE_COMMAND_PREPROCESS_BIT_NV, VK_PIPELINE_STAGE_FLAG_BITS_MAX_ENUM = 0x7fffffff, } VkPipelineStageFlagBits;

@@ -4071,6 +4137,7 @@ static const VkPipelineStageFlagBits2 VK_PIPELINE_STAGE_2_ALL_GRAPHICS_BIT_KHR = static const VkPipelineStageFlagBits2 VK_PIPELINE_STAGE_2_ALL_COMMANDS_BIT = 0x00010000ull; static const VkPipelineStageFlagBits2 VK_PIPELINE_STAGE_2_ALL_COMMANDS_BIT_KHR = 0x00010000ull; static const VkPipelineStageFlagBits2 VK_PIPELINE_STAGE_2_COMMAND_PREPROCESS_BIT_NV = 0x00020000ull; +static const VkPipelineStageFlagBits2 VK_PIPELINE_STAGE_2_COMMAND_PREPROCESS_BIT_EXT = 0x00020000ull; static const VkPipelineStageFlagBits2 VK_PIPELINE_STAGE_2_CONDITIONAL_RENDERING_BIT_EXT = 0x00040000ull; static const VkPipelineStageFlagBits2 VK_PIPELINE_STAGE_2_TASK_SHADER_BIT_NV = 0x00080000ull; static const VkPipelineStageFlagBits2 VK_PIPELINE_STAGE_2_TASK_SHADER_BIT_EXT = 0x00080000ull; @@ -4538,6 +4605,7 @@ typedef enum VkShaderCreateFlagBitsEXT VK_SHADER_CREATE_DISPATCH_BASE_BIT_EXT = 0x00000010, VK_SHADER_CREATE_FRAGMENT_SHADING_RATE_ATTACHMENT_BIT_EXT = 0x00000020, VK_SHADER_CREATE_FRAGMENT_DENSITY_MAP_ATTACHMENT_BIT_EXT = 0x00000040, + VK_SHADER_CREATE_INDIRECT_BINDABLE_BIT_EXT = 0x00000080, VK_SHADER_CREATE_FLAG_BITS_EXT_MAX_ENUM = 0x7fffffff, } VkShaderCreateFlagBitsEXT;

@@ -5452,9 +5520,25 @@ typedef enum VkStructureType VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_ATOMIC_FLOAT16_VECTOR_FEATURES_NV = 1000563000, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_REPLICATED_COMPOSITES_FEATURES_EXT = 1000564000, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RAY_TRACING_VALIDATION_FEATURES_NV = 1000568000, + VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DEVICE_GENERATED_COMMANDS_FEATURES_EXT = 1000572000, + VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DEVICE_GENERATED_COMMANDS_PROPERTIES_EXT = 1000572001, + VK_STRUCTURE_TYPE_GENERATED_COMMANDS_MEMORY_REQUIREMENTS_INFO_EXT = 1000572002, + VK_STRUCTURE_TYPE_INDIRECT_EXECUTION_SET_CREATE_INFO_EXT = 1000572003, + VK_STRUCTURE_TYPE_GENERATED_COMMANDS_INFO_EXT = 1000572004, + VK_STRUCTURE_TYPE_INDIRECT_COMMANDS_LAYOUT_CREATE_INFO_EXT = 1000572006, + VK_STRUCTURE_TYPE_INDIRECT_COMMANDS_LAYOUT_TOKEN_EXT = 1000572007, + VK_STRUCTURE_TYPE_WRITE_INDIRECT_EXECUTION_SET_PIPELINE_EXT = 1000572008, + VK_STRUCTURE_TYPE_WRITE_INDIRECT_EXECUTION_SET_SHADER_EXT = 1000572009, + VK_STRUCTURE_TYPE_INDIRECT_EXECUTION_SET_PIPELINE_INFO_EXT = 1000572010, + VK_STRUCTURE_TYPE_INDIRECT_EXECUTION_SET_SHADER_INFO_EXT = 1000572011, + VK_STRUCTURE_TYPE_INDIRECT_EXECUTION_SET_SHADER_LAYOUT_INFO_EXT = 1000572012, + VK_STRUCTURE_TYPE_GENERATED_COMMANDS_PIPELINE_INFO_EXT = 1000572013, + VK_STRUCTURE_TYPE_GENERATED_COMMANDS_SHADER_INFO_EXT = 1000572014, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_ALIGNMENT_CONTROL_FEATURES_MESA = 1000575000, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_ALIGNMENT_CONTROL_PROPERTIES_MESA = 1000575001, VK_STRUCTURE_TYPE_IMAGE_ALIGNMENT_CONTROL_CREATE_INFO_MESA = 1000575002, + VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DEPTH_CLAMP_CONTROL_FEATURES_EXT = 1000582000, + VK_STRUCTURE_TYPE_PIPELINE_VIEWPORT_DEPTH_CLAMP_CONTROL_CREATE_INFO_EXT = 1000582001, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VARIABLE_POINTER_FEATURES = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VARIABLE_POINTERS_FEATURES, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_DRAW_PARAMETER_FEATURES = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_DRAW_PARAMETERS_FEATURES, VK_STRUCTURE_TYPE_DEBUG_REPORT_CREATE_INFO_EXT = VK_STRUCTURE_TYPE_DEBUG_REPORT_CALLBACK_CREATE_INFO_EXT, @@ -6948,6 +7032,13 @@ typedef struct VkBindImagePlaneMemoryInfo } VkBindImagePlaneMemoryInfo; typedef VkBindImagePlaneMemoryInfo VkBindImagePlaneMemoryInfoKHR;

+typedef struct VkBindIndexBufferIndirectCommandEXT +{ + VkDeviceAddress WINE_VK_ALIGN(8) bufferAddress; + uint32_t size; + VkIndexType indexType; +} VkBindIndexBufferIndirectCommandEXT; + typedef struct VkBindIndexBufferIndirectCommandNV { VkDeviceAddress WINE_VK_ALIGN(8) bufferAddress; @@ -6972,6 +7063,13 @@ typedef struct VkBindShaderGroupIndirectCommandNV uint32_t groupIndex; } VkBindShaderGroupIndirectCommandNV;

+typedef struct VkBindVertexBufferIndirectCommandEXT +{ + VkDeviceAddress WINE_VK_ALIGN(8) bufferAddress; + uint32_t size; + uint32_t stride; +} VkBindVertexBufferIndirectCommandEXT; + typedef struct VkBindVertexBufferIndirectCommandNV { VkDeviceAddress WINE_VK_ALIGN(8) bufferAddress; @@ -7559,6 +7657,12 @@ typedef struct VkDepthBiasRepresentationInfoEXT VkBool32 depthBiasExact; } VkDepthBiasRepresentationInfoEXT;

+typedef struct VkDepthClampRangeEXT +{ + float minDepthClamp; + float maxDepthClamp; +} VkDepthClampRangeEXT; + typedef struct VkDescriptorAddressInfoEXT { VkStructureType sType; @@ -7925,6 +8029,13 @@ typedef struct VkDrawIndirectCommand uint32_t firstInstance; } VkDrawIndirectCommand;

+typedef struct VkDrawIndirectCountIndirectCommandEXT +{ + VkDeviceAddress WINE_VK_ALIGN(8) bufferAddress; + uint32_t stride; + uint32_t commandCount; +} VkDrawIndirectCountIndirectCommandEXT; + typedef struct VkDrawMeshTasksIndirectCommandEXT { uint32_t groupCountX; @@ -8157,6 +8268,32 @@ typedef struct VkFramebufferMixedSamplesCombinationNV VkSampleCountFlags colorSamples; } VkFramebufferMixedSamplesCombinationNV;

+typedef struct VkGeneratedCommandsInfoEXT +{ + VkStructureType sType; + const void *pNext; + VkShaderStageFlags shaderStages; + VkIndirectExecutionSetEXT WINE_VK_ALIGN(8) indirectExecutionSet; + VkIndirectCommandsLayoutEXT WINE_VK_ALIGN(8) indirectCommandsLayout; + VkDeviceAddress WINE_VK_ALIGN(8) indirectAddress; + VkDeviceSize WINE_VK_ALIGN(8) indirectAddressSize; + VkDeviceAddress WINE_VK_ALIGN(8) preprocessAddress; + VkDeviceSize WINE_VK_ALIGN(8) preprocessSize; + uint32_t maxSequenceCount; + VkDeviceAddress WINE_VK_ALIGN(8) sequenceCountAddress; + uint32_t maxDrawCount; +} VkGeneratedCommandsInfoEXT; + +typedef struct VkGeneratedCommandsMemoryRequirementsInfoEXT +{ + VkStructureType sType; + void *pNext; + VkIndirectExecutionSetEXT WINE_VK_ALIGN(8) indirectExecutionSet; + VkIndirectCommandsLayoutEXT WINE_VK_ALIGN(8) indirectCommandsLayout; + uint32_t maxSequenceCount; + uint32_t maxDrawCount; +} VkGeneratedCommandsMemoryRequirementsInfoEXT; + typedef struct VkGeneratedCommandsMemoryRequirementsInfoNV { VkStructureType sType; @@ -8167,6 +8304,21 @@ typedef struct VkGeneratedCommandsMemoryRequirementsInfoNV uint32_t maxSequencesCount; } VkGeneratedCommandsMemoryRequirementsInfoNV;

+typedef struct VkGeneratedCommandsPipelineInfoEXT +{ + VkStructureType sType; + void *pNext; + VkPipeline WINE_VK_ALIGN(8) pipeline; +} VkGeneratedCommandsPipelineInfoEXT; + +typedef struct VkGeneratedCommandsShaderInfoEXT +{ + VkStructureType sType; + void *pNext; + uint32_t shaderCount; + const VkShaderEXT *pShaders; +} VkGeneratedCommandsShaderInfoEXT; + typedef struct VkGeometryAABBNV { VkStructureType sType; @@ -8439,6 +8591,17 @@ typedef struct VkImportMemoryWin32HandleInfoKHR LPCWSTR name; } VkImportMemoryWin32HandleInfoKHR;

+typedef struct VkIndirectCommandsExecutionSetTokenEXT +{ + VkIndirectExecutionSetInfoTypeEXT type; + VkShaderStageFlags shaderStages; +} VkIndirectCommandsExecutionSetTokenEXT; + +typedef struct VkIndirectCommandsIndexBufferTokenEXT +{ + VkIndirectCommandsInputModeFlagBitsEXT mode; +} VkIndirectCommandsIndexBufferTokenEXT; + typedef struct VkIndirectCommandsLayoutTokenNV { VkStructureType sType; @@ -8464,6 +8627,27 @@ typedef struct VkIndirectCommandsStreamNV VkDeviceSize WINE_VK_ALIGN(8) offset; } VkIndirectCommandsStreamNV;

+typedef struct VkIndirectCommandsVertexBufferTokenEXT +{ + uint32_t vertexBindingUnit; +} VkIndirectCommandsVertexBufferTokenEXT; + +typedef struct VkIndirectExecutionSetPipelineInfoEXT +{ + VkStructureType sType; + const void *pNext; + VkPipeline WINE_VK_ALIGN(8) initialPipeline; + uint32_t maxPipelineCount; +} VkIndirectExecutionSetPipelineInfoEXT; + +typedef struct VkIndirectExecutionSetShaderLayoutInfoEXT +{ + VkStructureType sType; + const void *pNext; + uint32_t setLayoutCount; + const VkDescriptorSetLayout *pSetLayouts; +} VkIndirectExecutionSetShaderLayoutInfoEXT; + typedef struct VkInitializePerformanceApiInfoINTEL { VkStructureType sType; @@ -9300,6 +9484,13 @@ typedef struct VkPhysicalDeviceDepthBiasControlFeaturesEXT VkBool32 depthBiasExact; } VkPhysicalDeviceDepthBiasControlFeaturesEXT;

+typedef struct VkPhysicalDeviceDepthClampControlFeaturesEXT +{ + VkStructureType sType; + void *pNext; + VkBool32 depthClampControl; +} VkPhysicalDeviceDepthClampControlFeaturesEXT; + typedef struct VkPhysicalDeviceDepthClampZeroOneFeaturesEXT { VkStructureType sType; @@ -9468,6 +9659,14 @@ typedef struct VkPhysicalDeviceDeviceGeneratedCommandsComputeFeaturesNV VkBool32 deviceGeneratedComputeCaptureReplay; } VkPhysicalDeviceDeviceGeneratedCommandsComputeFeaturesNV;

+typedef struct VkPhysicalDeviceDeviceGeneratedCommandsFeaturesEXT +{ + VkStructureType sType; + void *pNext; + VkBool32 deviceGeneratedCommands; + VkBool32 dynamicGeneratedPipelineLayout; +} VkPhysicalDeviceDeviceGeneratedCommandsFeaturesEXT; + typedef struct VkPhysicalDeviceDeviceGeneratedCommandsFeaturesNV { VkStructureType sType; @@ -9475,6 +9674,24 @@ typedef struct VkPhysicalDeviceDeviceGeneratedCommandsFeaturesNV VkBool32 deviceGeneratedCommands; } VkPhysicalDeviceDeviceGeneratedCommandsFeaturesNV;

+typedef struct VkPhysicalDeviceDeviceGeneratedCommandsPropertiesEXT +{ + VkStructureType sType; + void *pNext; + uint32_t maxIndirectPipelineCount; + uint32_t maxIndirectShaderObjectCount; + uint32_t maxIndirectSequenceCount; + uint32_t maxIndirectCommandsTokenCount; + uint32_t maxIndirectCommandsTokenOffset; + uint32_t maxIndirectCommandsIndirectStride; + VkIndirectCommandsInputModeFlagsEXT supportedIndirectCommandsInputModes; + VkShaderStageFlags supportedIndirectCommandsShaderStages; + VkShaderStageFlags supportedIndirectCommandsShaderStagesPipelineBinding; + VkShaderStageFlags supportedIndirectCommandsShaderStagesShaderBinding; + VkBool32 deviceGeneratedCommandsTransformFeedback; + VkBool32 deviceGeneratedCommandsMultiDrawIndirectCount; +} VkPhysicalDeviceDeviceGeneratedCommandsPropertiesEXT; + typedef struct VkPhysicalDeviceDeviceGeneratedCommandsPropertiesNV { VkStructureType sType; @@ -12339,6 +12556,14 @@ typedef struct VkPipelineViewportCoarseSampleOrderStateCreateInfoNV const VkCoarseSampleOrderCustomNV *pCustomSampleOrders; } VkPipelineViewportCoarseSampleOrderStateCreateInfoNV;

+typedef struct VkPipelineViewportDepthClampControlCreateInfoEXT +{ + VkStructureType sType; + const void *pNext; + VkDepthClampModeEXT depthClampMode; + const VkDepthClampRangeEXT *pDepthClampRange; +} VkPipelineViewportDepthClampControlCreateInfoEXT; + typedef struct VkPipelineViewportDepthClipControlCreateInfoEXT { VkStructureType sType; @@ -14031,6 +14256,22 @@ typedef struct VkWriteDescriptorSetInlineUniformBlock } VkWriteDescriptorSetInlineUniformBlock; typedef VkWriteDescriptorSetInlineUniformBlock VkWriteDescriptorSetInlineUniformBlockEXT;

+typedef struct VkWriteIndirectExecutionSetPipelineEXT +{ + VkStructureType sType; + const void *pNext; + uint32_t index; + VkPipeline WINE_VK_ALIGN(8) pipeline; +} VkWriteIndirectExecutionSetPipelineEXT; + +typedef struct VkWriteIndirectExecutionSetShaderEXT +{ + VkStructureType sType; + const void *pNext; + uint32_t index; + VkShaderEXT WINE_VK_ALIGN(8) shader; +} VkWriteIndirectExecutionSetShaderEXT; + typedef struct VkXYColorEXT { float x; @@ -15007,6 +15248,31 @@ typedef struct VkIndirectCommandsLayoutCreateInfoNV const uint32_t *pStreamStrides; } VkIndirectCommandsLayoutCreateInfoNV;

+typedef struct VkIndirectCommandsPushConstantTokenEXT +{ + VkPushConstantRange updateRange; +} VkIndirectCommandsPushConstantTokenEXT; + +typedef union VkIndirectCommandsTokenDataEXT +{ + const VkIndirectCommandsPushConstantTokenEXT *pPushConstant; + const VkIndirectCommandsVertexBufferTokenEXT *pVertexBuffer; + const VkIndirectCommandsIndexBufferTokenEXT *pIndexBuffer; + const VkIndirectCommandsExecutionSetTokenEXT *pExecutionSet; +} VkIndirectCommandsTokenDataEXT; + +typedef struct VkIndirectExecutionSetShaderInfoEXT +{ + VkStructureType sType; + const void *pNext; + uint32_t shaderCount; + const VkShaderEXT *pInitialShaders; + const VkIndirectExecutionSetShaderLayoutInfoEXT *pSetLayoutInfos; + uint32_t maxShaderCount; + uint32_t pushConstantRangeCount; + const VkPushConstantRange *pPushConstantRanges; +} VkIndirectExecutionSetShaderInfoEXT; + typedef struct VkMemoryToImageCopyEXT { VkStructureType sType; @@ -15767,6 +16033,21 @@ typedef struct VkDependencyInfo } VkDependencyInfo; typedef VkDependencyInfo VkDependencyInfoKHR;

+typedef struct VkIndirectCommandsLayoutTokenEXT +{ + VkStructureType sType; + const void *pNext; + VkIndirectCommandsTokenTypeEXT type; + VkIndirectCommandsTokenDataEXT data; + uint32_t offset; +} VkIndirectCommandsLayoutTokenEXT; + +typedef union VkIndirectExecutionSetInfoEXT +{ + const VkIndirectExecutionSetPipelineInfoEXT *pPipelineInfo; + const VkIndirectExecutionSetShaderInfoEXT *pShaderInfo; +} VkIndirectExecutionSetInfoEXT; + typedef struct VkPipelineShaderStageCreateInfo { VkStructureType sType; @@ -16020,6 +16301,26 @@ typedef struct VkGraphicsShaderGroupCreateInfoNV const VkPipelineTessellationStateCreateInfo *pTessellationState; } VkGraphicsShaderGroupCreateInfoNV;

+typedef struct VkIndirectCommandsLayoutCreateInfoEXT +{ + VkStructureType sType; + const void *pNext; + VkIndirectCommandsLayoutUsageFlagsEXT flags; + VkShaderStageFlags shaderStages; + uint32_t indirectStride; + VkPipelineLayout WINE_VK_ALIGN(8) pipelineLayout; + uint32_t tokenCount; + const VkIndirectCommandsLayoutTokenEXT *pTokens; +} VkIndirectCommandsLayoutCreateInfoEXT; + +typedef struct VkIndirectExecutionSetCreateInfoEXT +{ + VkStructureType sType; + const void *pNext; + VkIndirectExecutionSetInfoTypeEXT type; + VkIndirectExecutionSetInfoEXT info; +} VkIndirectExecutionSetCreateInfoEXT; + typedef struct VkGraphicsPipelineShaderGroupsCreateInfoNV { VkStructureType sType; @@ -16156,6 +16457,7 @@ typedef void (VKAPI_PTR *PFN_vkCmdEndRenderingKHR)(VkCommandBuffer); typedef void (VKAPI_PTR *PFN_vkCmdEndTransformFeedbackEXT)(VkCommandBuffer, uint32_t, uint32_t, const VkBuffer *, const VkDeviceSize *); typedef void (VKAPI_PTR *PFN_vkCmdEndVideoCodingKHR)(VkCommandBuffer, const VkVideoEndCodingInfoKHR *); typedef void (VKAPI_PTR *PFN_vkCmdExecuteCommands)(VkCommandBuffer, uint32_t, const VkCommandBuffer *); +typedef void (VKAPI_PTR *PFN_vkCmdExecuteGeneratedCommandsEXT)(VkCommandBuffer, VkBool32, const VkGeneratedCommandsInfoEXT *); typedef void (VKAPI_PTR *PFN_vkCmdExecuteGeneratedCommandsNV)(VkCommandBuffer, VkBool32, const VkGeneratedCommandsInfoNV *); typedef void (VKAPI_PTR *PFN_vkCmdFillBuffer)(VkCommandBuffer, VkBuffer, VkDeviceSize, VkDeviceSize, uint32_t); typedef void (VKAPI_PTR *PFN_vkCmdInsertDebugUtilsLabelEXT)(VkCommandBuffer, const VkDebugUtilsLabelEXT *); @@ -16166,6 +16468,7 @@ typedef void (VKAPI_PTR *PFN_vkCmdOpticalFlowExecuteNV)(VkCommandBuffer, VkOptic typedef void (VKAPI_PTR *PFN_vkCmdPipelineBarrier)(VkCommandBuffer, VkPipelineStageFlags, VkPipelineStageFlags, VkDependencyFlags, uint32_t, const VkMemoryBarrier *, uint32_t, const VkBufferMemoryBarrier *, uint32_t, const VkImageMemoryBarrier *); typedef void (VKAPI_PTR *PFN_vkCmdPipelineBarrier2)(VkCommandBuffer, const VkDependencyInfo *); typedef void (VKAPI_PTR *PFN_vkCmdPipelineBarrier2KHR)(VkCommandBuffer, const VkDependencyInfo *); +typedef void (VKAPI_PTR *PFN_vkCmdPreprocessGeneratedCommandsEXT)(VkCommandBuffer, const VkGeneratedCommandsInfoEXT *, VkCommandBuffer); typedef void (VKAPI_PTR *PFN_vkCmdPreprocessGeneratedCommandsNV)(VkCommandBuffer, const VkGeneratedCommandsInfoNV *); typedef void (VKAPI_PTR *PFN_vkCmdPushConstants)(VkCommandBuffer, VkPipelineLayout, VkShaderStageFlags, uint32_t, uint32_t, const void *); typedef void (VKAPI_PTR *PFN_vkCmdPushConstants2KHR)(VkCommandBuffer, const VkPushConstantsInfoKHR *); @@ -16208,6 +16511,7 @@ typedef void (VKAPI_PTR *PFN_vkCmdSetDepthBounds)(VkCommandBuffer, float, float) typedef void (VKAPI_PTR *PFN_vkCmdSetDepthBoundsTestEnable)(VkCommandBuffer, VkBool32); typedef void (VKAPI_PTR *PFN_vkCmdSetDepthBoundsTestEnableEXT)(VkCommandBuffer, VkBool32); typedef void (VKAPI_PTR *PFN_vkCmdSetDepthClampEnableEXT)(VkCommandBuffer, VkBool32); +typedef void (VKAPI_PTR *PFN_vkCmdSetDepthClampRangeEXT)(VkCommandBuffer, VkDepthClampModeEXT, const VkDepthClampRangeEXT *); typedef void (VKAPI_PTR *PFN_vkCmdSetDepthClipEnableEXT)(VkCommandBuffer, VkBool32); typedef void (VKAPI_PTR *PFN_vkCmdSetDepthClipNegativeOneToOneEXT)(VkCommandBuffer, VkBool32); typedef void (VKAPI_PTR *PFN_vkCmdSetDepthCompareOp)(VkCommandBuffer, VkCompareOp); @@ -16333,7 +16637,9 @@ typedef VkResult (VKAPI_PTR *PFN_vkCreateFramebuffer)(VkDevice, const VkFramebuf typedef VkResult (VKAPI_PTR *PFN_vkCreateGraphicsPipelines)(VkDevice, VkPipelineCache, uint32_t, const VkGraphicsPipelineCreateInfo *, const VkAllocationCallbacks *, VkPipeline *); typedef VkResult (VKAPI_PTR *PFN_vkCreateImage)(VkDevice, const VkImageCreateInfo *, const VkAllocationCallbacks *, VkImage *); typedef VkResult (VKAPI_PTR *PFN_vkCreateImageView)(VkDevice, const VkImageViewCreateInfo *, const VkAllocationCallbacks *, VkImageView *); +typedef VkResult (VKAPI_PTR *PFN_vkCreateIndirectCommandsLayoutEXT)(VkDevice, const VkIndirectCommandsLayoutCreateInfoEXT *, const VkAllocationCallbacks *, VkIndirectCommandsLayoutEXT *); typedef VkResult (VKAPI_PTR *PFN_vkCreateIndirectCommandsLayoutNV)(VkDevice, const VkIndirectCommandsLayoutCreateInfoNV *, const VkAllocationCallbacks *, VkIndirectCommandsLayoutNV *); +typedef VkResult (VKAPI_PTR *PFN_vkCreateIndirectExecutionSetEXT)(VkDevice, const VkIndirectExecutionSetCreateInfoEXT *, const VkAllocationCallbacks *, VkIndirectExecutionSetEXT *); typedef VkResult (VKAPI_PTR *PFN_vkCreateInstance)(const VkInstanceCreateInfo *, const VkAllocationCallbacks *, VkInstance *); typedef VkResult (VKAPI_PTR *PFN_vkCreateMicromapEXT)(VkDevice, const VkMicromapCreateInfoEXT *, const VkAllocationCallbacks *, VkMicromapEXT *); typedef VkResult (VKAPI_PTR *PFN_vkCreateOpticalFlowSessionNV)(VkDevice, const VkOpticalFlowSessionCreateInfoNV *, const VkAllocationCallbacks *, VkOpticalFlowSessionNV *); @@ -16385,7 +16691,9 @@ typedef void (VKAPI_PTR *PFN_vkDestroyFence)(VkDevice, VkFence, const VkAllocati typedef void (VKAPI_PTR *PFN_vkDestroyFramebuffer)(VkDevice, VkFramebuffer, const VkAllocationCallbacks *); typedef void (VKAPI_PTR *PFN_vkDestroyImage)(VkDevice, VkImage, const VkAllocationCallbacks *); typedef void (VKAPI_PTR *PFN_vkDestroyImageView)(VkDevice, VkImageView, const VkAllocationCallbacks *); +typedef void (VKAPI_PTR *PFN_vkDestroyIndirectCommandsLayoutEXT)(VkDevice, VkIndirectCommandsLayoutEXT, const VkAllocationCallbacks *); typedef void (VKAPI_PTR *PFN_vkDestroyIndirectCommandsLayoutNV)(VkDevice, VkIndirectCommandsLayoutNV, const VkAllocationCallbacks *); +typedef void (VKAPI_PTR *PFN_vkDestroyIndirectExecutionSetEXT)(VkDevice, VkIndirectExecutionSetEXT, const VkAllocationCallbacks *); typedef void (VKAPI_PTR *PFN_vkDestroyInstance)(VkInstance, const VkAllocationCallbacks *); typedef void (VKAPI_PTR *PFN_vkDestroyMicromapEXT)(VkDevice, VkMicromapEXT, const VkAllocationCallbacks *); typedef void (VKAPI_PTR *PFN_vkDestroyOpticalFlowSessionNV)(VkDevice, VkOpticalFlowSessionNV, const VkAllocationCallbacks *); @@ -16475,6 +16783,7 @@ typedef VkResult (VKAPI_PTR *PFN_vkGetEncodedVideoSessionParametersKHR)(VkDevice typedef VkResult (VKAPI_PTR *PFN_vkGetEventStatus)(VkDevice, VkEvent); typedef VkResult (VKAPI_PTR *PFN_vkGetFenceStatus)(VkDevice, VkFence); typedef VkResult (VKAPI_PTR *PFN_vkGetFramebufferTilePropertiesQCOM)(VkDevice, VkFramebuffer, uint32_t *, VkTilePropertiesQCOM *); +typedef void (VKAPI_PTR *PFN_vkGetGeneratedCommandsMemoryRequirementsEXT)(VkDevice, const VkGeneratedCommandsMemoryRequirementsInfoEXT *, VkMemoryRequirements2 *); typedef void (VKAPI_PTR *PFN_vkGetGeneratedCommandsMemoryRequirementsNV)(VkDevice, const VkGeneratedCommandsMemoryRequirementsInfoNV *, VkMemoryRequirements2 *); typedef void (VKAPI_PTR *PFN_vkGetImageMemoryRequirements)(VkDevice, VkImage, VkMemoryRequirements *); typedef void (VKAPI_PTR *PFN_vkGetImageMemoryRequirements2)(VkDevice, const VkImageMemoryRequirementsInfo2 *, VkMemoryRequirements2 *); @@ -16625,6 +16934,8 @@ typedef VkResult (VKAPI_PTR *PFN_vkUnmapMemory2KHR)(VkDevice, const VkMemoryUnma typedef void (VKAPI_PTR *PFN_vkUpdateDescriptorSetWithTemplate)(VkDevice, VkDescriptorSet, VkDescriptorUpdateTemplate, const void *); typedef void (VKAPI_PTR *PFN_vkUpdateDescriptorSetWithTemplateKHR)(VkDevice, VkDescriptorSet, VkDescriptorUpdateTemplate, const void *); typedef void (VKAPI_PTR *PFN_vkUpdateDescriptorSets)(VkDevice, uint32_t, const VkWriteDescriptorSet *, uint32_t, const VkCopyDescriptorSet *); +typedef void (VKAPI_PTR *PFN_vkUpdateIndirectExecutionSetPipelineEXT)(VkDevice, VkIndirectExecutionSetEXT, uint32_t, const VkWriteIndirectExecutionSetPipelineEXT *); +typedef void (VKAPI_PTR *PFN_vkUpdateIndirectExecutionSetShaderEXT)(VkDevice, VkIndirectExecutionSetEXT, uint32_t, const VkWriteIndirectExecutionSetShaderEXT *); typedef VkResult (VKAPI_PTR *PFN_vkUpdateVideoSessionParametersKHR)(VkDevice, VkVideoSessionParametersKHR, const VkVideoSessionParametersUpdateInfoKHR *); typedef VkResult (VKAPI_PTR *PFN_vkWaitForFences)(VkDevice, uint32_t, const VkFence *, VkBool32, uint64_t); typedef VkResult (VKAPI_PTR *PFN_vkWaitForPresentKHR)(VkDevice, VkSwapchainKHR, uint64_t, uint64_t); @@ -16760,6 +17071,7 @@ void VKAPI_CALL vkCmdEndRenderingKHR(VkCommandBuffer commandBuffer); void VKAPI_CALL vkCmdEndTransformFeedbackEXT(VkCommandBuffer commandBuffer, uint32_t firstCounterBuffer, uint32_t counterBufferCount, const VkBuffer *pCounterBuffers, const VkDeviceSize *pCounterBufferOffsets); void VKAPI_CALL vkCmdEndVideoCodingKHR(VkCommandBuffer commandBuffer, const VkVideoEndCodingInfoKHR *pEndCodingInfo); void VKAPI_CALL vkCmdExecuteCommands(VkCommandBuffer commandBuffer, uint32_t commandBufferCount, const VkCommandBuffer *pCommandBuffers); +void VKAPI_CALL vkCmdExecuteGeneratedCommandsEXT(VkCommandBuffer commandBuffer, VkBool32 isPreprocessed, const VkGeneratedCommandsInfoEXT *pGeneratedCommandsInfo); void VKAPI_CALL vkCmdExecuteGeneratedCommandsNV(VkCommandBuffer commandBuffer, VkBool32 isPreprocessed, const VkGeneratedCommandsInfoNV *pGeneratedCommandsInfo); void VKAPI_CALL vkCmdFillBuffer(VkCommandBuffer commandBuffer, VkBuffer dstBuffer, VkDeviceSize dstOffset, VkDeviceSize size, uint32_t data); void VKAPI_CALL vkCmdInsertDebugUtilsLabelEXT(VkCommandBuffer commandBuffer, const VkDebugUtilsLabelEXT *pLabelInfo); @@ -16770,6 +17082,7 @@ void VKAPI_CALL vkCmdOpticalFlowExecuteNV(VkCommandBuffer commandBuffer, VkOptic void VKAPI_CALL vkCmdPipelineBarrier(VkCommandBuffer commandBuffer, VkPipelineStageFlags srcStageMask, VkPipelineStageFlags dstStageMask, VkDependencyFlags dependencyFlags, uint32_t memoryBarrierCount, const VkMemoryBarrier *pMemoryBarriers, uint32_t bufferMemoryBarrierCount, const VkBufferMemoryBarrier *pBufferMemoryBarriers, uint32_t imageMemoryBarrierCount, const VkImageMemoryBarrier *pImageMemoryBarriers); void VKAPI_CALL vkCmdPipelineBarrier2(VkCommandBuffer commandBuffer, const VkDependencyInfo *pDependencyInfo); void VKAPI_CALL vkCmdPipelineBarrier2KHR(VkCommandBuffer commandBuffer, const VkDependencyInfo *pDependencyInfo); +void VKAPI_CALL vkCmdPreprocessGeneratedCommandsEXT(VkCommandBuffer commandBuffer, const VkGeneratedCommandsInfoEXT *pGeneratedCommandsInfo, VkCommandBuffer stateCommandBuffer); void VKAPI_CALL vkCmdPreprocessGeneratedCommandsNV(VkCommandBuffer commandBuffer, const VkGeneratedCommandsInfoNV *pGeneratedCommandsInfo); void VKAPI_CALL vkCmdPushConstants(VkCommandBuffer commandBuffer, VkPipelineLayout layout, VkShaderStageFlags stageFlags, uint32_t offset, uint32_t size, const void *pValues); void VKAPI_CALL vkCmdPushConstants2KHR(VkCommandBuffer commandBuffer, const VkPushConstantsInfoKHR *pPushConstantsInfo); @@ -16812,6 +17125,7 @@ void VKAPI_CALL vkCmdSetDepthBounds(VkCommandBuffer commandBuffer, float minDept void VKAPI_CALL vkCmdSetDepthBoundsTestEnable(VkCommandBuffer commandBuffer, VkBool32 depthBoundsTestEnable); void VKAPI_CALL vkCmdSetDepthBoundsTestEnableEXT(VkCommandBuffer commandBuffer, VkBool32 depthBoundsTestEnable); void VKAPI_CALL vkCmdSetDepthClampEnableEXT(VkCommandBuffer commandBuffer, VkBool32 depthClampEnable); +void VKAPI_CALL vkCmdSetDepthClampRangeEXT(VkCommandBuffer commandBuffer, VkDepthClampModeEXT depthClampMode, const VkDepthClampRangeEXT *pDepthClampRange); void VKAPI_CALL vkCmdSetDepthClipEnableEXT(VkCommandBuffer commandBuffer, VkBool32 depthClipEnable); void VKAPI_CALL vkCmdSetDepthClipNegativeOneToOneEXT(VkCommandBuffer commandBuffer, VkBool32 negativeOneToOne); void VKAPI_CALL vkCmdSetDepthCompareOp(VkCommandBuffer commandBuffer, VkCompareOp depthCompareOp); @@ -16937,7 +17251,9 @@ VkResult VKAPI_CALL vkCreateFramebuffer(VkDevice device, const VkFramebufferCrea VkResult VKAPI_CALL vkCreateGraphicsPipelines(VkDevice device, VkPipelineCache pipelineCache, uint32_t createInfoCount, const VkGraphicsPipelineCreateInfo *pCreateInfos, const VkAllocationCallbacks *pAllocator, VkPipeline *pPipelines); VkResult VKAPI_CALL vkCreateImage(VkDevice device, const VkImageCreateInfo *pCreateInfo, const VkAllocationCallbacks *pAllocator, VkImage *pImage); VkResult VKAPI_CALL vkCreateImageView(VkDevice device, const VkImageViewCreateInfo *pCreateInfo, const VkAllocationCallbacks *pAllocator, VkImageView *pView); +VkResult VKAPI_CALL vkCreateIndirectCommandsLayoutEXT(VkDevice device, const VkIndirectCommandsLayoutCreateInfoEXT *pCreateInfo, const VkAllocationCallbacks *pAllocator, VkIndirectCommandsLayoutEXT *pIndirectCommandsLayout); VkResult VKAPI_CALL vkCreateIndirectCommandsLayoutNV(VkDevice device, const VkIndirectCommandsLayoutCreateInfoNV *pCreateInfo, const VkAllocationCallbacks *pAllocator, VkIndirectCommandsLayoutNV *pIndirectCommandsLayout); +VkResult VKAPI_CALL vkCreateIndirectExecutionSetEXT(VkDevice device, const VkIndirectExecutionSetCreateInfoEXT *pCreateInfo, const VkAllocationCallbacks *pAllocator, VkIndirectExecutionSetEXT *pIndirectExecutionSet); VkResult VKAPI_CALL vkCreateInstance(const VkInstanceCreateInfo *pCreateInfo, const VkAllocationCallbacks *pAllocator, VkInstance *pInstance); VkResult VKAPI_CALL vkCreateMicromapEXT(VkDevice device, const VkMicromapCreateInfoEXT *pCreateInfo, const VkAllocationCallbacks *pAllocator, VkMicromapEXT *pMicromap); VkResult VKAPI_CALL vkCreateOpticalFlowSessionNV(VkDevice device, const VkOpticalFlowSessionCreateInfoNV *pCreateInfo, const VkAllocationCallbacks *pAllocator, VkOpticalFlowSessionNV *pSession); @@ -16989,7 +17305,9 @@ void VKAPI_CALL vkDestroyFence(VkDevice device, VkFence fence, const VkAllocatio void VKAPI_CALL vkDestroyFramebuffer(VkDevice device, VkFramebuffer framebuffer, const VkAllocationCallbacks *pAllocator); void VKAPI_CALL vkDestroyImage(VkDevice device, VkImage image, const VkAllocationCallbacks *pAllocator); void VKAPI_CALL vkDestroyImageView(VkDevice device, VkImageView imageView, const VkAllocationCallbacks *pAllocator); +void VKAPI_CALL vkDestroyIndirectCommandsLayoutEXT(VkDevice device, VkIndirectCommandsLayoutEXT indirectCommandsLayout, const VkAllocationCallbacks *pAllocator); void VKAPI_CALL vkDestroyIndirectCommandsLayoutNV(VkDevice device, VkIndirectCommandsLayoutNV indirectCommandsLayout, const VkAllocationCallbacks *pAllocator); +void VKAPI_CALL vkDestroyIndirectExecutionSetEXT(VkDevice device, VkIndirectExecutionSetEXT indirectExecutionSet, const VkAllocationCallbacks *pAllocator); void VKAPI_CALL vkDestroyInstance(VkInstance instance, const VkAllocationCallbacks *pAllocator); void VKAPI_CALL vkDestroyMicromapEXT(VkDevice device, VkMicromapEXT micromap, const VkAllocationCallbacks *pAllocator); void VKAPI_CALL vkDestroyOpticalFlowSessionNV(VkDevice device, VkOpticalFlowSessionNV session, const VkAllocationCallbacks *pAllocator); @@ -17079,6 +17397,7 @@ VkResult VKAPI_CALL vkGetEncodedVideoSessionParametersKHR(VkDevice device, const VkResult VKAPI_CALL vkGetEventStatus(VkDevice device, VkEvent event); VkResult VKAPI_CALL vkGetFenceStatus(VkDevice device, VkFence fence); VkResult VKAPI_CALL vkGetFramebufferTilePropertiesQCOM(VkDevice device, VkFramebuffer framebuffer, uint32_t *pPropertiesCount, VkTilePropertiesQCOM *pProperties); +void VKAPI_CALL vkGetGeneratedCommandsMemoryRequirementsEXT(VkDevice device, const VkGeneratedCommandsMemoryRequirementsInfoEXT *pInfo, VkMemoryRequirements2 *pMemoryRequirements); void VKAPI_CALL vkGetGeneratedCommandsMemoryRequirementsNV(VkDevice device, const VkGeneratedCommandsMemoryRequirementsInfoNV *pInfo, VkMemoryRequirements2 *pMemoryRequirements); void VKAPI_CALL vkGetImageMemoryRequirements(VkDevice device, VkImage image, VkMemoryRequirements *pMemoryRequirements); void VKAPI_CALL vkGetImageMemoryRequirements2(VkDevice device, const VkImageMemoryRequirementsInfo2 *pInfo, VkMemoryRequirements2 *pMemoryRequirements); @@ -17229,6 +17548,8 @@ VkResult VKAPI_CALL vkUnmapMemory2KHR(VkDevice device, const VkMemoryUnmapInfoKH void VKAPI_CALL vkUpdateDescriptorSetWithTemplate(VkDevice device, VkDescriptorSet descriptorSet, VkDescriptorUpdateTemplate descriptorUpdateTemplate, const void *pData); void VKAPI_CALL vkUpdateDescriptorSetWithTemplateKHR(VkDevice device, VkDescriptorSet descriptorSet, VkDescriptorUpdateTemplate descriptorUpdateTemplate, const void *pData); void VKAPI_CALL vkUpdateDescriptorSets(VkDevice device, uint32_t descriptorWriteCount, const VkWriteDescriptorSet *pDescriptorWrites, uint32_t descriptorCopyCount, const VkCopyDescriptorSet *pDescriptorCopies); +void VKAPI_CALL vkUpdateIndirectExecutionSetPipelineEXT(VkDevice device, VkIndirectExecutionSetEXT indirectExecutionSet, uint32_t executionSetWriteCount, const VkWriteIndirectExecutionSetPipelineEXT *pExecutionSetWrites); +void VKAPI_CALL vkUpdateIndirectExecutionSetShaderEXT(VkDevice device, VkIndirectExecutionSetEXT indirectExecutionSet, uint32_t executionSetWriteCount, const VkWriteIndirectExecutionSetShaderEXT *pExecutionSetWrites); VkResult VKAPI_CALL vkUpdateVideoSessionParametersKHR(VkDevice device, VkVideoSessionParametersKHR videoSessionParameters, const VkVideoSessionParametersUpdateInfoKHR *pUpdateInfo); VkResult VKAPI_CALL vkWaitForFences(VkDevice device, uint32_t fenceCount, const VkFence *pFences, VkBool32 waitAll, uint64_t timeout); VkResult VKAPI_CALL vkWaitForPresentKHR(VkDevice device, VkSwapchainKHR swapchain, uint64_t presentId, uint64_t timeout);

-- GitLab https://gitlab.winehq.org/wine/wine/-/merge_requests/6571

Marvin

27 Sep 27 Sep

9:15 p.m.

New subject: [PATCH 2/2] winevulkan: Update to VK spec version 1.3.296.

Hi,

It looks like your patch introduced the new failures shown below. Please investigate and fix them before resubmitting your patch. If they are not new, fixing them anyway would help a lot. Otherwise please ask for the known failures list to be updated.

The tests also ran into some preexisting test failures. If you know how to fix them that would be helpful. See the TestBot job for the details:

The full results can be found at: https://testbot.winehq.org/JobDetails.pl?Key=148704

Your paranoid android.

=== debian11 (build log) ===

error: patch failed: dlls/winevulkan/make_vulkan:2412 error: patch failed: dlls/winevulkan/loader_thunks.c:1310 error: patch failed: dlls/winevulkan/loader_thunks.h:149 error: patch failed: dlls/winevulkan/make_vulkan:64 error: patch failed: dlls/winevulkan/vulkan_thunks.c:1402 error: patch failed: dlls/winevulkan/vulkan_thunks.h:205 error: patch failed: dlls/winevulkan/winevulkan.json:2 error: patch failed: include/wine/vulkan.h:716 Task: Patch failed to apply

=== debian11b (64 bit WoW report) ===

user32: input.c:733: Test failed: peek: raw_legacy: 0: test->expect 0 (missing): got WM_INPUT key hwnd 0000000000000000, code 0, make_code 0x1, flags 0, vkey F, message WM_KEYDOWN, extra 0 input.c:733: Test failed: peek: raw_legacy: 0: test->expect 1 (missing): MSG_TEST_WIN hwnd 0000000000000000, WM_KEYDOWN, wparam 0x46, lparam 0x10001 input.c:733: Test failed: peek: raw_legacy: 0: test->expect 2 (missing): MSG_TEST_WIN hwnd 0000000000000000, WM_CHAR, wparam 0x66, lparam 0x10001 input.c:734: Test failed: peek: raw_legacy: 0: got F: 0 input.c:733: Test failed: peek: raw_legacy: 1: test->expect 0 (missing): got WM_INPUT key hwnd 0000000000000000, code 0, make_code 0x2, flags 0x1, vkey F, message WM_KEYUP, extra 0 input.c:733: Test failed: peek: raw_legacy: 1: test->expect 1 (missing): MSG_TEST_WIN hwnd 0000000000000000, WM_KEYUP, wparam 0x46, lparam 0xffffffffc0020001 input.c:733: Test failed: peek: raw_vk_packet_legacy: 0: test->expect 0 (missing): got WM_INPUT key hwnd 0000000000000000, code 0, make_code 0x1, flags 0, vkey 0xe7, message WM_KEYDOWN, extra 0 input.c:733: Test failed: peek: raw_vk_packet_legacy: 0: test->expect 1 (missing): MSG_TEST_WIN hwnd 0000000000000000, WM_KEYDOWN, wparam 0xe7, lparam 0x10001 input.c:734: Test failed: peek: raw_vk_packet_legacy: 0: got 0xe7: 0 input.c:733: Test failed: peek: raw_vk_packet_legacy: 1: test->expect 0 (missing): got WM_INPUT key hwnd 0000000000000000, code 0, make_code 0x2, flags 0x1, vkey 0xe7, message WM_KEYUP, extra 0 input.c:733: Test failed: peek: raw_vk_packet_legacy: 1: test->expect 1 (missing): MSG_TEST_WIN hwnd 0000000000000000, WM_KEYUP, wparam 0xe7, lparam 0xffffffffc0020001 input.c:733: Test failed: peek: raw_unicode_legacy: 0: test->expect 1 (missing): MSG_TEST_WIN hwnd 0000000000000000, WM_CHAR, wparam 0x3c0, lparam 0x1 input.c:734: Test failed: peek: raw_unicode_legacy: 0: got 0xe7: 0 input.c:733: Test failed: peek: raw_unicode_vkey_ctrl_legacy: 0: test->expect 0 (missing): MSG_TEST_WIN hwnd 0000000000000000, WM_KEYDOWN, wparam 0x11, lparam 0xc00001 input.c:734: Test failed: peek: raw_unicode_vkey_ctrl_legacy: 0: got VK_CONTROL: 0 input.c:734: Test failed: peek: raw_unicode_vkey_ctrl_legacy: 0: got VK_LCONTROL: 0 input.c:733: Test failed: peek: raw_unicode_vkey_ctrl_legacy: 1: test->expect 0 (missing): MSG_TEST_WIN hwnd 0000000000000000, WM_KEYUP, wparam 0x11, lparam 0xffffffffc0c00001 input.c:733: Test failed: peek: raw_nolegacy: 0: test->expect 0 (missing): got WM_INPUT key hwnd 0000000000000000, code 0, make_code 0x1, flags 0, vkey F, message WM_KEYDOWN, extra 0 input.c:733: Test failed: peek: raw_nolegacy: 1: test->expect 0 (missing): got WM_INPUT key hwnd 0000000000000000, code 0, make_code 0x2, flags 0x1, vkey F, message WM_KEYUP, extra 0 input.c:733: Test failed: peek: raw_vk_packet_nolegacy: 0: test->expect 0 (missing): got WM_INPUT key hwnd 0000000000000000, code 0, make_code 0x1, flags 0, vkey 0xe7, message WM_KEYDOWN, extra 0 input.c:733: Test failed: peek: raw_vk_packet_nolegacy: 1: test->expect 0 (missing): got WM_INPUT key hwnd 0000000000000000, code 0, make_code 0x2, flags 0x1, vkey 0xe7, message WM_KEYUP, extra 0 input.c:733: Test failed: receive: raw_legacy: 0: test->expect 0 (missing): got WM_INPUT key hwnd 0000000000000000, code 0, make_code 0x1, flags 0, vkey F, message WM_KEYDOWN, extra 0 input.c:733: Test failed: receive: raw_legacy: 0: test->expect 1 (missing): MSG_TEST_WIN hwnd 0000000000000000, WM_KEYDOWN, wparam 0x46, lparam 0x10001 input.c:733: Test failed: receive: raw_legacy: 0: test->expect 2 (missing): MSG_TEST_WIN hwnd 0000000000000000, WM_CHAR, wparam 0x66, lparam 0x10001 input.c:734: Test failed: receive: raw_legacy: 0: got F: 0 input.c:733: Test failed: receive: raw_legacy: 1: test->expect 0 (missing): got WM_INPUT key hwnd 0000000000000000, code 0, make_code 0x2, flags 0x1, vkey F, message WM_KEYUP, extra 0 input.c:733: Test failed: receive: raw_legacy: 1: test->expect 1 (missing): MSG_TEST_WIN hwnd 0000000000000000, WM_KEYUP, wparam 0x46, lparam 0xffffffffc0020001 input.c:733: Test failed: receive: raw_vk_packet_legacy: 0: test->expect 0 (missing): got WM_INPUT key hwnd 0000000000000000, code 0, make_code 0x1, flags 0, vkey 0xe7, message WM_KEYDOWN, extra 0 input.c:733: Test failed: receive: raw_vk_packet_legacy: 0: test->expect 1 (missing): MSG_TEST_WIN hwnd 0000000000000000, WM_KEYDOWN, wparam 0xe7, lparam 0x10001 input.c:734: Test failed: receive: raw_vk_packet_legacy: 0: got 0xe7: 0 input.c:733: Test failed: receive: raw_vk_packet_legacy: 1: test->expect 0 (missing): got WM_INPUT key hwnd 0000000000000000, code 0, make_code 0x2, flags 0x1, vkey 0xe7, message WM_KEYUP, extra 0 input.c:733: Test failed: receive: raw_vk_packet_legacy: 1: test->expect 1 (missing): MSG_TEST_WIN hwnd 0000000000000000, WM_KEYUP, wparam 0xe7, lparam 0xffffffffc0020001 input.c:733: Test failed: receive: raw_unicode_legacy: 0: test->expect 1 (missing): MSG_TEST_WIN hwnd 0000000000000000, WM_CHAR, wparam 0x3c0, lparam 0x1 input.c:734: Test failed: receive: raw_unicode_legacy: 0: got 0xe7: 0 input.c:733: Test failed: receive: raw_unicode_vkey_ctrl_legacy: 0: test->expect 0 (missing): MSG_TEST_WIN hwnd 0000000000000000, WM_KEYDOWN, wparam 0x11, lparam 0xc00001 input.c:734: Test failed: receive: raw_unicode_vkey_ctrl_legacy: 0: got VK_CONTROL: 0 input.c:734: Test failed: receive: raw_unicode_vkey_ctrl_legacy: 0: got VK_LCONTROL: 0 input.c:733: Test failed: receive: raw_unicode_vkey_ctrl_legacy: 1: test->expect 0 (missing): MSG_TEST_WIN hwnd 0000000000000000, WM_KEYUP, wparam 0x11, lparam 0xffffffffc0c00001 input.c:733: Test failed: receive: raw_nolegacy: 0: test->expect 0 (missing): got WM_INPUT key hwnd 0000000000000000, code 0, make_code 0x1, flags 0, vkey F, message WM_KEYDOWN, extra 0 input.c:733: Test failed: receive: raw_nolegacy: 1: test->expect 0 (missing): got WM_INPUT key hwnd 0000000000000000, code 0, make_code 0x2, flags 0x1, vkey F, message WM_KEYUP, extra 0 input.c:733: Test failed: receive: raw_vk_packet_nolegacy: 0: test->expect 0 (missing): got WM_INPUT key hwnd 0000000000000000, code 0, make_code 0x1, flags 0, vkey 0xe7, message WM_KEYDOWN, extra 0 input.c:733: Test failed: receive: raw_vk_packet_nolegacy: 1: test->expect 0 (missing): got WM_INPUT key hwnd 0000000000000000, code 0, make_code 0x2, flags 0x1, vkey 0xe7, message WM_KEYUP, extra 0

winmm: mci: Timeout

132

Age (days ago)

133

Last active (days ago)

wine-gitlab@winehq.org

3 comments

3 participants

tags (0)

participants (3)

Georg Lehmann
Georg Lehmann (＠DadSchoorse)
Marvin