[PATCH 1/1] winevulkan: Update to VK spec version 1.3.230.

[Georg Lehmann]

From: Georg Lehmann

---
 dlls/winevulkan/loader_thunks.c |  512 ++++++++
 dlls/winevulkan/loader_thunks.h |  410 +++++++
 dlls/winevulkan/make_vulkan     |    2 +-
 dlls/winevulkan/vulkan_thunks.c | 1938 +++++++++++++++++++++++++++++--
 dlls/winevulkan/vulkan_thunks.h |  242 +++-
 dlls/winevulkan/winevulkan.json |    2 +-
 include/wine/vulkan.h           |  704 ++++++++++-
 7 files changed, 3701 insertions(+), 109 deletions(-)

diff --git a/dlls/winevulkan/loader_thunks.c b/dlls/winevulkan/loader_thunks.c
index 708021a49f1..d7a92430b9a 100644
--- a/dlls/winevulkan/loader_thunks.c
+++ b/dlls/winevulkan/loader_thunks.c
@@ -157,6 +157,18 @@ VkResult WINAPI vkBindImageMemory2KHR(VkDevice device, uint32_t bindInfoCount, c
     return params.result;
 }

+VkResult WINAPI vkBindOpticalFlowSessionImageNV(VkDevice device, VkOpticalFlowSessionNV session, VkOpticalFlowSessionBindingPointNV bindingPoint, VkImageView view, VkImageLayout layout)
+{
+    struct vkBindOpticalFlowSessionImageNV_params params;
+    params.device = device;
+    params.session = session;
+    params.bindingPoint = bindingPoint;
+    params.view = view;
+    params.layout = layout;
+    vk_unix_call(unix_vkBindOpticalFlowSessionImageNV, &params);
+    return params.result;
+}
+
 VkResult WINAPI vkBuildAccelerationStructuresKHR(VkDevice device, VkDeferredOperationKHR deferredOperation, uint32_t infoCount, const VkAccelerationStructureBuildGeometryInfoKHR *pInfos, const VkAccelerationStructureBuildRangeInfoKHR * const*ppBuildRangeInfos)
 {
     struct vkBuildAccelerationStructuresKHR_params params;
@@ -169,6 +181,17 @@ VkResult WINAPI vkBuildAccelerationStructuresKHR(VkDevice device, VkDeferredOper
     return params.result;
 }

+VkResult WINAPI vkBuildMicromapsEXT(VkDevice device, VkDeferredOperationKHR deferredOperation, uint32_t infoCount, const VkMicromapBuildInfoEXT *pInfos)
+{
+    struct vkBuildMicromapsEXT_params params;
+    params.device = device;
+    params.deferredOperation = deferredOperation;
+    params.infoCount = infoCount;
+    params.pInfos = pInfos;
+    vk_unix_call(unix_vkBuildMicromapsEXT, &params);
+    return params.result;
+}
+
 void WINAPI vkCmdBeginConditionalRenderingEXT(VkCommandBuffer commandBuffer, const VkConditionalRenderingBeginInfoEXT *pConditionalRenderingBegin)
 {
     struct vkCmdBeginConditionalRenderingEXT_params params;
@@ -437,6 +460,15 @@ void WINAPI vkCmdBuildAccelerationStructuresKHR(VkCommandBuffer commandBuffer, u
     p_vk_direct_unix_call(unix_handle, unix_vkCmdBuildAccelerationStructuresKHR, &params);
 }

+void WINAPI vkCmdBuildMicromapsEXT(VkCommandBuffer commandBuffer, uint32_t infoCount, const VkMicromapBuildInfoEXT *pInfos)
+{
+    struct vkCmdBuildMicromapsEXT_params params;
+    params.commandBuffer = commandBuffer;
+    params.infoCount = infoCount;
+    params.pInfos = pInfos;
+    p_vk_direct_unix_call(unix_handle, unix_vkCmdBuildMicromapsEXT, &params);
+}
+
 void WINAPI vkCmdClearAttachments(VkCommandBuffer commandBuffer, uint32_t attachmentCount, const VkClearAttachment *pAttachments, uint32_t rectCount, const VkClearRect *pRects)
 {
     struct vkCmdClearAttachments_params params;
@@ -618,6 +650,30 @@ void WINAPI vkCmdCopyMemoryToAccelerationStructureKHR(VkCommandBuffer commandBuf
     p_vk_direct_unix_call(unix_handle, unix_vkCmdCopyMemoryToAccelerationStructureKHR, &params);
 }

+void WINAPI vkCmdCopyMemoryToMicromapEXT(VkCommandBuffer commandBuffer, const VkCopyMemoryToMicromapInfoEXT *pInfo)
+{
+    struct vkCmdCopyMemoryToMicromapEXT_params params;
+    params.commandBuffer = commandBuffer;
+    params.pInfo = pInfo;
+    p_vk_direct_unix_call(unix_handle, unix_vkCmdCopyMemoryToMicromapEXT, &params);
+}
+
+void WINAPI vkCmdCopyMicromapEXT(VkCommandBuffer commandBuffer, const VkCopyMicromapInfoEXT *pInfo)
+{
+    struct vkCmdCopyMicromapEXT_params params;
+    params.commandBuffer = commandBuffer;
+    params.pInfo = pInfo;
+    p_vk_direct_unix_call(unix_handle, unix_vkCmdCopyMicromapEXT, &params);
+}
+
+void WINAPI vkCmdCopyMicromapToMemoryEXT(VkCommandBuffer commandBuffer, const VkCopyMicromapToMemoryInfoEXT *pInfo)
+{
+    struct vkCmdCopyMicromapToMemoryEXT_params params;
+    params.commandBuffer = commandBuffer;
+    params.pInfo = pInfo;
+    p_vk_direct_unix_call(unix_handle, unix_vkCmdCopyMicromapToMemoryEXT, &params);
+}
+
 void WINAPI vkCmdCopyQueryPoolResults(VkCommandBuffer commandBuffer, VkQueryPool queryPool, uint32_t firstQuery, uint32_t queryCount, VkBuffer dstBuffer, VkDeviceSize dstOffset, VkDeviceSize stride, VkQueryResultFlags flags)
 {
     struct vkCmdCopyQueryPoolResults_params params;
@@ -1080,6 +1136,15 @@ void WINAPI vkCmdNextSubpass2KHR(VkCommandBuffer commandBuffer, const VkSubpassB
     p_vk_direct_unix_call(unix_handle, unix_vkCmdNextSubpass2KHR, &params);
 }

+void WINAPI vkCmdOpticalFlowExecuteNV(VkCommandBuffer commandBuffer, VkOpticalFlowSessionNV session, const VkOpticalFlowExecuteInfoNV *pExecuteInfo)
+{
+    struct vkCmdOpticalFlowExecuteNV_params params;
+    params.commandBuffer = commandBuffer;
+    params.session = session;
+    params.pExecuteInfo = pExecuteInfo;
+    p_vk_direct_unix_call(unix_handle, unix_vkCmdOpticalFlowExecuteNV, &params);
+}
+
 void WINAPI 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)
 {
     struct vkCmdPipelineBarrier_params params;
@@ -1221,6 +1286,22 @@ void WINAPI vkCmdResolveImage2KHR(VkCommandBuffer commandBuffer, const VkResolve
     p_vk_direct_unix_call(unix_handle, unix_vkCmdResolveImage2KHR, &params);
 }

+void WINAPI vkCmdSetAlphaToCoverageEnableEXT(VkCommandBuffer commandBuffer, VkBool32 alphaToCoverageEnable)
+{
+    struct vkCmdSetAlphaToCoverageEnableEXT_params params;
+    params.commandBuffer = commandBuffer;
+    params.alphaToCoverageEnable = alphaToCoverageEnable;
+    p_vk_direct_unix_call(unix_handle, unix_vkCmdSetAlphaToCoverageEnableEXT, &params);
+}
+
+void WINAPI vkCmdSetAlphaToOneEnableEXT(VkCommandBuffer commandBuffer, VkBool32 alphaToOneEnable)
+{
+    struct vkCmdSetAlphaToOneEnableEXT_params params;
+    params.commandBuffer = commandBuffer;
+    params.alphaToOneEnable = alphaToOneEnable;
+    p_vk_direct_unix_call(unix_handle, unix_vkCmdSetAlphaToOneEnableEXT, &params);
+}
+
 void WINAPI vkCmdSetBlendConstants(VkCommandBuffer commandBuffer, const float blendConstants[4])
 {
     struct vkCmdSetBlendConstants_params params;
@@ -1247,6 +1328,36 @@ void WINAPI vkCmdSetCoarseSampleOrderNV(VkCommandBuffer commandBuffer, VkCoarseS
     p_vk_direct_unix_call(unix_handle, unix_vkCmdSetCoarseSampleOrderNV, &params);
 }

+void WINAPI vkCmdSetColorBlendAdvancedEXT(VkCommandBuffer commandBuffer, uint32_t firstAttachment, uint32_t attachmentCount, const VkColorBlendAdvancedEXT *pColorBlendAdvanced)
+{
+    struct vkCmdSetColorBlendAdvancedEXT_params params;
+    params.commandBuffer = commandBuffer;
+    params.firstAttachment = firstAttachment;
+    params.attachmentCount = attachmentCount;
+    params.pColorBlendAdvanced = pColorBlendAdvanced;
+    p_vk_direct_unix_call(unix_handle, unix_vkCmdSetColorBlendAdvancedEXT, &params);
+}
+
+void WINAPI vkCmdSetColorBlendEnableEXT(VkCommandBuffer commandBuffer, uint32_t firstAttachment, uint32_t attachmentCount, const VkBool32 *pColorBlendEnables)
+{
+    struct vkCmdSetColorBlendEnableEXT_params params;
+    params.commandBuffer = commandBuffer;
+    params.firstAttachment = firstAttachment;
+    params.attachmentCount = attachmentCount;
+    params.pColorBlendEnables = pColorBlendEnables;
+    p_vk_direct_unix_call(unix_handle, unix_vkCmdSetColorBlendEnableEXT, &params);
+}
+
+void WINAPI vkCmdSetColorBlendEquationEXT(VkCommandBuffer commandBuffer, uint32_t firstAttachment, uint32_t attachmentCount, const VkColorBlendEquationEXT *pColorBlendEquations)
+{
+    struct vkCmdSetColorBlendEquationEXT_params params;
+    params.commandBuffer = commandBuffer;
+    params.firstAttachment = firstAttachment;
+    params.attachmentCount = attachmentCount;
+    params.pColorBlendEquations = pColorBlendEquations;
+    p_vk_direct_unix_call(unix_handle, unix_vkCmdSetColorBlendEquationEXT, &params);
+}
+
 void WINAPI vkCmdSetColorWriteEnableEXT(VkCommandBuffer commandBuffer, uint32_t attachmentCount, const VkBool32 *pColorWriteEnables)
 {
     struct vkCmdSetColorWriteEnableEXT_params params;
@@ -1256,6 +1367,73 @@ void WINAPI vkCmdSetColorWriteEnableEXT(VkCommandBuffer commandBuffer, uint32_t
     p_vk_direct_unix_call(unix_handle, unix_vkCmdSetColorWriteEnableEXT, &params);
 }

+void WINAPI vkCmdSetColorWriteMaskEXT(VkCommandBuffer commandBuffer, uint32_t firstAttachment, uint32_t attachmentCount, const VkColorComponentFlags *pColorWriteMasks)
+{
+    struct vkCmdSetColorWriteMaskEXT_params params;
+    params.commandBuffer = commandBuffer;
+    params.firstAttachment = firstAttachment;
+    params.attachmentCount = attachmentCount;
+    params.pColorWriteMasks = pColorWriteMasks;
+    p_vk_direct_unix_call(unix_handle, unix_vkCmdSetColorWriteMaskEXT, &params);
+}
+
+void WINAPI vkCmdSetConservativeRasterizationModeEXT(VkCommandBuffer commandBuffer, VkConservativeRasterizationModeEXT conservativeRasterizationMode)
+{
+    struct vkCmdSetConservativeRasterizationModeEXT_params params;
+    params.commandBuffer = commandBuffer;
+    params.conservativeRasterizationMode = conservativeRasterizationMode;
+    p_vk_direct_unix_call(unix_handle, unix_vkCmdSetConservativeRasterizationModeEXT, &params);
+}
+
+void WINAPI vkCmdSetCoverageModulationModeNV(VkCommandBuffer commandBuffer, VkCoverageModulationModeNV coverageModulationMode)
+{
+    struct vkCmdSetCoverageModulationModeNV_params params;
+    params.commandBuffer = commandBuffer;
+    params.coverageModulationMode = coverageModulationMode;
+    p_vk_direct_unix_call(unix_handle, unix_vkCmdSetCoverageModulationModeNV, &params);
+}
+
+void WINAPI vkCmdSetCoverageModulationTableEnableNV(VkCommandBuffer commandBuffer, VkBool32 coverageModulationTableEnable)
+{
+    struct vkCmdSetCoverageModulationTableEnableNV_params params;
+    params.commandBuffer = commandBuffer;
+    params.coverageModulationTableEnable = coverageModulationTableEnable;
+    p_vk_direct_unix_call(unix_handle, unix_vkCmdSetCoverageModulationTableEnableNV, &params);
+}
+
+void WINAPI vkCmdSetCoverageModulationTableNV(VkCommandBuffer commandBuffer, uint32_t coverageModulationTableCount, const float *pCoverageModulationTable)
+{
+    struct vkCmdSetCoverageModulationTableNV_params params;
+    params.commandBuffer = commandBuffer;
+    params.coverageModulationTableCount = coverageModulationTableCount;
+    params.pCoverageModulationTable = pCoverageModulationTable;
+    p_vk_direct_unix_call(unix_handle, unix_vkCmdSetCoverageModulationTableNV, &params);
+}
+
+void WINAPI vkCmdSetCoverageReductionModeNV(VkCommandBuffer commandBuffer, VkCoverageReductionModeNV coverageReductionMode)
+{
+    struct vkCmdSetCoverageReductionModeNV_params params;
+    params.commandBuffer = commandBuffer;
+    params.coverageReductionMode = coverageReductionMode;
+    p_vk_direct_unix_call(unix_handle, unix_vkCmdSetCoverageReductionModeNV, &params);
+}
+
+void WINAPI vkCmdSetCoverageToColorEnableNV(VkCommandBuffer commandBuffer, VkBool32 coverageToColorEnable)
+{
+    struct vkCmdSetCoverageToColorEnableNV_params params;
+    params.commandBuffer = commandBuffer;
+    params.coverageToColorEnable = coverageToColorEnable;
+    p_vk_direct_unix_call(unix_handle, unix_vkCmdSetCoverageToColorEnableNV, &params);
+}
+
+void WINAPI vkCmdSetCoverageToColorLocationNV(VkCommandBuffer commandBuffer, uint32_t coverageToColorLocation)
+{
+    struct vkCmdSetCoverageToColorLocationNV_params params;
+    params.commandBuffer = commandBuffer;
+    params.coverageToColorLocation = coverageToColorLocation;
+    p_vk_direct_unix_call(unix_handle, unix_vkCmdSetCoverageToColorLocationNV, &params);
+}
+
 void WINAPI vkCmdSetCullMode(VkCommandBuffer commandBuffer, VkCullModeFlags cullMode)
 {
     struct vkCmdSetCullMode_params params;
@@ -1323,6 +1501,30 @@ void WINAPI vkCmdSetDepthBoundsTestEnableEXT(VkCommandBuffer commandBuffer, VkBo
     p_vk_direct_unix_call(unix_handle, unix_vkCmdSetDepthBoundsTestEnableEXT, &params);
 }

+void WINAPI vkCmdSetDepthClampEnableEXT(VkCommandBuffer commandBuffer, VkBool32 depthClampEnable)
+{
+    struct vkCmdSetDepthClampEnableEXT_params params;
+    params.commandBuffer = commandBuffer;
+    params.depthClampEnable = depthClampEnable;
+    p_vk_direct_unix_call(unix_handle, unix_vkCmdSetDepthClampEnableEXT, &params);
+}
+
+void WINAPI vkCmdSetDepthClipEnableEXT(VkCommandBuffer commandBuffer, VkBool32 depthClipEnable)
+{
+    struct vkCmdSetDepthClipEnableEXT_params params;
+    params.commandBuffer = commandBuffer;
+    params.depthClipEnable = depthClipEnable;
+    p_vk_direct_unix_call(unix_handle, unix_vkCmdSetDepthClipEnableEXT, &params);
+}
+
+void WINAPI vkCmdSetDepthClipNegativeOneToOneEXT(VkCommandBuffer commandBuffer, VkBool32 negativeOneToOne)
+{
+    struct vkCmdSetDepthClipNegativeOneToOneEXT_params params;
+    params.commandBuffer = commandBuffer;
+    params.negativeOneToOne = negativeOneToOne;
+    p_vk_direct_unix_call(unix_handle, unix_vkCmdSetDepthClipNegativeOneToOneEXT, &params);
+}
+
 void WINAPI vkCmdSetDepthCompareOp(VkCommandBuffer commandBuffer, VkCompareOp depthCompareOp)
 {
     struct vkCmdSetDepthCompareOp_params params;
@@ -1434,6 +1636,14 @@ void WINAPI vkCmdSetExclusiveScissorNV(VkCommandBuffer commandBuffer, uint32_t f
     p_vk_direct_unix_call(unix_handle, unix_vkCmdSetExclusiveScissorNV, &params);
 }

+void WINAPI vkCmdSetExtraPrimitiveOverestimationSizeEXT(VkCommandBuffer commandBuffer, float extraPrimitiveOverestimationSize)
+{
+    struct vkCmdSetExtraPrimitiveOverestimationSizeEXT_params params;
+    params.commandBuffer = commandBuffer;
+    params.extraPrimitiveOverestimationSize = extraPrimitiveOverestimationSize;
+    p_vk_direct_unix_call(unix_handle, unix_vkCmdSetExtraPrimitiveOverestimationSizeEXT, &params);
+}
+
 void WINAPI vkCmdSetFragmentShadingRateEnumNV(VkCommandBuffer commandBuffer, VkFragmentShadingRateNV shadingRate, const VkFragmentShadingRateCombinerOpKHR combinerOps[2])
 {
     struct vkCmdSetFragmentShadingRateEnumNV_params params;
@@ -1468,6 +1678,14 @@ void WINAPI vkCmdSetFrontFaceEXT(VkCommandBuffer commandBuffer, VkFrontFace fron
     p_vk_direct_unix_call(unix_handle, unix_vkCmdSetFrontFaceEXT, &params);
 }

+void WINAPI vkCmdSetLineRasterizationModeEXT(VkCommandBuffer commandBuffer, VkLineRasterizationModeEXT lineRasterizationMode)
+{
+    struct vkCmdSetLineRasterizationModeEXT_params params;
+    params.commandBuffer = commandBuffer;
+    params.lineRasterizationMode = lineRasterizationMode;
+    p_vk_direct_unix_call(unix_handle, unix_vkCmdSetLineRasterizationModeEXT, &params);
+}
+
 void WINAPI vkCmdSetLineStippleEXT(VkCommandBuffer commandBuffer, uint32_t lineStippleFactor, uint16_t lineStipplePattern)
 {
     struct vkCmdSetLineStippleEXT_params params;
@@ -1477,6 +1695,14 @@ void WINAPI vkCmdSetLineStippleEXT(VkCommandBuffer commandBuffer, uint32_t lineS
     p_vk_direct_unix_call(unix_handle, unix_vkCmdSetLineStippleEXT, &params);
 }

+void WINAPI vkCmdSetLineStippleEnableEXT(VkCommandBuffer commandBuffer, VkBool32 stippledLineEnable)
+{
+    struct vkCmdSetLineStippleEnableEXT_params params;
+    params.commandBuffer = commandBuffer;
+    params.stippledLineEnable = stippledLineEnable;
+    p_vk_direct_unix_call(unix_handle, unix_vkCmdSetLineStippleEnableEXT, &params);
+}
+
 void WINAPI vkCmdSetLineWidth(VkCommandBuffer commandBuffer, float lineWidth)
 {
     struct vkCmdSetLineWidth_params params;
@@ -1493,6 +1719,14 @@ void WINAPI vkCmdSetLogicOpEXT(VkCommandBuffer commandBuffer, VkLogicOp logicOp)
     p_vk_direct_unix_call(unix_handle, unix_vkCmdSetLogicOpEXT, &params);
 }

+void WINAPI vkCmdSetLogicOpEnableEXT(VkCommandBuffer commandBuffer, VkBool32 logicOpEnable)
+{
+    struct vkCmdSetLogicOpEnableEXT_params params;
+    params.commandBuffer = commandBuffer;
+    params.logicOpEnable = logicOpEnable;
+    p_vk_direct_unix_call(unix_handle, unix_vkCmdSetLogicOpEnableEXT, &params);
+}
+
 void WINAPI vkCmdSetPatchControlPointsEXT(VkCommandBuffer commandBuffer, uint32_t patchControlPoints)
 {
     struct vkCmdSetPatchControlPointsEXT_params params;
@@ -1528,6 +1762,14 @@ VkResult WINAPI vkCmdSetPerformanceStreamMarkerINTEL(VkCommandBuffer commandBuff
     return params.result;
 }

+void WINAPI vkCmdSetPolygonModeEXT(VkCommandBuffer commandBuffer, VkPolygonMode polygonMode)
+{
+    struct vkCmdSetPolygonModeEXT_params params;
+    params.commandBuffer = commandBuffer;
+    params.polygonMode = polygonMode;
+    p_vk_direct_unix_call(unix_handle, unix_vkCmdSetPolygonModeEXT, &params);
+}
+
 void WINAPI vkCmdSetPrimitiveRestartEnable(VkCommandBuffer commandBuffer, VkBool32 primitiveRestartEnable)
 {
     struct vkCmdSetPrimitiveRestartEnable_params params;
@@ -1560,6 +1802,30 @@ void WINAPI vkCmdSetPrimitiveTopologyEXT(VkCommandBuffer commandBuffer, VkPrimit
     p_vk_direct_unix_call(unix_handle, unix_vkCmdSetPrimitiveTopologyEXT, &params);
 }

+void WINAPI vkCmdSetProvokingVertexModeEXT(VkCommandBuffer commandBuffer, VkProvokingVertexModeEXT provokingVertexMode)
+{
+    struct vkCmdSetProvokingVertexModeEXT_params params;
+    params.commandBuffer = commandBuffer;
+    params.provokingVertexMode = provokingVertexMode;
+    p_vk_direct_unix_call(unix_handle, unix_vkCmdSetProvokingVertexModeEXT, &params);
+}
+
+void WINAPI vkCmdSetRasterizationSamplesEXT(VkCommandBuffer commandBuffer, VkSampleCountFlagBits rasterizationSamples)
+{
+    struct vkCmdSetRasterizationSamplesEXT_params params;
+    params.commandBuffer = commandBuffer;
+    params.rasterizationSamples = rasterizationSamples;
+    p_vk_direct_unix_call(unix_handle, unix_vkCmdSetRasterizationSamplesEXT, &params);
+}
+
+void WINAPI vkCmdSetRasterizationStreamEXT(VkCommandBuffer commandBuffer, uint32_t rasterizationStream)
+{
+    struct vkCmdSetRasterizationStreamEXT_params params;
+    params.commandBuffer = commandBuffer;
+    params.rasterizationStream = rasterizationStream;
+    p_vk_direct_unix_call(unix_handle, unix_vkCmdSetRasterizationStreamEXT, &params);
+}
+
 void WINAPI vkCmdSetRasterizerDiscardEnable(VkCommandBuffer commandBuffer, VkBool32 rasterizerDiscardEnable)
 {
     struct vkCmdSetRasterizerDiscardEnable_params params;
@@ -1584,6 +1850,14 @@ void WINAPI vkCmdSetRayTracingPipelineStackSizeKHR(VkCommandBuffer commandBuffer
     p_vk_direct_unix_call(unix_handle, unix_vkCmdSetRayTracingPipelineStackSizeKHR, &params);
 }

+void WINAPI vkCmdSetRepresentativeFragmentTestEnableNV(VkCommandBuffer commandBuffer, VkBool32 representativeFragmentTestEnable)
+{
+    struct vkCmdSetRepresentativeFragmentTestEnableNV_params params;
+    params.commandBuffer = commandBuffer;
+    params.representativeFragmentTestEnable = representativeFragmentTestEnable;
+    p_vk_direct_unix_call(unix_handle, unix_vkCmdSetRepresentativeFragmentTestEnableNV, &params);
+}
+
 void WINAPI vkCmdSetSampleLocationsEXT(VkCommandBuffer commandBuffer, const VkSampleLocationsInfoEXT *pSampleLocationsInfo)
 {
     struct vkCmdSetSampleLocationsEXT_params params;
@@ -1592,6 +1866,23 @@ void WINAPI vkCmdSetSampleLocationsEXT(VkCommandBuffer commandBuffer, const VkSa
     p_vk_direct_unix_call(unix_handle, unix_vkCmdSetSampleLocationsEXT, &params);
 }

+void WINAPI vkCmdSetSampleLocationsEnableEXT(VkCommandBuffer commandBuffer, VkBool32 sampleLocationsEnable)
+{
+    struct vkCmdSetSampleLocationsEnableEXT_params params;
+    params.commandBuffer = commandBuffer;
+    params.sampleLocationsEnable = sampleLocationsEnable;
+    p_vk_direct_unix_call(unix_handle, unix_vkCmdSetSampleLocationsEnableEXT, &params);
+}
+
+void WINAPI vkCmdSetSampleMaskEXT(VkCommandBuffer commandBuffer, VkSampleCountFlagBits samples, const VkSampleMask *pSampleMask)
+{
+    struct vkCmdSetSampleMaskEXT_params params;
+    params.commandBuffer = commandBuffer;
+    params.samples = samples;
+    params.pSampleMask = pSampleMask;
+    p_vk_direct_unix_call(unix_handle, unix_vkCmdSetSampleMaskEXT, &params);
+}
+
 void WINAPI vkCmdSetScissor(VkCommandBuffer commandBuffer, uint32_t firstScissor, uint32_t scissorCount, const VkRect2D *pScissors)
 {
     struct vkCmdSetScissor_params params;
@@ -1620,6 +1911,14 @@ void WINAPI vkCmdSetScissorWithCountEXT(VkCommandBuffer commandBuffer, uint32_t
     p_vk_direct_unix_call(unix_handle, unix_vkCmdSetScissorWithCountEXT, &params);
 }

+void WINAPI vkCmdSetShadingRateImageEnableNV(VkCommandBuffer commandBuffer, VkBool32 shadingRateImageEnable)
+{
+    struct vkCmdSetShadingRateImageEnableNV_params params;
+    params.commandBuffer = commandBuffer;
+    params.shadingRateImageEnable = shadingRateImageEnable;
+    p_vk_direct_unix_call(unix_handle, unix_vkCmdSetShadingRateImageEnableNV, &params);
+}
+
 void WINAPI vkCmdSetStencilCompareMask(VkCommandBuffer commandBuffer, VkStencilFaceFlags faceMask, uint32_t compareMask)
 {
     struct vkCmdSetStencilCompareMask_params params;
@@ -1687,6 +1986,14 @@ void WINAPI vkCmdSetStencilWriteMask(VkCommandBuffer commandBuffer, VkStencilFac
     p_vk_direct_unix_call(unix_handle, unix_vkCmdSetStencilWriteMask, &params);
 }

+void WINAPI vkCmdSetTessellationDomainOriginEXT(VkCommandBuffer commandBuffer, VkTessellationDomainOrigin domainOrigin)
+{
+    struct vkCmdSetTessellationDomainOriginEXT_params params;
+    params.commandBuffer = commandBuffer;
+    params.domainOrigin = domainOrigin;
+    p_vk_direct_unix_call(unix_handle, unix_vkCmdSetTessellationDomainOriginEXT, &params);
+}
+
 void WINAPI vkCmdSetVertexInputEXT(VkCommandBuffer commandBuffer, uint32_t vertexBindingDescriptionCount, const VkVertexInputBindingDescription2EXT *pVertexBindingDescriptions, uint32_t vertexAttributeDescriptionCount, const VkVertexInputAttributeDescription2EXT *pVertexAttributeDescriptions)
 {
     struct vkCmdSetVertexInputEXT_params params;
@@ -1718,6 +2025,24 @@ void WINAPI vkCmdSetViewportShadingRatePaletteNV(VkCommandBuffer commandBuffer,
     p_vk_direct_unix_call(unix_handle, unix_vkCmdSetViewportShadingRatePaletteNV, &params);
 }

+void WINAPI vkCmdSetViewportSwizzleNV(VkCommandBuffer commandBuffer, uint32_t firstViewport, uint32_t viewportCount, const VkViewportSwizzleNV *pViewportSwizzles)
+{
+    struct vkCmdSetViewportSwizzleNV_params params;
+    params.commandBuffer = commandBuffer;
+    params.firstViewport = firstViewport;
+    params.viewportCount = viewportCount;
+    params.pViewportSwizzles = pViewportSwizzles;
+    p_vk_direct_unix_call(unix_handle, unix_vkCmdSetViewportSwizzleNV, &params);
+}
+
+void WINAPI vkCmdSetViewportWScalingEnableNV(VkCommandBuffer commandBuffer, VkBool32 viewportWScalingEnable)
+{
+    struct vkCmdSetViewportWScalingEnableNV_params params;
+    params.commandBuffer = commandBuffer;
+    params.viewportWScalingEnable = viewportWScalingEnable;
+    p_vk_direct_unix_call(unix_handle, unix_vkCmdSetViewportWScalingEnableNV, &params);
+}
+
 void WINAPI vkCmdSetViewportWScalingNV(VkCommandBuffer commandBuffer, uint32_t firstViewport, uint32_t viewportCount, const VkViewportWScalingNV *pViewportWScalings)
 {
     struct vkCmdSetViewportWScalingNV_params params;
@@ -1902,6 +2227,18 @@ void WINAPI vkCmdWriteBufferMarkerAMD(VkCommandBuffer commandBuffer, VkPipelineS
     p_vk_direct_unix_call(unix_handle, unix_vkCmdWriteBufferMarkerAMD, &params);
 }

+void WINAPI vkCmdWriteMicromapsPropertiesEXT(VkCommandBuffer commandBuffer, uint32_t micromapCount, const VkMicromapEXT *pMicromaps, VkQueryType queryType, VkQueryPool queryPool, uint32_t firstQuery)
+{
+    struct vkCmdWriteMicromapsPropertiesEXT_params params;
+    params.commandBuffer = commandBuffer;
+    params.micromapCount = micromapCount;
+    params.pMicromaps = pMicromaps;
+    params.queryType = queryType;
+    params.queryPool = queryPool;
+    params.firstQuery = firstQuery;
+    p_vk_direct_unix_call(unix_handle, unix_vkCmdWriteMicromapsPropertiesEXT, &params);
+}
+
 void WINAPI vkCmdWriteTimestamp(VkCommandBuffer commandBuffer, VkPipelineStageFlagBits pipelineStage, VkQueryPool queryPool, uint32_t query)
 {
     struct vkCmdWriteTimestamp_params params;
@@ -1972,6 +2309,36 @@ VkResult WINAPI vkCopyMemoryToAccelerationStructureKHR(VkDevice device, VkDeferr
     return params.result;
 }

+VkResult WINAPI vkCopyMemoryToMicromapEXT(VkDevice device, VkDeferredOperationKHR deferredOperation, const VkCopyMemoryToMicromapInfoEXT *pInfo)
+{
+    struct vkCopyMemoryToMicromapEXT_params params;
+    params.device = device;
+    params.deferredOperation = deferredOperation;
+    params.pInfo = pInfo;
+    vk_unix_call(unix_vkCopyMemoryToMicromapEXT, &params);
+    return params.result;
+}
+
+VkResult WINAPI vkCopyMicromapEXT(VkDevice device, VkDeferredOperationKHR deferredOperation, const VkCopyMicromapInfoEXT *pInfo)
+{
+    struct vkCopyMicromapEXT_params params;
+    params.device = device;
+    params.deferredOperation = deferredOperation;
+    params.pInfo = pInfo;
+    vk_unix_call(unix_vkCopyMicromapEXT, &params);
+    return params.result;
+}
+
+VkResult WINAPI vkCopyMicromapToMemoryEXT(VkDevice device, VkDeferredOperationKHR deferredOperation, const VkCopyMicromapToMemoryInfoEXT *pInfo)
+{
+    struct vkCopyMicromapToMemoryEXT_params params;
+    params.device = device;
+    params.deferredOperation = deferredOperation;
+    params.pInfo = pInfo;
+    vk_unix_call(unix_vkCopyMicromapToMemoryEXT, &params);
+    return params.result;
+}
+
 VkResult WINAPI vkCreateAccelerationStructureKHR(VkDevice device, const VkAccelerationStructureCreateInfoKHR *pCreateInfo, const VkAllocationCallbacks *pAllocator, VkAccelerationStructureKHR *pAccelerationStructure)
 {
     struct vkCreateAccelerationStructureKHR_params params;
@@ -2206,6 +2573,28 @@ VkResult WINAPI vkCreateIndirectCommandsLayoutNV(VkDevice device, const VkIndire
     return params.result;
 }

+VkResult WINAPI vkCreateMicromapEXT(VkDevice device, const VkMicromapCreateInfoEXT *pCreateInfo, const VkAllocationCallbacks *pAllocator, VkMicromapEXT *pMicromap)
+{
+    struct vkCreateMicromapEXT_params params;
+    params.device = device;
+    params.pCreateInfo = pCreateInfo;
+    params.pAllocator = pAllocator;
+    params.pMicromap = pMicromap;
+    vk_unix_call(unix_vkCreateMicromapEXT, &params);
+    return params.result;
+}
+
+VkResult WINAPI vkCreateOpticalFlowSessionNV(VkDevice device, const VkOpticalFlowSessionCreateInfoNV *pCreateInfo, const VkAllocationCallbacks *pAllocator, VkOpticalFlowSessionNV *pSession)
+{
+    struct vkCreateOpticalFlowSessionNV_params params;
+    params.device = device;
+    params.pCreateInfo = pCreateInfo;
+    params.pAllocator = pAllocator;
+    params.pSession = pSession;
+    vk_unix_call(unix_vkCreateOpticalFlowSessionNV, &params);
+    return params.result;
+}
+
 VkResult WINAPI vkCreatePipelineCache(VkDevice device, const VkPipelineCacheCreateInfo *pCreateInfo, const VkAllocationCallbacks *pAllocator, VkPipelineCache *pPipelineCache)
 {
     struct vkCreatePipelineCache_params params;
@@ -2621,6 +3010,24 @@ void WINAPI vkDestroyIndirectCommandsLayoutNV(VkDevice device, VkIndirectCommand
     vk_unix_call(unix_vkDestroyIndirectCommandsLayoutNV, &params);
 }

+void WINAPI vkDestroyMicromapEXT(VkDevice device, VkMicromapEXT micromap, const VkAllocationCallbacks *pAllocator)
+{
+    struct vkDestroyMicromapEXT_params params;
+    params.device = device;
+    params.micromap = micromap;
+    params.pAllocator = pAllocator;
+    vk_unix_call(unix_vkDestroyMicromapEXT, &params);
+}
+
+void WINAPI vkDestroyOpticalFlowSessionNV(VkDevice device, VkOpticalFlowSessionNV session, const VkAllocationCallbacks *pAllocator)
+{
+    struct vkDestroyOpticalFlowSessionNV_params params;
+    params.device = device;
+    params.session = session;
+    params.pAllocator = pAllocator;
+    vk_unix_call(unix_vkDestroyOpticalFlowSessionNV, &params);
+}
+
 void WINAPI vkDestroyPipeline(VkDevice device, VkPipeline pipeline, const VkAllocationCallbacks *pAllocator)
 {
     struct vkDestroyPipeline_params params;
@@ -3070,6 +3477,16 @@ void WINAPI vkGetDeviceBufferMemoryRequirementsKHR(VkDevice device, const VkDevi
     vk_unix_call(unix_vkGetDeviceBufferMemoryRequirementsKHR, &params);
 }

+VkResult WINAPI vkGetDeviceFaultInfoEXT(VkDevice device, VkDeviceFaultCountsEXT *pFaultCounts, VkDeviceFaultInfoEXT *pFaultInfo)
+{
+    struct vkGetDeviceFaultInfoEXT_params params;
+    params.device = device;
+    params.pFaultCounts = pFaultCounts;
+    params.pFaultInfo = pFaultInfo;
+    vk_unix_call(unix_vkGetDeviceFaultInfoEXT, &params);
+    return params.result;
+}
+
 void WINAPI vkGetDeviceGroupPeerMemoryFeatures(VkDevice device, uint32_t heapIndex, uint32_t localDeviceIndex, uint32_t remoteDeviceIndex, VkPeerMemoryFeatureFlags *pPeerMemoryFeatures)
 {
     struct vkGetDeviceGroupPeerMemoryFeatures_params params;
@@ -3176,6 +3593,15 @@ uint64_t WINAPI vkGetDeviceMemoryOpaqueCaptureAddressKHR(VkDevice device, const
     return params.result;
 }

+void WINAPI vkGetDeviceMicromapCompatibilityEXT(VkDevice device, const VkMicromapVersionInfoEXT *pVersionInfo, VkAccelerationStructureCompatibilityKHR *pCompatibility)
+{
+    struct vkGetDeviceMicromapCompatibilityEXT_params params;
+    params.device = device;
+    params.pVersionInfo = pVersionInfo;
+    params.pCompatibility = pCompatibility;
+    vk_unix_call(unix_vkGetDeviceMicromapCompatibilityEXT, &params);
+}
+
 void WINAPI vkGetDeviceQueue(VkDevice device, uint32_t queueFamilyIndex, uint32_t queueIndex, VkQueue *pQueue)
 {
     struct vkGetDeviceQueue_params params;
@@ -3360,6 +3786,16 @@ VkResult WINAPI vkGetMemoryHostPointerPropertiesEXT(VkDevice device, VkExternalM
     return params.result;
 }

+void WINAPI vkGetMicromapBuildSizesEXT(VkDevice device, VkAccelerationStructureBuildTypeKHR buildType, const VkMicromapBuildInfoEXT *pBuildInfo, VkMicromapBuildSizesInfoEXT *pSizeInfo)
+{
+    struct vkGetMicromapBuildSizesEXT_params params;
+    params.device = device;
+    params.buildType = buildType;
+    params.pBuildInfo = pBuildInfo;
+    params.pSizeInfo = pSizeInfo;
+    vk_unix_call(unix_vkGetMicromapBuildSizesEXT, &params);
+}
+
 VkResult WINAPI vkGetPerformanceParameterINTEL(VkDevice device, VkPerformanceParameterTypeINTEL parameter, VkPerformanceValueINTEL *pValue)
 {
     struct vkGetPerformanceParameterINTEL_params params;
@@ -3572,6 +4008,17 @@ void WINAPI vkGetPhysicalDeviceMultisamplePropertiesEXT(VkPhysicalDevice physica
     vk_unix_call(unix_vkGetPhysicalDeviceMultisamplePropertiesEXT, &params);
 }

+VkResult WINAPI vkGetPhysicalDeviceOpticalFlowImageFormatsNV(VkPhysicalDevice physicalDevice, const VkOpticalFlowImageFormatInfoNV *pOpticalFlowImageFormatInfo, uint32_t *pFormatCount, VkOpticalFlowImageFormatPropertiesNV *pImageFormatProperties)
+{
+    struct vkGetPhysicalDeviceOpticalFlowImageFormatsNV_params params;
+    params.physicalDevice = physicalDevice;
+    params.pOpticalFlowImageFormatInfo = pOpticalFlowImageFormatInfo;
+    params.pFormatCount = pFormatCount;
+    params.pImageFormatProperties = pImageFormatProperties;
+    vk_unix_call(unix_vkGetPhysicalDeviceOpticalFlowImageFormatsNV, &params);
+    return params.result;
+}
+
 VkResult WINAPI vkGetPhysicalDevicePresentRectanglesKHR(VkPhysicalDevice physicalDevice, VkSurfaceKHR surface, uint32_t *pRectCount, VkRect2D *pRects)
 {
     struct vkGetPhysicalDevicePresentRectanglesKHR_params params;
@@ -4445,6 +4892,20 @@ VkResult WINAPI vkWriteAccelerationStructuresPropertiesKHR(VkDevice device, uint
     return params.result;
 }

+VkResult WINAPI vkWriteMicromapsPropertiesEXT(VkDevice device, uint32_t micromapCount, const VkMicromapEXT *pMicromaps, VkQueryType queryType, size_t dataSize, void *pData, size_t stride)
+{
+    struct vkWriteMicromapsPropertiesEXT_params params;
+    params.device = device;
+    params.micromapCount = micromapCount;
+    params.pMicromaps = pMicromaps;
+    params.queryType = queryType;
+    params.dataSize = dataSize;
+    params.pData = pData;
+    params.stride = stride;
+    vk_unix_call(unix_vkWriteMicromapsPropertiesEXT, &params);
+    return params.result;
+}
+
 static const struct vulkan_func vk_device_dispatch_table[] =
 {
     {"vkAcquireNextImage2KHR", vkAcquireNextImage2KHR},
@@ -4462,7 +4923,9 @@ static const struct vulkan_func vk_device_dispatch_table[] =
     {"vkBindImageMemory", vkBindImageMemory},
     {"vkBindImageMemory2", vkBindImageMemory2},
     {"vkBindImageMemory2KHR", vkBindImageMemory2KHR},
+    {"vkBindOpticalFlowSessionImageNV", vkBindOpticalFlowSessionImageNV},
     {"vkBuildAccelerationStructuresKHR", vkBuildAccelerationStructuresKHR},
+    {"vkBuildMicromapsEXT", vkBuildMicromapsEXT},
     {"vkCmdBeginConditionalRenderingEXT", vkCmdBeginConditionalRenderingEXT},
     {"vkCmdBeginDebugUtilsLabelEXT", vkCmdBeginDebugUtilsLabelEXT},
     {"vkCmdBeginQuery", vkCmdBeginQuery},
@@ -4489,6 +4952,7 @@ static const struct vulkan_func vk_device_dispatch_table[] =
     {"vkCmdBuildAccelerationStructureNV", vkCmdBuildAccelerationStructureNV},
     {"vkCmdBuildAccelerationStructuresIndirectKHR", vkCmdBuildAccelerationStructuresIndirectKHR},
     {"vkCmdBuildAccelerationStructuresKHR", vkCmdBuildAccelerationStructuresKHR},
+    {"vkCmdBuildMicromapsEXT", vkCmdBuildMicromapsEXT},
     {"vkCmdClearAttachments", vkCmdClearAttachments},
     {"vkCmdClearColorImage", vkCmdClearColorImage},
     {"vkCmdClearDepthStencilImage", vkCmdClearDepthStencilImage},
@@ -4508,6 +4972,9 @@ static const struct vulkan_func vk_device_dispatch_table[] =
     {"vkCmdCopyImageToBuffer2", vkCmdCopyImageToBuffer2},
     {"vkCmdCopyImageToBuffer2KHR", vkCmdCopyImageToBuffer2KHR},
     {"vkCmdCopyMemoryToAccelerationStructureKHR", vkCmdCopyMemoryToAccelerationStructureKHR},
+    {"vkCmdCopyMemoryToMicromapEXT", vkCmdCopyMemoryToMicromapEXT},
+    {"vkCmdCopyMicromapEXT", vkCmdCopyMicromapEXT},
+    {"vkCmdCopyMicromapToMemoryEXT", vkCmdCopyMicromapToMemoryEXT},
     {"vkCmdCopyQueryPoolResults", vkCmdCopyQueryPoolResults},
     {"vkCmdCuLaunchKernelNVX", vkCmdCuLaunchKernelNVX},
     {"vkCmdDebugMarkerBeginEXT", vkCmdDebugMarkerBeginEXT},
@@ -4553,6 +5020,7 @@ static const struct vulkan_func vk_device_dispatch_table[] =
     {"vkCmdNextSubpass", vkCmdNextSubpass},
     {"vkCmdNextSubpass2", vkCmdNextSubpass2},
     {"vkCmdNextSubpass2KHR", vkCmdNextSubpass2KHR},
+    {"vkCmdOpticalFlowExecuteNV", vkCmdOpticalFlowExecuteNV},
     {"vkCmdPipelineBarrier", vkCmdPipelineBarrier},
     {"vkCmdPipelineBarrier2", vkCmdPipelineBarrier2},
     {"vkCmdPipelineBarrier2KHR", vkCmdPipelineBarrier2KHR},
@@ -4567,10 +5035,23 @@ static const struct vulkan_func vk_device_dispatch_table[] =
     {"vkCmdResolveImage", vkCmdResolveImage},
     {"vkCmdResolveImage2", vkCmdResolveImage2},
     {"vkCmdResolveImage2KHR", vkCmdResolveImage2KHR},
+    {"vkCmdSetAlphaToCoverageEnableEXT", vkCmdSetAlphaToCoverageEnableEXT},
+    {"vkCmdSetAlphaToOneEnableEXT", vkCmdSetAlphaToOneEnableEXT},
     {"vkCmdSetBlendConstants", vkCmdSetBlendConstants},
     {"vkCmdSetCheckpointNV", vkCmdSetCheckpointNV},
     {"vkCmdSetCoarseSampleOrderNV", vkCmdSetCoarseSampleOrderNV},
+    {"vkCmdSetColorBlendAdvancedEXT", vkCmdSetColorBlendAdvancedEXT},
+    {"vkCmdSetColorBlendEnableEXT", vkCmdSetColorBlendEnableEXT},
+    {"vkCmdSetColorBlendEquationEXT", vkCmdSetColorBlendEquationEXT},
     {"vkCmdSetColorWriteEnableEXT", vkCmdSetColorWriteEnableEXT},
+    {"vkCmdSetColorWriteMaskEXT", vkCmdSetColorWriteMaskEXT},
+    {"vkCmdSetConservativeRasterizationModeEXT", vkCmdSetConservativeRasterizationModeEXT},
+    {"vkCmdSetCoverageModulationModeNV", vkCmdSetCoverageModulationModeNV},
+    {"vkCmdSetCoverageModulationTableEnableNV", vkCmdSetCoverageModulationTableEnableNV},
+    {"vkCmdSetCoverageModulationTableNV", vkCmdSetCoverageModulationTableNV},
+    {"vkCmdSetCoverageReductionModeNV", vkCmdSetCoverageReductionModeNV},
+    {"vkCmdSetCoverageToColorEnableNV", vkCmdSetCoverageToColorEnableNV},
+    {"vkCmdSetCoverageToColorLocationNV", vkCmdSetCoverageToColorLocationNV},
     {"vkCmdSetCullMode", vkCmdSetCullMode},
     {"vkCmdSetCullModeEXT", vkCmdSetCullModeEXT},
     {"vkCmdSetDepthBias", vkCmdSetDepthBias},
@@ -4579,6 +5060,9 @@ static const struct vulkan_func vk_device_dispatch_table[] =
     {"vkCmdSetDepthBounds", vkCmdSetDepthBounds},
     {"vkCmdSetDepthBoundsTestEnable", vkCmdSetDepthBoundsTestEnable},
     {"vkCmdSetDepthBoundsTestEnableEXT", vkCmdSetDepthBoundsTestEnableEXT},
+    {"vkCmdSetDepthClampEnableEXT", vkCmdSetDepthClampEnableEXT},
+    {"vkCmdSetDepthClipEnableEXT", vkCmdSetDepthClipEnableEXT},
+    {"vkCmdSetDepthClipNegativeOneToOneEXT", vkCmdSetDepthClipNegativeOneToOneEXT},
     {"vkCmdSetDepthCompareOp", vkCmdSetDepthCompareOp},
     {"vkCmdSetDepthCompareOpEXT", vkCmdSetDepthCompareOpEXT},
     {"vkCmdSetDepthTestEnable", vkCmdSetDepthTestEnable},
@@ -4592,28 +5076,40 @@ static const struct vulkan_func vk_device_dispatch_table[] =
     {"vkCmdSetEvent2", vkCmdSetEvent2},
     {"vkCmdSetEvent2KHR", vkCmdSetEvent2KHR},
     {"vkCmdSetExclusiveScissorNV", vkCmdSetExclusiveScissorNV},
+    {"vkCmdSetExtraPrimitiveOverestimationSizeEXT", vkCmdSetExtraPrimitiveOverestimationSizeEXT},
     {"vkCmdSetFragmentShadingRateEnumNV", vkCmdSetFragmentShadingRateEnumNV},
     {"vkCmdSetFragmentShadingRateKHR", vkCmdSetFragmentShadingRateKHR},
     {"vkCmdSetFrontFace", vkCmdSetFrontFace},
     {"vkCmdSetFrontFaceEXT", vkCmdSetFrontFaceEXT},
+    {"vkCmdSetLineRasterizationModeEXT", vkCmdSetLineRasterizationModeEXT},
     {"vkCmdSetLineStippleEXT", vkCmdSetLineStippleEXT},
+    {"vkCmdSetLineStippleEnableEXT", vkCmdSetLineStippleEnableEXT},
     {"vkCmdSetLineWidth", vkCmdSetLineWidth},
     {"vkCmdSetLogicOpEXT", vkCmdSetLogicOpEXT},
+    {"vkCmdSetLogicOpEnableEXT", vkCmdSetLogicOpEnableEXT},
     {"vkCmdSetPatchControlPointsEXT", vkCmdSetPatchControlPointsEXT},
     {"vkCmdSetPerformanceMarkerINTEL", vkCmdSetPerformanceMarkerINTEL},
     {"vkCmdSetPerformanceOverrideINTEL", vkCmdSetPerformanceOverrideINTEL},
     {"vkCmdSetPerformanceStreamMarkerINTEL", vkCmdSetPerformanceStreamMarkerINTEL},
+    {"vkCmdSetPolygonModeEXT", vkCmdSetPolygonModeEXT},
     {"vkCmdSetPrimitiveRestartEnable", vkCmdSetPrimitiveRestartEnable},
     {"vkCmdSetPrimitiveRestartEnableEXT", vkCmdSetPrimitiveRestartEnableEXT},
     {"vkCmdSetPrimitiveTopology", vkCmdSetPrimitiveTopology},
     {"vkCmdSetPrimitiveTopologyEXT", vkCmdSetPrimitiveTopologyEXT},
+    {"vkCmdSetProvokingVertexModeEXT", vkCmdSetProvokingVertexModeEXT},
+    {"vkCmdSetRasterizationSamplesEXT", vkCmdSetRasterizationSamplesEXT},
+    {"vkCmdSetRasterizationStreamEXT", vkCmdSetRasterizationStreamEXT},
     {"vkCmdSetRasterizerDiscardEnable", vkCmdSetRasterizerDiscardEnable},
     {"vkCmdSetRasterizerDiscardEnableEXT", vkCmdSetRasterizerDiscardEnableEXT},
     {"vkCmdSetRayTracingPipelineStackSizeKHR", vkCmdSetRayTracingPipelineStackSizeKHR},
+    {"vkCmdSetRepresentativeFragmentTestEnableNV", vkCmdSetRepresentativeFragmentTestEnableNV},
     {"vkCmdSetSampleLocationsEXT", vkCmdSetSampleLocationsEXT},
+    {"vkCmdSetSampleLocationsEnableEXT", vkCmdSetSampleLocationsEnableEXT},
+    {"vkCmdSetSampleMaskEXT", vkCmdSetSampleMaskEXT},
     {"vkCmdSetScissor", vkCmdSetScissor},
     {"vkCmdSetScissorWithCount", vkCmdSetScissorWithCount},
     {"vkCmdSetScissorWithCountEXT", vkCmdSetScissorWithCountEXT},
+    {"vkCmdSetShadingRateImageEnableNV", vkCmdSetShadingRateImageEnableNV},
     {"vkCmdSetStencilCompareMask", vkCmdSetStencilCompareMask},
     {"vkCmdSetStencilOp", vkCmdSetStencilOp},
     {"vkCmdSetStencilOpEXT", vkCmdSetStencilOpEXT},
@@ -4621,9 +5117,12 @@ static const struct vulkan_func vk_device_dispatch_table[] =
     {"vkCmdSetStencilTestEnable", vkCmdSetStencilTestEnable},
     {"vkCmdSetStencilTestEnableEXT", vkCmdSetStencilTestEnableEXT},
     {"vkCmdSetStencilWriteMask", vkCmdSetStencilWriteMask},
+    {"vkCmdSetTessellationDomainOriginEXT", vkCmdSetTessellationDomainOriginEXT},
     {"vkCmdSetVertexInputEXT", vkCmdSetVertexInputEXT},
     {"vkCmdSetViewport", vkCmdSetViewport},
     {"vkCmdSetViewportShadingRatePaletteNV", vkCmdSetViewportShadingRatePaletteNV},
+    {"vkCmdSetViewportSwizzleNV", vkCmdSetViewportSwizzleNV},
+    {"vkCmdSetViewportWScalingEnableNV", vkCmdSetViewportWScalingEnableNV},
     {"vkCmdSetViewportWScalingNV", vkCmdSetViewportWScalingNV},
     {"vkCmdSetViewportWithCount", vkCmdSetViewportWithCount},
     {"vkCmdSetViewportWithCountEXT", vkCmdSetViewportWithCountEXT},
@@ -4640,6 +5139,7 @@ static const struct vulkan_func vk_device_dispatch_table[] =
     {"vkCmdWriteAccelerationStructuresPropertiesNV", vkCmdWriteAccelerationStructuresPropertiesNV},
     {"vkCmdWriteBufferMarker2AMD", vkCmdWriteBufferMarker2AMD},
     {"vkCmdWriteBufferMarkerAMD", vkCmdWriteBufferMarkerAMD},
+    {"vkCmdWriteMicromapsPropertiesEXT", vkCmdWriteMicromapsPropertiesEXT},
     {"vkCmdWriteTimestamp", vkCmdWriteTimestamp},
     {"vkCmdWriteTimestamp2", vkCmdWriteTimestamp2},
     {"vkCmdWriteTimestamp2KHR", vkCmdWriteTimestamp2KHR},
@@ -4647,6 +5147,9 @@ static const struct vulkan_func vk_device_dispatch_table[] =
     {"vkCopyAccelerationStructureKHR", vkCopyAccelerationStructureKHR},
     {"vkCopyAccelerationStructureToMemoryKHR", vkCopyAccelerationStructureToMemoryKHR},
     {"vkCopyMemoryToAccelerationStructureKHR", vkCopyMemoryToAccelerationStructureKHR},
+    {"vkCopyMemoryToMicromapEXT", vkCopyMemoryToMicromapEXT},
+    {"vkCopyMicromapEXT", vkCopyMicromapEXT},
+    {"vkCopyMicromapToMemoryEXT", vkCopyMicromapToMemoryEXT},
     {"vkCreateAccelerationStructureKHR", vkCreateAccelerationStructureKHR},
     {"vkCreateAccelerationStructureNV", vkCreateAccelerationStructureNV},
     {"vkCreateBuffer", vkCreateBuffer},
@@ -4667,6 +5170,8 @@ static const struct vulkan_func vk_device_dispatch_table[] =
     {"vkCreateImage", vkCreateImage},
     {"vkCreateImageView", vkCreateImageView},
     {"vkCreateIndirectCommandsLayoutNV", vkCreateIndirectCommandsLayoutNV},
+    {"vkCreateMicromapEXT", vkCreateMicromapEXT},
+    {"vkCreateOpticalFlowSessionNV", vkCreateOpticalFlowSessionNV},
     {"vkCreatePipelineCache", vkCreatePipelineCache},
     {"vkCreatePipelineLayout", vkCreatePipelineLayout},
     {"vkCreatePrivateDataSlot", vkCreatePrivateDataSlot},
@@ -4706,6 +5211,8 @@ static const struct vulkan_func vk_device_dispatch_table[] =
     {"vkDestroyImage", vkDestroyImage},
     {"vkDestroyImageView", vkDestroyImageView},
     {"vkDestroyIndirectCommandsLayoutNV", vkDestroyIndirectCommandsLayoutNV},
+    {"vkDestroyMicromapEXT", vkDestroyMicromapEXT},
+    {"vkDestroyOpticalFlowSessionNV", vkDestroyOpticalFlowSessionNV},
     {"vkDestroyPipeline", vkDestroyPipeline},
     {"vkDestroyPipelineCache", vkDestroyPipelineCache},
     {"vkDestroyPipelineLayout", vkDestroyPipelineLayout},
@@ -4748,6 +5255,7 @@ static const struct vulkan_func vk_device_dispatch_table[] =
     {"vkGetDeviceAccelerationStructureCompatibilityKHR", vkGetDeviceAccelerationStructureCompatibilityKHR},
     {"vkGetDeviceBufferMemoryRequirements", vkGetDeviceBufferMemoryRequirements},
     {"vkGetDeviceBufferMemoryRequirementsKHR", vkGetDeviceBufferMemoryRequirementsKHR},
+    {"vkGetDeviceFaultInfoEXT", vkGetDeviceFaultInfoEXT},
     {"vkGetDeviceGroupPeerMemoryFeatures", vkGetDeviceGroupPeerMemoryFeatures},
     {"vkGetDeviceGroupPeerMemoryFeaturesKHR", vkGetDeviceGroupPeerMemoryFeaturesKHR},
     {"vkGetDeviceGroupPresentCapabilitiesKHR", vkGetDeviceGroupPresentCapabilitiesKHR},
@@ -4759,6 +5267,7 @@ static const struct vulkan_func vk_device_dispatch_table[] =
     {"vkGetDeviceMemoryCommitment", vkGetDeviceMemoryCommitment},
     {"vkGetDeviceMemoryOpaqueCaptureAddress", vkGetDeviceMemoryOpaqueCaptureAddress},
     {"vkGetDeviceMemoryOpaqueCaptureAddressKHR", vkGetDeviceMemoryOpaqueCaptureAddressKHR},
+    {"vkGetDeviceMicromapCompatibilityEXT", vkGetDeviceMicromapCompatibilityEXT},
     {"vkGetDeviceProcAddr", vkGetDeviceProcAddr},
     {"vkGetDeviceQueue", vkGetDeviceQueue},
     {"vkGetDeviceQueue2", vkGetDeviceQueue2},
@@ -4779,6 +5288,7 @@ static const struct vulkan_func vk_device_dispatch_table[] =
     {"vkGetImageViewAddressNVX", vkGetImageViewAddressNVX},
     {"vkGetImageViewHandleNVX", vkGetImageViewHandleNVX},
     {"vkGetMemoryHostPointerPropertiesEXT", vkGetMemoryHostPointerPropertiesEXT},
+    {"vkGetMicromapBuildSizesEXT", vkGetMicromapBuildSizesEXT},
     {"vkGetPerformanceParameterINTEL", vkGetPerformanceParameterINTEL},
     {"vkGetPipelineCacheData", vkGetPipelineCacheData},
     {"vkGetPipelineExecutableInternalRepresentationsKHR", vkGetPipelineExecutableInternalRepresentationsKHR},
@@ -4846,6 +5356,7 @@ static const struct vulkan_func vk_device_dispatch_table[] =
     {"vkWaitSemaphores", vkWaitSemaphores},
     {"vkWaitSemaphoresKHR", vkWaitSemaphoresKHR},
     {"vkWriteAccelerationStructuresPropertiesKHR", vkWriteAccelerationStructuresPropertiesKHR},
+    {"vkWriteMicromapsPropertiesEXT", vkWriteMicromapsPropertiesEXT},
 };

static const struct vulkan_func vk_phys_dev_dispatch_table[] =
@@ -4876,6 +5387,7 @@ static const struct vulkan_func vk_phys_dev_dispatch_table[] =
     {"vkGetPhysicalDeviceMemoryProperties2", vkGetPhysicalDeviceMemoryProperties2},
     {"vkGetPhysicalDeviceMemoryProperties2KHR", vkGetPhysicalDeviceMemoryProperties2KHR},
     {"vkGetPhysicalDeviceMultisamplePropertiesEXT", vkGetPhysicalDeviceMultisamplePropertiesEXT},
+    {"vkGetPhysicalDeviceOpticalFlowImageFormatsNV", vkGetPhysicalDeviceOpticalFlowImageFormatsNV},
     {"vkGetPhysicalDevicePresentRectanglesKHR", vkGetPhysicalDevicePresentRectanglesKHR},
     {"vkGetPhysicalDeviceProperties", vkGetPhysicalDeviceProperties},
     {"vkGetPhysicalDeviceProperties2", vkGetPhysicalDeviceProperties2},
diff --git a/dlls/winevulkan/loader_thunks.h b/dlls/winevulkan/loader_thunks.h
index 4590fa1dbc6..b262c9d29fb 100644
--- a/dlls/winevulkan/loader_thunks.h
+++ b/dlls/winevulkan/loader_thunks.h
@@ -32,7 +32,9 @@ enum unix_call
     unix_vkBindImageMemory,
     unix_vkBindImageMemory2,
     unix_vkBindImageMemory2KHR,
+    unix_vkBindOpticalFlowSessionImageNV,
     unix_vkBuildAccelerationStructuresKHR,
+    unix_vkBuildMicromapsEXT,
     unix_vkCmdBeginConditionalRenderingEXT,
     unix_vkCmdBeginDebugUtilsLabelEXT,
     unix_vkCmdBeginQuery,
@@ -59,6 +61,7 @@ enum unix_call
     unix_vkCmdBuildAccelerationStructureNV,
     unix_vkCmdBuildAccelerationStructuresIndirectKHR,
     unix_vkCmdBuildAccelerationStructuresKHR,
+    unix_vkCmdBuildMicromapsEXT,
     unix_vkCmdClearAttachments,
     unix_vkCmdClearColorImage,
     unix_vkCmdClearDepthStencilImage,
@@ -78,6 +81,9 @@ enum unix_call
     unix_vkCmdCopyImageToBuffer2,
     unix_vkCmdCopyImageToBuffer2KHR,
     unix_vkCmdCopyMemoryToAccelerationStructureKHR,
+    unix_vkCmdCopyMemoryToMicromapEXT,
+    unix_vkCmdCopyMicromapEXT,
+    unix_vkCmdCopyMicromapToMemoryEXT,
     unix_vkCmdCopyQueryPoolResults,
     unix_vkCmdCuLaunchKernelNVX,
     unix_vkCmdDebugMarkerBeginEXT,
@@ -123,6 +129,7 @@ enum unix_call
     unix_vkCmdNextSubpass,
     unix_vkCmdNextSubpass2,
     unix_vkCmdNextSubpass2KHR,
+    unix_vkCmdOpticalFlowExecuteNV,
     unix_vkCmdPipelineBarrier,
     unix_vkCmdPipelineBarrier2,
     unix_vkCmdPipelineBarrier2KHR,
@@ -137,10 +144,23 @@ enum unix_call
     unix_vkCmdResolveImage,
     unix_vkCmdResolveImage2,
     unix_vkCmdResolveImage2KHR,
+    unix_vkCmdSetAlphaToCoverageEnableEXT,
+    unix_vkCmdSetAlphaToOneEnableEXT,
     unix_vkCmdSetBlendConstants,
     unix_vkCmdSetCheckpointNV,
     unix_vkCmdSetCoarseSampleOrderNV,
+    unix_vkCmdSetColorBlendAdvancedEXT,
+    unix_vkCmdSetColorBlendEnableEXT,
+    unix_vkCmdSetColorBlendEquationEXT,
     unix_vkCmdSetColorWriteEnableEXT,
+    unix_vkCmdSetColorWriteMaskEXT,
+    unix_vkCmdSetConservativeRasterizationModeEXT,
+    unix_vkCmdSetCoverageModulationModeNV,
+    unix_vkCmdSetCoverageModulationTableEnableNV,
+    unix_vkCmdSetCoverageModulationTableNV,
+    unix_vkCmdSetCoverageReductionModeNV,
+    unix_vkCmdSetCoverageToColorEnableNV,
+    unix_vkCmdSetCoverageToColorLocationNV,
     unix_vkCmdSetCullMode,
     unix_vkCmdSetCullModeEXT,
     unix_vkCmdSetDepthBias,
@@ -149,6 +169,9 @@ enum unix_call
     unix_vkCmdSetDepthBounds,
     unix_vkCmdSetDepthBoundsTestEnable,
     unix_vkCmdSetDepthBoundsTestEnableEXT,
+    unix_vkCmdSetDepthClampEnableEXT,
+    unix_vkCmdSetDepthClipEnableEXT,
+    unix_vkCmdSetDepthClipNegativeOneToOneEXT,
     unix_vkCmdSetDepthCompareOp,
     unix_vkCmdSetDepthCompareOpEXT,
     unix_vkCmdSetDepthTestEnable,
@@ -162,28 +185,40 @@ enum unix_call
     unix_vkCmdSetEvent2,
     unix_vkCmdSetEvent2KHR,
     unix_vkCmdSetExclusiveScissorNV,
+    unix_vkCmdSetExtraPrimitiveOverestimationSizeEXT,
     unix_vkCmdSetFragmentShadingRateEnumNV,
     unix_vkCmdSetFragmentShadingRateKHR,
     unix_vkCmdSetFrontFace,
     unix_vkCmdSetFrontFaceEXT,
+    unix_vkCmdSetLineRasterizationModeEXT,
     unix_vkCmdSetLineStippleEXT,
+    unix_vkCmdSetLineStippleEnableEXT,
     unix_vkCmdSetLineWidth,
     unix_vkCmdSetLogicOpEXT,
+    unix_vkCmdSetLogicOpEnableEXT,
     unix_vkCmdSetPatchControlPointsEXT,
     unix_vkCmdSetPerformanceMarkerINTEL,
     unix_vkCmdSetPerformanceOverrideINTEL,
     unix_vkCmdSetPerformanceStreamMarkerINTEL,
+    unix_vkCmdSetPolygonModeEXT,
     unix_vkCmdSetPrimitiveRestartEnable,
     unix_vkCmdSetPrimitiveRestartEnableEXT,
     unix_vkCmdSetPrimitiveTopology,
     unix_vkCmdSetPrimitiveTopologyEXT,
+    unix_vkCmdSetProvokingVertexModeEXT,
+    unix_vkCmdSetRasterizationSamplesEXT,
+    unix_vkCmdSetRasterizationStreamEXT,
     unix_vkCmdSetRasterizerDiscardEnable,
     unix_vkCmdSetRasterizerDiscardEnableEXT,
     unix_vkCmdSetRayTracingPipelineStackSizeKHR,
+    unix_vkCmdSetRepresentativeFragmentTestEnableNV,
     unix_vkCmdSetSampleLocationsEXT,
+    unix_vkCmdSetSampleLocationsEnableEXT,
+    unix_vkCmdSetSampleMaskEXT,
     unix_vkCmdSetScissor,
     unix_vkCmdSetScissorWithCount,
     unix_vkCmdSetScissorWithCountEXT,
+    unix_vkCmdSetShadingRateImageEnableNV,
     unix_vkCmdSetStencilCompareMask,
     unix_vkCmdSetStencilOp,
     unix_vkCmdSetStencilOpEXT,
@@ -191,9 +226,12 @@ enum unix_call
     unix_vkCmdSetStencilTestEnable,
     unix_vkCmdSetStencilTestEnableEXT,
     unix_vkCmdSetStencilWriteMask,
+    unix_vkCmdSetTessellationDomainOriginEXT,
     unix_vkCmdSetVertexInputEXT,
     unix_vkCmdSetViewport,
     unix_vkCmdSetViewportShadingRatePaletteNV,
+    unix_vkCmdSetViewportSwizzleNV,
+    unix_vkCmdSetViewportWScalingEnableNV,
     unix_vkCmdSetViewportWScalingNV,
     unix_vkCmdSetViewportWithCount,
     unix_vkCmdSetViewportWithCountEXT,
@@ -210,6 +248,7 @@ enum unix_call
     unix_vkCmdWriteAccelerationStructuresPropertiesNV,
     unix_vkCmdWriteBufferMarker2AMD,
     unix_vkCmdWriteBufferMarkerAMD,
+    unix_vkCmdWriteMicromapsPropertiesEXT,
     unix_vkCmdWriteTimestamp,
     unix_vkCmdWriteTimestamp2,
     unix_vkCmdWriteTimestamp2KHR,
@@ -217,6 +256,9 @@ enum unix_call
     unix_vkCopyAccelerationStructureKHR,
     unix_vkCopyAccelerationStructureToMemoryKHR,
     unix_vkCopyMemoryToAccelerationStructureKHR,
+    unix_vkCopyMemoryToMicromapEXT,
+    unix_vkCopyMicromapEXT,
+    unix_vkCopyMicromapToMemoryEXT,
     unix_vkCreateAccelerationStructureKHR,
     unix_vkCreateAccelerationStructureNV,
     unix_vkCreateBuffer,
@@ -241,6 +283,8 @@ enum unix_call
     unix_vkCreateImageView,
     unix_vkCreateIndirectCommandsLayoutNV,
     unix_vkCreateInstance,
+    unix_vkCreateMicromapEXT,
+    unix_vkCreateOpticalFlowSessionNV,
     unix_vkCreatePipelineCache,
     unix_vkCreatePipelineLayout,
     unix_vkCreatePrivateDataSlot,
@@ -285,6 +329,8 @@ enum unix_call
     unix_vkDestroyImageView,
     unix_vkDestroyIndirectCommandsLayoutNV,
     unix_vkDestroyInstance,
+    unix_vkDestroyMicromapEXT,
+    unix_vkDestroyOpticalFlowSessionNV,
     unix_vkDestroyPipeline,
     unix_vkDestroyPipelineCache,
     unix_vkDestroyPipelineLayout,
@@ -336,6 +382,7 @@ enum unix_call
     unix_vkGetDeviceAccelerationStructureCompatibilityKHR,
     unix_vkGetDeviceBufferMemoryRequirements,
     unix_vkGetDeviceBufferMemoryRequirementsKHR,
+    unix_vkGetDeviceFaultInfoEXT,
     unix_vkGetDeviceGroupPeerMemoryFeatures,
     unix_vkGetDeviceGroupPeerMemoryFeaturesKHR,
     unix_vkGetDeviceGroupPresentCapabilitiesKHR,
@@ -347,6 +394,7 @@ enum unix_call
     unix_vkGetDeviceMemoryCommitment,
     unix_vkGetDeviceMemoryOpaqueCaptureAddress,
     unix_vkGetDeviceMemoryOpaqueCaptureAddressKHR,
+    unix_vkGetDeviceMicromapCompatibilityEXT,
     unix_vkGetDeviceQueue,
     unix_vkGetDeviceQueue2,
     unix_vkGetDeviceSubpassShadingMaxWorkgroupSizeHUAWEI,
@@ -366,6 +414,7 @@ enum unix_call
     unix_vkGetImageViewAddressNVX,
     unix_vkGetImageViewHandleNVX,
     unix_vkGetMemoryHostPointerPropertiesEXT,
+    unix_vkGetMicromapBuildSizesEXT,
     unix_vkGetPerformanceParameterINTEL,
     unix_vkGetPhysicalDeviceCalibrateableTimeDomainsEXT,
     unix_vkGetPhysicalDeviceCooperativeMatrixPropertiesNV,
@@ -389,6 +438,7 @@ enum unix_call
     unix_vkGetPhysicalDeviceMemoryProperties2,
     unix_vkGetPhysicalDeviceMemoryProperties2KHR,
     unix_vkGetPhysicalDeviceMultisamplePropertiesEXT,
+    unix_vkGetPhysicalDeviceOpticalFlowImageFormatsNV,
     unix_vkGetPhysicalDevicePresentRectanglesKHR,
     unix_vkGetPhysicalDeviceProperties,
     unix_vkGetPhysicalDeviceProperties2,
@@ -477,6 +527,7 @@ enum unix_call
     unix_vkWaitSemaphores,
     unix_vkWaitSemaphoresKHR,
     unix_vkWriteAccelerationStructuresPropertiesKHR,
+    unix_vkWriteMicromapsPropertiesEXT,
     unix_count,
 };

@@ -604,6 +655,16 @@ struct vkBindImageMemory2KHR_params
     VkResult result;
 };

+struct vkBindOpticalFlowSessionImageNV_params
+{
+    VkDevice device;
+    VkOpticalFlowSessionNV DECLSPEC_ALIGN(8) session;
+    VkOpticalFlowSessionBindingPointNV bindingPoint;
+    VkImageView DECLSPEC_ALIGN(8) view;
+    VkImageLayout layout;
+    VkResult result;
+};
+
 struct vkBuildAccelerationStructuresKHR_params
 {
     VkDevice device;
@@ -614,6 +675,15 @@ struct vkBuildAccelerationStructuresKHR_params
     VkResult result;
 };

+struct vkBuildMicromapsEXT_params
+{
+    VkDevice device;
+    VkDeferredOperationKHR DECLSPEC_ALIGN(8) deferredOperation;
+    uint32_t infoCount;
+    const VkMicromapBuildInfoEXT *pInfos;
+    VkResult result;
+};
+
 struct vkCmdBeginConditionalRenderingEXT_params
 {
     VkCommandBuffer commandBuffer;
@@ -830,6 +900,13 @@ struct vkCmdBuildAccelerationStructuresKHR_params
     const VkAccelerationStructureBuildRangeInfoKHR * const*ppBuildRangeInfos;
 };

+struct vkCmdBuildMicromapsEXT_params
+{
+    VkCommandBuffer commandBuffer;
+    uint32_t infoCount;
+    const VkMicromapBuildInfoEXT *pInfos;
+};
+
 struct vkCmdClearAttachments_params
 {
     VkCommandBuffer commandBuffer;
@@ -973,6 +1050,24 @@ struct vkCmdCopyMemoryToAccelerationStructureKHR_params
     const VkCopyMemoryToAccelerationStructureInfoKHR *pInfo;
 };

+struct vkCmdCopyMemoryToMicromapEXT_params
+{
+    VkCommandBuffer commandBuffer;
+    const VkCopyMemoryToMicromapInfoEXT *pInfo;
+};
+
+struct vkCmdCopyMicromapEXT_params
+{
+    VkCommandBuffer commandBuffer;
+    const VkCopyMicromapInfoEXT *pInfo;
+};
+
+struct vkCmdCopyMicromapToMemoryEXT_params
+{
+    VkCommandBuffer commandBuffer;
+    const VkCopyMicromapToMemoryInfoEXT *pInfo;
+};
+
 struct vkCmdCopyQueryPoolResults_params
 {
     VkCommandBuffer commandBuffer;
@@ -1345,6 +1440,13 @@ struct vkCmdNextSubpass2KHR_params
     const VkSubpassEndInfo *pSubpassEndInfo;
 };

+struct vkCmdOpticalFlowExecuteNV_params
+{
+    VkCommandBuffer commandBuffer;
+    VkOpticalFlowSessionNV DECLSPEC_ALIGN(8) session;
+    const VkOpticalFlowExecuteInfoNV *pExecuteInfo;
+};
+
 struct vkCmdPipelineBarrier_params
 {
     VkCommandBuffer commandBuffer;
@@ -1458,6 +1560,18 @@ struct vkCmdResolveImage2KHR_params
     const VkResolveImageInfo2 *pResolveImageInfo;
 };

+struct vkCmdSetAlphaToCoverageEnableEXT_params
+{
+    VkCommandBuffer commandBuffer;
+    VkBool32 alphaToCoverageEnable;
+};
+
+struct vkCmdSetAlphaToOneEnableEXT_params
+{
+    VkCommandBuffer commandBuffer;
+    VkBool32 alphaToOneEnable;
+};
+
 struct vkCmdSetBlendConstants_params
 {
     VkCommandBuffer commandBuffer;
@@ -1478,6 +1592,30 @@ struct vkCmdSetCoarseSampleOrderNV_params
     const VkCoarseSampleOrderCustomNV *pCustomSampleOrders;
 };

+struct vkCmdSetColorBlendAdvancedEXT_params
+{
+    VkCommandBuffer commandBuffer;
+    uint32_t firstAttachment;
+    uint32_t attachmentCount;
+    const VkColorBlendAdvancedEXT *pColorBlendAdvanced;
+};
+
+struct vkCmdSetColorBlendEnableEXT_params
+{
+    VkCommandBuffer commandBuffer;
+    uint32_t firstAttachment;
+    uint32_t attachmentCount;
+    const VkBool32 *pColorBlendEnables;
+};
+
+struct vkCmdSetColorBlendEquationEXT_params
+{
+    VkCommandBuffer commandBuffer;
+    uint32_t firstAttachment;
+    uint32_t attachmentCount;
+    const VkColorBlendEquationEXT *pColorBlendEquations;
+};
+
 struct vkCmdSetColorWriteEnableEXT_params
 {
     VkCommandBuffer commandBuffer;
@@ -1485,6 +1623,57 @@ struct vkCmdSetColorWriteEnableEXT_params
     const VkBool32 *pColorWriteEnables;
 };

+struct vkCmdSetColorWriteMaskEXT_params
+{
+    VkCommandBuffer commandBuffer;
+    uint32_t firstAttachment;
+    uint32_t attachmentCount;
+    const VkColorComponentFlags *pColorWriteMasks;
+};
+
+struct vkCmdSetConservativeRasterizationModeEXT_params
+{
+    VkCommandBuffer commandBuffer;
+    VkConservativeRasterizationModeEXT conservativeRasterizationMode;
+};
+
+struct vkCmdSetCoverageModulationModeNV_params
+{
+    VkCommandBuffer commandBuffer;
+    VkCoverageModulationModeNV coverageModulationMode;
+};
+
+struct vkCmdSetCoverageModulationTableEnableNV_params
+{
+    VkCommandBuffer commandBuffer;
+    VkBool32 coverageModulationTableEnable;
+};
+
+struct vkCmdSetCoverageModulationTableNV_params
+{
+    VkCommandBuffer commandBuffer;
+    uint32_t coverageModulationTableCount;
+    const float *pCoverageModulationTable;
+};
+
+struct vkCmdSetCoverageReductionModeNV_params
+{
+    VkCommandBuffer commandBuffer;
+    VkCoverageReductionModeNV coverageReductionMode;
+};
+
+struct vkCmdSetCoverageToColorEnableNV_params
+{
+    VkCommandBuffer commandBuffer;
+    VkBool32 coverageToColorEnable;
+};
+
+struct vkCmdSetCoverageToColorLocationNV_params
+{
+    VkCommandBuffer commandBuffer;
+    uint32_t coverageToColorLocation;
+};
+
 struct vkCmdSetCullMode_params
 {
     VkCommandBuffer commandBuffer;
@@ -1536,6 +1725,24 @@ struct vkCmdSetDepthBoundsTestEnableEXT_params
     VkBool32 depthBoundsTestEnable;
 };

+struct vkCmdSetDepthClampEnableEXT_params
+{
+    VkCommandBuffer commandBuffer;
+    VkBool32 depthClampEnable;
+};
+
+struct vkCmdSetDepthClipEnableEXT_params
+{
+    VkCommandBuffer commandBuffer;
+    VkBool32 depthClipEnable;
+};
+
+struct vkCmdSetDepthClipNegativeOneToOneEXT_params
+{
+    VkCommandBuffer commandBuffer;
+    VkBool32 negativeOneToOne;
+};
+
 struct vkCmdSetDepthCompareOp_params
 {
     VkCommandBuffer commandBuffer;
@@ -1621,6 +1828,12 @@ struct vkCmdSetExclusiveScissorNV_params
     const VkRect2D *pExclusiveScissors;
 };

+struct vkCmdSetExtraPrimitiveOverestimationSizeEXT_params
+{
+    VkCommandBuffer commandBuffer;
+    float extraPrimitiveOverestimationSize;
+};
+
 struct vkCmdSetFragmentShadingRateEnumNV_params
 {
     VkCommandBuffer commandBuffer;
@@ -1647,6 +1860,12 @@ struct vkCmdSetFrontFaceEXT_params
     VkFrontFace frontFace;
 };

+struct vkCmdSetLineRasterizationModeEXT_params
+{
+    VkCommandBuffer commandBuffer;
+    VkLineRasterizationModeEXT lineRasterizationMode;
+};
+
 struct vkCmdSetLineStippleEXT_params
 {
     VkCommandBuffer commandBuffer;
@@ -1654,6 +1873,12 @@ struct vkCmdSetLineStippleEXT_params
     uint16_t lineStipplePattern;
 };

+struct vkCmdSetLineStippleEnableEXT_params
+{
+    VkCommandBuffer commandBuffer;
+    VkBool32 stippledLineEnable;
+};
+
 struct vkCmdSetLineWidth_params
 {
     VkCommandBuffer commandBuffer;
@@ -1666,6 +1891,12 @@ struct vkCmdSetLogicOpEXT_params
     VkLogicOp logicOp;
 };

+struct vkCmdSetLogicOpEnableEXT_params
+{
+    VkCommandBuffer commandBuffer;
+    VkBool32 logicOpEnable;
+};
+
 struct vkCmdSetPatchControlPointsEXT_params
 {
     VkCommandBuffer commandBuffer;
@@ -1693,6 +1924,12 @@ struct vkCmdSetPerformanceStreamMarkerINTEL_params
     VkResult result;
 };

+struct vkCmdSetPolygonModeEXT_params
+{
+    VkCommandBuffer commandBuffer;
+    VkPolygonMode polygonMode;
+};
+
 struct vkCmdSetPrimitiveRestartEnable_params
 {
     VkCommandBuffer commandBuffer;
@@ -1717,6 +1954,24 @@ struct vkCmdSetPrimitiveTopologyEXT_params
     VkPrimitiveTopology primitiveTopology;
 };

+struct vkCmdSetProvokingVertexModeEXT_params
+{
+    VkCommandBuffer commandBuffer;
+    VkProvokingVertexModeEXT provokingVertexMode;
+};
+
+struct vkCmdSetRasterizationSamplesEXT_params
+{
+    VkCommandBuffer commandBuffer;
+    VkSampleCountFlagBits rasterizationSamples;
+};
+
+struct vkCmdSetRasterizationStreamEXT_params
+{
+    VkCommandBuffer commandBuffer;
+    uint32_t rasterizationStream;
+};
+
 struct vkCmdSetRasterizerDiscardEnable_params
 {
     VkCommandBuffer commandBuffer;
@@ -1735,12 +1990,31 @@ struct vkCmdSetRayTracingPipelineStackSizeKHR_params
     uint32_t pipelineStackSize;
 };

+struct vkCmdSetRepresentativeFragmentTestEnableNV_params
+{
+    VkCommandBuffer commandBuffer;
+    VkBool32 representativeFragmentTestEnable;
+};
+
 struct vkCmdSetSampleLocationsEXT_params
 {
     VkCommandBuffer commandBuffer;
     const VkSampleLocationsInfoEXT *pSampleLocationsInfo;
 };

+struct vkCmdSetSampleLocationsEnableEXT_params
+{
+    VkCommandBuffer commandBuffer;
+    VkBool32 sampleLocationsEnable;
+};
+
+struct vkCmdSetSampleMaskEXT_params
+{
+    VkCommandBuffer commandBuffer;
+    VkSampleCountFlagBits samples;
+    const VkSampleMask *pSampleMask;
+};
+
 struct vkCmdSetScissor_params
 {
     VkCommandBuffer commandBuffer;
@@ -1763,6 +2037,12 @@ struct vkCmdSetScissorWithCountEXT_params
     const VkRect2D *pScissors;
 };

+struct vkCmdSetShadingRateImageEnableNV_params
+{
+    VkCommandBuffer commandBuffer;
+    VkBool32 shadingRateImageEnable;
+};
+
 struct vkCmdSetStencilCompareMask_params
 {
     VkCommandBuffer commandBuffer;
@@ -1816,6 +2096,12 @@ struct vkCmdSetStencilWriteMask_params
     uint32_t writeMask;
 };

+struct vkCmdSetTessellationDomainOriginEXT_params
+{
+    VkCommandBuffer commandBuffer;
+    VkTessellationDomainOrigin domainOrigin;
+};
+
 struct vkCmdSetVertexInputEXT_params
 {
     VkCommandBuffer commandBuffer;
@@ -1841,6 +2127,20 @@ struct vkCmdSetViewportShadingRatePaletteNV_params
     const VkShadingRatePaletteNV *pShadingRatePalettes;
 };

+struct vkCmdSetViewportSwizzleNV_params
+{
+    VkCommandBuffer commandBuffer;
+    uint32_t firstViewport;
+    uint32_t viewportCount;
+    const VkViewportSwizzleNV *pViewportSwizzles;
+};
+
+struct vkCmdSetViewportWScalingEnableNV_params
+{
+    VkCommandBuffer commandBuffer;
+    VkBool32 viewportWScalingEnable;
+};
+
 struct vkCmdSetViewportWScalingNV_params
 {
     VkCommandBuffer commandBuffer;
@@ -1993,6 +2293,16 @@ struct vkCmdWriteBufferMarkerAMD_params
     uint32_t marker;
 };

+struct vkCmdWriteMicromapsPropertiesEXT_params
+{
+    VkCommandBuffer commandBuffer;
+    uint32_t micromapCount;
+    const VkMicromapEXT *pMicromaps;
+    VkQueryType queryType;
+    VkQueryPool DECLSPEC_ALIGN(8) queryPool;
+    uint32_t firstQuery;
+};
+
 struct vkCmdWriteTimestamp_params
 {
     VkCommandBuffer commandBuffer;
@@ -2049,6 +2359,30 @@ struct vkCopyMemoryToAccelerationStructureKHR_params
     VkResult result;
 };

+struct vkCopyMemoryToMicromapEXT_params
+{
+    VkDevice device;
+    VkDeferredOperationKHR DECLSPEC_ALIGN(8) deferredOperation;
+    const VkCopyMemoryToMicromapInfoEXT *pInfo;
+    VkResult result;
+};
+
+struct vkCopyMicromapEXT_params
+{
+    VkDevice device;
+    VkDeferredOperationKHR DECLSPEC_ALIGN(8) deferredOperation;
+    const VkCopyMicromapInfoEXT *pInfo;
+    VkResult result;
+};
+
+struct vkCopyMicromapToMemoryEXT_params
+{
+    VkDevice device;
+    VkDeferredOperationKHR DECLSPEC_ALIGN(8) deferredOperation;
+    const VkCopyMicromapToMemoryInfoEXT *pInfo;
+    VkResult result;
+};
+
 struct vkCreateAccelerationStructureKHR_params
 {
     VkDevice device;
@@ -2270,6 +2604,24 @@ struct vkCreateInstance_params
     VkResult result;
 };

+struct vkCreateMicromapEXT_params
+{
+    VkDevice device;
+    const VkMicromapCreateInfoEXT *pCreateInfo;
+    const VkAllocationCallbacks *pAllocator;
+    VkMicromapEXT *pMicromap;
+    VkResult result;
+};
+
+struct vkCreateOpticalFlowSessionNV_params
+{
+    VkDevice device;
+    const VkOpticalFlowSessionCreateInfoNV *pCreateInfo;
+    const VkAllocationCallbacks *pAllocator;
+    VkOpticalFlowSessionNV *pSession;
+    VkResult result;
+};
+
 struct vkCreatePipelineCache_params
 {
     VkDevice device;
@@ -2622,6 +2974,20 @@ struct vkDestroyInstance_params
     const VkAllocationCallbacks *pAllocator;
 };

+struct vkDestroyMicromapEXT_params
+{
+    VkDevice device;
+    VkMicromapEXT DECLSPEC_ALIGN(8) micromap;
+    const VkAllocationCallbacks *pAllocator;
+};
+
+struct vkDestroyOpticalFlowSessionNV_params
+{
+    VkDevice device;
+    VkOpticalFlowSessionNV DECLSPEC_ALIGN(8) session;
+    const VkAllocationCallbacks *pAllocator;
+};
+
 struct vkDestroyPipeline_params
 {
     VkDevice device;
@@ -2997,6 +3363,14 @@ struct vkGetDeviceBufferMemoryRequirementsKHR_params
     VkMemoryRequirements2 *pMemoryRequirements;
 };

+struct vkGetDeviceFaultInfoEXT_params
+{
+    VkDevice device;
+    VkDeviceFaultCountsEXT *pFaultCounts;
+    VkDeviceFaultInfoEXT *pFaultInfo;
+    VkResult result;
+};
+
 struct vkGetDeviceGroupPeerMemoryFeatures_params
 {
     VkDevice device;
@@ -3081,6 +3455,13 @@ struct vkGetDeviceMemoryOpaqueCaptureAddressKHR_params
     uint64_t result;
 };

+struct vkGetDeviceMicromapCompatibilityEXT_params
+{
+    VkDevice device;
+    const VkMicromapVersionInfoEXT *pVersionInfo;
+    VkAccelerationStructureCompatibilityKHR *pCompatibility;
+};
+
 struct vkGetDeviceQueue_params
 {
     VkDevice device;
@@ -3227,6 +3608,14 @@ struct vkGetMemoryHostPointerPropertiesEXT_params
     VkResult result;
 };

+struct vkGetMicromapBuildSizesEXT_params
+{
+    VkDevice device;
+    VkAccelerationStructureBuildTypeKHR buildType;
+    const VkMicromapBuildInfoEXT *pBuildInfo;
+    VkMicromapBuildSizesInfoEXT *pSizeInfo;
+};
+
 struct vkGetPerformanceParameterINTEL_params
 {
     VkDevice device;
@@ -3393,6 +3782,15 @@ struct vkGetPhysicalDeviceMultisamplePropertiesEXT_params
     VkMultisamplePropertiesEXT *pMultisampleProperties;
 };

+struct vkGetPhysicalDeviceOpticalFlowImageFormatsNV_params
+{
+    VkPhysicalDevice physicalDevice;
+    const VkOpticalFlowImageFormatInfoNV *pOpticalFlowImageFormatInfo;
+    uint32_t *pFormatCount;
+    VkOpticalFlowImageFormatPropertiesNV *pImageFormatProperties;
+    VkResult result;
+};
+
 struct vkGetPhysicalDevicePresentRectanglesKHR_params
 {
     VkPhysicalDevice physicalDevice;
@@ -4106,4 +4504,16 @@ struct vkWriteAccelerationStructuresPropertiesKHR_params
     VkResult result;
 };

+struct vkWriteMicromapsPropertiesEXT_params
+{
+    VkDevice device;
+    uint32_t micromapCount;
+    const VkMicromapEXT *pMicromaps;
+    VkQueryType queryType;
+    size_t dataSize;
+    void *pData;
+    size_t stride;
+    VkResult result;
+};
+
 #endif /* __WINE_VULKAN_LOADER_THUNKS_H */
diff --git a/dlls/winevulkan/make_vulkan b/dlls/winevulkan/make_vulkan
index dbc43329c46..c20a9a90c30 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.228"
+VK_XML_VERSION = "1.3.230"
 WINE_VK_VERSION = (1, 3)

# Filenames to create.
diff --git a/dlls/winevulkan/vulkan_thunks.c b/dlls/winevulkan/vulkan_thunks.c
index bff4d1b449a..32a5c7806f8 100644
--- a/dlls/winevulkan/vulkan_thunks.c
+++ b/dlls/winevulkan/vulkan_thunks.c
@@ -258,6 +258,45 @@ static inline void free_VkAccelerationStructureBuildGeometryInfoKHR_array(VkAcce
 }
 #endif /* USE_STRUCT_CONVERSION */

+#if defined(USE_STRUCT_CONVERSION)
+static inline VkMicromapBuildInfoEXT_host *convert_VkMicromapBuildInfoEXT_array_win32_to_host(const VkMicromapBuildInfoEXT *in, uint32_t count)
+{
+    VkMicromapBuildInfoEXT_host *out;
+    unsigned int i;
+
+    if (!in || !count) return NULL;
+
+    out = malloc(count * sizeof(*out));
+    for (i = 0; i < count; i++)
+    {
+        out[i].sType = in[i].sType;
+        out[i].pNext = in[i].pNext;
+        out[i].type = in[i].type;
+        out[i].flags = in[i].flags;
+        out[i].mode = in[i].mode;
+        out[i].dstMicromap = in[i].dstMicromap;
+        out[i].usageCountsCount = in[i].usageCountsCount;
+        out[i].pUsageCounts = in[i].pUsageCounts;
+        out[i].ppUsageCounts = in[i].ppUsageCounts;
+        out[i].data = in[i].data;
+        out[i].scratchData = in[i].scratchData;
+        out[i].triangleArray = in[i].triangleArray;
+        out[i].triangleArrayStride = in[i].triangleArrayStride;
+    }
+
+    return out;
+}
+#endif /* USE_STRUCT_CONVERSION */
+
+#if defined(USE_STRUCT_CONVERSION)
+static inline void free_VkMicromapBuildInfoEXT_array(VkMicromapBuildInfoEXT_host *in, uint32_t count)
+{
+    if (!in) return;
+
+    free(in);
+}
+#endif /* USE_STRUCT_CONVERSION */
+
 #if defined(USE_STRUCT_CONVERSION)
 static inline void convert_VkConditionalRenderingBeginInfoEXT_win32_to_host(const VkConditionalRenderingBeginInfoEXT *in, VkConditionalRenderingBeginInfoEXT_host *out)
 {
@@ -710,6 +749,45 @@ static inline void convert_VkCopyMemoryToAccelerationStructureInfoKHR_win32_to_h
 }
 #endif /* USE_STRUCT_CONVERSION */

+#if defined(USE_STRUCT_CONVERSION)
+static inline void convert_VkCopyMemoryToMicromapInfoEXT_win32_to_host(const VkCopyMemoryToMicromapInfoEXT *in, VkCopyMemoryToMicromapInfoEXT_host *out)
+{
+    if (!in) return;
+
+    out->sType = in->sType;
+    out->pNext = in->pNext;
+    out->src = in->src;
+    out->dst = in->dst;
+    out->mode = in->mode;
+}
+#endif /* USE_STRUCT_CONVERSION */
+
+#if defined(USE_STRUCT_CONVERSION)
+static inline void convert_VkCopyMicromapInfoEXT_win32_to_host(const VkCopyMicromapInfoEXT *in, VkCopyMicromapInfoEXT_host *out)
+{
+    if (!in) return;
+
+    out->sType = in->sType;
+    out->pNext = in->pNext;
+    out->src = in->src;
+    out->dst = in->dst;
+    out->mode = in->mode;
+}
+#endif /* USE_STRUCT_CONVERSION */
+
+#if defined(USE_STRUCT_CONVERSION)
+static inline void convert_VkCopyMicromapToMemoryInfoEXT_win32_to_host(const VkCopyMicromapToMemoryInfoEXT *in, VkCopyMicromapToMemoryInfoEXT_host *out)
+{
+    if (!in) return;
+
+    out->sType = in->sType;
+    out->pNext = in->pNext;
+    out->src = in->src;
+    out->dst = in->dst;
+    out->mode = in->mode;
+}
+#endif /* USE_STRUCT_CONVERSION */
+
 #if defined(USE_STRUCT_CONVERSION)
 static inline void convert_VkCuLaunchInfoNVX_win32_to_host(const VkCuLaunchInfoNVX *in, VkCuLaunchInfoNVX_host *out)
 {
@@ -1516,6 +1594,22 @@ static inline void free_VkIndirectCommandsLayoutCreateInfoNV(VkIndirectCommandsL
 }
 #endif /* USE_STRUCT_CONVERSION */

+#if defined(USE_STRUCT_CONVERSION)
+static inline void convert_VkMicromapCreateInfoEXT_win32_to_host(const VkMicromapCreateInfoEXT *in, VkMicromapCreateInfoEXT_host *out)
+{
+    if (!in) return;
+
+    out->sType = in->sType;
+    out->pNext = in->pNext;
+    out->createFlags = in->createFlags;
+    out->buffer = in->buffer;
+    out->offset = in->offset;
+    out->size = in->size;
+    out->type = in->type;
+    out->deviceAddress = in->deviceAddress;
+}
+#endif /* USE_STRUCT_CONVERSION */
+
 #if defined(USE_STRUCT_CONVERSION)
 static inline VkRayTracingPipelineCreateInfoKHR_host *convert_VkRayTracingPipelineCreateInfoKHR_array_win32_to_host(const VkRayTracingPipelineCreateInfoKHR *in, uint32_t count)
 {
@@ -1938,6 +2032,99 @@ static inline void free_VkDeviceBufferMemoryRequirements(VkDeviceBufferMemoryReq
 }
 #endif /* USE_STRUCT_CONVERSION */

+#if defined(USE_STRUCT_CONVERSION)
+static inline void convert_VkDeviceFaultCountsEXT_win32_to_host(const VkDeviceFaultCountsEXT *in, VkDeviceFaultCountsEXT_host *out)
+{
+    if (!in) return;
+
+    out->sType = in->sType;
+    out->pNext = in->pNext;
+    out->addressInfoCount = in->addressInfoCount;
+    out->vendorInfoCount = in->vendorInfoCount;
+    out->vendorBinarySize = in->vendorBinarySize;
+}
+#endif /* USE_STRUCT_CONVERSION */
+
+#if defined(USE_STRUCT_CONVERSION)
+static inline VkDeviceFaultAddressInfoEXT_host *convert_VkDeviceFaultAddressInfoEXT_array_win32_to_host(const VkDeviceFaultAddressInfoEXT *in, uint32_t count)
+{
+    VkDeviceFaultAddressInfoEXT_host *out;
+    unsigned int i;
+
+    if (!in || !count) return NULL;
+
+    out = malloc(count * sizeof(*out));
+    for (i = 0; i < count; i++)
+    {
+        out[i].addressType = in[i].addressType;
+        out[i].reportedAddress = in[i].reportedAddress;
+        out[i].addressPrecision = in[i].addressPrecision;
+    }
+
+    return out;
+}
+#endif /* USE_STRUCT_CONVERSION */
+
+#if defined(USE_STRUCT_CONVERSION)
+static inline void free_VkDeviceFaultAddressInfoEXT_array(VkDeviceFaultAddressInfoEXT_host *in, uint32_t count)
+{
+    if (!in) return;
+
+    free(in);
+}
+#endif /* USE_STRUCT_CONVERSION */
+
+#if defined(USE_STRUCT_CONVERSION)
+static inline VkDeviceFaultVendorInfoEXT_host *convert_VkDeviceFaultVendorInfoEXT_array_win32_to_host(const VkDeviceFaultVendorInfoEXT *in, uint32_t count)
+{
+    VkDeviceFaultVendorInfoEXT_host *out;
+    unsigned int i;
+
+    if (!in || !count) return NULL;
+
+    out = malloc(count * sizeof(*out));
+    for (i = 0; i < count; i++)
+    {
+        memcpy(out[i].description, in[i].description, VK_MAX_DESCRIPTION_SIZE * sizeof(char));
+        out[i].vendorFaultCode = in[i].vendorFaultCode;
+        out[i].vendorFaultData = in[i].vendorFaultData;
+    }
+
+    return out;
+}
+#endif /* USE_STRUCT_CONVERSION */
+
+#if defined(USE_STRUCT_CONVERSION)
+static inline void free_VkDeviceFaultVendorInfoEXT_array(VkDeviceFaultVendorInfoEXT_host *in, uint32_t count)
+{
+    if (!in) return;
+
+    free(in);
+}
+#endif /* USE_STRUCT_CONVERSION */
+
+#if defined(USE_STRUCT_CONVERSION)
+static inline void convert_VkDeviceFaultInfoEXT_win32_to_host(const VkDeviceFaultInfoEXT *in, VkDeviceFaultInfoEXT_host *out)
+{
+    if (!in) return;
+
+    out->sType = in->sType;
+    out->pNext = in->pNext;
+    memcpy(out->description, in->description, VK_MAX_DESCRIPTION_SIZE * sizeof(char));
+    out->pAddressInfos = convert_VkDeviceFaultAddressInfoEXT_array_win32_to_host(in->pAddressInfos, 1);
+    out->pVendorInfos = convert_VkDeviceFaultVendorInfoEXT_array_win32_to_host(in->pVendorInfos, 1);
+    out->pVendorBinaryData = in->pVendorBinaryData;
+}
+#endif /* USE_STRUCT_CONVERSION */
+
+#if defined(USE_STRUCT_CONVERSION)
+static inline void free_VkDeviceFaultInfoEXT(VkDeviceFaultInfoEXT_host *in)
+{
+    free_VkDeviceFaultAddressInfoEXT_array(in->pAddressInfos, 1);
+    free_VkDeviceFaultVendorInfoEXT_array(in->pVendorInfos, 1);
+}
+#endif /* USE_STRUCT_CONVERSION */
+
 #if defined(USE_STRUCT_CONVERSION)
 static inline void convert_VkDeviceMemoryOpaqueCaptureAddressInfo_win32_to_host(const VkDeviceMemoryOpaqueCaptureAddressInfo *in, VkDeviceMemoryOpaqueCaptureAddressInfo_host *out)
 {
@@ -2066,6 +2253,40 @@ static inline void convert_VkMemoryGetWin32HandleInfoKHR_win32_to_host(const VkM
 }
 #endif /* USE_STRUCT_CONVERSION */

+#if defined(USE_STRUCT_CONVERSION)
+static inline void convert_VkMicromapBuildInfoEXT_win32_to_host(const VkMicromapBuildInfoEXT *in, VkMicromapBuildInfoEXT_host *out)
+{
+    if (!in) return;
+
+    out->sType = in->sType;
+    out->pNext = in->pNext;
+    out->type = in->type;
+    out->flags = in->flags;
+    out->mode = in->mode;
+    out->dstMicromap = in->dstMicromap;
+    out->usageCountsCount = in->usageCountsCount;
+    out->pUsageCounts = in->pUsageCounts;
+    out->ppUsageCounts = in->ppUsageCounts;
+    out->data = in->data;
+    out->scratchData = in->scratchData;
+    out->triangleArray = in->triangleArray;
+    out->triangleArrayStride = in->triangleArrayStride;
+}
+#endif /* USE_STRUCT_CONVERSION */
+
+#if defined(USE_STRUCT_CONVERSION)
+static inline void convert_VkMicromapBuildSizesInfoEXT_win32_to_host(const VkMicromapBuildSizesInfoEXT *in, VkMicromapBuildSizesInfoEXT_host *out)
+{
+    if (!in) return;
+
+    out->sType = in->sType;
+    out->pNext = in->pNext;
+    out->micromapSize = in->micromapSize;
+    out->buildScratchSize = in->buildScratchSize;
+    out->discardable = in->discardable;
+}
+#endif /* USE_STRUCT_CONVERSION */
+
 #if defined(USE_STRUCT_CONVERSION)
 static inline void convert_VkImageFormatProperties_host_to_win32(const VkImageFormatProperties_host *in, VkImageFormatProperties *out)
 {
@@ -4120,6 +4341,22 @@ VkResult convert_VkDeviceCreateInfo_struct_chain(const void *pNext, VkDeviceCrea
             break;
         }

+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PRESENT_BARRIER_FEATURES_NV:
+        {
+            const VkPhysicalDevicePresentBarrierFeaturesNV *in = (const VkPhysicalDevicePresentBarrierFeaturesNV *)in_header;
+            VkPhysicalDevicePresentBarrierFeaturesNV *out;
+
+            if (!(out = malloc(sizeof(*out)))) goto out_of_memory;
+
+            out->sType = in->sType;
+            out->pNext = NULL;
+            out->presentBarrier = in->presentBarrier;
+
+            out_header->pNext = (VkBaseOutStructure *)out;
+            out_header = out_header->pNext;
+            break;
+        }
+
         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PERFORMANCE_QUERY_FEATURES_KHR:
         {
             const VkPhysicalDevicePerformanceQueryFeaturesKHR *in = (const VkPhysicalDevicePerformanceQueryFeaturesKHR *)in_header;
@@ -4574,6 +4811,52 @@ VkResult convert_VkDeviceCreateInfo_struct_chain(const void *pNext, VkDeviceCrea
             break;
         }

+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTENDED_DYNAMIC_STATE_3_FEATURES_EXT:
+        {
+            const VkPhysicalDeviceExtendedDynamicState3FeaturesEXT *in = (const VkPhysicalDeviceExtendedDynamicState3FeaturesEXT *)in_header;
+            VkPhysicalDeviceExtendedDynamicState3FeaturesEXT *out;
+
+            if (!(out = malloc(sizeof(*out)))) goto out_of_memory;
+
+            out->sType = in->sType;
+            out->pNext = NULL;
+            out->extendedDynamicState3TessellationDomainOrigin = in->extendedDynamicState3TessellationDomainOrigin;
+            out->extendedDynamicState3DepthClampEnable = in->extendedDynamicState3DepthClampEnable;
+            out->extendedDynamicState3PolygonMode = in->extendedDynamicState3PolygonMode;
+            out->extendedDynamicState3RasterizationSamples = in->extendedDynamicState3RasterizationSamples;
+            out->extendedDynamicState3SampleMask = in->extendedDynamicState3SampleMask;
+            out->extendedDynamicState3AlphaToCoverageEnable = in->extendedDynamicState3AlphaToCoverageEnable;
+            out->extendedDynamicState3AlphaToOneEnable = in->extendedDynamicState3AlphaToOneEnable;
+            out->extendedDynamicState3LogicOpEnable = in->extendedDynamicState3LogicOpEnable;
+            out->extendedDynamicState3ColorBlendEnable = in->extendedDynamicState3ColorBlendEnable;
+            out->extendedDynamicState3ColorBlendEquation = in->extendedDynamicState3ColorBlendEquation;
+            out->extendedDynamicState3ColorWriteMask = in->extendedDynamicState3ColorWriteMask;
+            out->extendedDynamicState3RasterizationStream = in->extendedDynamicState3RasterizationStream;
+            out->extendedDynamicState3ConservativeRasterizationMode = in->extendedDynamicState3ConservativeRasterizationMode;
+            out->extendedDynamicState3ExtraPrimitiveOverestimationSize = in->extendedDynamicState3ExtraPrimitiveOverestimationSize;
+            out->extendedDynamicState3DepthClipEnable = in->extendedDynamicState3DepthClipEnable;
+            out->extendedDynamicState3SampleLocationsEnable = in->extendedDynamicState3SampleLocationsEnable;
+            out->extendedDynamicState3ColorBlendAdvanced = in->extendedDynamicState3ColorBlendAdvanced;
+            out->extendedDynamicState3ProvokingVertexMode = in->extendedDynamicState3ProvokingVertexMode;
+            out->extendedDynamicState3LineRasterizationMode = in->extendedDynamicState3LineRasterizationMode;
+            out->extendedDynamicState3LineStippleEnable = in->extendedDynamicState3LineStippleEnable;
+            out->extendedDynamicState3DepthClipNegativeOneToOne = in->extendedDynamicState3DepthClipNegativeOneToOne;
+            out->extendedDynamicState3ViewportWScalingEnable = in->extendedDynamicState3ViewportWScalingEnable;
+            out->extendedDynamicState3ViewportSwizzle = in->extendedDynamicState3ViewportSwizzle;
+            out->extendedDynamicState3CoverageToColorEnable = in->extendedDynamicState3CoverageToColorEnable;
+            out->extendedDynamicState3CoverageToColorLocation = in->extendedDynamicState3CoverageToColorLocation;
+            out->extendedDynamicState3CoverageModulationMode = in->extendedDynamicState3CoverageModulationMode;
+            out->extendedDynamicState3CoverageModulationTableEnable = in->extendedDynamicState3CoverageModulationTableEnable;
+            out->extendedDynamicState3CoverageModulationTable = in->extendedDynamicState3CoverageModulationTable;
+            out->extendedDynamicState3CoverageReductionMode = in->extendedDynamicState3CoverageReductionMode;
+            out->extendedDynamicState3RepresentativeFragmentTestEnable = in->extendedDynamicState3RepresentativeFragmentTestEnable;
+            out->extendedDynamicState3ShadingRateImageEnable = in->extendedDynamicState3ShadingRateImageEnable;
+
+            out_header->pNext = (VkBaseOutStructure *)out;
+            out_header = out_header->pNext;
+            break;
+        }
+
         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DIAGNOSTICS_CONFIG_FEATURES_NV:
         {
             const VkPhysicalDeviceDiagnosticsConfigFeaturesNV *in = (const VkPhysicalDeviceDiagnosticsConfigFeaturesNV *)in_header;
@@ -4940,6 +5223,22 @@ VkResult convert_VkDeviceCreateInfo_struct_chain(const void *pNext, VkDeviceCrea
             break;
         }

+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PIPELINE_PROTECTED_ACCESS_FEATURES_EXT:
+        {
+            const VkPhysicalDevicePipelineProtectedAccessFeaturesEXT *in = (const VkPhysicalDevicePipelineProtectedAccessFeaturesEXT *)in_header;
+            VkPhysicalDevicePipelineProtectedAccessFeaturesEXT *out;
+
+            if (!(out = malloc(sizeof(*out)))) goto out_of_memory;
+
+            out->sType = in->sType;
+            out->pNext = NULL;
+            out->pipelineProtectedAccess = in->pipelineProtectedAccess;
+
+            out_header->pNext = (VkBaseOutStructure *)out;
+            out_header = out_header->pNext;
+            break;
+        }
+
         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_INHERITED_VIEWPORT_SCISSOR_FEATURES_NV:
         {
             const VkPhysicalDeviceInheritedViewportScissorFeaturesNV *in = (const VkPhysicalDeviceInheritedViewportScissorFeaturesNV *)in_header;
@@ -5216,6 +5515,24 @@ VkResult convert_VkDeviceCreateInfo_struct_chain(const void *pNext, VkDeviceCrea
             break;
         }

+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_OPACITY_MICROMAP_FEATURES_EXT:
+        {
+            const VkPhysicalDeviceOpacityMicromapFeaturesEXT *in = (const VkPhysicalDeviceOpacityMicromapFeaturesEXT *)in_header;
+            VkPhysicalDeviceOpacityMicromapFeaturesEXT *out;
+
+            if (!(out = malloc(sizeof(*out)))) goto out_of_memory;
+
+            out->sType = in->sType;
+            out->pNext = NULL;
+            out->micromap = in->micromap;
+            out->micromapCaptureReplay = in->micromapCaptureReplay;
+            out->micromapHostCommands = in->micromapHostCommands;
+
+            out_header->pNext = (VkBaseOutStructure *)out;
+            out_header = out_header->pNext;
+            break;
+        }
+
         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PIPELINE_PROPERTIES_FEATURES_EXT:
         {
             const VkPhysicalDevicePipelinePropertiesFeaturesEXT *in = (const VkPhysicalDevicePipelinePropertiesFeaturesEXT *)in_header;
@@ -5346,6 +5663,55 @@ VkResult convert_VkDeviceCreateInfo_struct_chain(const void *pNext, VkDeviceCrea
             break;
         }

+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ADDRESS_BINDING_REPORT_FEATURES_EXT:
+        {
+            const VkPhysicalDeviceAddressBindingReportFeaturesEXT *in = (const VkPhysicalDeviceAddressBindingReportFeaturesEXT *)in_header;
+            VkPhysicalDeviceAddressBindingReportFeaturesEXT *out;
+
+            if (!(out = malloc(sizeof(*out)))) goto out_of_memory;
+
+            out->sType = in->sType;
+            out->pNext = NULL;
+            out->reportAddressBinding = in->reportAddressBinding;
+
+            out_header->pNext = (VkBaseOutStructure *)out;
+            out_header = out_header->pNext;
+            break;
+        }
+
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_OPTICAL_FLOW_FEATURES_NV:
+        {
+            const VkPhysicalDeviceOpticalFlowFeaturesNV *in = (const VkPhysicalDeviceOpticalFlowFeaturesNV *)in_header;
+            VkPhysicalDeviceOpticalFlowFeaturesNV *out;
+
+            if (!(out = malloc(sizeof(*out)))) goto out_of_memory;
+
+            out->sType = in->sType;
+            out->pNext = NULL;
+            out->opticalFlow = in->opticalFlow;
+
+            out_header->pNext = (VkBaseOutStructure *)out;
+            out_header = out_header->pNext;
+            break;
+        }
+
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FAULT_FEATURES_EXT:
+        {
+            const VkPhysicalDeviceFaultFeaturesEXT *in = (const VkPhysicalDeviceFaultFeaturesEXT *)in_header;
+            VkPhysicalDeviceFaultFeaturesEXT *out;
+
+            if (!(out = malloc(sizeof(*out)))) goto out_of_memory;
+
+            out->sType = in->sType;
+            out->pNext = NULL;
+            out->deviceFault = in->deviceFault;
+            out->deviceFaultVendorBinary = in->deviceFaultVendorBinary;
+
+            out_header->pNext = (VkBaseOutStructure *)out;
+            out_header = out_header->pNext;
+            break;
+        }
+
         default:
             FIXME("Application requested a linked structure of type %u.\n", in_header->sType);
         }
@@ -5892,6 +6258,30 @@ static NTSTATUS thunk32_vkBindImageMemory2KHR(void *args)

#if !defined(USE_STRUCT_CONVERSION)

+static NTSTATUS thunk64_vkBindOpticalFlowSessionImageNV(void *args)
+{
+    struct vkBindOpticalFlowSessionImageNV_params *params = args;
+    TRACE("%p, 0x%s, %#x, 0x%s, %#x\n", params->device, wine_dbgstr_longlong(params->session), params->bindingPoint, wine_dbgstr_longlong(params->view), params->layout);
+
+    params->result = wine_device_from_handle(params->device)->funcs.p_vkBindOpticalFlowSessionImageNV(wine_device_from_handle(params->device)->device, params->session, params->bindingPoint, params->view, params->layout);
+    return STATUS_SUCCESS;
+}
+
+#else /* USE_STRUCT_CONVERSION */
+
+static NTSTATUS thunk32_vkBindOpticalFlowSessionImageNV(void *args)
+{
+    struct vkBindOpticalFlowSessionImageNV_params *params = args;
+    TRACE("%p, 0x%s, %#x, 0x%s, %#x\n", params->device, wine_dbgstr_longlong(params->session), params->bindingPoint, wine_dbgstr_longlong(params->view), params->layout);
+
+    params->result = wine_device_from_handle(params->device)->funcs.p_vkBindOpticalFlowSessionImageNV(wine_device_from_handle(params->device)->device, params->session, params->bindingPoint, params->view, params->layout);
+    return STATUS_SUCCESS;
+}
+
+#endif /* USE_STRUCT_CONVERSION */
+
+#if !defined(USE_STRUCT_CONVERSION)
+
 static NTSTATUS thunk64_vkBuildAccelerationStructuresKHR(void *args)
 {
     struct vkBuildAccelerationStructuresKHR_params *params = args;
@@ -5919,6 +6309,33 @@ static NTSTATUS thunk32_vkBuildAccelerationStructuresKHR(void *args)

#if !defined(USE_STRUCT_CONVERSION)

+static NTSTATUS thunk64_vkBuildMicromapsEXT(void *args)
+{
+    struct vkBuildMicromapsEXT_params *params = args;
+    TRACE("%p, 0x%s, %u, %p\n", params->device, wine_dbgstr_longlong(params->deferredOperation), params->infoCount, params->pInfos);
+
+    params->result = wine_device_from_handle(params->device)->funcs.p_vkBuildMicromapsEXT(wine_device_from_handle(params->device)->device, params->deferredOperation, params->infoCount, params->pInfos);
+    return STATUS_SUCCESS;
+}
+
+#else /* USE_STRUCT_CONVERSION */
+
+static NTSTATUS thunk32_vkBuildMicromapsEXT(void *args)
+{
+    struct vkBuildMicromapsEXT_params *params = args;
+    VkMicromapBuildInfoEXT_host *pInfos_host;
+    TRACE("%p, 0x%s, %u, %p\n", params->device, wine_dbgstr_longlong(params->deferredOperation), params->infoCount, params->pInfos);
+
+    pInfos_host = convert_VkMicromapBuildInfoEXT_array_win32_to_host(params->pInfos, params->infoCount);
+    params->result = wine_device_from_handle(params->device)->funcs.p_vkBuildMicromapsEXT(wine_device_from_handle(params->device)->device, params->deferredOperation, params->infoCount, pInfos_host);
+    free_VkMicromapBuildInfoEXT_array(pInfos_host, params->infoCount);
+    return STATUS_SUCCESS;
+}
+
+#endif /* USE_STRUCT_CONVERSION */
+
+#if !defined(USE_STRUCT_CONVERSION)
+
 static NTSTATUS thunk64_vkCmdBeginConditionalRenderingEXT(void *args)
 {
     struct vkCmdBeginConditionalRenderingEXT_params *params = args;
@@ -6570,6 +6987,33 @@ static NTSTATUS thunk32_vkCmdBuildAccelerationStructuresKHR(void *args)

#if !defined(USE_STRUCT_CONVERSION)

+static NTSTATUS thunk64_vkCmdBuildMicromapsEXT(void *args)
+{
+    struct vkCmdBuildMicromapsEXT_params *params = args;
+    TRACE("%p, %u, %p\n", params->commandBuffer, params->infoCount, params->pInfos);
+
+    wine_cmd_buffer_from_handle(params->commandBuffer)->device->funcs.p_vkCmdBuildMicromapsEXT(wine_cmd_buffer_from_handle(params->commandBuffer)->command_buffer, params->infoCount, params->pInfos);
+    return STATUS_SUCCESS;
+}
+
+#else /* USE_STRUCT_CONVERSION */
+
+static NTSTATUS thunk32_vkCmdBuildMicromapsEXT(void *args)
+{
+    struct vkCmdBuildMicromapsEXT_params *params = args;
+    VkMicromapBuildInfoEXT_host *pInfos_host;
+    TRACE("%p, %u, %p\n", params->commandBuffer, params->infoCount, params->pInfos);
+
+    pInfos_host = convert_VkMicromapBuildInfoEXT_array_win32_to_host(params->pInfos, params->infoCount);
+    wine_cmd_buffer_from_handle(params->commandBuffer)->device->funcs.p_vkCmdBuildMicromapsEXT(wine_cmd_buffer_from_handle(params->commandBuffer)->command_buffer, params->infoCount, pInfos_host);
+    free_VkMicromapBuildInfoEXT_array(pInfos_host, params->infoCount);
+    return STATUS_SUCCESS;
+}
+
+#endif /* USE_STRUCT_CONVERSION */
+
+#if !defined(USE_STRUCT_CONVERSION)
+
 static NTSTATUS thunk64_vkCmdClearAttachments(void *args)
 {
     struct vkCmdClearAttachments_params *params = args;
@@ -7063,6 +7507,84 @@ static NTSTATUS thunk32_vkCmdCopyMemoryToAccelerationStructureKHR(void *args)

#if !defined(USE_STRUCT_CONVERSION)

+static NTSTATUS thunk64_vkCmdCopyMemoryToMicromapEXT(void *args)
+{
+    struct vkCmdCopyMemoryToMicromapEXT_params *params = args;
+    TRACE("%p, %p\n", params->commandBuffer, params->pInfo);
+
+    wine_cmd_buffer_from_handle(params->commandBuffer)->device->funcs.p_vkCmdCopyMemoryToMicromapEXT(wine_cmd_buffer_from_handle(params->commandBuffer)->command_buffer, params->pInfo);
+    return STATUS_SUCCESS;
+}
+
+#else /* USE_STRUCT_CONVERSION */
+
+static NTSTATUS thunk32_vkCmdCopyMemoryToMicromapEXT(void *args)
+{
+    struct vkCmdCopyMemoryToMicromapEXT_params *params = args;
+    VkCopyMemoryToMicromapInfoEXT_host pInfo_host;
+    TRACE("%p, %p\n", params->commandBuffer, params->pInfo);
+
+    convert_VkCopyMemoryToMicromapInfoEXT_win32_to_host(params->pInfo, &pInfo_host);
+    wine_cmd_buffer_from_handle(params->commandBuffer)->device->funcs.p_vkCmdCopyMemoryToMicromapEXT(wine_cmd_buffer_from_handle(params->commandBuffer)->command_buffer, &pInfo_host);
+    return STATUS_SUCCESS;
+}
+
+#endif /* USE_STRUCT_CONVERSION */
+
+#if !defined(USE_STRUCT_CONVERSION)
+
+static NTSTATUS thunk64_vkCmdCopyMicromapEXT(void *args)
+{
+    struct vkCmdCopyMicromapEXT_params *params = args;
+    TRACE("%p, %p\n", params->commandBuffer, params->pInfo);
+
+    wine_cmd_buffer_from_handle(params->commandBuffer)->device->funcs.p_vkCmdCopyMicromapEXT(wine_cmd_buffer_from_handle(params->commandBuffer)->command_buffer, params->pInfo);
+    return STATUS_SUCCESS;
+}
+
+#else /* USE_STRUCT_CONVERSION */
+
+static NTSTATUS thunk32_vkCmdCopyMicromapEXT(void *args)
+{
+    struct vkCmdCopyMicromapEXT_params *params = args;
+    VkCopyMicromapInfoEXT_host pInfo_host;
+    TRACE("%p, %p\n", params->commandBuffer, params->pInfo);
+
+    convert_VkCopyMicromapInfoEXT_win32_to_host(params->pInfo, &pInfo_host);
+    wine_cmd_buffer_from_handle(params->commandBuffer)->device->funcs.p_vkCmdCopyMicromapEXT(wine_cmd_buffer_from_handle(params->commandBuffer)->command_buffer, &pInfo_host);
+    return STATUS_SUCCESS;
+}
+
+#endif /* USE_STRUCT_CONVERSION */
+
+#if !defined(USE_STRUCT_CONVERSION)
+
+static NTSTATUS thunk64_vkCmdCopyMicromapToMemoryEXT(void *args)
+{
+    struct vkCmdCopyMicromapToMemoryEXT_params *params = args;
+    TRACE("%p, %p\n", params->commandBuffer, params->pInfo);
+
+    wine_cmd_buffer_from_handle(params->commandBuffer)->device->funcs.p_vkCmdCopyMicromapToMemoryEXT(wine_cmd_buffer_from_handle(params->commandBuffer)->command_buffer, params->pInfo);
+    return STATUS_SUCCESS;
+}
+
+#else /* USE_STRUCT_CONVERSION */
+
+static NTSTATUS thunk32_vkCmdCopyMicromapToMemoryEXT(void *args)
+{
+    struct vkCmdCopyMicromapToMemoryEXT_params *params = args;
+    VkCopyMicromapToMemoryInfoEXT_host pInfo_host;
+    TRACE("%p, %p\n", params->commandBuffer, params->pInfo);
+
+    convert_VkCopyMicromapToMemoryInfoEXT_win32_to_host(params->pInfo, &pInfo_host);
+    wine_cmd_buffer_from_handle(params->commandBuffer)->device->funcs.p_vkCmdCopyMicromapToMemoryEXT(wine_cmd_buffer_from_handle(params->commandBuffer)->command_buffer, &pInfo_host);
+    return STATUS_SUCCESS;
+}
+
+#endif /* USE_STRUCT_CONVERSION */
+
+#if !defined(USE_STRUCT_CONVERSION)
+
 static NTSTATUS thunk64_vkCmdCopyQueryPoolResults(void *args)
 {
     struct vkCmdCopyQueryPoolResults_params *params = args;
@@ -8154,6 +8676,30 @@ static NTSTATUS thunk32_vkCmdNextSubpass2KHR(void *args)

#if !defined(USE_STRUCT_CONVERSION)

+static NTSTATUS thunk64_vkCmdOpticalFlowExecuteNV(void *args)
+{
+    struct vkCmdOpticalFlowExecuteNV_params *params = args;
+    TRACE("%p, 0x%s, %p\n", params->commandBuffer, wine_dbgstr_longlong(params->session), params->pExecuteInfo);
+
+    wine_cmd_buffer_from_handle(params->commandBuffer)->device->funcs.p_vkCmdOpticalFlowExecuteNV(wine_cmd_buffer_from_handle(params->commandBuffer)->command_buffer, params->session, params->pExecuteInfo);
+    return STATUS_SUCCESS;
+}
+
+#else /* USE_STRUCT_CONVERSION */
+
+static NTSTATUS thunk32_vkCmdOpticalFlowExecuteNV(void *args)
+{
+    struct vkCmdOpticalFlowExecuteNV_params *params = args;
+    TRACE("%p, 0x%s, %p\n", params->commandBuffer, wine_dbgstr_longlong(params->session), params->pExecuteInfo);
+
+    wine_cmd_buffer_from_handle(params->commandBuffer)->device->funcs.p_vkCmdOpticalFlowExecuteNV(wine_cmd_buffer_from_handle(params->commandBuffer)->command_buffer, params->session, params->pExecuteInfo);
+    return STATUS_SUCCESS;
+}
+
+#endif /* USE_STRUCT_CONVERSION */
+
+#if !defined(USE_STRUCT_CONVERSION)
+
 static NTSTATUS thunk64_vkCmdPipelineBarrier(void *args)
 {
     struct vkCmdPipelineBarrier_params *params = args;
@@ -8512,6 +9058,54 @@ static NTSTATUS thunk32_vkCmdResolveImage2KHR(void *args)

#if !defined(USE_STRUCT_CONVERSION)

+static NTSTATUS thunk64_vkCmdSetAlphaToCoverageEnableEXT(void *args)
+{
+    struct vkCmdSetAlphaToCoverageEnableEXT_params *params = args;
+    TRACE("%p, %u\n", params->commandBuffer, params->alphaToCoverageEnable);
+
+    wine_cmd_buffer_from_handle(params->commandBuffer)->device->funcs.p_vkCmdSetAlphaToCoverageEnableEXT(wine_cmd_buffer_from_handle(params->commandBuffer)->command_buffer, params->alphaToCoverageEnable);
+    return STATUS_SUCCESS;
+}
+
+#else /* USE_STRUCT_CONVERSION */
+
+static NTSTATUS thunk32_vkCmdSetAlphaToCoverageEnableEXT(void *args)
+{
+    struct vkCmdSetAlphaToCoverageEnableEXT_params *params = args;
+    TRACE("%p, %u\n", params->commandBuffer, params->alphaToCoverageEnable);
+
+    wine_cmd_buffer_from_handle(params->commandBuffer)->device->funcs.p_vkCmdSetAlphaToCoverageEnableEXT(wine_cmd_buffer_from_handle(params->commandBuffer)->command_buffer, params->alphaToCoverageEnable);
+    return STATUS_SUCCESS;
+}
+
+#endif /* USE_STRUCT_CONVERSION */
+
+#if !defined(USE_STRUCT_CONVERSION)
+
+static NTSTATUS thunk64_vkCmdSetAlphaToOneEnableEXT(void *args)
+{
+    struct vkCmdSetAlphaToOneEnableEXT_params *params = args;
+    TRACE("%p, %u\n", params->commandBuffer, params->alphaToOneEnable);
+
+    wine_cmd_buffer_from_handle(params->commandBuffer)->device->funcs.p_vkCmdSetAlphaToOneEnableEXT(wine_cmd_buffer_from_handle(params->commandBuffer)->command_buffer, params->alphaToOneEnable);
+    return STATUS_SUCCESS;
+}
+
+#else /* USE_STRUCT_CONVERSION */
+
+static NTSTATUS thunk32_vkCmdSetAlphaToOneEnableEXT(void *args)
+{
+    struct vkCmdSetAlphaToOneEnableEXT_params *params = args;
+    TRACE("%p, %u\n", params->commandBuffer, params->alphaToOneEnable);
+
+    wine_cmd_buffer_from_handle(params->commandBuffer)->device->funcs.p_vkCmdSetAlphaToOneEnableEXT(wine_cmd_buffer_from_handle(params->commandBuffer)->command_buffer, params->alphaToOneEnable);
+    return STATUS_SUCCESS;
+}
+
+#endif /* USE_STRUCT_CONVERSION */
+
+#if !defined(USE_STRUCT_CONVERSION)
+
 static NTSTATUS thunk64_vkCmdSetBlendConstants(void *args)
 {
     struct vkCmdSetBlendConstants_params *params = args;
@@ -8584,23 +9178,23 @@ static NTSTATUS thunk32_vkCmdSetCoarseSampleOrderNV(void *args)

#if !defined(USE_STRUCT_CONVERSION)

-static NTSTATUS thunk64_vkCmdSetColorWriteEnableEXT(void *args)
+static NTSTATUS thunk64_vkCmdSetColorBlendAdvancedEXT(void *args)
 {
-    struct vkCmdSetColorWriteEnableEXT_params *params = args;
-    TRACE("%p, %u, %p\n", params->commandBuffer, params->attachmentCount, params->pColorWriteEnables);
+    struct vkCmdSetColorBlendAdvancedEXT_params *params = args;
+    TRACE("%p, %u, %u, %p\n", params->commandBuffer, params->firstAttachment, params->attachmentCount, params->pColorBlendAdvanced);

-    wine_cmd_buffer_from_handle(params->commandBuffer)->device->funcs.p_vkCmdSetColorWriteEnableEXT(wine_cmd_buffer_from_handle(params->commandBuffer)->command_buffer, params->attachmentCount, params->pColorWriteEnables);
+    wine_cmd_buffer_from_handle(params->commandBuffer)->device->funcs.p_vkCmdSetColorBlendAdvancedEXT(wine_cmd_buffer_from_handle(params->commandBuffer)->command_buffer, params->firstAttachment, params->attachmentCount, params->pColorBlendAdvanced);
     return STATUS_SUCCESS;
 }

#else /* USE_STRUCT_CONVERSION */

-static NTSTATUS thunk32_vkCmdSetColorWriteEnableEXT(void *args)
+static NTSTATUS thunk32_vkCmdSetColorBlendAdvancedEXT(void *args)
 {
-    struct vkCmdSetColorWriteEnableEXT_params *params = args;
-    TRACE("%p, %u, %p\n", params->commandBuffer, params->attachmentCount, params->pColorWriteEnables);
+    struct vkCmdSetColorBlendAdvancedEXT_params *params = args;
+    TRACE("%p, %u, %u, %p\n", params->commandBuffer, params->firstAttachment, params->attachmentCount, params->pColorBlendAdvanced);

-    wine_cmd_buffer_from_handle(params->commandBuffer)->device->funcs.p_vkCmdSetColorWriteEnableEXT(wine_cmd_buffer_from_handle(params->commandBuffer)->command_buffer, params->attachmentCount, params->pColorWriteEnables);
+    wine_cmd_buffer_from_handle(params->commandBuffer)->device->funcs.p_vkCmdSetColorBlendAdvancedEXT(wine_cmd_buffer_from_handle(params->commandBuffer)->command_buffer, params->firstAttachment, params->attachmentCount, params->pColorBlendAdvanced);
     return STATUS_SUCCESS;
 }

@@ -8608,23 +9202,23 @@ static NTSTATUS thunk32_vkCmdSetColorWriteEnableEXT(void *args)

#if !defined(USE_STRUCT_CONVERSION)

-static NTSTATUS thunk64_vkCmdSetCullMode(void *args)
+static NTSTATUS thunk64_vkCmdSetColorBlendEnableEXT(void *args)
 {
-    struct vkCmdSetCullMode_params *params = args;
-    TRACE("%p, %#x\n", params->commandBuffer, params->cullMode);
+    struct vkCmdSetColorBlendEnableEXT_params *params = args;
+    TRACE("%p, %u, %u, %p\n", params->commandBuffer, params->firstAttachment, params->attachmentCount, params->pColorBlendEnables);

-    wine_cmd_buffer_from_handle(params->commandBuffer)->device->funcs.p_vkCmdSetCullMode(wine_cmd_buffer_from_handle(params->commandBuffer)->command_buffer, params->cullMode);
+    wine_cmd_buffer_from_handle(params->commandBuffer)->device->funcs.p_vkCmdSetColorBlendEnableEXT(wine_cmd_buffer_from_handle(params->commandBuffer)->command_buffer, params->firstAttachment, params->attachmentCount, params->pColorBlendEnables);
     return STATUS_SUCCESS;
 }

#else /* USE_STRUCT_CONVERSION */

-static NTSTATUS thunk32_vkCmdSetCullMode(void *args)
+static NTSTATUS thunk32_vkCmdSetColorBlendEnableEXT(void *args)
 {
-    struct vkCmdSetCullMode_params *params = args;
-    TRACE("%p, %#x\n", params->commandBuffer, params->cullMode);
+    struct vkCmdSetColorBlendEnableEXT_params *params = args;
+    TRACE("%p, %u, %u, %p\n", params->commandBuffer, params->firstAttachment, params->attachmentCount, params->pColorBlendEnables);

-    wine_cmd_buffer_from_handle(params->commandBuffer)->device->funcs.p_vkCmdSetCullMode(wine_cmd_buffer_from_handle(params->commandBuffer)->command_buffer, params->cullMode);
+    wine_cmd_buffer_from_handle(params->commandBuffer)->device->funcs.p_vkCmdSetColorBlendEnableEXT(wine_cmd_buffer_from_handle(params->commandBuffer)->command_buffer, params->firstAttachment, params->attachmentCount, params->pColorBlendEnables);
     return STATUS_SUCCESS;
 }

@@ -8632,23 +9226,23 @@ static NTSTATUS thunk32_vkCmdSetCullMode(void *args)

#if !defined(USE_STRUCT_CONVERSION)

-static NTSTATUS thunk64_vkCmdSetCullModeEXT(void *args)
+static NTSTATUS thunk64_vkCmdSetColorBlendEquationEXT(void *args)
 {
-    struct vkCmdSetCullModeEXT_params *params = args;
-    TRACE("%p, %#x\n", params->commandBuffer, params->cullMode);
+    struct vkCmdSetColorBlendEquationEXT_params *params = args;
+    TRACE("%p, %u, %u, %p\n", params->commandBuffer, params->firstAttachment, params->attachmentCount, params->pColorBlendEquations);

-    wine_cmd_buffer_from_handle(params->commandBuffer)->device->funcs.p_vkCmdSetCullModeEXT(wine_cmd_buffer_from_handle(params->commandBuffer)->command_buffer, params->cullMode);
+    wine_cmd_buffer_from_handle(params->commandBuffer)->device->funcs.p_vkCmdSetColorBlendEquationEXT(wine_cmd_buffer_from_handle(params->commandBuffer)->command_buffer, params->firstAttachment, params->attachmentCount, params->pColorBlendEquations);
     return STATUS_SUCCESS;
 }

#else /* USE_STRUCT_CONVERSION */

-static NTSTATUS thunk32_vkCmdSetCullModeEXT(void *args)
+static NTSTATUS thunk32_vkCmdSetColorBlendEquationEXT(void *args)
 {
-    struct vkCmdSetCullModeEXT_params *params = args;
-    TRACE("%p, %#x\n", params->commandBuffer, params->cullMode);
+    struct vkCmdSetColorBlendEquationEXT_params *params = args;
+    TRACE("%p, %u, %u, %p\n", params->commandBuffer, params->firstAttachment, params->attachmentCount, params->pColorBlendEquations);

-    wine_cmd_buffer_from_handle(params->commandBuffer)->device->funcs.p_vkCmdSetCullModeEXT(wine_cmd_buffer_from_handle(params->commandBuffer)->command_buffer, params->cullMode);
+    wine_cmd_buffer_from_handle(params->commandBuffer)->device->funcs.p_vkCmdSetColorBlendEquationEXT(wine_cmd_buffer_from_handle(params->commandBuffer)->command_buffer, params->firstAttachment, params->attachmentCount, params->pColorBlendEquations);
     return STATUS_SUCCESS;
 }

@@ -8656,23 +9250,23 @@ static NTSTATUS thunk32_vkCmdSetCullModeEXT(void *args)

#if !defined(USE_STRUCT_CONVERSION)

-static NTSTATUS thunk64_vkCmdSetDepthBias(void *args)
+static NTSTATUS thunk64_vkCmdSetColorWriteEnableEXT(void *args)
 {
-    struct vkCmdSetDepthBias_params *params = args;
-    TRACE("%p, %f, %f, %f\n", params->commandBuffer, params->depthBiasConstantFactor, params->depthBiasClamp, params->depthBiasSlopeFactor);
+    struct vkCmdSetColorWriteEnableEXT_params *params = args;
+    TRACE("%p, %u, %p\n", params->commandBuffer, params->attachmentCount, params->pColorWriteEnables);

-    wine_cmd_buffer_from_handle(params->commandBuffer)->device->funcs.p_vkCmdSetDepthBias(wine_cmd_buffer_from_handle(params->commandBuffer)->command_buffer, params->depthBiasConstantFactor, params->depthBiasClamp, params->depthBiasSlopeFactor);
+    wine_cmd_buffer_from_handle(params->commandBuffer)->device->funcs.p_vkCmdSetColorWriteEnableEXT(wine_cmd_buffer_from_handle(params->commandBuffer)->command_buffer, params->attachmentCount, params->pColorWriteEnables);
     return STATUS_SUCCESS;
 }

#else /* USE_STRUCT_CONVERSION */

-static NTSTATUS thunk32_vkCmdSetDepthBias(void *args)
+static NTSTATUS thunk32_vkCmdSetColorWriteEnableEXT(void *args)
 {
-    struct vkCmdSetDepthBias_params *params = args;
-    TRACE("%p, %f, %f, %f\n", params->commandBuffer, params->depthBiasConstantFactor, params->depthBiasClamp, params->depthBiasSlopeFactor);
+    struct vkCmdSetColorWriteEnableEXT_params *params = args;
+    TRACE("%p, %u, %p\n", params->commandBuffer, params->attachmentCount, params->pColorWriteEnables);

-    wine_cmd_buffer_from_handle(params->commandBuffer)->device->funcs.p_vkCmdSetDepthBias(wine_cmd_buffer_from_handle(params->commandBuffer)->command_buffer, params->depthBiasConstantFactor, params->depthBiasClamp, params->depthBiasSlopeFactor);
+    wine_cmd_buffer_from_handle(params->commandBuffer)->device->funcs.p_vkCmdSetColorWriteEnableEXT(wine_cmd_buffer_from_handle(params->commandBuffer)->command_buffer, params->attachmentCount, params->pColorWriteEnables);
     return STATUS_SUCCESS;
 }

@@ -8680,23 +9274,23 @@ static NTSTATUS thunk32_vkCmdSetDepthBias(void *args)

#if !defined(USE_STRUCT_CONVERSION)

-static NTSTATUS thunk64_vkCmdSetDepthBiasEnable(void *args)
+static NTSTATUS thunk64_vkCmdSetColorWriteMaskEXT(void *args)
 {
-    struct vkCmdSetDepthBiasEnable_params *params = args;
-    TRACE("%p, %u\n", params->commandBuffer, params->depthBiasEnable);
+    struct vkCmdSetColorWriteMaskEXT_params *params = args;
+    TRACE("%p, %u, %u, %p\n", params->commandBuffer, params->firstAttachment, params->attachmentCount, params->pColorWriteMasks);

-    wine_cmd_buffer_from_handle(params->commandBuffer)->device->funcs.p_vkCmdSetDepthBiasEnable(wine_cmd_buffer_from_handle(params->commandBuffer)->command_buffer, params->depthBiasEnable);
+    wine_cmd_buffer_from_handle(params->commandBuffer)->device->funcs.p_vkCmdSetColorWriteMaskEXT(wine_cmd_buffer_from_handle(params->commandBuffer)->command_buffer, params->firstAttachment, params->attachmentCount, params->pColorWriteMasks);
     return STATUS_SUCCESS;
 }

#else /* USE_STRUCT_CONVERSION */

-static NTSTATUS thunk32_vkCmdSetDepthBiasEnable(void *args)
+static NTSTATUS thunk32_vkCmdSetColorWriteMaskEXT(void *args)
 {
-    struct vkCmdSetDepthBiasEnable_params *params = args;
-    TRACE("%p, %u\n", params->commandBuffer, params->depthBiasEnable);
+    struct vkCmdSetColorWriteMaskEXT_params *params = args;
+    TRACE("%p, %u, %u, %p\n", params->commandBuffer, params->firstAttachment, params->attachmentCount, params->pColorWriteMasks);

-    wine_cmd_buffer_from_handle(params->commandBuffer)->device->funcs.p_vkCmdSetDepthBiasEnable(wine_cmd_buffer_from_handle(params->commandBuffer)->command_buffer, params->depthBiasEnable);
+    wine_cmd_buffer_from_handle(params->commandBuffer)->device->funcs.p_vkCmdSetColorWriteMaskEXT(wine_cmd_buffer_from_handle(params->commandBuffer)->command_buffer, params->firstAttachment, params->attachmentCount, params->pColorWriteMasks);
     return STATUS_SUCCESS;
 }

@@ -8704,23 +9298,23 @@ static NTSTATUS thunk32_vkCmdSetDepthBiasEnable(void *args)

#if !defined(USE_STRUCT_CONVERSION)

-static NTSTATUS thunk64_vkCmdSetDepthBiasEnableEXT(void *args)
+static NTSTATUS thunk64_vkCmdSetConservativeRasterizationModeEXT(void *args)
 {
-    struct vkCmdSetDepthBiasEnableEXT_params *params = args;
-    TRACE("%p, %u\n", params->commandBuffer, params->depthBiasEnable);
+    struct vkCmdSetConservativeRasterizationModeEXT_params *params = args;
+    TRACE("%p, %#x\n", params->commandBuffer, params->conservativeRasterizationMode);

-    wine_cmd_buffer_from_handle(params->commandBuffer)->device->funcs.p_vkCmdSetDepthBiasEnableEXT(wine_cmd_buffer_from_handle(params->commandBuffer)->command_buffer, params->depthBiasEnable);
+    wine_cmd_buffer_from_handle(params->commandBuffer)->device->funcs.p_vkCmdSetConservativeRasterizationModeEXT(wine_cmd_buffer_from_handle(params->commandBuffer)->command_buffer, params->conservativeRasterizationMode);
     return STATUS_SUCCESS;
 }

#else /* USE_STRUCT_CONVERSION */

-static NTSTATUS thunk32_vkCmdSetDepthBiasEnableEXT(void *args)
+static NTSTATUS thunk32_vkCmdSetConservativeRasterizationModeEXT(void *args)
 {
-    struct vkCmdSetDepthBiasEnableEXT_params *params = args;
-    TRACE("%p, %u\n", params->commandBuffer, params->depthBiasEnable);
+    struct vkCmdSetConservativeRasterizationModeEXT_params *params = args;
+    TRACE("%p, %#x\n", params->commandBuffer, params->conservativeRasterizationMode);

-    wine_cmd_buffer_from_handle(params->commandBuffer)->device->funcs.p_vkCmdSetDepthBiasEnableEXT(wine_cmd_buffer_from_handle(params->commandBuffer)->command_buffer, params->depthBiasEnable);
+    wine_cmd_buffer_from_handle(params->commandBuffer)->device->funcs.p_vkCmdSetConservativeRasterizationModeEXT(wine_cmd_buffer_from_handle(params->commandBuffer)->command_buffer, params->conservativeRasterizationMode);
     return STATUS_SUCCESS;
 }

@@ -8728,23 +9322,23 @@ static NTSTATUS thunk32_vkCmdSetDepthBiasEnableEXT(void *args)

#if !defined(USE_STRUCT_CONVERSION)

-static NTSTATUS thunk64_vkCmdSetDepthBounds(void *args)
+static NTSTATUS thunk64_vkCmdSetCoverageModulationModeNV(void *args)
 {
-    struct vkCmdSetDepthBounds_params *params = args;
-    TRACE("%p, %f, %f\n", params->commandBuffer, params->minDepthBounds, params->maxDepthBounds);
+    struct vkCmdSetCoverageModulationModeNV_params *params = args;
+    TRACE("%p, %#x\n", params->commandBuffer, params->coverageModulationMode);

-    wine_cmd_buffer_from_handle(params->commandBuffer)->device->funcs.p_vkCmdSetDepthBounds(wine_cmd_buffer_from_handle(params->commandBuffer)->command_buffer, params->minDepthBounds, params->maxDepthBounds);
+    wine_cmd_buffer_from_handle(params->commandBuffer)->device->funcs.p_vkCmdSetCoverageModulationModeNV(wine_cmd_buffer_from_handle(params->commandBuffer)->command_buffer, params->coverageModulationMode);
     return STATUS_SUCCESS;
 }

#else /* USE_STRUCT_CONVERSION */

-static NTSTATUS thunk32_vkCmdSetDepthBounds(void *args)
+static NTSTATUS thunk32_vkCmdSetCoverageModulationModeNV(void *args)
 {
-    struct vkCmdSetDepthBounds_params *params = args;
-    TRACE("%p, %f, %f\n", params->commandBuffer, params->minDepthBounds, params->maxDepthBounds);
+    struct vkCmdSetCoverageModulationModeNV_params *params = args;
+    TRACE("%p, %#x\n", params->commandBuffer, params->coverageModulationMode);

-    wine_cmd_buffer_from_handle(params->commandBuffer)->device->funcs.p_vkCmdSetDepthBounds(wine_cmd_buffer_from_handle(params->commandBuffer)->command_buffer, params->minDepthBounds, params->maxDepthBounds);
+    wine_cmd_buffer_from_handle(params->commandBuffer)->device->funcs.p_vkCmdSetCoverageModulationModeNV(wine_cmd_buffer_from_handle(params->commandBuffer)->command_buffer, params->coverageModulationMode);
     return STATUS_SUCCESS;
 }

@@ -8752,23 +9346,23 @@ static NTSTATUS thunk32_vkCmdSetDepthBounds(void *args)

#if !defined(USE_STRUCT_CONVERSION)

-static NTSTATUS thunk64_vkCmdSetDepthBoundsTestEnable(void *args)
+static NTSTATUS thunk64_vkCmdSetCoverageModulationTableEnableNV(void *args)
 {
-    struct vkCmdSetDepthBoundsTestEnable_params *params = args;
-    TRACE("%p, %u\n", params->commandBuffer, params->depthBoundsTestEnable);
+    struct vkCmdSetCoverageModulationTableEnableNV_params *params = args;
+    TRACE("%p, %u\n", params->commandBuffer, params->coverageModulationTableEnable);

-    wine_cmd_buffer_from_handle(params->commandBuffer)->device->funcs.p_vkCmdSetDepthBoundsTestEnable(wine_cmd_buffer_from_handle(params->commandBuffer)->command_buffer, params->depthBoundsTestEnable);
+    wine_cmd_buffer_from_handle(params->commandBuffer)->device->funcs.p_vkCmdSetCoverageModulationTableEnableNV(wine_cmd_buffer_from_handle(params->commandBuffer)->command_buffer, params->coverageModulationTableEnable);
     return STATUS_SUCCESS;
 }

#else /* USE_STRUCT_CONVERSION */

-static NTSTATUS thunk32_vkCmdSetDepthBoundsTestEnable(void *args)
+static NTSTATUS thunk32_vkCmdSetCoverageModulationTableEnableNV(void *args)
 {
-    struct vkCmdSetDepthBoundsTestEnable_params *params = args;
-    TRACE("%p, %u\n", params->commandBuffer, params->depthBoundsTestEnable);
+    struct vkCmdSetCoverageModulationTableEnableNV_params *params = args;
+    TRACE("%p, %u\n", params->commandBuffer, params->coverageModulationTableEnable);

-    wine_cmd_buffer_from_handle(params->commandBuffer)->device->funcs.p_vkCmdSetDepthBoundsTestEnable(wine_cmd_buffer_from_handle(params->commandBuffer)->command_buffer, params->depthBoundsTestEnable);
+    wine_cmd_buffer_from_handle(params->commandBuffer)->device->funcs.p_vkCmdSetCoverageModulationTableEnableNV(wine_cmd_buffer_from_handle(params->commandBuffer)->command_buffer, params->coverageModulationTableEnable);
     return STATUS_SUCCESS;
 }

@@ -8776,23 +9370,23 @@ static NTSTATUS thunk32_vkCmdSetDepthBoundsTestEnable(void *args)

#if !defined(USE_STRUCT_CONVERSION)

-static NTSTATUS thunk64_vkCmdSetDepthBoundsTestEnableEXT(void *args)
+static NTSTATUS thunk64_vkCmdSetCoverageModulationTableNV(void *args)
 {
-    struct vkCmdSetDepthBoundsTestEnableEXT_params *params = args;
-    TRACE("%p, %u\n", params->commandBuffer, params->depthBoundsTestEnable);
+    struct vkCmdSetCoverageModulationTableNV_params *params = args;
+    TRACE("%p, %u, %p\n", params->commandBuffer, params->coverageModulationTableCount, params->pCoverageModulationTable);

-    wine_cmd_buffer_from_handle(params->commandBuffer)->device->funcs.p_vkCmdSetDepthBoundsTestEnableEXT(wine_cmd_buffer_from_handle(params->commandBuffer)->command_buffer, params->depthBoundsTestEnable);
+    wine_cmd_buffer_from_handle(params->commandBuffer)->device->funcs.p_vkCmdSetCoverageModulationTableNV(wine_cmd_buffer_from_handle(params->commandBuffer)->command_buffer, params->coverageModulationTableCount, params->pCoverageModulationTable);
     return STATUS_SUCCESS;
 }

#else /* USE_STRUCT_CONVERSION */

-static NTSTATUS thunk32_vkCmdSetDepthBoundsTestEnableEXT(void *args)
+static NTSTATUS thunk32_vkCmdSetCoverageModulationTableNV(void *args)
 {
-    struct vkCmdSetDepthBoundsTestEnableEXT_params *params = args;
-    TRACE("%p, %u\n", params->commandBuffer, params->depthBoundsTestEnable);
+    struct vkCmdSetCoverageModulationTableNV_params *params = args;
+    TRACE("%p, %u, %p\n", params->commandBuffer, params->coverageModulationTableCount, params->pCoverageModulationTable);

-    wine_cmd_buffer_from_handle(params->commandBuffer)->device->funcs.p_vkCmdSetDepthBoundsTestEnableEXT(wine_cmd_buffer_from_handle(params->commandBuffer)->command_buffer, params->depthBoundsTestEnable);
+    wine_cmd_buffer_from_handle(params->commandBuffer)->device->funcs.p_vkCmdSetCoverageModulationTableNV(wine_cmd_buffer_from_handle(params->commandBuffer)->command_buffer, params->coverageModulationTableCount, params->pCoverageModulationTable);
     return STATUS_SUCCESS;
 }

@@ -8800,23 +9394,23 @@ static NTSTATUS thunk32_vkCmdSetDepthBoundsTestEnableEXT(void *args)

#if !defined(USE_STRUCT_CONVERSION)

-static NTSTATUS thunk64_vkCmdSetDepthCompareOp(void *args)
+static NTSTATUS thunk64_vkCmdSetCoverageReductionModeNV(void *args)
 {
-    struct vkCmdSetDepthCompareOp_params *params = args;
-    TRACE("%p, %#x\n", params->commandBuffer, params->depthCompareOp);
+    struct vkCmdSetCoverageReductionModeNV_params *params = args;
+    TRACE("%p, %#x\n", params->commandBuffer, params->coverageReductionMode);

-    wine_cmd_buffer_from_handle(params->commandBuffer)->device->funcs.p_vkCmdSetDepthCompareOp(wine_cmd_buffer_from_handle(params->commandBuffer)->command_buffer, params->depthCompareOp);
+    wine_cmd_buffer_from_handle(params->commandBuffer)->device->funcs.p_vkCmdSetCoverageReductionModeNV(wine_cmd_buffer_from_handle(params->commandBuffer)->command_buffer, params->coverageReductionMode);
     return STATUS_SUCCESS;
 }

#else /* USE_STRUCT_CONVERSION */

-static NTSTATUS thunk32_vkCmdSetDepthCompareOp(void *args)
+static NTSTATUS thunk32_vkCmdSetCoverageReductionModeNV(void *args)
 {
-    struct vkCmdSetDepthCompareOp_params *params = args;
-    TRACE("%p, %#x\n", params->commandBuffer, params->depthCompareOp);
+    struct vkCmdSetCoverageReductionModeNV_params *params = args;
+    TRACE("%p, %#x\n", params->commandBuffer, params->coverageReductionMode);

-    wine_cmd_buffer_from_handle(params->commandBuffer)->device->funcs.p_vkCmdSetDepthCompareOp(wine_cmd_buffer_from_handle(params->commandBuffer)->command_buffer, params->depthCompareOp);
+    wine_cmd_buffer_from_handle(params->commandBuffer)->device->funcs.p_vkCmdSetCoverageReductionModeNV(wine_cmd_buffer_from_handle(params->commandBuffer)->command_buffer, params->coverageReductionMode);
     return STATUS_SUCCESS;
 }

@@ -8824,23 +9418,23 @@ static NTSTATUS thunk32_vkCmdSetDepthCompareOp(void *args)

#if !defined(USE_STRUCT_CONVERSION)

-static NTSTATUS thunk64_vkCmdSetDepthCompareOpEXT(void *args)
+static NTSTATUS thunk64_vkCmdSetCoverageToColorEnableNV(void *args)
 {
-    struct vkCmdSetDepthCompareOpEXT_params *params = args;
-    TRACE("%p, %#x\n", params->commandBuffer, params->depthCompareOp);
+    struct vkCmdSetCoverageToColorEnableNV_params *params = args;
+    TRACE("%p, %u\n", params->commandBuffer, params->coverageToColorEnable);

-    wine_cmd_buffer_from_handle(params->commandBuffer)->device->funcs.p_vkCmdSetDepthCompareOpEXT(wine_cmd_buffer_from_handle(params->commandBuffer)->command_buffer, params->depthCompareOp);
+    wine_cmd_buffer_from_handle(params->commandBuffer)->device->funcs.p_vkCmdSetCoverageToColorEnableNV(wine_cmd_buffer_from_handle(params->commandBuffer)->command_buffer, params->coverageToColorEnable);
     return STATUS_SUCCESS;
 }

#else /* USE_STRUCT_CONVERSION */

-static NTSTATUS thunk32_vkCmdSetDepthCompareOpEXT(void *args)
+static NTSTATUS thunk32_vkCmdSetCoverageToColorEnableNV(void *args)
 {
-    struct vkCmdSetDepthCompareOpEXT_params *params = args;
-    TRACE("%p, %#x\n", params->commandBuffer, params->depthCompareOp);
+    struct vkCmdSetCoverageToColorEnableNV_params *params = args;
+    TRACE("%p, %u\n", params->commandBuffer, params->coverageToColorEnable);

-    wine_cmd_buffer_from_handle(params->commandBuffer)->device->funcs.p_vkCmdSetDepthCompareOpEXT(wine_cmd_buffer_from_handle(params->commandBuffer)->command_buffer, params->depthCompareOp);
+    wine_cmd_buffer_from_handle(params->commandBuffer)->device->funcs.p_vkCmdSetCoverageToColorEnableNV(wine_cmd_buffer_from_handle(params->commandBuffer)->command_buffer, params->coverageToColorEnable);
     return STATUS_SUCCESS;
 }

@@ -8848,23 +9442,23 @@ static NTSTATUS thunk32_vkCmdSetDepthCompareOpEXT(void *args)

#if !defined(USE_STRUCT_CONVERSION)

-static NTSTATUS thunk64_vkCmdSetDepthTestEnable(void *args)
+static NTSTATUS thunk64_vkCmdSetCoverageToColorLocationNV(void *args)
 {
-    struct vkCmdSetDepthTestEnable_params *params = args;
-    TRACE("%p, %u\n", params->commandBuffer, params->depthTestEnable);
+    struct vkCmdSetCoverageToColorLocationNV_params *params = args;
+    TRACE("%p, %u\n", params->commandBuffer, params->coverageToColorLocation);

-    wine_cmd_buffer_from_handle(params->commandBuffer)->device->funcs.p_vkCmdSetDepthTestEnable(wine_cmd_buffer_from_handle(params->commandBuffer)->command_buffer, params->depthTestEnable);
+    wine_cmd_buffer_from_handle(params->commandBuffer)->device->funcs.p_vkCmdSetCoverageToColorLocationNV(wine_cmd_buffer_from_handle(params->commandBuffer)->command_buffer, params->coverageToColorLocation);
     return STATUS_SUCCESS;
 }

#else /* USE_STRUCT_CONVERSION */

-static NTSTATUS thunk32_vkCmdSetDepthTestEnable(void *args)
+static NTSTATUS thunk32_vkCmdSetCoverageToColorLocationNV(void *args)
 {
-    struct vkCmdSetDepthTestEnable_params *params = args;
-    TRACE("%p, %u\n", params->commandBuffer, params->depthTestEnable);
+    struct vkCmdSetCoverageToColorLocationNV_params *params = args;
+    TRACE("%p, %u\n", params->commandBuffer, params->coverageToColorLocation);

-    wine_cmd_buffer_from_handle(params->commandBuffer)->device->funcs.p_vkCmdSetDepthTestEnable(wine_cmd_buffer_from_handle(params->commandBuffer)->command_buffer, params->depthTestEnable);
+    wine_cmd_buffer_from_handle(params->commandBuffer)->device->funcs.p_vkCmdSetCoverageToColorLocationNV(wine_cmd_buffer_from_handle(params->commandBuffer)->command_buffer, params->coverageToColorLocation);
     return STATUS_SUCCESS;
 }

@@ -8872,7 +9466,343 @@ static NTSTATUS thunk32_vkCmdSetDepthTestEnable(void *args)

#if !defined(USE_STRUCT_CONVERSION)

-static NTSTATUS thunk64_vkCmdSetDepthTestEnableEXT(void *args)
+static NTSTATUS thunk64_vkCmdSetCullMode(void *args)
+{
+    struct vkCmdSetCullMode_params *params = args;
+    TRACE("%p, %#x\n", params->commandBuffer, params->cullMode);
+
+    wine_cmd_buffer_from_handle(params->commandBuffer)->device->funcs.p_vkCmdSetCullMode(wine_cmd_buffer_from_handle(params->commandBuffer)->command_buffer, params->cullMode);
+    return STATUS_SUCCESS;
+}
+
+#else /* USE_STRUCT_CONVERSION */
+
+static NTSTATUS thunk32_vkCmdSetCullMode(void *args)
+{
+    struct vkCmdSetCullMode_params *params = args;
+    TRACE("%p, %#x\n", params->commandBuffer, params->cullMode);
+
+    wine_cmd_buffer_from_handle(params->commandBuffer)->device->funcs.p_vkCmdSetCullMode(wine_cmd_buffer_from_handle(params->commandBuffer)->command_buffer, params->cullMode);
+    return STATUS_SUCCESS;
+}
+
+#endif /* USE_STRUCT_CONVERSION */
+
+#if !defined(USE_STRUCT_CONVERSION)
+
+static NTSTATUS thunk64_vkCmdSetCullModeEXT(void *args)
+{
+    struct vkCmdSetCullModeEXT_params *params = args;
+    TRACE("%p, %#x\n", params->commandBuffer, params->cullMode);
+
+    wine_cmd_buffer_from_handle(params->commandBuffer)->device->funcs.p_vkCmdSetCullModeEXT(wine_cmd_buffer_from_handle(params->commandBuffer)->command_buffer, params->cullMode);
+    return STATUS_SUCCESS;
+}
+
+#else /* USE_STRUCT_CONVERSION */
+
+static NTSTATUS thunk32_vkCmdSetCullModeEXT(void *args)
+{
+    struct vkCmdSetCullModeEXT_params *params = args;
+    TRACE("%p, %#x\n", params->commandBuffer, params->cullMode);
+
+    wine_cmd_buffer_from_handle(params->commandBuffer)->device->funcs.p_vkCmdSetCullModeEXT(wine_cmd_buffer_from_handle(params->commandBuffer)->command_buffer, params->cullMode);
+    return STATUS_SUCCESS;
+}
+
+#endif /* USE_STRUCT_CONVERSION */
+
+#if !defined(USE_STRUCT_CONVERSION)
+
+static NTSTATUS thunk64_vkCmdSetDepthBias(void *args)
+{
+    struct vkCmdSetDepthBias_params *params = args;
+    TRACE("%p, %f, %f, %f\n", params->commandBuffer, params->depthBiasConstantFactor, params->depthBiasClamp, params->depthBiasSlopeFactor);
+
+    wine_cmd_buffer_from_handle(params->commandBuffer)->device->funcs.p_vkCmdSetDepthBias(wine_cmd_buffer_from_handle(params->commandBuffer)->command_buffer, params->depthBiasConstantFactor, params->depthBiasClamp, params->depthBiasSlopeFactor);
+    return STATUS_SUCCESS;
+}
+
+#else /* USE_STRUCT_CONVERSION */
+
+static NTSTATUS thunk32_vkCmdSetDepthBias(void *args)
+{
+    struct vkCmdSetDepthBias_params *params = args;
+    TRACE("%p, %f, %f, %f\n", params->commandBuffer, params->depthBiasConstantFactor, params->depthBiasClamp, params->depthBiasSlopeFactor);
+
+    wine_cmd_buffer_from_handle(params->commandBuffer)->device->funcs.p_vkCmdSetDepthBias(wine_cmd_buffer_from_handle(params->commandBuffer)->command_buffer, params->depthBiasConstantFactor, params->depthBiasClamp, params->depthBiasSlopeFactor);
+    return STATUS_SUCCESS;
+}
+
+#endif /* USE_STRUCT_CONVERSION */
+
+#if !defined(USE_STRUCT_CONVERSION)
+
+static NTSTATUS thunk64_vkCmdSetDepthBiasEnable(void *args)
+{
+    struct vkCmdSetDepthBiasEnable_params *params = args;
+    TRACE("%p, %u\n", params->commandBuffer, params->depthBiasEnable);
+
+    wine_cmd_buffer_from_handle(params->commandBuffer)->device->funcs.p_vkCmdSetDepthBiasEnable(wine_cmd_buffer_from_handle(params->commandBuffer)->command_buffer, params->depthBiasEnable);
+    return STATUS_SUCCESS;
+}
+
+#else /* USE_STRUCT_CONVERSION */
+
+static NTSTATUS thunk32_vkCmdSetDepthBiasEnable(void *args)
+{
+    struct vkCmdSetDepthBiasEnable_params *params = args;
+    TRACE("%p, %u\n", params->commandBuffer, params->depthBiasEnable);
+
+    wine_cmd_buffer_from_handle(params->commandBuffer)->device->funcs.p_vkCmdSetDepthBiasEnable(wine_cmd_buffer_from_handle(params->commandBuffer)->command_buffer, params->depthBiasEnable);
+    return STATUS_SUCCESS;
+}
+
+#endif /* USE_STRUCT_CONVERSION */
+
+#if !defined(USE_STRUCT_CONVERSION)
+
+static NTSTATUS thunk64_vkCmdSetDepthBiasEnableEXT(void *args)
+{
+    struct vkCmdSetDepthBiasEnableEXT_params *params = args;
+    TRACE("%p, %u\n", params->commandBuffer, params->depthBiasEnable);
+
+    wine_cmd_buffer_from_handle(params->commandBuffer)->device->funcs.p_vkCmdSetDepthBiasEnableEXT(wine_cmd_buffer_from_handle(params->commandBuffer)->command_buffer, params->depthBiasEnable);
+    return STATUS_SUCCESS;
+}
+
+#else /* USE_STRUCT_CONVERSION */
+
+static NTSTATUS thunk32_vkCmdSetDepthBiasEnableEXT(void *args)
+{
+    struct vkCmdSetDepthBiasEnableEXT_params *params = args;
+    TRACE("%p, %u\n", params->commandBuffer, params->depthBiasEnable);
+
+    wine_cmd_buffer_from_handle(params->commandBuffer)->device->funcs.p_vkCmdSetDepthBiasEnableEXT(wine_cmd_buffer_from_handle(params->commandBuffer)->command_buffer, params->depthBiasEnable);
+    return STATUS_SUCCESS;
+}
+
+#endif /* USE_STRUCT_CONVERSION */
+
+#if !defined(USE_STRUCT_CONVERSION)
+
+static NTSTATUS thunk64_vkCmdSetDepthBounds(void *args)
+{
+    struct vkCmdSetDepthBounds_params *params = args;
+    TRACE("%p, %f, %f\n", params->commandBuffer, params->minDepthBounds, params->maxDepthBounds);
+
+    wine_cmd_buffer_from_handle(params->commandBuffer)->device->funcs.p_vkCmdSetDepthBounds(wine_cmd_buffer_from_handle(params->commandBuffer)->command_buffer, params->minDepthBounds, params->maxDepthBounds);
+    return STATUS_SUCCESS;
+}
+
+#else /* USE_STRUCT_CONVERSION */
+
+static NTSTATUS thunk32_vkCmdSetDepthBounds(void *args)
+{
+    struct vkCmdSetDepthBounds_params *params = args;
+    TRACE("%p, %f, %f\n", params->commandBuffer, params->minDepthBounds, params->maxDepthBounds);
+
+    wine_cmd_buffer_from_handle(params->commandBuffer)->device->funcs.p_vkCmdSetDepthBounds(wine_cmd_buffer_from_handle(params->commandBuffer)->command_buffer, params->minDepthBounds, params->maxDepthBounds);
+    return STATUS_SUCCESS;
+}
+
+#endif /* USE_STRUCT_CONVERSION */
+
+#if !defined(USE_STRUCT_CONVERSION)
+
+static NTSTATUS thunk64_vkCmdSetDepthBoundsTestEnable(void *args)
+{
+    struct vkCmdSetDepthBoundsTestEnable_params *params = args;
+    TRACE("%p, %u\n", params->commandBuffer, params->depthBoundsTestEnable);
+
+    wine_cmd_buffer_from_handle(params->commandBuffer)->device->funcs.p_vkCmdSetDepthBoundsTestEnable(wine_cmd_buffer_from_handle(params->commandBuffer)->command_buffer, params->depthBoundsTestEnable);
+    return STATUS_SUCCESS;
+}
+
+#else /* USE_STRUCT_CONVERSION */
+
+static NTSTATUS thunk32_vkCmdSetDepthBoundsTestEnable(void *args)
+{
+    struct vkCmdSetDepthBoundsTestEnable_params *params = args;
+    TRACE("%p, %u\n", params->commandBuffer, params->depthBoundsTestEnable);
+
+    wine_cmd_buffer_from_handle(params->commandBuffer)->device->funcs.p_vkCmdSetDepthBoundsTestEnable(wine_cmd_buffer_from_handle(params->commandBuffer)->command_buffer, params->depthBoundsTestEnable);
+    return STATUS_SUCCESS;
+}
+
+#endif /* USE_STRUCT_CONVERSION */
+
+#if !defined(USE_STRUCT_CONVERSION)
+
+static NTSTATUS thunk64_vkCmdSetDepthBoundsTestEnableEXT(void *args)
+{
+    struct vkCmdSetDepthBoundsTestEnableEXT_params *params = args;
+    TRACE("%p, %u\n", params->commandBuffer, params->depthBoundsTestEnable);
+
+    wine_cmd_buffer_from_handle(params->commandBuffer)->device->funcs.p_vkCmdSetDepthBoundsTestEnableEXT(wine_cmd_buffer_from_handle(params->commandBuffer)->command_buffer, params->depthBoundsTestEnable);
+    return STATUS_SUCCESS;
+}
+
+#else /* USE_STRUCT_CONVERSION */
+
+static NTSTATUS thunk32_vkCmdSetDepthBoundsTestEnableEXT(void *args)
+{
+    struct vkCmdSetDepthBoundsTestEnableEXT_params *params = args;
+    TRACE("%p, %u\n", params->commandBuffer, params->depthBoundsTestEnable);
+
+    wine_cmd_buffer_from_handle(params->commandBuffer)->device->funcs.p_vkCmdSetDepthBoundsTestEnableEXT(wine_cmd_buffer_from_handle(params->commandBuffer)->command_buffer, params->depthBoundsTestEnable);
+    return STATUS_SUCCESS;
+}
+
+#endif /* USE_STRUCT_CONVERSION */
+
+#if !defined(USE_STRUCT_CONVERSION)
+
+static NTSTATUS thunk64_vkCmdSetDepthClampEnableEXT(void *args)
+{
+    struct vkCmdSetDepthClampEnableEXT_params *params = args;
+    TRACE("%p, %u\n", params->commandBuffer, params->depthClampEnable);
+
+    wine_cmd_buffer_from_handle(params->commandBuffer)->device->funcs.p_vkCmdSetDepthClampEnableEXT(wine_cmd_buffer_from_handle(params->commandBuffer)->command_buffer, params->depthClampEnable);
+    return STATUS_SUCCESS;
+}
+
+#else /* USE_STRUCT_CONVERSION */
+
+static NTSTATUS thunk32_vkCmdSetDepthClampEnableEXT(void *args)
+{
+    struct vkCmdSetDepthClampEnableEXT_params *params = args;
+    TRACE("%p, %u\n", params->commandBuffer, params->depthClampEnable);
+
+    wine_cmd_buffer_from_handle(params->commandBuffer)->device->funcs.p_vkCmdSetDepthClampEnableEXT(wine_cmd_buffer_from_handle(params->commandBuffer)->command_buffer, params->depthClampEnable);
+    return STATUS_SUCCESS;
+}
+
+#endif /* USE_STRUCT_CONVERSION */
+
+#if !defined(USE_STRUCT_CONVERSION)
+
+static NTSTATUS thunk64_vkCmdSetDepthClipEnableEXT(void *args)
+{
+    struct vkCmdSetDepthClipEnableEXT_params *params = args;
+    TRACE("%p, %u\n", params->commandBuffer, params->depthClipEnable);
+
+    wine_cmd_buffer_from_handle(params->commandBuffer)->device->funcs.p_vkCmdSetDepthClipEnableEXT(wine_cmd_buffer_from_handle(params->commandBuffer)->command_buffer, params->depthClipEnable);
+    return STATUS_SUCCESS;
+}
+
+#else /* USE_STRUCT_CONVERSION */
+
+static NTSTATUS thunk32_vkCmdSetDepthClipEnableEXT(void *args)
+{
+    struct vkCmdSetDepthClipEnableEXT_params *params = args;
+    TRACE("%p, %u\n", params->commandBuffer, params->depthClipEnable);
+
+    wine_cmd_buffer_from_handle(params->commandBuffer)->device->funcs.p_vkCmdSetDepthClipEnableEXT(wine_cmd_buffer_from_handle(params->commandBuffer)->command_buffer, params->depthClipEnable);
+    return STATUS_SUCCESS;
+}
+
+#endif /* USE_STRUCT_CONVERSION */
+
+#if !defined(USE_STRUCT_CONVERSION)
+
+static NTSTATUS thunk64_vkCmdSetDepthClipNegativeOneToOneEXT(void *args)
+{
+    struct vkCmdSetDepthClipNegativeOneToOneEXT_params *params = args;
+    TRACE("%p, %u\n", params->commandBuffer, params->negativeOneToOne);
+
+    wine_cmd_buffer_from_handle(params->commandBuffer)->device->funcs.p_vkCmdSetDepthClipNegativeOneToOneEXT(wine_cmd_buffer_from_handle(params->commandBuffer)->command_buffer, params->negativeOneToOne);
+    return STATUS_SUCCESS;
+}
+
+#else /* USE_STRUCT_CONVERSION */
+
+static NTSTATUS thunk32_vkCmdSetDepthClipNegativeOneToOneEXT(void *args)
+{
+    struct vkCmdSetDepthClipNegativeOneToOneEXT_params *params = args;
+    TRACE("%p, %u\n", params->commandBuffer, params->negativeOneToOne);
+
+    wine_cmd_buffer_from_handle(params->commandBuffer)->device->funcs.p_vkCmdSetDepthClipNegativeOneToOneEXT(wine_cmd_buffer_from_handle(params->commandBuffer)->command_buffer, params->negativeOneToOne);
+    return STATUS_SUCCESS;
+}
+
+#endif /* USE_STRUCT_CONVERSION */
+
+#if !defined(USE_STRUCT_CONVERSION)
+
+static NTSTATUS thunk64_vkCmdSetDepthCompareOp(void *args)
+{
+    struct vkCmdSetDepthCompareOp_params *params = args;
+    TRACE("%p, %#x\n", params->commandBuffer, params->depthCompareOp);
+
+    wine_cmd_buffer_from_handle(params->commandBuffer)->device->funcs.p_vkCmdSetDepthCompareOp(wine_cmd_buffer_from_handle(params->commandBuffer)->command_buffer, params->depthCompareOp);
+    return STATUS_SUCCESS;
+}
+
+#else /* USE_STRUCT_CONVERSION */
+
+static NTSTATUS thunk32_vkCmdSetDepthCompareOp(void *args)
+{
+    struct vkCmdSetDepthCompareOp_params *params = args;
+    TRACE("%p, %#x\n", params->commandBuffer, params->depthCompareOp);
+
+    wine_cmd_buffer_from_handle(params->commandBuffer)->device->funcs.p_vkCmdSetDepthCompareOp(wine_cmd_buffer_from_handle(params->commandBuffer)->command_buffer, params->depthCompareOp);
+    return STATUS_SUCCESS;
+}
+
+#endif /* USE_STRUCT_CONVERSION */
+
+#if !defined(USE_STRUCT_CONVERSION)
+
+static NTSTATUS thunk64_vkCmdSetDepthCompareOpEXT(void *args)
+{
+    struct vkCmdSetDepthCompareOpEXT_params *params = args;
+    TRACE("%p, %#x\n", params->commandBuffer, params->depthCompareOp);
+
+    wine_cmd_buffer_from_handle(params->commandBuffer)->device->funcs.p_vkCmdSetDepthCompareOpEXT(wine_cmd_buffer_from_handle(params->commandBuffer)->command_buffer, params->depthCompareOp);
+    return STATUS_SUCCESS;
+}
+
+#else /* USE_STRUCT_CONVERSION */
+
+static NTSTATUS thunk32_vkCmdSetDepthCompareOpEXT(void *args)
+{
+    struct vkCmdSetDepthCompareOpEXT_params *params = args;
+    TRACE("%p, %#x\n", params->commandBuffer, params->depthCompareOp);
+
+    wine_cmd_buffer_from_handle(params->commandBuffer)->device->funcs.p_vkCmdSetDepthCompareOpEXT(wine_cmd_buffer_from_handle(params->commandBuffer)->command_buffer, params->depthCompareOp);
+    return STATUS_SUCCESS;
+}
+
+#endif /* USE_STRUCT_CONVERSION */
+
+#if !defined(USE_STRUCT_CONVERSION)
+
+static NTSTATUS thunk64_vkCmdSetDepthTestEnable(void *args)
+{
+    struct vkCmdSetDepthTestEnable_params *params = args;
+    TRACE("%p, %u\n", params->commandBuffer, params->depthTestEnable);
+
+    wine_cmd_buffer_from_handle(params->commandBuffer)->device->funcs.p_vkCmdSetDepthTestEnable(wine_cmd_buffer_from_handle(params->commandBuffer)->command_buffer, params->depthTestEnable);
+    return STATUS_SUCCESS;
+}
+
+#else /* USE_STRUCT_CONVERSION */
+
+static NTSTATUS thunk32_vkCmdSetDepthTestEnable(void *args)
+{
+    struct vkCmdSetDepthTestEnable_params *params = args;
+    TRACE("%p, %u\n", params->commandBuffer, params->depthTestEnable);
+
+    wine_cmd_buffer_from_handle(params->commandBuffer)->device->funcs.p_vkCmdSetDepthTestEnable(wine_cmd_buffer_from_handle(params->commandBuffer)->command_buffer, params->depthTestEnable);
+    return STATUS_SUCCESS;
+}
+
+#endif /* USE_STRUCT_CONVERSION */
+
+#if !defined(USE_STRUCT_CONVERSION)
+
+static NTSTATUS thunk64_vkCmdSetDepthTestEnableEXT(void *args)
 {
     struct vkCmdSetDepthTestEnableEXT_params *params = args;
     TRACE("%p, %u\n", params->commandBuffer, params->depthTestEnable);
@@ -9118,6 +10048,30 @@ static NTSTATUS thunk32_vkCmdSetExclusiveScissorNV(void *args)

#if !defined(USE_STRUCT_CONVERSION)

+static NTSTATUS thunk64_vkCmdSetExtraPrimitiveOverestimationSizeEXT(void *args)
+{
+    struct vkCmdSetExtraPrimitiveOverestimationSizeEXT_params *params = args;
+    TRACE("%p, %f\n", params->commandBuffer, params->extraPrimitiveOverestimationSize);
+
+    wine_cmd_buffer_from_handle(params->commandBuffer)->device->funcs.p_vkCmdSetExtraPrimitiveOverestimationSizeEXT(wine_cmd_buffer_from_handle(params->commandBuffer)->command_buffer, params->extraPrimitiveOverestimationSize);
+    return STATUS_SUCCESS;
+}
+
+#else /* USE_STRUCT_CONVERSION */
+
+static NTSTATUS thunk32_vkCmdSetExtraPrimitiveOverestimationSizeEXT(void *args)
+{
+    struct vkCmdSetExtraPrimitiveOverestimationSizeEXT_params *params = args;
+    TRACE("%p, %f\n", params->commandBuffer, params->extraPrimitiveOverestimationSize);
+
+    wine_cmd_buffer_from_handle(params->commandBuffer)->device->funcs.p_vkCmdSetExtraPrimitiveOverestimationSizeEXT(wine_cmd_buffer_from_handle(params->commandBuffer)->command_buffer, params->extraPrimitiveOverestimationSize);
+    return STATUS_SUCCESS;
+}
+
+#endif /* USE_STRUCT_CONVERSION */
+
+#if !defined(USE_STRUCT_CONVERSION)
+
 static NTSTATUS thunk64_vkCmdSetFragmentShadingRateEnumNV(void *args)
 {
     struct vkCmdSetFragmentShadingRateEnumNV_params *params = args;
@@ -9214,6 +10168,30 @@ static NTSTATUS thunk32_vkCmdSetFrontFaceEXT(void *args)

#if !defined(USE_STRUCT_CONVERSION)

+static NTSTATUS thunk64_vkCmdSetLineRasterizationModeEXT(void *args)
+{
+    struct vkCmdSetLineRasterizationModeEXT_params *params = args;
+    TRACE("%p, %#x\n", params->commandBuffer, params->lineRasterizationMode);
+
+    wine_cmd_buffer_from_handle(params->commandBuffer)->device->funcs.p_vkCmdSetLineRasterizationModeEXT(wine_cmd_buffer_from_handle(params->commandBuffer)->command_buffer, params->lineRasterizationMode);
+    return STATUS_SUCCESS;
+}
+
+#else /* USE_STRUCT_CONVERSION */
+
+static NTSTATUS thunk32_vkCmdSetLineRasterizationModeEXT(void *args)
+{
+    struct vkCmdSetLineRasterizationModeEXT_params *params = args;
+    TRACE("%p, %#x\n", params->commandBuffer, params->lineRasterizationMode);
+
+    wine_cmd_buffer_from_handle(params->commandBuffer)->device->funcs.p_vkCmdSetLineRasterizationModeEXT(wine_cmd_buffer_from_handle(params->commandBuffer)->command_buffer, params->lineRasterizationMode);
+    return STATUS_SUCCESS;
+}
+
+#endif /* USE_STRUCT_CONVERSION */
+
+#if !defined(USE_STRUCT_CONVERSION)
+
 static NTSTATUS thunk64_vkCmdSetLineStippleEXT(void *args)
 {
     struct vkCmdSetLineStippleEXT_params *params = args;
@@ -9238,6 +10216,30 @@ static NTSTATUS thunk32_vkCmdSetLineStippleEXT(void *args)

#if !defined(USE_STRUCT_CONVERSION)

+static NTSTATUS thunk64_vkCmdSetLineStippleEnableEXT(void *args)
+{
+    struct vkCmdSetLineStippleEnableEXT_params *params = args;
+    TRACE("%p, %u\n", params->commandBuffer, params->stippledLineEnable);
+
+    wine_cmd_buffer_from_handle(params->commandBuffer)->device->funcs.p_vkCmdSetLineStippleEnableEXT(wine_cmd_buffer_from_handle(params->commandBuffer)->command_buffer, params->stippledLineEnable);
+    return STATUS_SUCCESS;
+}
+
+#else /* USE_STRUCT_CONVERSION */
+
+static NTSTATUS thunk32_vkCmdSetLineStippleEnableEXT(void *args)
+{
+    struct vkCmdSetLineStippleEnableEXT_params *params = args;
+    TRACE("%p, %u\n", params->commandBuffer, params->stippledLineEnable);
+
+    wine_cmd_buffer_from_handle(params->commandBuffer)->device->funcs.p_vkCmdSetLineStippleEnableEXT(wine_cmd_buffer_from_handle(params->commandBuffer)->command_buffer, params->stippledLineEnable);
+    return STATUS_SUCCESS;
+}
+
+#endif /* USE_STRUCT_CONVERSION */
+
+#if !defined(USE_STRUCT_CONVERSION)
+
 static NTSTATUS thunk64_vkCmdSetLineWidth(void *args)
 {
     struct vkCmdSetLineWidth_params *params = args;
@@ -9286,6 +10288,30 @@ static NTSTATUS thunk32_vkCmdSetLogicOpEXT(void *args)

#if !defined(USE_STRUCT_CONVERSION)

+static NTSTATUS thunk64_vkCmdSetLogicOpEnableEXT(void *args)
+{
+    struct vkCmdSetLogicOpEnableEXT_params *params = args;
+    TRACE("%p, %u\n", params->commandBuffer, params->logicOpEnable);
+
+    wine_cmd_buffer_from_handle(params->commandBuffer)->device->funcs.p_vkCmdSetLogicOpEnableEXT(wine_cmd_buffer_from_handle(params->commandBuffer)->command_buffer, params->logicOpEnable);
+    return STATUS_SUCCESS;
+}
+
+#else /* USE_STRUCT_CONVERSION */
+
+static NTSTATUS thunk32_vkCmdSetLogicOpEnableEXT(void *args)
+{
+    struct vkCmdSetLogicOpEnableEXT_params *params = args;
+    TRACE("%p, %u\n", params->commandBuffer, params->logicOpEnable);
+
+    wine_cmd_buffer_from_handle(params->commandBuffer)->device->funcs.p_vkCmdSetLogicOpEnableEXT(wine_cmd_buffer_from_handle(params->commandBuffer)->command_buffer, params->logicOpEnable);
+    return STATUS_SUCCESS;
+}
+
+#endif /* USE_STRUCT_CONVERSION */
+
+#if !defined(USE_STRUCT_CONVERSION)
+
 static NTSTATUS thunk64_vkCmdSetPatchControlPointsEXT(void *args)
 {
     struct vkCmdSetPatchControlPointsEXT_params *params = args;
@@ -9386,6 +10412,30 @@ static NTSTATUS thunk32_vkCmdSetPerformanceStreamMarkerINTEL(void *args)

#if !defined(USE_STRUCT_CONVERSION)

+static NTSTATUS thunk64_vkCmdSetPolygonModeEXT(void *args)
+{
+    struct vkCmdSetPolygonModeEXT_params *params = args;
+    TRACE("%p, %#x\n", params->commandBuffer, params->polygonMode);
+
+    wine_cmd_buffer_from_handle(params->commandBuffer)->device->funcs.p_vkCmdSetPolygonModeEXT(wine_cmd_buffer_from_handle(params->commandBuffer)->command_buffer, params->polygonMode);
+    return STATUS_SUCCESS;
+}
+
+#else /* USE_STRUCT_CONVERSION */
+
+static NTSTATUS thunk32_vkCmdSetPolygonModeEXT(void *args)
+{
+    struct vkCmdSetPolygonModeEXT_params *params = args;
+    TRACE("%p, %#x\n", params->commandBuffer, params->polygonMode);
+
+    wine_cmd_buffer_from_handle(params->commandBuffer)->device->funcs.p_vkCmdSetPolygonModeEXT(wine_cmd_buffer_from_handle(params->commandBuffer)->command_buffer, params->polygonMode);
+    return STATUS_SUCCESS;
+}
+
+#endif /* USE_STRUCT_CONVERSION */
+
+#if !defined(USE_STRUCT_CONVERSION)
+
 static NTSTATUS thunk64_vkCmdSetPrimitiveRestartEnable(void *args)
 {
     struct vkCmdSetPrimitiveRestartEnable_params *params = args;
@@ -9482,6 +10532,78 @@ static NTSTATUS thunk32_vkCmdSetPrimitiveTopologyEXT(void *args)

#if !defined(USE_STRUCT_CONVERSION)

+static NTSTATUS thunk64_vkCmdSetProvokingVertexModeEXT(void *args)
+{
+    struct vkCmdSetProvokingVertexModeEXT_params *params = args;
+    TRACE("%p, %#x\n", params->commandBuffer, params->provokingVertexMode);
+
+    wine_cmd_buffer_from_handle(params->commandBuffer)->device->funcs.p_vkCmdSetProvokingVertexModeEXT(wine_cmd_buffer_from_handle(params->commandBuffer)->command_buffer, params->provokingVertexMode);
+    return STATUS_SUCCESS;
+}
+
+#else /* USE_STRUCT_CONVERSION */
+
+static NTSTATUS thunk32_vkCmdSetProvokingVertexModeEXT(void *args)
+{
+    struct vkCmdSetProvokingVertexModeEXT_params *params = args;
+    TRACE("%p, %#x\n", params->commandBuffer, params->provokingVertexMode);
+
+    wine_cmd_buffer_from_handle(params->commandBuffer)->device->funcs.p_vkCmdSetProvokingVertexModeEXT(wine_cmd_buffer_from_handle(params->commandBuffer)->command_buffer, params->provokingVertexMode);
+    return STATUS_SUCCESS;
+}
+
+#endif /* USE_STRUCT_CONVERSION */
+
+#if !defined(USE_STRUCT_CONVERSION)
+
+static NTSTATUS thunk64_vkCmdSetRasterizationSamplesEXT(void *args)
+{
+    struct vkCmdSetRasterizationSamplesEXT_params *params = args;
+    TRACE("%p, %#x\n", params->commandBuffer, params->rasterizationSamples);
+
+    wine_cmd_buffer_from_handle(params->commandBuffer)->device->funcs.p_vkCmdSetRasterizationSamplesEXT(wine_cmd_buffer_from_handle(params->commandBuffer)->command_buffer, params->rasterizationSamples);
+    return STATUS_SUCCESS;
+}
+
+#else /* USE_STRUCT_CONVERSION */
+
+static NTSTATUS thunk32_vkCmdSetRasterizationSamplesEXT(void *args)
+{
+    struct vkCmdSetRasterizationSamplesEXT_params *params = args;
+    TRACE("%p, %#x\n", params->commandBuffer, params->rasterizationSamples);
+
+    wine_cmd_buffer_from_handle(params->commandBuffer)->device->funcs.p_vkCmdSetRasterizationSamplesEXT(wine_cmd_buffer_from_handle(params->commandBuffer)->command_buffer, params->rasterizationSamples);
+    return STATUS_SUCCESS;
+}
+
+#endif /* USE_STRUCT_CONVERSION */
+
+#if !defined(USE_STRUCT_CONVERSION)
+
+static NTSTATUS thunk64_vkCmdSetRasterizationStreamEXT(void *args)
+{
+    struct vkCmdSetRasterizationStreamEXT_params *params = args;
+    TRACE("%p, %u\n", params->commandBuffer, params->rasterizationStream);
+
+    wine_cmd_buffer_from_handle(params->commandBuffer)->device->funcs.p_vkCmdSetRasterizationStreamEXT(wine_cmd_buffer_from_handle(params->commandBuffer)->command_buffer, params->rasterizationStream);
+    return STATUS_SUCCESS;
+}
+
+#else /* USE_STRUCT_CONVERSION */
+
+static NTSTATUS thunk32_vkCmdSetRasterizationStreamEXT(void *args)
+{
+    struct vkCmdSetRasterizationStreamEXT_params *params = args;
+    TRACE("%p, %u\n", params->commandBuffer, params->rasterizationStream);
+
+    wine_cmd_buffer_from_handle(params->commandBuffer)->device->funcs.p_vkCmdSetRasterizationStreamEXT(wine_cmd_buffer_from_handle(params->commandBuffer)->command_buffer, params->rasterizationStream);
+    return STATUS_SUCCESS;
+}
+
+#endif /* USE_STRUCT_CONVERSION */
+
+#if !defined(USE_STRUCT_CONVERSION)
+
 static NTSTATUS thunk64_vkCmdSetRasterizerDiscardEnable(void *args)
 {
     struct vkCmdSetRasterizerDiscardEnable_params *params = args;
@@ -9554,6 +10676,30 @@ static NTSTATUS thunk32_vkCmdSetRayTracingPipelineStackSizeKHR(void *args)

#if !defined(USE_STRUCT_CONVERSION)

+static NTSTATUS thunk64_vkCmdSetRepresentativeFragmentTestEnableNV(void *args)
+{
+    struct vkCmdSetRepresentativeFragmentTestEnableNV_params *params = args;
+    TRACE("%p, %u\n", params->commandBuffer, params->representativeFragmentTestEnable);
+
+    wine_cmd_buffer_from_handle(params->commandBuffer)->device->funcs.p_vkCmdSetRepresentativeFragmentTestEnableNV(wine_cmd_buffer_from_handle(params->commandBuffer)->command_buffer, params->representativeFragmentTestEnable);
+    return STATUS_SUCCESS;
+}
+
+#else /* USE_STRUCT_CONVERSION */
+
+static NTSTATUS thunk32_vkCmdSetRepresentativeFragmentTestEnableNV(void *args)
+{
+    struct vkCmdSetRepresentativeFragmentTestEnableNV_params *params = args;
+    TRACE("%p, %u\n", params->commandBuffer, params->representativeFragmentTestEnable);
+
+    wine_cmd_buffer_from_handle(params->commandBuffer)->device->funcs.p_vkCmdSetRepresentativeFragmentTestEnableNV(wine_cmd_buffer_from_handle(params->commandBuffer)->command_buffer, params->representativeFragmentTestEnable);
+    return STATUS_SUCCESS;
+}
+
+#endif /* USE_STRUCT_CONVERSION */
+
+#if !defined(USE_STRUCT_CONVERSION)
+
 static NTSTATUS thunk64_vkCmdSetSampleLocationsEXT(void *args)
 {
     struct vkCmdSetSampleLocationsEXT_params *params = args;
@@ -9578,6 +10724,54 @@ static NTSTATUS thunk32_vkCmdSetSampleLocationsEXT(void *args)

#if !defined(USE_STRUCT_CONVERSION)

+static NTSTATUS thunk64_vkCmdSetSampleLocationsEnableEXT(void *args)
+{
+    struct vkCmdSetSampleLocationsEnableEXT_params *params = args;
+    TRACE("%p, %u\n", params->commandBuffer, params->sampleLocationsEnable);
+
+    wine_cmd_buffer_from_handle(params->commandBuffer)->device->funcs.p_vkCmdSetSampleLocationsEnableEXT(wine_cmd_buffer_from_handle(params->commandBuffer)->command_buffer, params->sampleLocationsEnable);
+    return STATUS_SUCCESS;
+}
+
+#else /* USE_STRUCT_CONVERSION */
+
+static NTSTATUS thunk32_vkCmdSetSampleLocationsEnableEXT(void *args)
+{
+    struct vkCmdSetSampleLocationsEnableEXT_params *params = args;
+    TRACE("%p, %u\n", params->commandBuffer, params->sampleLocationsEnable);
+
+    wine_cmd_buffer_from_handle(params->commandBuffer)->device->funcs.p_vkCmdSetSampleLocationsEnableEXT(wine_cmd_buffer_from_handle(params->commandBuffer)->command_buffer, params->sampleLocationsEnable);
+    return STATUS_SUCCESS;
+}
+
+#endif /* USE_STRUCT_CONVERSION */
+
+#if !defined(USE_STRUCT_CONVERSION)
+
+static NTSTATUS thunk64_vkCmdSetSampleMaskEXT(void *args)
+{
+    struct vkCmdSetSampleMaskEXT_params *params = args;
+    TRACE("%p, %#x, %p\n", params->commandBuffer, params->samples, params->pSampleMask);
+
+    wine_cmd_buffer_from_handle(params->commandBuffer)->device->funcs.p_vkCmdSetSampleMaskEXT(wine_cmd_buffer_from_handle(params->commandBuffer)->command_buffer, params->samples, params->pSampleMask);
+    return STATUS_SUCCESS;
+}
+
+#else /* USE_STRUCT_CONVERSION */
+
+static NTSTATUS thunk32_vkCmdSetSampleMaskEXT(void *args)
+{
+    struct vkCmdSetSampleMaskEXT_params *params = args;
+    TRACE("%p, %#x, %p\n", params->commandBuffer, params->samples, params->pSampleMask);
+
+    wine_cmd_buffer_from_handle(params->commandBuffer)->device->funcs.p_vkCmdSetSampleMaskEXT(wine_cmd_buffer_from_handle(params->commandBuffer)->command_buffer, params->samples, params->pSampleMask);
+    return STATUS_SUCCESS;
+}
+
+#endif /* USE_STRUCT_CONVERSION */
+
+#if !defined(USE_STRUCT_CONVERSION)
+
 static NTSTATUS thunk64_vkCmdSetScissor(void *args)
 {
     struct vkCmdSetScissor_params *params = args;
@@ -9650,6 +10844,30 @@ static NTSTATUS thunk32_vkCmdSetScissorWithCountEXT(void *args)

#if !defined(USE_STRUCT_CONVERSION)

+static NTSTATUS thunk64_vkCmdSetShadingRateImageEnableNV(void *args)
+{
+    struct vkCmdSetShadingRateImageEnableNV_params *params = args;
+    TRACE("%p, %u\n", params->commandBuffer, params->shadingRateImageEnable);
+
+    wine_cmd_buffer_from_handle(params->commandBuffer)->device->funcs.p_vkCmdSetShadingRateImageEnableNV(wine_cmd_buffer_from_handle(params->commandBuffer)->command_buffer, params->shadingRateImageEnable);
+    return STATUS_SUCCESS;
+}
+
+#else /* USE_STRUCT_CONVERSION */
+
+static NTSTATUS thunk32_vkCmdSetShadingRateImageEnableNV(void *args)
+{
+    struct vkCmdSetShadingRateImageEnableNV_params *params = args;
+    TRACE("%p, %u\n", params->commandBuffer, params->shadingRateImageEnable);
+
+    wine_cmd_buffer_from_handle(params->commandBuffer)->device->funcs.p_vkCmdSetShadingRateImageEnableNV(wine_cmd_buffer_from_handle(params->commandBuffer)->command_buffer, params->shadingRateImageEnable);
+    return STATUS_SUCCESS;
+}
+
+#endif /* USE_STRUCT_CONVERSION */
+
+#if !defined(USE_STRUCT_CONVERSION)
+
 static NTSTATUS thunk64_vkCmdSetStencilCompareMask(void *args)
 {
     struct vkCmdSetStencilCompareMask_params *params = args;
@@ -9794,23 +11012,47 @@ static NTSTATUS thunk32_vkCmdSetStencilTestEnableEXT(void *args)

#if !defined(USE_STRUCT_CONVERSION)

-static NTSTATUS thunk64_vkCmdSetStencilWriteMask(void *args)
+static NTSTATUS thunk64_vkCmdSetStencilWriteMask(void *args)
+{
+    struct vkCmdSetStencilWriteMask_params *params = args;
+    TRACE("%p, %#x, %u\n", params->commandBuffer, params->faceMask, params->writeMask);
+
+    wine_cmd_buffer_from_handle(params->commandBuffer)->device->funcs.p_vkCmdSetStencilWriteMask(wine_cmd_buffer_from_handle(params->commandBuffer)->command_buffer, params->faceMask, params->writeMask);
+    return STATUS_SUCCESS;
+}
+
+#else /* USE_STRUCT_CONVERSION */
+
+static NTSTATUS thunk32_vkCmdSetStencilWriteMask(void *args)
+{
+    struct vkCmdSetStencilWriteMask_params *params = args;
+    TRACE("%p, %#x, %u\n", params->commandBuffer, params->faceMask, params->writeMask);
+
+    wine_cmd_buffer_from_handle(params->commandBuffer)->device->funcs.p_vkCmdSetStencilWriteMask(wine_cmd_buffer_from_handle(params->commandBuffer)->command_buffer, params->faceMask, params->writeMask);
+    return STATUS_SUCCESS;
+}
+
+#endif /* USE_STRUCT_CONVERSION */
+
+#if !defined(USE_STRUCT_CONVERSION)
+
+static NTSTATUS thunk64_vkCmdSetTessellationDomainOriginEXT(void *args)
 {
-    struct vkCmdSetStencilWriteMask_params *params = args;
-    TRACE("%p, %#x, %u\n", params->commandBuffer, params->faceMask, params->writeMask);
+    struct vkCmdSetTessellationDomainOriginEXT_params *params = args;
+    TRACE("%p, %#x\n", params->commandBuffer, params->domainOrigin);

-    wine_cmd_buffer_from_handle(params->commandBuffer)->device->funcs.p_vkCmdSetStencilWriteMask(wine_cmd_buffer_from_handle(params->commandBuffer)->command_buffer, params->faceMask, params->writeMask);
+    wine_cmd_buffer_from_handle(params->commandBuffer)->device->funcs.p_vkCmdSetTessellationDomainOriginEXT(wine_cmd_buffer_from_handle(params->commandBuffer)->command_buffer, params->domainOrigin);
     return STATUS_SUCCESS;
 }

#else /* USE_STRUCT_CONVERSION */

-static NTSTATUS thunk32_vkCmdSetStencilWriteMask(void *args)
+static NTSTATUS thunk32_vkCmdSetTessellationDomainOriginEXT(void *args)
 {
-    struct vkCmdSetStencilWriteMask_params *params = args;
-    TRACE("%p, %#x, %u\n", params->commandBuffer, params->faceMask, params->writeMask);
+    struct vkCmdSetTessellationDomainOriginEXT_params *params = args;
+    TRACE("%p, %#x\n", params->commandBuffer, params->domainOrigin);

-    wine_cmd_buffer_from_handle(params->commandBuffer)->device->funcs.p_vkCmdSetStencilWriteMask(wine_cmd_buffer_from_handle(params->commandBuffer)->command_buffer, params->faceMask, params->writeMask);
+    wine_cmd_buffer_from_handle(params->commandBuffer)->device->funcs.p_vkCmdSetTessellationDomainOriginEXT(wine_cmd_buffer_from_handle(params->commandBuffer)->command_buffer, params->domainOrigin);
     return STATUS_SUCCESS;
 }

@@ -9890,6 +11132,54 @@ static NTSTATUS thunk32_vkCmdSetViewportShadingRatePaletteNV(void *args)

#if !defined(USE_STRUCT_CONVERSION)

+static NTSTATUS thunk64_vkCmdSetViewportSwizzleNV(void *args)
+{
+    struct vkCmdSetViewportSwizzleNV_params *params = args;
+    TRACE("%p, %u, %u, %p\n", params->commandBuffer, params->firstViewport, params->viewportCount, params->pViewportSwizzles);
+
+    wine_cmd_buffer_from_handle(params->commandBuffer)->device->funcs.p_vkCmdSetViewportSwizzleNV(wine_cmd_buffer_from_handle(params->commandBuffer)->command_buffer, params->firstViewport, params->viewportCount, params->pViewportSwizzles);
+    return STATUS_SUCCESS;
+}
+
+#else /* USE_STRUCT_CONVERSION */
+
+static NTSTATUS thunk32_vkCmdSetViewportSwizzleNV(void *args)
+{
+    struct vkCmdSetViewportSwizzleNV_params *params = args;
+    TRACE("%p, %u, %u, %p\n", params->commandBuffer, params->firstViewport, params->viewportCount, params->pViewportSwizzles);
+
+    wine_cmd_buffer_from_handle(params->commandBuffer)->device->funcs.p_vkCmdSetViewportSwizzleNV(wine_cmd_buffer_from_handle(params->commandBuffer)->command_buffer, params->firstViewport, params->viewportCount, params->pViewportSwizzles);
+    return STATUS_SUCCESS;
+}
+
+#endif /* USE_STRUCT_CONVERSION */
+
+#if !defined(USE_STRUCT_CONVERSION)
+
+static NTSTATUS thunk64_vkCmdSetViewportWScalingEnableNV(void *args)
+{
+    struct vkCmdSetViewportWScalingEnableNV_params *params = args;
+    TRACE("%p, %u\n", params->commandBuffer, params->viewportWScalingEnable);
+
+    wine_cmd_buffer_from_handle(params->commandBuffer)->device->funcs.p_vkCmdSetViewportWScalingEnableNV(wine_cmd_buffer_from_handle(params->commandBuffer)->command_buffer, params->viewportWScalingEnable);
+    return STATUS_SUCCESS;
+}
+
+#else /* USE_STRUCT_CONVERSION */
+
+static NTSTATUS thunk32_vkCmdSetViewportWScalingEnableNV(void *args)
+{
+    struct vkCmdSetViewportWScalingEnableNV_params *params = args;
+    TRACE("%p, %u\n", params->commandBuffer, params->viewportWScalingEnable);
+
+    wine_cmd_buffer_from_handle(params->commandBuffer)->device->funcs.p_vkCmdSetViewportWScalingEnableNV(wine_cmd_buffer_from_handle(params->commandBuffer)->command_buffer, params->viewportWScalingEnable);
+    return STATUS_SUCCESS;
+}
+
+#endif /* USE_STRUCT_CONVERSION */
+
+#if !defined(USE_STRUCT_CONVERSION)
+
 static NTSTATUS thunk64_vkCmdSetViewportWScalingNV(void *args)
 {
     struct vkCmdSetViewportWScalingNV_params *params = args;
@@ -10302,6 +11592,30 @@ static NTSTATUS thunk32_vkCmdWriteBufferMarkerAMD(void *args)

#if !defined(USE_STRUCT_CONVERSION)

+static NTSTATUS thunk64_vkCmdWriteMicromapsPropertiesEXT(void *args)
+{
+    struct vkCmdWriteMicromapsPropertiesEXT_params *params = args;
+    TRACE("%p, %u, %p, %#x, 0x%s, %u\n", params->commandBuffer, params->micromapCount, params->pMicromaps, params->queryType, wine_dbgstr_longlong(params->queryPool), params->firstQuery);
+
+    wine_cmd_buffer_from_handle(params->commandBuffer)->device->funcs.p_vkCmdWriteMicromapsPropertiesEXT(wine_cmd_buffer_from_handle(params->commandBuffer)->command_buffer, params->micromapCount, params->pMicromaps, params->queryType, params->queryPool, params->firstQuery);
+    return STATUS_SUCCESS;
+}
+
+#else /* USE_STRUCT_CONVERSION */
+
+static NTSTATUS thunk32_vkCmdWriteMicromapsPropertiesEXT(void *args)
+{
+    struct vkCmdWriteMicromapsPropertiesEXT_params *params = args;
+    TRACE("%p, %u, %p, %#x, 0x%s, %u\n", params->commandBuffer, params->micromapCount, params->pMicromaps, params->queryType, wine_dbgstr_longlong(params->queryPool), params->firstQuery);
+
+    wine_cmd_buffer_from_handle(params->commandBuffer)->device->funcs.p_vkCmdWriteMicromapsPropertiesEXT(wine_cmd_buffer_from_handle(params->commandBuffer)->command_buffer, params->micromapCount, params->pMicromaps, params->queryType, params->queryPool, params->firstQuery);
+    return STATUS_SUCCESS;
+}
+
+#endif /* USE_STRUCT_CONVERSION */
+
+#if !defined(USE_STRUCT_CONVERSION)
+
 static NTSTATUS thunk64_vkCmdWriteTimestamp(void *args)
 {
     struct vkCmdWriteTimestamp_params *params = args;
@@ -10476,6 +11790,84 @@ static NTSTATUS thunk32_vkCopyMemoryToAccelerationStructureKHR(void *args)

#if !defined(USE_STRUCT_CONVERSION)

+static NTSTATUS thunk64_vkCopyMemoryToMicromapEXT(void *args)
+{
+    struct vkCopyMemoryToMicromapEXT_params *params = args;
+    TRACE("%p, 0x%s, %p\n", params->device, wine_dbgstr_longlong(params->deferredOperation), params->pInfo);
+
+    params->result = wine_device_from_handle(params->device)->funcs.p_vkCopyMemoryToMicromapEXT(wine_device_from_handle(params->device)->device, params->deferredOperation, params->pInfo);
+    return STATUS_SUCCESS;
+}
+
+#else /* USE_STRUCT_CONVERSION */
+
+static NTSTATUS thunk32_vkCopyMemoryToMicromapEXT(void *args)
+{
+    struct vkCopyMemoryToMicromapEXT_params *params = args;
+    VkCopyMemoryToMicromapInfoEXT_host pInfo_host;
+    TRACE("%p, 0x%s, %p\n", params->device, wine_dbgstr_longlong(params->deferredOperation), params->pInfo);
+
+    convert_VkCopyMemoryToMicromapInfoEXT_win32_to_host(params->pInfo, &pInfo_host);
+    params->result = wine_device_from_handle(params->device)->funcs.p_vkCopyMemoryToMicromapEXT(wine_device_from_handle(params->device)->device, params->deferredOperation, &pInfo_host);
+    return STATUS_SUCCESS;
+}
+
+#endif /* USE_STRUCT_CONVERSION */
+
+#if !defined(USE_STRUCT_CONVERSION)
+
+static NTSTATUS thunk64_vkCopyMicromapEXT(void *args)
+{
+    struct vkCopyMicromapEXT_params *params = args;
+    TRACE("%p, 0x%s, %p\n", params->device, wine_dbgstr_longlong(params->deferredOperation), params->pInfo);
+
+    params->result = wine_device_from_handle(params->device)->funcs.p_vkCopyMicromapEXT(wine_device_from_handle(params->device)->device, params->deferredOperation, params->pInfo);
+    return STATUS_SUCCESS;
+}
+
+#else /* USE_STRUCT_CONVERSION */
+
+static NTSTATUS thunk32_vkCopyMicromapEXT(void *args)
+{
+    struct vkCopyMicromapEXT_params *params = args;
+    VkCopyMicromapInfoEXT_host pInfo_host;
+    TRACE("%p, 0x%s, %p\n", params->device, wine_dbgstr_longlong(params->deferredOperation), params->pInfo);
+
+    convert_VkCopyMicromapInfoEXT_win32_to_host(params->pInfo, &pInfo_host);
+    params->result = wine_device_from_handle(params->device)->funcs.p_vkCopyMicromapEXT(wine_device_from_handle(params->device)->device, params->deferredOperation, &pInfo_host);
+    return STATUS_SUCCESS;
+}
+
+#endif /* USE_STRUCT_CONVERSION */
+
+#if !defined(USE_STRUCT_CONVERSION)
+
+static NTSTATUS thunk64_vkCopyMicromapToMemoryEXT(void *args)
+{
+    struct vkCopyMicromapToMemoryEXT_params *params = args;
+    TRACE("%p, 0x%s, %p\n", params->device, wine_dbgstr_longlong(params->deferredOperation), params->pInfo);
+
+    params->result = wine_device_from_handle(params->device)->funcs.p_vkCopyMicromapToMemoryEXT(wine_device_from_handle(params->device)->device, params->deferredOperation, params->pInfo);
+    return STATUS_SUCCESS;
+}
+
+#else /* USE_STRUCT_CONVERSION */
+
+static NTSTATUS thunk32_vkCopyMicromapToMemoryEXT(void *args)
+{
+    struct vkCopyMicromapToMemoryEXT_params *params = args;
+    VkCopyMicromapToMemoryInfoEXT_host pInfo_host;
+    TRACE("%p, 0x%s, %p\n", params->device, wine_dbgstr_longlong(params->deferredOperation), params->pInfo);
+
+    convert_VkCopyMicromapToMemoryInfoEXT_win32_to_host(params->pInfo, &pInfo_host);
+    params->result = wine_device_from_handle(params->device)->funcs.p_vkCopyMicromapToMemoryEXT(wine_device_from_handle(params->device)->device, params->deferredOperation, &pInfo_host);
+    return STATUS_SUCCESS;
+}
+
+#endif /* USE_STRUCT_CONVERSION */
+
+#if !defined(USE_STRUCT_CONVERSION)
+
 static NTSTATUS thunk64_vkCreateAccelerationStructureKHR(void *args)
 {
     struct vkCreateAccelerationStructureKHR_params *params = args;
@@ -11107,6 +12499,56 @@ static NTSTATUS thunk32_vkCreateInstance(void *args)

#if !defined(USE_STRUCT_CONVERSION)

+static NTSTATUS thunk64_vkCreateMicromapEXT(void *args)
+{
+    struct vkCreateMicromapEXT_params *params = args;
+    TRACE("%p, %p, %p, %p\n", params->device, params->pCreateInfo, params->pAllocator, params->pMicromap);
+
+    params->result = wine_device_from_handle(params->device)->funcs.p_vkCreateMicromapEXT(wine_device_from_handle(params->device)->device, params->pCreateInfo, NULL, params->pMicromap);
+    return STATUS_SUCCESS;
+}
+
+#else /* USE_STRUCT_CONVERSION */
+
+static NTSTATUS thunk32_vkCreateMicromapEXT(void *args)
+{
+    struct vkCreateMicromapEXT_params *params = args;
+    VkMicromapCreateInfoEXT_host pCreateInfo_host;
+    TRACE("%p, %p, %p, %p\n", params->device, params->pCreateInfo, params->pAllocator, params->pMicromap);
+
+    convert_VkMicromapCreateInfoEXT_win32_to_host(params->pCreateInfo, &pCreateInfo_host);
+    params->result = wine_device_from_handle(params->device)->funcs.p_vkCreateMicromapEXT(wine_device_from_handle(params->device)->device, &pCreateInfo_host, NULL, params->pMicromap);
+    return STATUS_SUCCESS;
+}
+
+#endif /* USE_STRUCT_CONVERSION */
+
+#if !defined(USE_STRUCT_CONVERSION)
+
+static NTSTATUS thunk64_vkCreateOpticalFlowSessionNV(void *args)
+{
+    struct vkCreateOpticalFlowSessionNV_params *params = args;
+    TRACE("%p, %p, %p, %p\n", params->device, params->pCreateInfo, params->pAllocator, params->pSession);
+
+    params->result = wine_device_from_handle(params->device)->funcs.p_vkCreateOpticalFlowSessionNV(wine_device_from_handle(params->device)->device, params->pCreateInfo, NULL, params->pSession);
+    return STATUS_SUCCESS;
+}
+
+#else /* USE_STRUCT_CONVERSION */
+
+static NTSTATUS thunk32_vkCreateOpticalFlowSessionNV(void *args)
+{
+    struct vkCreateOpticalFlowSessionNV_params *params = args;
+    TRACE("%p, %p, %p, %p\n", params->device, params->pCreateInfo, params->pAllocator, params->pSession);
+
+    params->result = wine_device_from_handle(params->device)->funcs.p_vkCreateOpticalFlowSessionNV(wine_device_from_handle(params->device)->device, params->pCreateInfo, NULL, params->pSession);
+    return STATUS_SUCCESS;
+}
+
+#endif /* USE_STRUCT_CONVERSION */
+
+#if !defined(USE_STRUCT_CONVERSION)
+
 static NTSTATUS thunk64_vkCreatePipelineCache(void *args)
 {
     struct vkCreatePipelineCache_params *params = args;
@@ -12209,6 +13651,54 @@ static NTSTATUS thunk32_vkDestroyInstance(void *args)

#if !defined(USE_STRUCT_CONVERSION)

+static NTSTATUS thunk64_vkDestroyMicromapEXT(void *args)
+{
+    struct vkDestroyMicromapEXT_params *params = args;
+    TRACE("%p, 0x%s, %p\n", params->device, wine_dbgstr_longlong(params->micromap), params->pAllocator);
+
+    wine_device_from_handle(params->device)->funcs.p_vkDestroyMicromapEXT(wine_device_from_handle(params->device)->device, params->micromap, NULL);
+    return STATUS_SUCCESS;
+}
+
+#else /* USE_STRUCT_CONVERSION */
+
+static NTSTATUS thunk32_vkDestroyMicromapEXT(void *args)
+{
+    struct vkDestroyMicromapEXT_params *params = args;
+    TRACE("%p, 0x%s, %p\n", params->device, wine_dbgstr_longlong(params->micromap), params->pAllocator);
+
+    wine_device_from_handle(params->device)->funcs.p_vkDestroyMicromapEXT(wine_device_from_handle(params->device)->device, params->micromap, NULL);
+    return STATUS_SUCCESS;
+}
+
+#endif /* USE_STRUCT_CONVERSION */
+
+#if !defined(USE_STRUCT_CONVERSION)
+
+static NTSTATUS thunk64_vkDestroyOpticalFlowSessionNV(void *args)
+{
+    struct vkDestroyOpticalFlowSessionNV_params *params = args;
+    TRACE("%p, 0x%s, %p\n", params->device, wine_dbgstr_longlong(params->session), params->pAllocator);
+
+    wine_device_from_handle(params->device)->funcs.p_vkDestroyOpticalFlowSessionNV(wine_device_from_handle(params->device)->device, params->session, NULL);
+    return STATUS_SUCCESS;
+}
+
+#else /* USE_STRUCT_CONVERSION */
+
+static NTSTATUS thunk32_vkDestroyOpticalFlowSessionNV(void *args)
+{
+    struct vkDestroyOpticalFlowSessionNV_params *params = args;
+    TRACE("%p, 0x%s, %p\n", params->device, wine_dbgstr_longlong(params->session), params->pAllocator);
+
+    wine_device_from_handle(params->device)->funcs.p_vkDestroyOpticalFlowSessionNV(wine_device_from_handle(params->device)->device, params->session, NULL);
+    return STATUS_SUCCESS;
+}
+
+#endif /* USE_STRUCT_CONVERSION */
+
+#if !defined(USE_STRUCT_CONVERSION)
+
 static NTSTATUS thunk64_vkDestroyPipeline(void *args)
 {
     struct vkDestroyPipeline_params *params = args;
@@ -13483,6 +14973,35 @@ static NTSTATUS thunk32_vkGetDeviceBufferMemoryRequirementsKHR(void *args)

#if !defined(USE_STRUCT_CONVERSION)

+static NTSTATUS thunk64_vkGetDeviceFaultInfoEXT(void *args)
+{
+    struct vkGetDeviceFaultInfoEXT_params *params = args;
+    TRACE("%p, %p, %p\n", params->device, params->pFaultCounts, params->pFaultInfo);
+
+    params->result = wine_device_from_handle(params->device)->funcs.p_vkGetDeviceFaultInfoEXT(wine_device_from_handle(params->device)->device, params->pFaultCounts, params->pFaultInfo);
+    return STATUS_SUCCESS;
+}
+
+#else /* USE_STRUCT_CONVERSION */
+
+static NTSTATUS thunk32_vkGetDeviceFaultInfoEXT(void *args)
+{
+    struct vkGetDeviceFaultInfoEXT_params *params = args;
+    VkDeviceFaultCountsEXT_host pFaultCounts_host;
+    VkDeviceFaultInfoEXT_host pFaultInfo_host;
+    TRACE("%p, %p, %p\n", params->device, params->pFaultCounts, params->pFaultInfo);
+
+    convert_VkDeviceFaultCountsEXT_win32_to_host(params->pFaultCounts, &pFaultCounts_host);
+    convert_VkDeviceFaultInfoEXT_win32_to_host(params->pFaultInfo, &pFaultInfo_host);
+    params->result = wine_device_from_handle(params->device)->funcs.p_vkGetDeviceFaultInfoEXT(wine_device_from_handle(params->device)->device, &pFaultCounts_host, &pFaultInfo_host);
+    free_VkDeviceFaultInfoEXT(&pFaultInfo_host);
+    return STATUS_SUCCESS;
+}
+
+#endif /* USE_STRUCT_CONVERSION */
+
+#if !defined(USE_STRUCT_CONVERSION)
+
 static NTSTATUS thunk64_vkGetDeviceGroupPeerMemoryFeatures(void *args)
 {
     struct vkGetDeviceGroupPeerMemoryFeatures_params *params = args;
@@ -13757,6 +15276,30 @@ static NTSTATUS thunk32_vkGetDeviceMemoryOpaqueCaptureAddressKHR(void *args)

#if !defined(USE_STRUCT_CONVERSION)

+static NTSTATUS thunk64_vkGetDeviceMicromapCompatibilityEXT(void *args)
+{
+    struct vkGetDeviceMicromapCompatibilityEXT_params *params = args;
+    TRACE("%p, %p, %p\n", params->device, params->pVersionInfo, params->pCompatibility);
+
+    wine_device_from_handle(params->device)->funcs.p_vkGetDeviceMicromapCompatibilityEXT(wine_device_from_handle(params->device)->device, params->pVersionInfo, params->pCompatibility);
+    return STATUS_SUCCESS;
+}
+
+#else /* USE_STRUCT_CONVERSION */
+
+static NTSTATUS thunk32_vkGetDeviceMicromapCompatibilityEXT(void *args)
+{
+    struct vkGetDeviceMicromapCompatibilityEXT_params *params = args;
+    TRACE("%p, %p, %p\n", params->device, params->pVersionInfo, params->pCompatibility);
+
+    wine_device_from_handle(params->device)->funcs.p_vkGetDeviceMicromapCompatibilityEXT(wine_device_from_handle(params->device)->device, params->pVersionInfo, params->pCompatibility);
+    return STATUS_SUCCESS;
+}
+
+#endif /* USE_STRUCT_CONVERSION */
+
+#if !defined(USE_STRUCT_CONVERSION)
+
 static NTSTATUS thunk64_vkGetDeviceQueue(void *args)
 {
     struct vkGetDeviceQueue_params *params = args;
@@ -14247,6 +15790,34 @@ static NTSTATUS thunk32_vkGetMemoryHostPointerPropertiesEXT(void *args)

#if !defined(USE_STRUCT_CONVERSION)

+static NTSTATUS thunk64_vkGetMicromapBuildSizesEXT(void *args)
+{
+    struct vkGetMicromapBuildSizesEXT_params *params = args;
+    TRACE("%p, %#x, %p, %p\n", params->device, params->buildType, params->pBuildInfo, params->pSizeInfo);
+
+    wine_device_from_handle(params->device)->funcs.p_vkGetMicromapBuildSizesEXT(wine_device_from_handle(params->device)->device, params->buildType, params->pBuildInfo, params->pSizeInfo);
+    return STATUS_SUCCESS;
+}
+
+#else /* USE_STRUCT_CONVERSION */
+
+static NTSTATUS thunk32_vkGetMicromapBuildSizesEXT(void *args)
+{
+    struct vkGetMicromapBuildSizesEXT_params *params = args;
+    VkMicromapBuildInfoEXT_host pBuildInfo_host;
+    VkMicromapBuildSizesInfoEXT_host pSizeInfo_host;
+    TRACE("%p, %#x, %p, %p\n", params->device, params->buildType, params->pBuildInfo, params->pSizeInfo);
+
+    convert_VkMicromapBuildInfoEXT_win32_to_host(params->pBuildInfo, &pBuildInfo_host);
+    convert_VkMicromapBuildSizesInfoEXT_win32_to_host(params->pSizeInfo, &pSizeInfo_host);
+    wine_device_from_handle(params->device)->funcs.p_vkGetMicromapBuildSizesEXT(wine_device_from_handle(params->device)->device, params->buildType, &pBuildInfo_host, &pSizeInfo_host);
+    return STATUS_SUCCESS;
+}
+
+#endif /* USE_STRUCT_CONVERSION */
+
+#if !defined(USE_STRUCT_CONVERSION)
+
 static NTSTATUS thunk64_vkGetPerformanceParameterINTEL(void *args)
 {
     struct vkGetPerformanceParameterINTEL_params *params = args;
@@ -14843,6 +16414,30 @@ static NTSTATUS thunk32_vkGetPhysicalDeviceMultisamplePropertiesEXT(void *args)

#if !defined(USE_STRUCT_CONVERSION)

+static NTSTATUS thunk64_vkGetPhysicalDeviceOpticalFlowImageFormatsNV(void *args)
+{
+    struct vkGetPhysicalDeviceOpticalFlowImageFormatsNV_params *params = args;
+    TRACE("%p, %p, %p, %p\n", params->physicalDevice, params->pOpticalFlowImageFormatInfo, params->pFormatCount, params->pImageFormatProperties);
+
+    params->result = wine_phys_dev_from_handle(params->physicalDevice)->instance->funcs.p_vkGetPhysicalDeviceOpticalFlowImageFormatsNV(wine_phys_dev_from_handle(params->physicalDevice)->phys_dev, params->pOpticalFlowImageFormatInfo, params->pFormatCount, params->pImageFormatProperties);
+    return STATUS_SUCCESS;
+}
+
+#else /* USE_STRUCT_CONVERSION */
+
+static NTSTATUS thunk32_vkGetPhysicalDeviceOpticalFlowImageFormatsNV(void *args)
+{
+    struct vkGetPhysicalDeviceOpticalFlowImageFormatsNV_params *params = args;
+    TRACE("%p, %p, %p, %p\n", params->physicalDevice, params->pOpticalFlowImageFormatInfo, params->pFormatCount, params->pImageFormatProperties);
+
+    params->result = wine_phys_dev_from_handle(params->physicalDevice)->instance->funcs.p_vkGetPhysicalDeviceOpticalFlowImageFormatsNV(wine_phys_dev_from_handle(params->physicalDevice)->phys_dev, params->pOpticalFlowImageFormatInfo, params->pFormatCount, params->pImageFormatProperties);
+    return STATUS_SUCCESS;
+}
+
+#endif /* USE_STRUCT_CONVERSION */
+
+#if !defined(USE_STRUCT_CONVERSION)
+
 static NTSTATUS thunk64_vkGetPhysicalDevicePresentRectanglesKHR(void *args)
 {
     struct vkGetPhysicalDevicePresentRectanglesKHR_params *params = args;
@@ -17053,6 +18648,30 @@ static NTSTATUS thunk32_vkWriteAccelerationStructuresPropertiesKHR(void *args)

#endif /* USE_STRUCT_CONVERSION */

+#if !defined(USE_STRUCT_CONVERSION)
+
+static NTSTATUS thunk64_vkWriteMicromapsPropertiesEXT(void *args)
+{
+    struct vkWriteMicromapsPropertiesEXT_params *params = args;
+    TRACE("%p, %u, %p, %#x, 0x%s, %p, 0x%s\n", params->device, params->micromapCount, params->pMicromaps, params->queryType, wine_dbgstr_longlong(params->dataSize), params->pData, wine_dbgstr_longlong(params->stride));
+
+    params->result = wine_device_from_handle(params->device)->funcs.p_vkWriteMicromapsPropertiesEXT(wine_device_from_handle(params->device)->device, params->micromapCount, params->pMicromaps, params->queryType, params->dataSize, params->pData, params->stride);
+    return STATUS_SUCCESS;
+}
+
+#else /* USE_STRUCT_CONVERSION */
+
+static NTSTATUS thunk32_vkWriteMicromapsPropertiesEXT(void *args)
+{
+    struct vkWriteMicromapsPropertiesEXT_params *params = args;
+    TRACE("%p, %u, %p, %#x, 0x%s, %p, 0x%s\n", params->device, params->micromapCount, params->pMicromaps, params->queryType, wine_dbgstr_longlong(params->dataSize), params->pData, wine_dbgstr_longlong(params->stride));
+
+    params->result = wine_device_from_handle(params->device)->funcs.p_vkWriteMicromapsPropertiesEXT(wine_device_from_handle(params->device)->device, params->micromapCount, params->pMicromaps, params->queryType, params->dataSize, params->pData, params->stride);
+    return STATUS_SUCCESS;
+}
+
+#endif /* USE_STRUCT_CONVERSION */
+
 static const char * const vk_device_extensions[] =
 {
     "VK_AMD_buffer_marker",
@@ -17094,9 +18713,12 @@ static const char * const vk_device_extensions[] =
     "VK_EXT_depth_clip_enable",
     "VK_EXT_depth_range_unrestricted",
     "VK_EXT_descriptor_indexing",
+    "VK_EXT_device_address_binding_report",
+    "VK_EXT_device_fault",
     "VK_EXT_discard_rectangles",
     "VK_EXT_extended_dynamic_state",
     "VK_EXT_extended_dynamic_state2",
+    "VK_EXT_extended_dynamic_state3",
     "VK_EXT_external_memory_host",
     "VK_EXT_filter_cubic",
     "VK_EXT_fragment_density_map",
@@ -17123,11 +18745,13 @@ static const char * const vk_device_extensions[] =
     "VK_EXT_multisampled_render_to_single_sampled",
     "VK_EXT_mutable_descriptor_type",
     "VK_EXT_non_seamless_cube_map",
+    "VK_EXT_opacity_micromap",
     "VK_EXT_pageable_device_local_memory",
     "VK_EXT_pci_bus_info",
     "VK_EXT_pipeline_creation_cache_control",
     "VK_EXT_pipeline_creation_feedback",
     "VK_EXT_pipeline_properties",
+    "VK_EXT_pipeline_protected_access",
     "VK_EXT_pipeline_robustness",
     "VK_EXT_post_depth_coverage",
     "VK_EXT_primitive_topology_list_restart",
@@ -17258,6 +18882,8 @@ static const char * const vk_device_extensions[] =
     "VK_NV_inherited_viewport_scissor",
     "VK_NV_linear_color_attachment",
     "VK_NV_mesh_shader",
+    "VK_NV_optical_flow",
+    "VK_NV_present_barrier",
     "VK_NV_ray_tracing",
     "VK_NV_ray_tracing_motion_blur",
     "VK_NV_representative_fragment_test",
@@ -17383,7 +19009,9 @@ const unixlib_entry_t __wine_unix_call_funcs[] =
     thunk64_vkBindImageMemory,
     thunk64_vkBindImageMemory2,
     thunk64_vkBindImageMemory2KHR,
+    thunk64_vkBindOpticalFlowSessionImageNV,
     thunk64_vkBuildAccelerationStructuresKHR,
+    thunk64_vkBuildMicromapsEXT,
     thunk64_vkCmdBeginConditionalRenderingEXT,
     thunk64_vkCmdBeginDebugUtilsLabelEXT,
     thunk64_vkCmdBeginQuery,
@@ -17410,6 +19038,7 @@ const unixlib_entry_t __wine_unix_call_funcs[] =
     thunk64_vkCmdBuildAccelerationStructureNV,
     thunk64_vkCmdBuildAccelerationStructuresIndirectKHR,
     thunk64_vkCmdBuildAccelerationStructuresKHR,
+    thunk64_vkCmdBuildMicromapsEXT,
     thunk64_vkCmdClearAttachments,
     thunk64_vkCmdClearColorImage,
     thunk64_vkCmdClearDepthStencilImage,
@@ -17429,6 +19058,9 @@ const unixlib_entry_t __wine_unix_call_funcs[] =
     thunk64_vkCmdCopyImageToBuffer2,
     thunk64_vkCmdCopyImageToBuffer2KHR,
     thunk64_vkCmdCopyMemoryToAccelerationStructureKHR,
+    thunk64_vkCmdCopyMemoryToMicromapEXT,
+    thunk64_vkCmdCopyMicromapEXT,
+    thunk64_vkCmdCopyMicromapToMemoryEXT,
     thunk64_vkCmdCopyQueryPoolResults,
     thunk64_vkCmdCuLaunchKernelNVX,
     thunk64_vkCmdDebugMarkerBeginEXT,
@@ -17474,6 +19106,7 @@ const unixlib_entry_t __wine_unix_call_funcs[] =
     thunk64_vkCmdNextSubpass,
     thunk64_vkCmdNextSubpass2,
     thunk64_vkCmdNextSubpass2KHR,
+    thunk64_vkCmdOpticalFlowExecuteNV,
     thunk64_vkCmdPipelineBarrier,
     thunk64_vkCmdPipelineBarrier2,
     thunk64_vkCmdPipelineBarrier2KHR,
@@ -17488,10 +19121,23 @@ const unixlib_entry_t __wine_unix_call_funcs[] =
     thunk64_vkCmdResolveImage,
     thunk64_vkCmdResolveImage2,
     thunk64_vkCmdResolveImage2KHR,
+    thunk64_vkCmdSetAlphaToCoverageEnableEXT,
+    thunk64_vkCmdSetAlphaToOneEnableEXT,
     thunk64_vkCmdSetBlendConstants,
     thunk64_vkCmdSetCheckpointNV,
     thunk64_vkCmdSetCoarseSampleOrderNV,
+    thunk64_vkCmdSetColorBlendAdvancedEXT,
+    thunk64_vkCmdSetColorBlendEnableEXT,
+    thunk64_vkCmdSetColorBlendEquationEXT,
     thunk64_vkCmdSetColorWriteEnableEXT,
+    thunk64_vkCmdSetColorWriteMaskEXT,
+    thunk64_vkCmdSetConservativeRasterizationModeEXT,
+    thunk64_vkCmdSetCoverageModulationModeNV,
+    thunk64_vkCmdSetCoverageModulationTableEnableNV,
+    thunk64_vkCmdSetCoverageModulationTableNV,
+    thunk64_vkCmdSetCoverageReductionModeNV,
+    thunk64_vkCmdSetCoverageToColorEnableNV,
+    thunk64_vkCmdSetCoverageToColorLocationNV,
     thunk64_vkCmdSetCullMode,
     thunk64_vkCmdSetCullModeEXT,
     thunk64_vkCmdSetDepthBias,
@@ -17500,6 +19146,9 @@ const unixlib_entry_t __wine_unix_call_funcs[] =
     thunk64_vkCmdSetDepthBounds,
     thunk64_vkCmdSetDepthBoundsTestEnable,
     thunk64_vkCmdSetDepthBoundsTestEnableEXT,
+    thunk64_vkCmdSetDepthClampEnableEXT,
+    thunk64_vkCmdSetDepthClipEnableEXT,
+    thunk64_vkCmdSetDepthClipNegativeOneToOneEXT,
     thunk64_vkCmdSetDepthCompareOp,
     thunk64_vkCmdSetDepthCompareOpEXT,
     thunk64_vkCmdSetDepthTestEnable,
@@ -17513,28 +19162,40 @@ const unixlib_entry_t __wine_unix_call_funcs[] =
     thunk64_vkCmdSetEvent2,
     thunk64_vkCmdSetEvent2KHR,
     thunk64_vkCmdSetExclusiveScissorNV,
+    thunk64_vkCmdSetExtraPrimitiveOverestimationSizeEXT,
     thunk64_vkCmdSetFragmentShadingRateEnumNV,
     thunk64_vkCmdSetFragmentShadingRateKHR,
     thunk64_vkCmdSetFrontFace,
     thunk64_vkCmdSetFrontFaceEXT,
+    thunk64_vkCmdSetLineRasterizationModeEXT,
     thunk64_vkCmdSetLineStippleEXT,
+    thunk64_vkCmdSetLineStippleEnableEXT,
     thunk64_vkCmdSetLineWidth,
     thunk64_vkCmdSetLogicOpEXT,
+    thunk64_vkCmdSetLogicOpEnableEXT,
     thunk64_vkCmdSetPatchControlPointsEXT,
     thunk64_vkCmdSetPerformanceMarkerINTEL,
     thunk64_vkCmdSetPerformanceOverrideINTEL,
     thunk64_vkCmdSetPerformanceStreamMarkerINTEL,
+    thunk64_vkCmdSetPolygonModeEXT,
     thunk64_vkCmdSetPrimitiveRestartEnable,
     thunk64_vkCmdSetPrimitiveRestartEnableEXT,
     thunk64_vkCmdSetPrimitiveTopology,
     thunk64_vkCmdSetPrimitiveTopologyEXT,
+    thunk64_vkCmdSetProvokingVertexModeEXT,
+    thunk64_vkCmdSetRasterizationSamplesEXT,
+    thunk64_vkCmdSetRasterizationStreamEXT,
     thunk64_vkCmdSetRasterizerDiscardEnable,
     thunk64_vkCmdSetRasterizerDiscardEnableEXT,
     thunk64_vkCmdSetRayTracingPipelineStackSizeKHR,
+    thunk64_vkCmdSetRepresentativeFragmentTestEnableNV,
     thunk64_vkCmdSetSampleLocationsEXT,
+    thunk64_vkCmdSetSampleLocationsEnableEXT,
+    thunk64_vkCmdSetSampleMaskEXT,
     thunk64_vkCmdSetScissor,
     thunk64_vkCmdSetScissorWithCount,
     thunk64_vkCmdSetScissorWithCountEXT,
+    thunk64_vkCmdSetShadingRateImageEnableNV,
     thunk64_vkCmdSetStencilCompareMask,
     thunk64_vkCmdSetStencilOp,
     thunk64_vkCmdSetStencilOpEXT,
@@ -17542,9 +19203,12 @@ const unixlib_entry_t __wine_unix_call_funcs[] =
     thunk64_vkCmdSetStencilTestEnable,
     thunk64_vkCmdSetStencilTestEnableEXT,
     thunk64_vkCmdSetStencilWriteMask,
+    thunk64_vkCmdSetTessellationDomainOriginEXT,
     thunk64_vkCmdSetVertexInputEXT,
     thunk64_vkCmdSetViewport,
     thunk64_vkCmdSetViewportShadingRatePaletteNV,
+    thunk64_vkCmdSetViewportSwizzleNV,
+    thunk64_vkCmdSetViewportWScalingEnableNV,
     thunk64_vkCmdSetViewportWScalingNV,
     thunk64_vkCmdSetViewportWithCount,
     thunk64_vkCmdSetViewportWithCountEXT,
@@ -17561,6 +19225,7 @@ const unixlib_entry_t __wine_unix_call_funcs[] =
     thunk64_vkCmdWriteAccelerationStructuresPropertiesNV,
     thunk64_vkCmdWriteBufferMarker2AMD,
     thunk64_vkCmdWriteBufferMarkerAMD,
+    thunk64_vkCmdWriteMicromapsPropertiesEXT,
     thunk64_vkCmdWriteTimestamp,
     thunk64_vkCmdWriteTimestamp2,
     thunk64_vkCmdWriteTimestamp2KHR,
@@ -17568,6 +19233,9 @@ const unixlib_entry_t __wine_unix_call_funcs[] =
     thunk64_vkCopyAccelerationStructureKHR,
     thunk64_vkCopyAccelerationStructureToMemoryKHR,
     thunk64_vkCopyMemoryToAccelerationStructureKHR,
+    thunk64_vkCopyMemoryToMicromapEXT,
+    thunk64_vkCopyMicromapEXT,
+    thunk64_vkCopyMicromapToMemoryEXT,
     thunk64_vkCreateAccelerationStructureKHR,
     thunk64_vkCreateAccelerationStructureNV,
     thunk64_vkCreateBuffer,
@@ -17592,6 +19260,8 @@ const unixlib_entry_t __wine_unix_call_funcs[] =
     thunk64_vkCreateImageView,
     thunk64_vkCreateIndirectCommandsLayoutNV,
     thunk64_vkCreateInstance,
+    thunk64_vkCreateMicromapEXT,
+    thunk64_vkCreateOpticalFlowSessionNV,
     thunk64_vkCreatePipelineCache,
     thunk64_vkCreatePipelineLayout,
     thunk64_vkCreatePrivateDataSlot,
@@ -17636,6 +19306,8 @@ const unixlib_entry_t __wine_unix_call_funcs[] =
     thunk64_vkDestroyImageView,
     thunk64_vkDestroyIndirectCommandsLayoutNV,
     thunk64_vkDestroyInstance,
+    thunk64_vkDestroyMicromapEXT,
+    thunk64_vkDestroyOpticalFlowSessionNV,
     thunk64_vkDestroyPipeline,
     thunk64_vkDestroyPipelineCache,
     thunk64_vkDestroyPipelineLayout,
@@ -17687,6 +19359,7 @@ const unixlib_entry_t __wine_unix_call_funcs[] =
     thunk64_vkGetDeviceAccelerationStructureCompatibilityKHR,
     thunk64_vkGetDeviceBufferMemoryRequirements,
     thunk64_vkGetDeviceBufferMemoryRequirementsKHR,
+    thunk64_vkGetDeviceFaultInfoEXT,
     thunk64_vkGetDeviceGroupPeerMemoryFeatures,
     thunk64_vkGetDeviceGroupPeerMemoryFeaturesKHR,
     thunk64_vkGetDeviceGroupPresentCapabilitiesKHR,
@@ -17698,6 +19371,7 @@ const unixlib_entry_t __wine_unix_call_funcs[] =
     thunk64_vkGetDeviceMemoryCommitment,
     thunk64_vkGetDeviceMemoryOpaqueCaptureAddress,
     thunk64_vkGetDeviceMemoryOpaqueCaptureAddressKHR,
+    thunk64_vkGetDeviceMicromapCompatibilityEXT,
     thunk64_vkGetDeviceQueue,
     thunk64_vkGetDeviceQueue2,
     thunk64_vkGetDeviceSubpassShadingMaxWorkgroupSizeHUAWEI,
@@ -17717,6 +19391,7 @@ const unixlib_entry_t __wine_unix_call_funcs[] =
     thunk64_vkGetImageViewAddressNVX,
     thunk64_vkGetImageViewHandleNVX,
     thunk64_vkGetMemoryHostPointerPropertiesEXT,
+    thunk64_vkGetMicromapBuildSizesEXT,
     thunk64_vkGetPerformanceParameterINTEL,
     thunk64_vkGetPhysicalDeviceCalibrateableTimeDomainsEXT,
     thunk64_vkGetPhysicalDeviceCooperativeMatrixPropertiesNV,
@@ -17740,6 +19415,7 @@ const unixlib_entry_t __wine_unix_call_funcs[] =
     thunk64_vkGetPhysicalDeviceMemoryProperties2,
     thunk64_vkGetPhysicalDeviceMemoryProperties2KHR,
     thunk64_vkGetPhysicalDeviceMultisamplePropertiesEXT,
+    thunk64_vkGetPhysicalDeviceOpticalFlowImageFormatsNV,
     thunk64_vkGetPhysicalDevicePresentRectanglesKHR,
     thunk64_vkGetPhysicalDeviceProperties,
     thunk64_vkGetPhysicalDeviceProperties2,
@@ -17828,6 +19504,7 @@ const unixlib_entry_t __wine_unix_call_funcs[] =
     thunk64_vkWaitSemaphores,
     thunk64_vkWaitSemaphoresKHR,
     thunk64_vkWriteAccelerationStructuresPropertiesKHR,
+    thunk64_vkWriteMicromapsPropertiesEXT,
 };
 C_ASSERT(ARRAYSIZE(__wine_unix_call_funcs) == unix_count);

@@ -17853,7 +19530,9 @@ const unixlib_entry_t __wine_unix_call_funcs[] =
     thunk32_vkBindImageMemory,
     thunk32_vkBindImageMemory2,
     thunk32_vkBindImageMemory2KHR,
+    thunk32_vkBindOpticalFlowSessionImageNV,
     thunk32_vkBuildAccelerationStructuresKHR,
+    thunk32_vkBuildMicromapsEXT,
     thunk32_vkCmdBeginConditionalRenderingEXT,
     thunk32_vkCmdBeginDebugUtilsLabelEXT,
     thunk32_vkCmdBeginQuery,
@@ -17880,6 +19559,7 @@ const unixlib_entry_t __wine_unix_call_funcs[] =
     thunk32_vkCmdBuildAccelerationStructureNV,
     thunk32_vkCmdBuildAccelerationStructuresIndirectKHR,
     thunk32_vkCmdBuildAccelerationStructuresKHR,
+    thunk32_vkCmdBuildMicromapsEXT,
     thunk32_vkCmdClearAttachments,
     thunk32_vkCmdClearColorImage,
     thunk32_vkCmdClearDepthStencilImage,
@@ -17899,6 +19579,9 @@ const unixlib_entry_t __wine_unix_call_funcs[] =
     thunk32_vkCmdCopyImageToBuffer2,
     thunk32_vkCmdCopyImageToBuffer2KHR,
     thunk32_vkCmdCopyMemoryToAccelerationStructureKHR,
+    thunk32_vkCmdCopyMemoryToMicromapEXT,
+    thunk32_vkCmdCopyMicromapEXT,
+    thunk32_vkCmdCopyMicromapToMemoryEXT,
     thunk32_vkCmdCopyQueryPoolResults,
     thunk32_vkCmdCuLaunchKernelNVX,
     thunk32_vkCmdDebugMarkerBeginEXT,
@@ -17944,6 +19627,7 @@ const unixlib_entry_t __wine_unix_call_funcs[] =
     thunk32_vkCmdNextSubpass,
     thunk32_vkCmdNextSubpass2,
     thunk32_vkCmdNextSubpass2KHR,
+    thunk32_vkCmdOpticalFlowExecuteNV,
     thunk32_vkCmdPipelineBarrier,
     thunk32_vkCmdPipelineBarrier2,
     thunk32_vkCmdPipelineBarrier2KHR,
@@ -17958,10 +19642,23 @@ const unixlib_entry_t __wine_unix_call_funcs[] =
     thunk32_vkCmdResolveImage,
     thunk32_vkCmdResolveImage2,
     thunk32_vkCmdResolveImage2KHR,
+    thunk32_vkCmdSetAlphaToCoverageEnableEXT,
+    thunk32_vkCmdSetAlphaToOneEnableEXT,
     thunk32_vkCmdSetBlendConstants,
     thunk32_vkCmdSetCheckpointNV,
     thunk32_vkCmdSetCoarseSampleOrderNV,
+    thunk32_vkCmdSetColorBlendAdvancedEXT,
+    thunk32_vkCmdSetColorBlendEnableEXT,
+    thunk32_vkCmdSetColorBlendEquationEXT,
     thunk32_vkCmdSetColorWriteEnableEXT,
+    thunk32_vkCmdSetColorWriteMaskEXT,
+    thunk32_vkCmdSetConservativeRasterizationModeEXT,
+    thunk32_vkCmdSetCoverageModulationModeNV,
+    thunk32_vkCmdSetCoverageModulationTableEnableNV,
+    thunk32_vkCmdSetCoverageModulationTableNV,
+    thunk32_vkCmdSetCoverageReductionModeNV,
+    thunk32_vkCmdSetCoverageToColorEnableNV,
+    thunk32_vkCmdSetCoverageToColorLocationNV,
     thunk32_vkCmdSetCullMode,
     thunk32_vkCmdSetCullModeEXT,
     thunk32_vkCmdSetDepthBias,
@@ -17970,6 +19667,9 @@ const unixlib_entry_t __wine_unix_call_funcs[] =
     thunk32_vkCmdSetDepthBounds,
     thunk32_vkCmdSetDepthBoundsTestEnable,
     thunk32_vkCmdSetDepthBoundsTestEnableEXT,
+    thunk32_vkCmdSetDepthClampEnableEXT,
+    thunk32_vkCmdSetDepthClipEnableEXT,
+    thunk32_vkCmdSetDepthClipNegativeOneToOneEXT,
     thunk32_vkCmdSetDepthCompareOp,
     thunk32_vkCmdSetDepthCompareOpEXT,
     thunk32_vkCmdSetDepthTestEnable,
@@ -17983,28 +19683,40 @@ const unixlib_entry_t __wine_unix_call_funcs[] =
     thunk32_vkCmdSetEvent2,
     thunk32_vkCmdSetEvent2KHR,
     thunk32_vkCmdSetExclusiveScissorNV,
+    thunk32_vkCmdSetExtraPrimitiveOverestimationSizeEXT,
     thunk32_vkCmdSetFragmentShadingRateEnumNV,
     thunk32_vkCmdSetFragmentShadingRateKHR,
     thunk32_vkCmdSetFrontFace,
     thunk32_vkCmdSetFrontFaceEXT,
+    thunk32_vkCmdSetLineRasterizationModeEXT,
     thunk32_vkCmdSetLineStippleEXT,
+    thunk32_vkCmdSetLineStippleEnableEXT,
     thunk32_vkCmdSetLineWidth,
     thunk32_vkCmdSetLogicOpEXT,
+    thunk32_vkCmdSetLogicOpEnableEXT,
     thunk32_vkCmdSetPatchControlPointsEXT,
     thunk32_vkCmdSetPerformanceMarkerINTEL,
     thunk32_vkCmdSetPerformanceOverrideINTEL,
     thunk32_vkCmdSetPerformanceStreamMarkerINTEL,
+    thunk32_vkCmdSetPolygonModeEXT,
     thunk32_vkCmdSetPrimitiveRestartEnable,
     thunk32_vkCmdSetPrimitiveRestartEnableEXT,
     thunk32_vkCmdSetPrimitiveTopology,
     thunk32_vkCmdSetPrimitiveTopologyEXT,
+    thunk32_vkCmdSetProvokingVertexModeEXT,
+    thunk32_vkCmdSetRasterizationSamplesEXT,
+    thunk32_vkCmdSetRasterizationStreamEXT,
     thunk32_vkCmdSetRasterizerDiscardEnable,
     thunk32_vkCmdSetRasterizerDiscardEnableEXT,
     thunk32_vkCmdSetRayTracingPipelineStackSizeKHR,
+    thunk32_vkCmdSetRepresentativeFragmentTestEnableNV,
     thunk32_vkCmdSetSampleLocationsEXT,
+    thunk32_vkCmdSetSampleLocationsEnableEXT,
+    thunk32_vkCmdSetSampleMaskEXT,
     thunk32_vkCmdSetScissor,
     thunk32_vkCmdSetScissorWithCount,
     thunk32_vkCmdSetScissorWithCountEXT,
+    thunk32_vkCmdSetShadingRateImageEnableNV,
     thunk32_vkCmdSetStencilCompareMask,
     thunk32_vkCmdSetStencilOp,
     thunk32_vkCmdSetStencilOpEXT,
@@ -18012,9 +19724,12 @@ const unixlib_entry_t __wine_unix_call_funcs[] =
     thunk32_vkCmdSetStencilTestEnable,
     thunk32_vkCmdSetStencilTestEnableEXT,
     thunk32_vkCmdSetStencilWriteMask,
+    thunk32_vkCmdSetTessellationDomainOriginEXT,
     thunk32_vkCmdSetVertexInputEXT,
     thunk32_vkCmdSetViewport,
     thunk32_vkCmdSetViewportShadingRatePaletteNV,
+    thunk32_vkCmdSetViewportSwizzleNV,
+    thunk32_vkCmdSetViewportWScalingEnableNV,
     thunk32_vkCmdSetViewportWScalingNV,
     thunk32_vkCmdSetViewportWithCount,
     thunk32_vkCmdSetViewportWithCountEXT,
@@ -18031,6 +19746,7 @@ const unixlib_entry_t __wine_unix_call_funcs[] =
     thunk32_vkCmdWriteAccelerationStructuresPropertiesNV,
     thunk32_vkCmdWriteBufferMarker2AMD,
     thunk32_vkCmdWriteBufferMarkerAMD,
+    thunk32_vkCmdWriteMicromapsPropertiesEXT,
     thunk32_vkCmdWriteTimestamp,
     thunk32_vkCmdWriteTimestamp2,
     thunk32_vkCmdWriteTimestamp2KHR,
@@ -18038,6 +19754,9 @@ const unixlib_entry_t __wine_unix_call_funcs[] =
     thunk32_vkCopyAccelerationStructureKHR,
     thunk32_vkCopyAccelerationStructureToMemoryKHR,
     thunk32_vkCopyMemoryToAccelerationStructureKHR,
+    thunk32_vkCopyMemoryToMicromapEXT,
+    thunk32_vkCopyMicromapEXT,
+    thunk32_vkCopyMicromapToMemoryEXT,
     thunk32_vkCreateAccelerationStructureKHR,
     thunk32_vkCreateAccelerationStructureNV,
     thunk32_vkCreateBuffer,
@@ -18062,6 +19781,8 @@ const unixlib_entry_t __wine_unix_call_funcs[] =
     thunk32_vkCreateImageView,
     thunk32_vkCreateIndirectCommandsLayoutNV,
     thunk32_vkCreateInstance,
+    thunk32_vkCreateMicromapEXT,
+    thunk32_vkCreateOpticalFlowSessionNV,
     thunk32_vkCreatePipelineCache,
     thunk32_vkCreatePipelineLayout,
     thunk32_vkCreatePrivateDataSlot,
@@ -18106,6 +19827,8 @@ const unixlib_entry_t __wine_unix_call_funcs[] =
     thunk32_vkDestroyImageView,
     thunk32_vkDestroyIndirectCommandsLayoutNV,
     thunk32_vkDestroyInstance,
+    thunk32_vkDestroyMicromapEXT,
+    thunk32_vkDestroyOpticalFlowSessionNV,
     thunk32_vkDestroyPipeline,
     thunk32_vkDestroyPipelineCache,
     thunk32_vkDestroyPipelineLayout,
@@ -18157,6 +19880,7 @@ const unixlib_entry_t __wine_unix_call_funcs[] =
     thunk32_vkGetDeviceAccelerationStructureCompatibilityKHR,
     thunk32_vkGetDeviceBufferMemoryRequirements,
     thunk32_vkGetDeviceBufferMemoryRequirementsKHR,
+    thunk32_vkGetDeviceFaultInfoEXT,
     thunk32_vkGetDeviceGroupPeerMemoryFeatures,
     thunk32_vkGetDeviceGroupPeerMemoryFeaturesKHR,
     thunk32_vkGetDeviceGroupPresentCapabilitiesKHR,
@@ -18168,6 +19892,7 @@ const unixlib_entry_t __wine_unix_call_funcs[] =
     thunk32_vkGetDeviceMemoryCommitment,
     thunk32_vkGetDeviceMemoryOpaqueCaptureAddress,
     thunk32_vkGetDeviceMemoryOpaqueCaptureAddressKHR,
+    thunk32_vkGetDeviceMicromapCompatibilityEXT,
     thunk32_vkGetDeviceQueue,
     thunk32_vkGetDeviceQueue2,
     thunk32_vkGetDeviceSubpassShadingMaxWorkgroupSizeHUAWEI,
@@ -18187,6 +19912,7 @@ const unixlib_entry_t __wine_unix_call_funcs[] =
     thunk32_vkGetImageViewAddressNVX,
     thunk32_vkGetImageViewHandleNVX,
     thunk32_vkGetMemoryHostPointerPropertiesEXT,
+    thunk32_vkGetMicromapBuildSizesEXT,
     thunk32_vkGetPerformanceParameterINTEL,
     thunk32_vkGetPhysicalDeviceCalibrateableTimeDomainsEXT,
     thunk32_vkGetPhysicalDeviceCooperativeMatrixPropertiesNV,
@@ -18210,6 +19936,7 @@ const unixlib_entry_t __wine_unix_call_funcs[] =
     thunk32_vkGetPhysicalDeviceMemoryProperties2,
     thunk32_vkGetPhysicalDeviceMemoryProperties2KHR,
     thunk32_vkGetPhysicalDeviceMultisamplePropertiesEXT,
+    thunk32_vkGetPhysicalDeviceOpticalFlowImageFormatsNV,
     thunk32_vkGetPhysicalDevicePresentRectanglesKHR,
     thunk32_vkGetPhysicalDeviceProperties,
     thunk32_vkGetPhysicalDeviceProperties2,
@@ -18298,6 +20025,7 @@ const unixlib_entry_t __wine_unix_call_funcs[] =
     thunk32_vkWaitSemaphores,
     thunk32_vkWaitSemaphoresKHR,
     thunk32_vkWriteAccelerationStructuresPropertiesKHR,
+    thunk32_vkWriteMicromapsPropertiesEXT,
 };
 C_ASSERT(ARRAYSIZE(__wine_unix_call_funcs) == unix_count);

diff --git a/dlls/winevulkan/vulkan_thunks.h b/dlls/winevulkan/vulkan_thunks.h
index 843eacffa90..af2069b5380 100644
--- a/dlls/winevulkan/vulkan_thunks.h
+++ b/dlls/winevulkan/vulkan_thunks.h
@@ -223,6 +223,27 @@ typedef struct VkAccelerationStructureBuildGeometryInfoKHR_host
 typedef VkAccelerationStructureBuildGeometryInfoKHR VkAccelerationStructureBuildGeometryInfoKHR_host;
 #endif

+#if defined(USE_STRUCT_CONVERSION)
+typedef struct VkMicromapBuildInfoEXT_host
+{
+    VkStructureType sType;
+    const void *pNext;
+    VkMicromapTypeEXT type;
+    VkBuildMicromapFlagsEXT flags;
+    VkBuildMicromapModeEXT mode;
+    VkMicromapEXT dstMicromap;
+    uint32_t usageCountsCount;
+    const VkMicromapUsageEXT *pUsageCounts;
+    const VkMicromapUsageEXT * const*ppUsageCounts;
+    VkDeviceOrHostAddressConstKHR data;
+    VkDeviceOrHostAddressKHR scratchData;
+    VkDeviceOrHostAddressConstKHR triangleArray;
+    VkDeviceSize triangleArrayStride;
+} VkMicromapBuildInfoEXT_host;
+#else
+typedef VkMicromapBuildInfoEXT VkMicromapBuildInfoEXT_host;
+#endif
+
 #if defined(USE_STRUCT_CONVERSION)
 typedef struct VkConditionalRenderingBeginInfoEXT_host
 {
@@ -539,6 +560,45 @@ typedef struct VkCopyMemoryToAccelerationStructureInfoKHR_host
 typedef VkCopyMemoryToAccelerationStructureInfoKHR VkCopyMemoryToAccelerationStructureInfoKHR_host;
 #endif

+#if defined(USE_STRUCT_CONVERSION)
+typedef struct VkCopyMemoryToMicromapInfoEXT_host
+{
+    VkStructureType sType;
+    const void *pNext;
+    VkDeviceOrHostAddressConstKHR src;
+    VkMicromapEXT dst;
+    VkCopyMicromapModeEXT mode;
+} VkCopyMemoryToMicromapInfoEXT_host;
+#else
+typedef VkCopyMemoryToMicromapInfoEXT VkCopyMemoryToMicromapInfoEXT_host;
+#endif
+
+#if defined(USE_STRUCT_CONVERSION)
+typedef struct VkCopyMicromapInfoEXT_host
+{
+    VkStructureType sType;
+    const void *pNext;
+    VkMicromapEXT src;
+    VkMicromapEXT dst;
+    VkCopyMicromapModeEXT mode;
+} VkCopyMicromapInfoEXT_host;
+#else
+typedef VkCopyMicromapInfoEXT VkCopyMicromapInfoEXT_host;
+#endif
+
+#if defined(USE_STRUCT_CONVERSION)
+typedef struct VkCopyMicromapToMemoryInfoEXT_host
+{
+    VkStructureType sType;
+    const void *pNext;
+    VkMicromapEXT src;
+    VkDeviceOrHostAddressKHR dst;
+    VkCopyMicromapModeEXT mode;
+} VkCopyMicromapToMemoryInfoEXT_host;
+#else
+typedef VkCopyMicromapToMemoryInfoEXT VkCopyMicromapToMemoryInfoEXT_host;
+#endif
+
 #if defined(USE_STRUCT_CONVERSION)
 typedef struct VkCuLaunchInfoNVX_host
 {
@@ -999,6 +1059,22 @@ typedef struct VkIndirectCommandsLayoutCreateInfoNV_host
 typedef VkIndirectCommandsLayoutCreateInfoNV VkIndirectCommandsLayoutCreateInfoNV_host;
 #endif

+#if defined(USE_STRUCT_CONVERSION)
+typedef struct VkMicromapCreateInfoEXT_host
+{
+    VkStructureType sType;
+    const void *pNext;
+    VkMicromapCreateFlagsEXT createFlags;
+    VkBuffer buffer;
+    VkDeviceSize offset;
+    VkDeviceSize size;
+    VkMicromapTypeEXT type;
+    VkDeviceAddress deviceAddress;
+} VkMicromapCreateInfoEXT_host;
+#else
+typedef VkMicromapCreateInfoEXT VkMicromapCreateInfoEXT_host;
+#endif
+
 #if defined(USE_STRUCT_CONVERSION)
 typedef struct VkRayTracingPipelineCreateInfoKHR_host
 {
@@ -1240,6 +1316,55 @@ typedef VkDeviceBufferMemoryRequirements VkDeviceBufferMemoryRequirementsKHR;
 typedef VkDeviceBufferMemoryRequirements VkDeviceBufferMemoryRequirements_host;
 #endif

+#if defined(USE_STRUCT_CONVERSION)
+typedef struct VkDeviceFaultCountsEXT_host
+{
+    VkStructureType sType;
+    void *pNext;
+    uint32_t addressInfoCount;
+    uint32_t vendorInfoCount;
+    VkDeviceSize vendorBinarySize;
+} VkDeviceFaultCountsEXT_host;
+#else
+typedef VkDeviceFaultCountsEXT VkDeviceFaultCountsEXT_host;
+#endif
+
+#if defined(USE_STRUCT_CONVERSION)
+typedef struct VkDeviceFaultAddressInfoEXT_host
+{
+    VkDeviceFaultAddressTypeEXT addressType;
+    VkDeviceAddress reportedAddress;
+    VkDeviceSize addressPrecision;
+} VkDeviceFaultAddressInfoEXT_host;
+#else
+typedef VkDeviceFaultAddressInfoEXT VkDeviceFaultAddressInfoEXT_host;
+#endif
+
+#if defined(USE_STRUCT_CONVERSION)
+typedef struct VkDeviceFaultVendorInfoEXT_host
+{
+    char description[VK_MAX_DESCRIPTION_SIZE];
+    uint64_t vendorFaultCode;
+    uint64_t vendorFaultData;
+} VkDeviceFaultVendorInfoEXT_host;
+#else
+typedef VkDeviceFaultVendorInfoEXT VkDeviceFaultVendorInfoEXT_host;
+#endif
+
+#if defined(USE_STRUCT_CONVERSION)
+typedef struct VkDeviceFaultInfoEXT_host
+{
+    VkStructureType sType;
+    void *pNext;
+    char description[VK_MAX_DESCRIPTION_SIZE];
+    VkDeviceFaultAddressInfoEXT_host *pAddressInfos;
+    VkDeviceFaultVendorInfoEXT_host *pVendorInfos;
+    void *pVendorBinaryData;
+} VkDeviceFaultInfoEXT_host;
+#else
+typedef VkDeviceFaultInfoEXT VkDeviceFaultInfoEXT_host;
+#endif
+
 #if defined(USE_STRUCT_CONVERSION)
 typedef struct VkDeviceMemoryOpaqueCaptureAddressInfo_host
 {
@@ -1351,6 +1476,19 @@ typedef struct VkMemoryGetWin32HandleInfoKHR_host
 typedef VkMemoryGetWin32HandleInfoKHR VkMemoryGetWin32HandleInfoKHR_host;
 #endif

+#if defined(USE_STRUCT_CONVERSION)
+typedef struct VkMicromapBuildSizesInfoEXT_host
+{
+    VkStructureType sType;
+    const void *pNext;
+    VkDeviceSize micromapSize;
+    VkDeviceSize buildScratchSize;
+    VkBool32 discardable;
+} VkMicromapBuildSizesInfoEXT_host;
+#else
+typedef VkMicromapBuildSizesInfoEXT VkMicromapBuildSizesInfoEXT_host;
+#endif
+
 #if defined(USE_STRUCT_CONVERSION)
 typedef struct VkImageFormatProperties_host
 {
@@ -1844,7 +1982,9 @@ struct vulkan_device_funcs
     VkResult (*p_vkBindImageMemory)(VkDevice, VkImage, VkDeviceMemory, VkDeviceSize);
     VkResult (*p_vkBindImageMemory2)(VkDevice, uint32_t, const VkBindImageMemoryInfo_host *);
     VkResult (*p_vkBindImageMemory2KHR)(VkDevice, uint32_t, const VkBindImageMemoryInfo_host *);
+    VkResult (*p_vkBindOpticalFlowSessionImageNV)(VkDevice, VkOpticalFlowSessionNV, VkOpticalFlowSessionBindingPointNV, VkImageView, VkImageLayout);
     VkResult (*p_vkBuildAccelerationStructuresKHR)(VkDevice, VkDeferredOperationKHR, uint32_t, const VkAccelerationStructureBuildGeometryInfoKHR_host *, const VkAccelerationStructureBuildRangeInfoKHR * const*);
+    VkResult (*p_vkBuildMicromapsEXT)(VkDevice, VkDeferredOperationKHR, uint32_t, const VkMicromapBuildInfoEXT_host *);
     void (*p_vkCmdBeginConditionalRenderingEXT)(VkCommandBuffer, const VkConditionalRenderingBeginInfoEXT_host *);
     void (*p_vkCmdBeginDebugUtilsLabelEXT)(VkCommandBuffer, const VkDebugUtilsLabelEXT *);
     void (*p_vkCmdBeginQuery)(VkCommandBuffer, VkQueryPool, uint32_t, VkQueryControlFlags);
@@ -1871,6 +2011,7 @@ struct vulkan_device_funcs
     void (*p_vkCmdBuildAccelerationStructureNV)(VkCommandBuffer, const VkAccelerationStructureInfoNV_host *, VkBuffer, VkDeviceSize, VkBool32, VkAccelerationStructureNV, VkAccelerationStructureNV, VkBuffer, VkDeviceSize);
     void (*p_vkCmdBuildAccelerationStructuresIndirectKHR)(VkCommandBuffer, uint32_t, const VkAccelerationStructureBuildGeometryInfoKHR_host *, const VkDeviceAddress *, const uint32_t *, const uint32_t * const*);
     void (*p_vkCmdBuildAccelerationStructuresKHR)(VkCommandBuffer, uint32_t, const VkAccelerationStructureBuildGeometryInfoKHR_host *, const VkAccelerationStructureBuildRangeInfoKHR * const*);
+    void (*p_vkCmdBuildMicromapsEXT)(VkCommandBuffer, uint32_t, const VkMicromapBuildInfoEXT_host *);
     void (*p_vkCmdClearAttachments)(VkCommandBuffer, uint32_t, const VkClearAttachment *, uint32_t, const VkClearRect *);
     void (*p_vkCmdClearColorImage)(VkCommandBuffer, VkImage, VkImageLayout, const VkClearColorValue *, uint32_t, const VkImageSubresourceRange *);
     void (*p_vkCmdClearDepthStencilImage)(VkCommandBuffer, VkImage, VkImageLayout, const VkClearDepthStencilValue *, uint32_t, const VkImageSubresourceRange *);
@@ -1890,6 +2031,9 @@ struct vulkan_device_funcs
     void (*p_vkCmdCopyImageToBuffer2)(VkCommandBuffer, const VkCopyImageToBufferInfo2_host *);
     void (*p_vkCmdCopyImageToBuffer2KHR)(VkCommandBuffer, const VkCopyImageToBufferInfo2_host *);
     void (*p_vkCmdCopyMemoryToAccelerationStructureKHR)(VkCommandBuffer, const VkCopyMemoryToAccelerationStructureInfoKHR_host *);
+    void (*p_vkCmdCopyMemoryToMicromapEXT)(VkCommandBuffer, const VkCopyMemoryToMicromapInfoEXT_host *);
+    void (*p_vkCmdCopyMicromapEXT)(VkCommandBuffer, const VkCopyMicromapInfoEXT_host *);
+    void (*p_vkCmdCopyMicromapToMemoryEXT)(VkCommandBuffer, const VkCopyMicromapToMemoryInfoEXT_host *);
     void (*p_vkCmdCopyQueryPoolResults)(VkCommandBuffer, VkQueryPool, uint32_t, uint32_t, VkBuffer, VkDeviceSize, VkDeviceSize, VkQueryResultFlags);
     void (*p_vkCmdCuLaunchKernelNVX)(VkCommandBuffer, const VkCuLaunchInfoNVX_host *);
     void (*p_vkCmdDebugMarkerBeginEXT)(VkCommandBuffer, const VkDebugMarkerMarkerInfoEXT *);
@@ -1935,6 +2079,7 @@ struct vulkan_device_funcs
     void (*p_vkCmdNextSubpass)(VkCommandBuffer, VkSubpassContents);
     void (*p_vkCmdNextSubpass2)(VkCommandBuffer, const VkSubpassBeginInfo *, const VkSubpassEndInfo *);
     void (*p_vkCmdNextSubpass2KHR)(VkCommandBuffer, const VkSubpassBeginInfo *, const VkSubpassEndInfo *);
+    void (*p_vkCmdOpticalFlowExecuteNV)(VkCommandBuffer, VkOpticalFlowSessionNV, const VkOpticalFlowExecuteInfoNV *);
     void (*p_vkCmdPipelineBarrier)(VkCommandBuffer, VkPipelineStageFlags, VkPipelineStageFlags, VkDependencyFlags, uint32_t, const VkMemoryBarrier *, uint32_t, const VkBufferMemoryBarrier_host *, uint32_t, const VkImageMemoryBarrier_host *);
     void (*p_vkCmdPipelineBarrier2)(VkCommandBuffer, const VkDependencyInfo_host *);
     void (*p_vkCmdPipelineBarrier2KHR)(VkCommandBuffer, const VkDependencyInfo_host *);
@@ -1949,10 +2094,23 @@ struct vulkan_device_funcs
     void (*p_vkCmdResolveImage)(VkCommandBuffer, VkImage, VkImageLayout, VkImage, VkImageLayout, uint32_t, const VkImageResolve *);
     void (*p_vkCmdResolveImage2)(VkCommandBuffer, const VkResolveImageInfo2_host *);
     void (*p_vkCmdResolveImage2KHR)(VkCommandBuffer, const VkResolveImageInfo2_host *);
+    void (*p_vkCmdSetAlphaToCoverageEnableEXT)(VkCommandBuffer, VkBool32);
+    void (*p_vkCmdSetAlphaToOneEnableEXT)(VkCommandBuffer, VkBool32);
     void (*p_vkCmdSetBlendConstants)(VkCommandBuffer, const float[4]);
     void (*p_vkCmdSetCheckpointNV)(VkCommandBuffer, const void *);
     void (*p_vkCmdSetCoarseSampleOrderNV)(VkCommandBuffer, VkCoarseSampleOrderTypeNV, uint32_t, const VkCoarseSampleOrderCustomNV *);
+    void (*p_vkCmdSetColorBlendAdvancedEXT)(VkCommandBuffer, uint32_t, uint32_t, const VkColorBlendAdvancedEXT *);
+    void (*p_vkCmdSetColorBlendEnableEXT)(VkCommandBuffer, uint32_t, uint32_t, const VkBool32 *);
+    void (*p_vkCmdSetColorBlendEquationEXT)(VkCommandBuffer, uint32_t, uint32_t, const VkColorBlendEquationEXT *);
     void (*p_vkCmdSetColorWriteEnableEXT)(VkCommandBuffer, uint32_t, const VkBool32 *);
+    void (*p_vkCmdSetColorWriteMaskEXT)(VkCommandBuffer, uint32_t, uint32_t, const VkColorComponentFlags *);
+    void (*p_vkCmdSetConservativeRasterizationModeEXT)(VkCommandBuffer, VkConservativeRasterizationModeEXT);
+    void (*p_vkCmdSetCoverageModulationModeNV)(VkCommandBuffer, VkCoverageModulationModeNV);
+    void (*p_vkCmdSetCoverageModulationTableEnableNV)(VkCommandBuffer, VkBool32);
+    void (*p_vkCmdSetCoverageModulationTableNV)(VkCommandBuffer, uint32_t, const float *);
+    void (*p_vkCmdSetCoverageReductionModeNV)(VkCommandBuffer, VkCoverageReductionModeNV);
+    void (*p_vkCmdSetCoverageToColorEnableNV)(VkCommandBuffer, VkBool32);
+    void (*p_vkCmdSetCoverageToColorLocationNV)(VkCommandBuffer, uint32_t);
     void (*p_vkCmdSetCullMode)(VkCommandBuffer, VkCullModeFlags);
     void (*p_vkCmdSetCullModeEXT)(VkCommandBuffer, VkCullModeFlags);
     void (*p_vkCmdSetDepthBias)(VkCommandBuffer, float, float, float);
@@ -1961,6 +2119,9 @@ struct vulkan_device_funcs
     void (*p_vkCmdSetDepthBounds)(VkCommandBuffer, float, float);
     void (*p_vkCmdSetDepthBoundsTestEnable)(VkCommandBuffer, VkBool32);
     void (*p_vkCmdSetDepthBoundsTestEnableEXT)(VkCommandBuffer, VkBool32);
+    void (*p_vkCmdSetDepthClampEnableEXT)(VkCommandBuffer, VkBool32);
+    void (*p_vkCmdSetDepthClipEnableEXT)(VkCommandBuffer, VkBool32);
+    void (*p_vkCmdSetDepthClipNegativeOneToOneEXT)(VkCommandBuffer, VkBool32);
     void (*p_vkCmdSetDepthCompareOp)(VkCommandBuffer, VkCompareOp);
     void (*p_vkCmdSetDepthCompareOpEXT)(VkCommandBuffer, VkCompareOp);
     void (*p_vkCmdSetDepthTestEnable)(VkCommandBuffer, VkBool32);
@@ -1974,28 +2135,40 @@ struct vulkan_device_funcs
     void (*p_vkCmdSetEvent2)(VkCommandBuffer, VkEvent, const VkDependencyInfo_host *);
     void (*p_vkCmdSetEvent2KHR)(VkCommandBuffer, VkEvent, const VkDependencyInfo_host *);
     void (*p_vkCmdSetExclusiveScissorNV)(VkCommandBuffer, uint32_t, uint32_t, const VkRect2D *);
+    void (*p_vkCmdSetExtraPrimitiveOverestimationSizeEXT)(VkCommandBuffer, float);
     void (*p_vkCmdSetFragmentShadingRateEnumNV)(VkCommandBuffer, VkFragmentShadingRateNV, const VkFragmentShadingRateCombinerOpKHR[2]);
     void (*p_vkCmdSetFragmentShadingRateKHR)(VkCommandBuffer, const VkExtent2D *, const VkFragmentShadingRateCombinerOpKHR[2]);
     void (*p_vkCmdSetFrontFace)(VkCommandBuffer, VkFrontFace);
     void (*p_vkCmdSetFrontFaceEXT)(VkCommandBuffer, VkFrontFace);
+    void (*p_vkCmdSetLineRasterizationModeEXT)(VkCommandBuffer, VkLineRasterizationModeEXT);
     void (*p_vkCmdSetLineStippleEXT)(VkCommandBuffer, uint32_t, uint16_t);
+    void (*p_vkCmdSetLineStippleEnableEXT)(VkCommandBuffer, VkBool32);
     void (*p_vkCmdSetLineWidth)(VkCommandBuffer, float);
     void (*p_vkCmdSetLogicOpEXT)(VkCommandBuffer, VkLogicOp);
+    void (*p_vkCmdSetLogicOpEnableEXT)(VkCommandBuffer, VkBool32);
     void (*p_vkCmdSetPatchControlPointsEXT)(VkCommandBuffer, uint32_t);
     VkResult (*p_vkCmdSetPerformanceMarkerINTEL)(VkCommandBuffer, const VkPerformanceMarkerInfoINTEL_host *);
     VkResult (*p_vkCmdSetPerformanceOverrideINTEL)(VkCommandBuffer, const VkPerformanceOverrideInfoINTEL_host *);
     VkResult (*p_vkCmdSetPerformanceStreamMarkerINTEL)(VkCommandBuffer, const VkPerformanceStreamMarkerInfoINTEL *);
+    void (*p_vkCmdSetPolygonModeEXT)(VkCommandBuffer, VkPolygonMode);
     void (*p_vkCmdSetPrimitiveRestartEnable)(VkCommandBuffer, VkBool32);
     void (*p_vkCmdSetPrimitiveRestartEnableEXT)(VkCommandBuffer, VkBool32);
     void (*p_vkCmdSetPrimitiveTopology)(VkCommandBuffer, VkPrimitiveTopology);
     void (*p_vkCmdSetPrimitiveTopologyEXT)(VkCommandBuffer, VkPrimitiveTopology);
+    void (*p_vkCmdSetProvokingVertexModeEXT)(VkCommandBuffer, VkProvokingVertexModeEXT);
+    void (*p_vkCmdSetRasterizationSamplesEXT)(VkCommandBuffer, VkSampleCountFlagBits);
+    void (*p_vkCmdSetRasterizationStreamEXT)(VkCommandBuffer, uint32_t);
     void (*p_vkCmdSetRasterizerDiscardEnable)(VkCommandBuffer, VkBool32);
     void (*p_vkCmdSetRasterizerDiscardEnableEXT)(VkCommandBuffer, VkBool32);
     void (*p_vkCmdSetRayTracingPipelineStackSizeKHR)(VkCommandBuffer, uint32_t);
+    void (*p_vkCmdSetRepresentativeFragmentTestEnableNV)(VkCommandBuffer, VkBool32);
     void (*p_vkCmdSetSampleLocationsEXT)(VkCommandBuffer, const VkSampleLocationsInfoEXT *);
+    void (*p_vkCmdSetSampleLocationsEnableEXT)(VkCommandBuffer, VkBool32);
+    void (*p_vkCmdSetSampleMaskEXT)(VkCommandBuffer, VkSampleCountFlagBits, const VkSampleMask *);
     void (*p_vkCmdSetScissor)(VkCommandBuffer, uint32_t, uint32_t, const VkRect2D *);
     void (*p_vkCmdSetScissorWithCount)(VkCommandBuffer, uint32_t, const VkRect2D *);
     void (*p_vkCmdSetScissorWithCountEXT)(VkCommandBuffer, uint32_t, const VkRect2D *);
+    void (*p_vkCmdSetShadingRateImageEnableNV)(VkCommandBuffer, VkBool32);
     void (*p_vkCmdSetStencilCompareMask)(VkCommandBuffer, VkStencilFaceFlags, uint32_t);
     void (*p_vkCmdSetStencilOp)(VkCommandBuffer, VkStencilFaceFlags, VkStencilOp, VkStencilOp, VkStencilOp, VkCompareOp);
     void (*p_vkCmdSetStencilOpEXT)(VkCommandBuffer, VkStencilFaceFlags, VkStencilOp, VkStencilOp, VkStencilOp, VkCompareOp);
@@ -2003,9 +2176,12 @@ struct vulkan_device_funcs
     void (*p_vkCmdSetStencilTestEnable)(VkCommandBuffer, VkBool32);
     void (*p_vkCmdSetStencilTestEnableEXT)(VkCommandBuffer, VkBool32);
     void (*p_vkCmdSetStencilWriteMask)(VkCommandBuffer, VkStencilFaceFlags, uint32_t);
+    void (*p_vkCmdSetTessellationDomainOriginEXT)(VkCommandBuffer, VkTessellationDomainOrigin);
     void (*p_vkCmdSetVertexInputEXT)(VkCommandBuffer, uint32_t, const VkVertexInputBindingDescription2EXT *, uint32_t, const VkVertexInputAttributeDescription2EXT *);
     void (*p_vkCmdSetViewport)(VkCommandBuffer, uint32_t, uint32_t, const VkViewport *);
     void (*p_vkCmdSetViewportShadingRatePaletteNV)(VkCommandBuffer, uint32_t, uint32_t, const VkShadingRatePaletteNV *);
+    void (*p_vkCmdSetViewportSwizzleNV)(VkCommandBuffer, uint32_t, uint32_t, const VkViewportSwizzleNV *);
+    void (*p_vkCmdSetViewportWScalingEnableNV)(VkCommandBuffer, VkBool32);
     void (*p_vkCmdSetViewportWScalingNV)(VkCommandBuffer, uint32_t, uint32_t, const VkViewportWScalingNV *);
     void (*p_vkCmdSetViewportWithCount)(VkCommandBuffer, uint32_t, const VkViewport *);
     void (*p_vkCmdSetViewportWithCountEXT)(VkCommandBuffer, uint32_t, const VkViewport *);
@@ -2022,6 +2198,7 @@ struct vulkan_device_funcs
     void (*p_vkCmdWriteAccelerationStructuresPropertiesNV)(VkCommandBuffer, uint32_t, const VkAccelerationStructureNV *, VkQueryType, VkQueryPool, uint32_t);
     void (*p_vkCmdWriteBufferMarker2AMD)(VkCommandBuffer, VkPipelineStageFlags2, VkBuffer, VkDeviceSize, uint32_t);
     void (*p_vkCmdWriteBufferMarkerAMD)(VkCommandBuffer, VkPipelineStageFlagBits, VkBuffer, VkDeviceSize, uint32_t);
+    void (*p_vkCmdWriteMicromapsPropertiesEXT)(VkCommandBuffer, uint32_t, const VkMicromapEXT *, VkQueryType, VkQueryPool, uint32_t);
     void (*p_vkCmdWriteTimestamp)(VkCommandBuffer, VkPipelineStageFlagBits, VkQueryPool, uint32_t);
     void (*p_vkCmdWriteTimestamp2)(VkCommandBuffer, VkPipelineStageFlags2, VkQueryPool, uint32_t);
     void (*p_vkCmdWriteTimestamp2KHR)(VkCommandBuffer, VkPipelineStageFlags2, VkQueryPool, uint32_t);
@@ -2029,6 +2206,9 @@ struct vulkan_device_funcs
     VkResult (*p_vkCopyAccelerationStructureKHR)(VkDevice, VkDeferredOperationKHR, const VkCopyAccelerationStructureInfoKHR_host *);
     VkResult (*p_vkCopyAccelerationStructureToMemoryKHR)(VkDevice, VkDeferredOperationKHR, const VkCopyAccelerationStructureToMemoryInfoKHR_host *);
     VkResult (*p_vkCopyMemoryToAccelerationStructureKHR)(VkDevice, VkDeferredOperationKHR, const VkCopyMemoryToAccelerationStructureInfoKHR_host *);
+    VkResult (*p_vkCopyMemoryToMicromapEXT)(VkDevice, VkDeferredOperationKHR, const VkCopyMemoryToMicromapInfoEXT_host *);
+    VkResult (*p_vkCopyMicromapEXT)(VkDevice, VkDeferredOperationKHR, const VkCopyMicromapInfoEXT_host *);
+    VkResult (*p_vkCopyMicromapToMemoryEXT)(VkDevice, VkDeferredOperationKHR, const VkCopyMicromapToMemoryInfoEXT_host *);
     VkResult (*p_vkCreateAccelerationStructureKHR)(VkDevice, const VkAccelerationStructureCreateInfoKHR_host *, const VkAllocationCallbacks *, VkAccelerationStructureKHR *);
     VkResult (*p_vkCreateAccelerationStructureNV)(VkDevice, const VkAccelerationStructureCreateInfoNV_host *, const VkAllocationCallbacks *, VkAccelerationStructureNV *);
     VkResult (*p_vkCreateBuffer)(VkDevice, const VkBufferCreateInfo_host *, const VkAllocationCallbacks *, VkBuffer *);
@@ -2049,6 +2229,8 @@ struct vulkan_device_funcs
     VkResult (*p_vkCreateImage)(VkDevice, const VkImageCreateInfo *, const VkAllocationCallbacks *, VkImage *);
     VkResult (*p_vkCreateImageView)(VkDevice, const VkImageViewCreateInfo_host *, const VkAllocationCallbacks *, VkImageView *);
     VkResult (*p_vkCreateIndirectCommandsLayoutNV)(VkDevice, const VkIndirectCommandsLayoutCreateInfoNV_host *, const VkAllocationCallbacks *, VkIndirectCommandsLayoutNV *);
+    VkResult (*p_vkCreateMicromapEXT)(VkDevice, const VkMicromapCreateInfoEXT_host *, const VkAllocationCallbacks *, VkMicromapEXT *);
+    VkResult (*p_vkCreateOpticalFlowSessionNV)(VkDevice, const VkOpticalFlowSessionCreateInfoNV *, const VkAllocationCallbacks *, VkOpticalFlowSessionNV *);
     VkResult (*p_vkCreatePipelineCache)(VkDevice, const VkPipelineCacheCreateInfo *, const VkAllocationCallbacks *, VkPipelineCache *);
     VkResult (*p_vkCreatePipelineLayout)(VkDevice, const VkPipelineLayoutCreateInfo *, const VkAllocationCallbacks *, VkPipelineLayout *);
     VkResult (*p_vkCreatePrivateDataSlot)(VkDevice, const VkPrivateDataSlotCreateInfo *, const VkAllocationCallbacks *, VkPrivateDataSlot *);
@@ -2088,6 +2270,8 @@ struct vulkan_device_funcs
     void (*p_vkDestroyImage)(VkDevice, VkImage, const VkAllocationCallbacks *);
     void (*p_vkDestroyImageView)(VkDevice, VkImageView, const VkAllocationCallbacks *);
     void (*p_vkDestroyIndirectCommandsLayoutNV)(VkDevice, VkIndirectCommandsLayoutNV, const VkAllocationCallbacks *);
+    void (*p_vkDestroyMicromapEXT)(VkDevice, VkMicromapEXT, const VkAllocationCallbacks *);
+    void (*p_vkDestroyOpticalFlowSessionNV)(VkDevice, VkOpticalFlowSessionNV, const VkAllocationCallbacks *);
     void (*p_vkDestroyPipeline)(VkDevice, VkPipeline, const VkAllocationCallbacks *);
     void (*p_vkDestroyPipelineCache)(VkDevice, VkPipelineCache, const VkAllocationCallbacks *);
     void (*p_vkDestroyPipelineLayout)(VkDevice, VkPipelineLayout, const VkAllocationCallbacks *);
@@ -2130,6 +2314,7 @@ struct vulkan_device_funcs
     void (*p_vkGetDeviceAccelerationStructureCompatibilityKHR)(VkDevice, const VkAccelerationStructureVersionInfoKHR *, VkAccelerationStructureCompatibilityKHR *);
     void (*p_vkGetDeviceBufferMemoryRequirements)(VkDevice, const VkDeviceBufferMemoryRequirements_host *, VkMemoryRequirements2_host *);
     void (*p_vkGetDeviceBufferMemoryRequirementsKHR)(VkDevice, const VkDeviceBufferMemoryRequirements_host *, VkMemoryRequirements2_host *);
+    VkResult (*p_vkGetDeviceFaultInfoEXT)(VkDevice, VkDeviceFaultCountsEXT_host *, VkDeviceFaultInfoEXT_host *);
     void (*p_vkGetDeviceGroupPeerMemoryFeatures)(VkDevice, uint32_t, uint32_t, uint32_t, VkPeerMemoryFeatureFlags *);
     void (*p_vkGetDeviceGroupPeerMemoryFeaturesKHR)(VkDevice, uint32_t, uint32_t, uint32_t, VkPeerMemoryFeatureFlags *);
     VkResult (*p_vkGetDeviceGroupPresentCapabilitiesKHR)(VkDevice, VkDeviceGroupPresentCapabilitiesKHR *);
@@ -2141,6 +2326,7 @@ struct vulkan_device_funcs
     void (*p_vkGetDeviceMemoryCommitment)(VkDevice, VkDeviceMemory, VkDeviceSize *);
     uint64_t (*p_vkGetDeviceMemoryOpaqueCaptureAddress)(VkDevice, const VkDeviceMemoryOpaqueCaptureAddressInfo_host *);
     uint64_t (*p_vkGetDeviceMemoryOpaqueCaptureAddressKHR)(VkDevice, const VkDeviceMemoryOpaqueCaptureAddressInfo_host *);
+    void (*p_vkGetDeviceMicromapCompatibilityEXT)(VkDevice, const VkMicromapVersionInfoEXT *, VkAccelerationStructureCompatibilityKHR *);
     void (*p_vkGetDeviceQueue)(VkDevice, uint32_t, uint32_t, VkQueue *);
     void (*p_vkGetDeviceQueue2)(VkDevice, const VkDeviceQueueInfo2 *, VkQueue *);
     VkResult (*p_vkGetDeviceSubpassShadingMaxWorkgroupSizeHUAWEI)(VkDevice, VkRenderPass, VkExtent2D *);
@@ -2162,6 +2348,7 @@ struct vulkan_device_funcs
     VkResult (*p_vkGetMemoryHostPointerPropertiesEXT)(VkDevice, VkExternalMemoryHandleTypeFlagBits, const void *, VkMemoryHostPointerPropertiesEXT *);
     VkResult (*p_vkGetMemoryWin32HandleKHR)(VkDevice, const VkMemoryGetWin32HandleInfoKHR_host *, HANDLE *);
     VkResult (*p_vkGetMemoryWin32HandlePropertiesKHR)(VkDevice, VkExternalMemoryHandleTypeFlagBits, HANDLE, VkMemoryWin32HandlePropertiesKHR *);
+    void (*p_vkGetMicromapBuildSizesEXT)(VkDevice, VkAccelerationStructureBuildTypeKHR, const VkMicromapBuildInfoEXT_host *, VkMicromapBuildSizesInfoEXT_host *);
     VkResult (*p_vkGetPerformanceParameterINTEL)(VkDevice, VkPerformanceParameterTypeINTEL, VkPerformanceValueINTEL *);
     VkResult (*p_vkGetPipelineCacheData)(VkDevice, VkPipelineCache, size_t *, void *);
     VkResult (*p_vkGetPipelineExecutableInternalRepresentationsKHR)(VkDevice, const VkPipelineExecutableInfoKHR_host *, uint32_t *, VkPipelineExecutableInternalRepresentationKHR *);
@@ -2229,6 +2416,7 @@ struct vulkan_device_funcs
     VkResult (*p_vkWaitSemaphores)(VkDevice, const VkSemaphoreWaitInfo *, uint64_t);
     VkResult (*p_vkWaitSemaphoresKHR)(VkDevice, const VkSemaphoreWaitInfo *, uint64_t);
     VkResult (*p_vkWriteAccelerationStructuresPropertiesKHR)(VkDevice, uint32_t, const VkAccelerationStructureKHR *, VkQueryType, size_t, void *, size_t);
+    VkResult (*p_vkWriteMicromapsPropertiesEXT)(VkDevice, uint32_t, const VkMicromapEXT *, VkQueryType, size_t, void *, size_t);
 };

/* For use by vkInstance and children */
@@ -2265,6 +2453,7 @@ struct vulkan_instance_funcs
     void (*p_vkGetPhysicalDeviceMemoryProperties2)(VkPhysicalDevice, VkPhysicalDeviceMemoryProperties2_host *);
     void (*p_vkGetPhysicalDeviceMemoryProperties2KHR)(VkPhysicalDevice, VkPhysicalDeviceMemoryProperties2_host *);
     void (*p_vkGetPhysicalDeviceMultisamplePropertiesEXT)(VkPhysicalDevice, VkSampleCountFlagBits, VkMultisamplePropertiesEXT *);
+    VkResult (*p_vkGetPhysicalDeviceOpticalFlowImageFormatsNV)(VkPhysicalDevice, const VkOpticalFlowImageFormatInfoNV *, uint32_t *, VkOpticalFlowImageFormatPropertiesNV *);
     VkResult (*p_vkGetPhysicalDevicePresentRectanglesKHR)(VkPhysicalDevice, VkSurfaceKHR, uint32_t *, VkRect2D *);
     void (*p_vkGetPhysicalDeviceProperties)(VkPhysicalDevice, VkPhysicalDeviceProperties_host *);
     void (*p_vkGetPhysicalDeviceProperties2)(VkPhysicalDevice, VkPhysicalDeviceProperties2_host *);
@@ -2304,7 +2493,9 @@ struct vulkan_instance_funcs
     USE_VK_FUNC(vkBindImageMemory) \
     USE_VK_FUNC(vkBindImageMemory2) \
     USE_VK_FUNC(vkBindImageMemory2KHR) \
+    USE_VK_FUNC(vkBindOpticalFlowSessionImageNV) \
     USE_VK_FUNC(vkBuildAccelerationStructuresKHR) \
+    USE_VK_FUNC(vkBuildMicromapsEXT) \
     USE_VK_FUNC(vkCmdBeginConditionalRenderingEXT) \
     USE_VK_FUNC(vkCmdBeginDebugUtilsLabelEXT) \
     USE_VK_FUNC(vkCmdBeginQuery) \
@@ -2331,6 +2522,7 @@ struct vulkan_instance_funcs
     USE_VK_FUNC(vkCmdBuildAccelerationStructureNV) \
     USE_VK_FUNC(vkCmdBuildAccelerationStructuresIndirectKHR) \
     USE_VK_FUNC(vkCmdBuildAccelerationStructuresKHR) \
+    USE_VK_FUNC(vkCmdBuildMicromapsEXT) \
     USE_VK_FUNC(vkCmdClearAttachments) \
     USE_VK_FUNC(vkCmdClearColorImage) \
     USE_VK_FUNC(vkCmdClearDepthStencilImage) \
@@ -2350,6 +2542,9 @@ struct vulkan_instance_funcs
     USE_VK_FUNC(vkCmdCopyImageToBuffer2) \
     USE_VK_FUNC(vkCmdCopyImageToBuffer2KHR) \
     USE_VK_FUNC(vkCmdCopyMemoryToAccelerationStructureKHR) \
+    USE_VK_FUNC(vkCmdCopyMemoryToMicromapEXT) \
+    USE_VK_FUNC(vkCmdCopyMicromapEXT) \
+    USE_VK_FUNC(vkCmdCopyMicromapToMemoryEXT) \
     USE_VK_FUNC(vkCmdCopyQueryPoolResults) \
     USE_VK_FUNC(vkCmdCuLaunchKernelNVX) \
     USE_VK_FUNC(vkCmdDebugMarkerBeginEXT) \
@@ -2395,6 +2590,7 @@ struct vulkan_instance_funcs
     USE_VK_FUNC(vkCmdNextSubpass) \
     USE_VK_FUNC(vkCmdNextSubpass2) \
     USE_VK_FUNC(vkCmdNextSubpass2KHR) \
+    USE_VK_FUNC(vkCmdOpticalFlowExecuteNV) \
     USE_VK_FUNC(vkCmdPipelineBarrier) \
     USE_VK_FUNC(vkCmdPipelineBarrier2) \
     USE_VK_FUNC(vkCmdPipelineBarrier2KHR) \
@@ -2409,10 +2605,23 @@ struct vulkan_instance_funcs
     USE_VK_FUNC(vkCmdResolveImage) \
     USE_VK_FUNC(vkCmdResolveImage2) \
     USE_VK_FUNC(vkCmdResolveImage2KHR) \
+    USE_VK_FUNC(vkCmdSetAlphaToCoverageEnableEXT) \
+    USE_VK_FUNC(vkCmdSetAlphaToOneEnableEXT) \
     USE_VK_FUNC(vkCmdSetBlendConstants) \
     USE_VK_FUNC(vkCmdSetCheckpointNV) \
     USE_VK_FUNC(vkCmdSetCoarseSampleOrderNV) \
+    USE_VK_FUNC(vkCmdSetColorBlendAdvancedEXT) \
+    USE_VK_FUNC(vkCmdSetColorBlendEnableEXT) \
+    USE_VK_FUNC(vkCmdSetColorBlendEquationEXT) \
     USE_VK_FUNC(vkCmdSetColorWriteEnableEXT) \
+    USE_VK_FUNC(vkCmdSetColorWriteMaskEXT) \
+    USE_VK_FUNC(vkCmdSetConservativeRasterizationModeEXT) \
+    USE_VK_FUNC(vkCmdSetCoverageModulationModeNV) \
+    USE_VK_FUNC(vkCmdSetCoverageModulationTableEnableNV) \
+    USE_VK_FUNC(vkCmdSetCoverageModulationTableNV) \
+    USE_VK_FUNC(vkCmdSetCoverageReductionModeNV) \
+    USE_VK_FUNC(vkCmdSetCoverageToColorEnableNV) \
+    USE_VK_FUNC(vkCmdSetCoverageToColorLocationNV) \
     USE_VK_FUNC(vkCmdSetCullMode) \
     USE_VK_FUNC(vkCmdSetCullModeEXT) \
     USE_VK_FUNC(vkCmdSetDepthBias) \
@@ -2421,6 +2630,9 @@ struct vulkan_instance_funcs
     USE_VK_FUNC(vkCmdSetDepthBounds) \
     USE_VK_FUNC(vkCmdSetDepthBoundsTestEnable) \
     USE_VK_FUNC(vkCmdSetDepthBoundsTestEnableEXT) \
+    USE_VK_FUNC(vkCmdSetDepthClampEnableEXT) \
+    USE_VK_FUNC(vkCmdSetDepthClipEnableEXT) \
+    USE_VK_FUNC(vkCmdSetDepthClipNegativeOneToOneEXT) \
     USE_VK_FUNC(vkCmdSetDepthCompareOp) \
     USE_VK_FUNC(vkCmdSetDepthCompareOpEXT) \
     USE_VK_FUNC(vkCmdSetDepthTestEnable) \
@@ -2434,28 +2646,40 @@ struct vulkan_instance_funcs
     USE_VK_FUNC(vkCmdSetEvent2) \
     USE_VK_FUNC(vkCmdSetEvent2KHR) \
     USE_VK_FUNC(vkCmdSetExclusiveScissorNV) \
+    USE_VK_FUNC(vkCmdSetExtraPrimitiveOverestimationSizeEXT) \
     USE_VK_FUNC(vkCmdSetFragmentShadingRateEnumNV) \
     USE_VK_FUNC(vkCmdSetFragmentShadingRateKHR) \
     USE_VK_FUNC(vkCmdSetFrontFace) \
     USE_VK_FUNC(vkCmdSetFrontFaceEXT) \
+    USE_VK_FUNC(vkCmdSetLineRasterizationModeEXT) \
     USE_VK_FUNC(vkCmdSetLineStippleEXT) \
+    USE_VK_FUNC(vkCmdSetLineStippleEnableEXT) \
     USE_VK_FUNC(vkCmdSetLineWidth) \
     USE_VK_FUNC(vkCmdSetLogicOpEXT) \
+    USE_VK_FUNC(vkCmdSetLogicOpEnableEXT) \
     USE_VK_FUNC(vkCmdSetPatchControlPointsEXT) \
     USE_VK_FUNC(vkCmdSetPerformanceMarkerINTEL) \
     USE_VK_FUNC(vkCmdSetPerformanceOverrideINTEL) \
     USE_VK_FUNC(vkCmdSetPerformanceStreamMarkerINTEL) \
+    USE_VK_FUNC(vkCmdSetPolygonModeEXT) \
     USE_VK_FUNC(vkCmdSetPrimitiveRestartEnable) \
     USE_VK_FUNC(vkCmdSetPrimitiveRestartEnableEXT) \
     USE_VK_FUNC(vkCmdSetPrimitiveTopology) \
     USE_VK_FUNC(vkCmdSetPrimitiveTopologyEXT) \
+    USE_VK_FUNC(vkCmdSetProvokingVertexModeEXT) \
+    USE_VK_FUNC(vkCmdSetRasterizationSamplesEXT) \
+    USE_VK_FUNC(vkCmdSetRasterizationStreamEXT) \
     USE_VK_FUNC(vkCmdSetRasterizerDiscardEnable) \
     USE_VK_FUNC(vkCmdSetRasterizerDiscardEnableEXT) \
     USE_VK_FUNC(vkCmdSetRayTracingPipelineStackSizeKHR) \
+    USE_VK_FUNC(vkCmdSetRepresentativeFragmentTestEnableNV) \
     USE_VK_FUNC(vkCmdSetSampleLocationsEXT) \
+    USE_VK_FUNC(vkCmdSetSampleLocationsEnableEXT) \
+    USE_VK_FUNC(vkCmdSetSampleMaskEXT) \
     USE_VK_FUNC(vkCmdSetScissor) \
     USE_VK_FUNC(vkCmdSetScissorWithCount) \
     USE_VK_FUNC(vkCmdSetScissorWithCountEXT) \
+    USE_VK_FUNC(vkCmdSetShadingRateImageEnableNV) \
     USE_VK_FUNC(vkCmdSetStencilCompareMask) \
     USE_VK_FUNC(vkCmdSetStencilOp) \
     USE_VK_FUNC(vkCmdSetStencilOpEXT) \
@@ -2463,9 +2687,12 @@ struct vulkan_instance_funcs
     USE_VK_FUNC(vkCmdSetStencilTestEnable) \
     USE_VK_FUNC(vkCmdSetStencilTestEnableEXT) \
     USE_VK_FUNC(vkCmdSetStencilWriteMask) \
+    USE_VK_FUNC(vkCmdSetTessellationDomainOriginEXT) \
     USE_VK_FUNC(vkCmdSetVertexInputEXT) \
     USE_VK_FUNC(vkCmdSetViewport) \
     USE_VK_FUNC(vkCmdSetViewportShadingRatePaletteNV) \
+    USE_VK_FUNC(vkCmdSetViewportSwizzleNV) \
+    USE_VK_FUNC(vkCmdSetViewportWScalingEnableNV) \
     USE_VK_FUNC(vkCmdSetViewportWScalingNV) \
     USE_VK_FUNC(vkCmdSetViewportWithCount) \
     USE_VK_FUNC(vkCmdSetViewportWithCountEXT) \
@@ -2482,6 +2709,7 @@ struct vulkan_instance_funcs
     USE_VK_FUNC(vkCmdWriteAccelerationStructuresPropertiesNV) \
     USE_VK_FUNC(vkCmdWriteBufferMarker2AMD) \
     USE_VK_FUNC(vkCmdWriteBufferMarkerAMD) \
+    USE_VK_FUNC(vkCmdWriteMicromapsPropertiesEXT) \
     USE_VK_FUNC(vkCmdWriteTimestamp) \
     USE_VK_FUNC(vkCmdWriteTimestamp2) \
     USE_VK_FUNC(vkCmdWriteTimestamp2KHR) \
@@ -2489,6 +2717,9 @@ struct vulkan_instance_funcs
     USE_VK_FUNC(vkCopyAccelerationStructureKHR) \
     USE_VK_FUNC(vkCopyAccelerationStructureToMemoryKHR) \
     USE_VK_FUNC(vkCopyMemoryToAccelerationStructureKHR) \
+    USE_VK_FUNC(vkCopyMemoryToMicromapEXT) \
+    USE_VK_FUNC(vkCopyMicromapEXT) \
+    USE_VK_FUNC(vkCopyMicromapToMemoryEXT) \
     USE_VK_FUNC(vkCreateAccelerationStructureKHR) \
     USE_VK_FUNC(vkCreateAccelerationStructureNV) \
     USE_VK_FUNC(vkCreateBuffer) \
@@ -2509,6 +2740,8 @@ struct vulkan_instance_funcs
     USE_VK_FUNC(vkCreateImage) \
     USE_VK_FUNC(vkCreateImageView) \
     USE_VK_FUNC(vkCreateIndirectCommandsLayoutNV) \
+    USE_VK_FUNC(vkCreateMicromapEXT) \
+    USE_VK_FUNC(vkCreateOpticalFlowSessionNV) \
     USE_VK_FUNC(vkCreatePipelineCache) \
     USE_VK_FUNC(vkCreatePipelineLayout) \
     USE_VK_FUNC(vkCreatePrivateDataSlot) \
@@ -2548,6 +2781,8 @@ struct vulkan_instance_funcs
     USE_VK_FUNC(vkDestroyImage) \
     USE_VK_FUNC(vkDestroyImageView) \
     USE_VK_FUNC(vkDestroyIndirectCommandsLayoutNV) \
+    USE_VK_FUNC(vkDestroyMicromapEXT) \
+    USE_VK_FUNC(vkDestroyOpticalFlowSessionNV) \
     USE_VK_FUNC(vkDestroyPipeline) \
     USE_VK_FUNC(vkDestroyPipelineCache) \
     USE_VK_FUNC(vkDestroyPipelineLayout) \
@@ -2590,6 +2825,7 @@ struct vulkan_instance_funcs
     USE_VK_FUNC(vkGetDeviceAccelerationStructureCompatibilityKHR) \
     USE_VK_FUNC(vkGetDeviceBufferMemoryRequirements) \
     USE_VK_FUNC(vkGetDeviceBufferMemoryRequirementsKHR) \
+    USE_VK_FUNC(vkGetDeviceFaultInfoEXT) \
     USE_VK_FUNC(vkGetDeviceGroupPeerMemoryFeatures) \
     USE_VK_FUNC(vkGetDeviceGroupPeerMemoryFeaturesKHR) \
     USE_VK_FUNC(vkGetDeviceGroupPresentCapabilitiesKHR) \
@@ -2601,6 +2837,7 @@ struct vulkan_instance_funcs
     USE_VK_FUNC(vkGetDeviceMemoryCommitment) \
     USE_VK_FUNC(vkGetDeviceMemoryOpaqueCaptureAddress) \
     USE_VK_FUNC(vkGetDeviceMemoryOpaqueCaptureAddressKHR) \
+    USE_VK_FUNC(vkGetDeviceMicromapCompatibilityEXT) \
     USE_VK_FUNC(vkGetDeviceQueue) \
     USE_VK_FUNC(vkGetDeviceQueue2) \
     USE_VK_FUNC(vkGetDeviceSubpassShadingMaxWorkgroupSizeHUAWEI) \
@@ -2622,6 +2859,7 @@ struct vulkan_instance_funcs
     USE_VK_FUNC(vkGetMemoryHostPointerPropertiesEXT) \
     USE_VK_FUNC(vkGetMemoryWin32HandleKHR) \
     USE_VK_FUNC(vkGetMemoryWin32HandlePropertiesKHR) \
+    USE_VK_FUNC(vkGetMicromapBuildSizesEXT) \
     USE_VK_FUNC(vkGetPerformanceParameterINTEL) \
     USE_VK_FUNC(vkGetPipelineCacheData) \
     USE_VK_FUNC(vkGetPipelineExecutableInternalRepresentationsKHR) \
@@ -2688,7 +2926,8 @@ struct vulkan_instance_funcs
     USE_VK_FUNC(vkWaitForPresentKHR) \
     USE_VK_FUNC(vkWaitSemaphores) \
     USE_VK_FUNC(vkWaitSemaphoresKHR) \
-    USE_VK_FUNC(vkWriteAccelerationStructuresPropertiesKHR)
+    USE_VK_FUNC(vkWriteAccelerationStructuresPropertiesKHR) \
+    USE_VK_FUNC(vkWriteMicromapsPropertiesEXT)

#define ALL_VK_INSTANCE_FUNCS() \
     USE_VK_FUNC(vkCreateDebugReportCallbackEXT) \
@@ -2722,6 +2961,7 @@ struct vulkan_instance_funcs
     USE_VK_FUNC(vkGetPhysicalDeviceMemoryProperties2) \
     USE_VK_FUNC(vkGetPhysicalDeviceMemoryProperties2KHR) \
     USE_VK_FUNC(vkGetPhysicalDeviceMultisamplePropertiesEXT) \
+    USE_VK_FUNC(vkGetPhysicalDeviceOpticalFlowImageFormatsNV) \
     USE_VK_FUNC(vkGetPhysicalDevicePresentRectanglesKHR) \
     USE_VK_FUNC(vkGetPhysicalDeviceProperties) \
     USE_VK_FUNC(vkGetPhysicalDeviceProperties2) \
diff --git a/dlls/winevulkan/winevulkan.json b/dlls/winevulkan/winevulkan.json
index 7eec7cda2a7..984485704d9 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.228"
+        "api_version": "1.3.230"
     }
 }
diff --git a/include/wine/vulkan.h b/include/wine/vulkan.h
index 0ebfc2deeba..821c2d6a3fb 100644
--- a/include/wine/vulkan.h
+++ b/include/wine/vulkan.h
@@ -422,6 +422,8 @@
 #define VK_GOOGLE_USER_TYPE_EXTENSION_NAME "VK_GOOGLE_user_type"
 #define VK_KHR_PIPELINE_LIBRARY_SPEC_VERSION 1
 #define VK_KHR_PIPELINE_LIBRARY_EXTENSION_NAME "VK_KHR_pipeline_library"
+#define VK_NV_PRESENT_BARRIER_SPEC_VERSION 1
+#define VK_NV_PRESENT_BARRIER_EXTENSION_NAME "VK_NV_present_barrier"
 #define VK_KHR_SHADER_NON_SEMANTIC_INFO_SPEC_VERSION 1
 #define VK_KHR_SHADER_NON_SEMANTIC_INFO_EXTENSION_NAME "VK_KHR_shader_non_semantic_info"
 #define VK_KHR_PRESENT_ID_SPEC_VERSION 1
@@ -468,6 +470,8 @@
 #define VK_EXT_ATTACHMENT_FEEDBACK_LOOP_LAYOUT_EXTENSION_NAME "VK_EXT_attachment_feedback_loop_layout"
 #define VK_EXT_4444_FORMATS_SPEC_VERSION 1
 #define VK_EXT_4444_FORMATS_EXTENSION_NAME "VK_EXT_4444_formats"
+#define VK_EXT_DEVICE_FAULT_SPEC_VERSION 1
+#define VK_EXT_DEVICE_FAULT_EXTENSION_NAME "VK_EXT_device_fault"
 #define VK_ARM_RASTERIZATION_ORDER_ATTACHMENT_ACCESS_SPEC_VERSION 1
 #define VK_ARM_RASTERIZATION_ORDER_ATTACHMENT_ACCESS_EXTENSION_NAME "VK_ARM_rasterization_order_attachment_access"
 #define VK_EXT_RGBA10X6_FORMATS_SPEC_VERSION 1
@@ -476,6 +480,8 @@
 #define VK_VALVE_MUTABLE_DESCRIPTOR_TYPE_EXTENSION_NAME "VK_VALVE_mutable_descriptor_type"
 #define VK_EXT_VERTEX_INPUT_DYNAMIC_STATE_SPEC_VERSION 2
 #define VK_EXT_VERTEX_INPUT_DYNAMIC_STATE_EXTENSION_NAME "VK_EXT_vertex_input_dynamic_state"
+#define VK_EXT_DEVICE_ADDRESS_BINDING_REPORT_SPEC_VERSION 1
+#define VK_EXT_DEVICE_ADDRESS_BINDING_REPORT_EXTENSION_NAME "VK_EXT_device_address_binding_report"
 #define VK_EXT_DEPTH_CLIP_CONTROL_SPEC_VERSION 1
 #define VK_EXT_DEPTH_CLIP_CONTROL_EXTENSION_NAME "VK_EXT_depth_clip_control"
 #define VK_EXT_PRIMITIVE_TOPOLOGY_LIST_RESTART_SPEC_VERSION 1
@@ -508,6 +514,8 @@
 #define VK_EXT_IMAGE_2D_VIEW_OF_3D_EXTENSION_NAME "VK_EXT_image_2d_view_of_3d"
 #define VK_KHR_PORTABILITY_ENUMERATION_SPEC_VERSION 1
 #define VK_KHR_PORTABILITY_ENUMERATION_EXTENSION_NAME "VK_KHR_portability_enumeration"
+#define VK_EXT_OPACITY_MICROMAP_SPEC_VERSION 2
+#define VK_EXT_OPACITY_MICROMAP_EXTENSION_NAME "VK_EXT_opacity_micromap"
 #define VK_EXT_LOAD_STORE_OP_NONE_SPEC_VERSION 1
 #define VK_EXT_LOAD_STORE_OP_NONE_EXTENSION_NAME "VK_EXT_load_store_op_none"
 #define VK_EXT_BORDER_COLOR_SWIZZLE_SPEC_VERSION 1
@@ -530,14 +538,20 @@
 #define VK_EXT_IMAGE_COMPRESSION_CONTROL_SWAPCHAIN_EXTENSION_NAME "VK_EXT_image_compression_control_swapchain"
 #define VK_QCOM_IMAGE_PROCESSING_SPEC_VERSION 1
 #define VK_QCOM_IMAGE_PROCESSING_EXTENSION_NAME "VK_QCOM_image_processing"
+#define VK_EXT_EXTENDED_DYNAMIC_STATE_3_SPEC_VERSION 2
+#define VK_EXT_EXTENDED_DYNAMIC_STATE_3_EXTENSION_NAME "VK_EXT_extended_dynamic_state3"
 #define VK_EXT_SUBPASS_MERGE_FEEDBACK_SPEC_VERSION 2
 #define VK_EXT_SUBPASS_MERGE_FEEDBACK_EXTENSION_NAME "VK_EXT_subpass_merge_feedback"
 #define VK_EXT_SHADER_MODULE_IDENTIFIER_SPEC_VERSION 1
 #define VK_EXT_SHADER_MODULE_IDENTIFIER_EXTENSION_NAME "VK_EXT_shader_module_identifier"
 #define VK_EXT_RASTERIZATION_ORDER_ATTACHMENT_ACCESS_SPEC_VERSION 1
 #define VK_EXT_RASTERIZATION_ORDER_ATTACHMENT_ACCESS_EXTENSION_NAME "VK_EXT_rasterization_order_attachment_access"
+#define VK_NV_OPTICAL_FLOW_SPEC_VERSION 1
+#define VK_NV_OPTICAL_FLOW_EXTENSION_NAME "VK_NV_optical_flow"
 #define VK_EXT_LEGACY_DITHERING_SPEC_VERSION 1
 #define VK_EXT_LEGACY_DITHERING_EXTENSION_NAME "VK_EXT_legacy_dithering"
+#define VK_EXT_PIPELINE_PROTECTED_ACCESS_SPEC_VERSION 1
+#define VK_EXT_PIPELINE_PROTECTED_ACCESS_EXTENSION_NAME "VK_EXT_pipeline_protected_access"
 #define VK_QCOM_TILE_PROPERTIES_SPEC_VERSION 1
 #define VK_QCOM_TILE_PROPERTIES_EXTENSION_NAME "VK_QCOM_tile_properties"
 #define VK_EXT_MUTABLE_DESCRIPTOR_TYPE_SPEC_VERSION 1
@@ -566,7 +580,7 @@
 #define VK_API_VERSION_1_1 VK_MAKE_API_VERSION(0, 1, 1, 0)
 #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 VK_HEADER_VERSION 228
+#define VK_HEADER_VERSION 230
 #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
@@ -618,6 +632,8 @@ VK_DEFINE_NON_DISPATCHABLE_HANDLE(VkImage)
 VK_DEFINE_NON_DISPATCHABLE_HANDLE(VkImageView)
 VK_DEFINE_NON_DISPATCHABLE_HANDLE(VkIndirectCommandsLayoutNV)
 VK_DEFINE_HANDLE(VkInstance)
+VK_DEFINE_NON_DISPATCHABLE_HANDLE(VkMicromapEXT)
+VK_DEFINE_NON_DISPATCHABLE_HANDLE(VkOpticalFlowSessionNV)
 VK_DEFINE_NON_DISPATCHABLE_HANDLE(VkPerformanceConfigurationINTEL)
 VK_DEFINE_HANDLE(VkPhysicalDevice)
 VK_DEFINE_NON_DISPATCHABLE_HANDLE(VkPipeline)
@@ -668,6 +684,7 @@ typedef VkFlags VkBufferUsageFlags;
 typedef VkFlags VkBufferViewCreateFlags;
 typedef VkFlags VkBuildAccelerationStructureFlagsKHR;
 typedef VkBuildAccelerationStructureFlagsKHR VkBuildAccelerationStructureFlagsNV;
+typedef VkFlags VkBuildMicromapFlagsEXT;
 typedef VkFlags VkColorComponentFlags;
 typedef VkFlags VkCommandBufferResetFlags;
 typedef VkFlags VkCommandBufferUsageFlags;
@@ -691,6 +708,7 @@ typedef VkFlags VkDescriptorPoolResetFlags;
 typedef VkFlags VkDescriptorSetLayoutCreateFlags;
 typedef VkFlags VkDescriptorUpdateTemplateCreateFlags;
 typedef VkDescriptorUpdateTemplateCreateFlags VkDescriptorUpdateTemplateCreateFlagsKHR;
+typedef VkFlags VkDeviceAddressBindingFlagsEXT;
 typedef VkFlags VkDeviceCreateFlags;
 typedef VkFlags VkDeviceDiagnosticsConfigFlagsNV;
 typedef VkFlags VkDeviceGroupPresentModeFlagsKHR;
@@ -749,6 +767,11 @@ typedef VkFlags VkMemoryHeapFlags;
 typedef VkFlags VkMemoryMapFlags;
 typedef VkFlags VkMemoryPropertyFlags;
 typedef VkFlags VkMetalSurfaceCreateFlagsEXT;
+typedef VkFlags VkMicromapCreateFlagsEXT;
+typedef VkFlags VkOpticalFlowExecuteFlagsNV;
+typedef VkFlags VkOpticalFlowGridSizeFlagsNV;
+typedef VkFlags VkOpticalFlowSessionCreateFlagsNV;
+typedef VkFlags VkOpticalFlowUsageFlagsNV;
 typedef VkFlags VkPeerMemoryFeatureFlags;
 typedef VkPeerMemoryFeatureFlags VkPeerMemoryFeatureFlagsKHR;
 typedef VkFlags VkPerformanceCounterDescriptionFlagsKHR;
@@ -997,6 +1020,10 @@ static const VkAccessFlagBits2 VK_ACCESS_2_SHADER_STORAGE_WRITE_BIT = 0x40000000
 static const VkAccessFlagBits2 VK_ACCESS_2_SHADER_STORAGE_WRITE_BIT_KHR = 0x400000000ull;
 static const VkAccessFlagBits2 VK_ACCESS_2_INVOCATION_MASK_READ_BIT_HUAWEI = 0x8000000000ull;
 static const VkAccessFlagBits2 VK_ACCESS_2_SHADER_BINDING_TABLE_READ_BIT_KHR = 0x10000000000ull;
+static const VkAccessFlagBits2 VK_ACCESS_2_OPTICAL_FLOW_READ_BIT_NV = 0x40000000000ull;
+static const VkAccessFlagBits2 VK_ACCESS_2_OPTICAL_FLOW_WRITE_BIT_NV = 0x80000000000ull;
+static const VkAccessFlagBits2 VK_ACCESS_2_MICROMAP_READ_BIT_EXT = 0x100000000000ull;
+static const VkAccessFlagBits2 VK_ACCESS_2_MICROMAP_WRITE_BIT_EXT = 0x200000000000ull;
 typedef VkAccessFlagBits2 VkAccessFlagBits2KHR;

typedef enum VkAcquireProfilingLockFlagBitsKHR
@@ -1161,6 +1188,8 @@ typedef enum VkBufferUsageFlagBits
     VK_BUFFER_USAGE_SHADER_DEVICE_ADDRESS_BIT = 0x00020000,
     VK_BUFFER_USAGE_ACCELERATION_STRUCTURE_BUILD_INPUT_READ_ONLY_BIT_KHR = 0x00080000,
     VK_BUFFER_USAGE_ACCELERATION_STRUCTURE_STORAGE_BIT_KHR = 0x00100000,
+    VK_BUFFER_USAGE_MICROMAP_BUILD_INPUT_READ_ONLY_BIT_EXT = 0x00800000,
+    VK_BUFFER_USAGE_MICROMAP_STORAGE_BIT_EXT = 0x01000000,
     VK_BUFFER_USAGE_RAY_TRACING_BIT_NV = VK_BUFFER_USAGE_SHADER_BINDING_TABLE_BIT_KHR,
     VK_BUFFER_USAGE_SHADER_DEVICE_ADDRESS_BIT_EXT = VK_BUFFER_USAGE_SHADER_DEVICE_ADDRESS_BIT,
     VK_BUFFER_USAGE_SHADER_DEVICE_ADDRESS_BIT_KHR = VK_BUFFER_USAGE_SHADER_DEVICE_ADDRESS_BIT,
@@ -1175,6 +1204,9 @@ typedef enum VkBuildAccelerationStructureFlagBitsKHR
     VK_BUILD_ACCELERATION_STRUCTURE_PREFER_FAST_BUILD_BIT_KHR = 0x00000008,
     VK_BUILD_ACCELERATION_STRUCTURE_LOW_MEMORY_BIT_KHR = 0x00000010,
     VK_BUILD_ACCELERATION_STRUCTURE_MOTION_BIT_NV = 0x00000020,
+    VK_BUILD_ACCELERATION_STRUCTURE_ALLOW_OPACITY_MICROMAP_UPDATE_EXT = 0x00000040,
+    VK_BUILD_ACCELERATION_STRUCTURE_ALLOW_DISABLE_OPACITY_MICROMAPS_EXT = 0x00000080,
+    VK_BUILD_ACCELERATION_STRUCTURE_ALLOW_OPACITY_MICROMAP_DATA_UPDATE_EXT = 0x00000100,
     VK_BUILD_ACCELERATION_STRUCTURE_ALLOW_UPDATE_BIT_NV = VK_BUILD_ACCELERATION_STRUCTURE_ALLOW_UPDATE_BIT_KHR,
     VK_BUILD_ACCELERATION_STRUCTURE_ALLOW_COMPACTION_BIT_NV = VK_BUILD_ACCELERATION_STRUCTURE_ALLOW_COMPACTION_BIT_KHR,
     VK_BUILD_ACCELERATION_STRUCTURE_PREFER_FAST_TRACE_BIT_NV = VK_BUILD_ACCELERATION_STRUCTURE_PREFER_FAST_TRACE_BIT_KHR,
@@ -1191,6 +1223,20 @@ typedef enum VkBuildAccelerationStructureModeKHR
     VK_BUILD_ACCELERATION_STRUCTURE_MODE_KHR_MAX_ENUM = 0x7fffffff,
 } VkBuildAccelerationStructureModeKHR;

+typedef enum VkBuildMicromapFlagBitsEXT
+{
+    VK_BUILD_MICROMAP_PREFER_FAST_TRACE_BIT_EXT = 0x00000001,
+    VK_BUILD_MICROMAP_PREFER_FAST_BUILD_BIT_EXT = 0x00000002,
+    VK_BUILD_MICROMAP_ALLOW_COMPACTION_BIT_EXT = 0x00000004,
+    VK_BUILD_MICROMAP_FLAG_BITS_EXT_MAX_ENUM = 0x7fffffff,
+} VkBuildMicromapFlagBitsEXT;
+
+typedef enum VkBuildMicromapModeEXT
+{
+    VK_BUILD_MICROMAP_MODE_BUILD_EXT = 0,
+    VK_BUILD_MICROMAP_MODE_EXT_MAX_ENUM = 0x7fffffff,
+} VkBuildMicromapModeEXT;
+
 typedef enum VkChromaLocation
 {
     VK_CHROMA_LOCATION_COSITED_EVEN = 0,
@@ -1352,6 +1398,15 @@ typedef enum VkCopyAccelerationStructureModeKHR
 } VkCopyAccelerationStructureModeKHR;
 typedef VkCopyAccelerationStructureModeKHR VkCopyAccelerationStructureModeNV;

+typedef enum VkCopyMicromapModeEXT
+{
+    VK_COPY_MICROMAP_MODE_CLONE_EXT = 0,
+    VK_COPY_MICROMAP_MODE_SERIALIZE_EXT = 1,
+    VK_COPY_MICROMAP_MODE_DESERIALIZE_EXT = 2,
+    VK_COPY_MICROMAP_MODE_COMPACT_EXT = 3,
+    VK_COPY_MICROMAP_MODE_EXT_MAX_ENUM = 0x7fffffff,
+} VkCopyMicromapModeEXT;
+
 typedef enum VkCoverageModulationModeNV
 {
     VK_COVERAGE_MODULATION_MODE_NONE_NV = 0,
@@ -1448,6 +1503,7 @@ typedef enum VkDebugUtilsMessageTypeFlagBitsEXT
     VK_DEBUG_UTILS_MESSAGE_TYPE_GENERAL_BIT_EXT = 0x00000001,
     VK_DEBUG_UTILS_MESSAGE_TYPE_VALIDATION_BIT_EXT = 0x00000002,
     VK_DEBUG_UTILS_MESSAGE_TYPE_PERFORMANCE_BIT_EXT = 0x00000004,
+    VK_DEBUG_UTILS_MESSAGE_TYPE_DEVICE_ADDRESS_BINDING_BIT_EXT = 0x00000008,
     VK_DEBUG_UTILS_MESSAGE_TYPE_FLAG_BITS_EXT_MAX_ENUM = 0x7fffffff,
 } VkDebugUtilsMessageTypeFlagBitsEXT;

@@ -1529,6 +1585,19 @@ typedef enum VkDescriptorUpdateTemplateType
 } VkDescriptorUpdateTemplateType;
 typedef VkDescriptorUpdateTemplateType VkDescriptorUpdateTemplateTypeKHR;

+typedef enum VkDeviceAddressBindingFlagBitsEXT
+{
+    VK_DEVICE_ADDRESS_BINDING_INTERNAL_OBJECT_BIT_EXT = 0x00000001,
+    VK_DEVICE_ADDRESS_BINDING_FLAG_BITS_EXT_MAX_ENUM = 0x7fffffff,
+} VkDeviceAddressBindingFlagBitsEXT;
+
+typedef enum VkDeviceAddressBindingTypeEXT
+{
+    VK_DEVICE_ADDRESS_BINDING_TYPE_BIND_EXT = 0,
+    VK_DEVICE_ADDRESS_BINDING_TYPE_UNBIND_EXT = 1,
+    VK_DEVICE_ADDRESS_BINDING_TYPE_EXT_MAX_ENUM = 0x7fffffff,
+} VkDeviceAddressBindingTypeEXT;
+
 typedef enum VkDeviceDiagnosticsConfigFlagBitsNV
 {
     VK_DEVICE_DIAGNOSTICS_CONFIG_ENABLE_SHADER_DEBUG_INFO_BIT_NV = 0x00000001,
@@ -1538,6 +1607,24 @@ typedef enum VkDeviceDiagnosticsConfigFlagBitsNV
     VK_DEVICE_DIAGNOSTICS_CONFIG_FLAG_BITS_NV_MAX_ENUM = 0x7fffffff,
 } VkDeviceDiagnosticsConfigFlagBitsNV;

+typedef enum VkDeviceFaultAddressTypeEXT
+{
+    VK_DEVICE_FAULT_ADDRESS_TYPE_NONE_EXT = 0,
+    VK_DEVICE_FAULT_ADDRESS_TYPE_READ_INVALID_EXT = 1,
+    VK_DEVICE_FAULT_ADDRESS_TYPE_WRITE_INVALID_EXT = 2,
+    VK_DEVICE_FAULT_ADDRESS_TYPE_EXECUTE_INVALID_EXT = 3,
+    VK_DEVICE_FAULT_ADDRESS_TYPE_INSTRUCTION_POINTER_UNKNOWN_EXT = 4,
+    VK_DEVICE_FAULT_ADDRESS_TYPE_INSTRUCTION_POINTER_INVALID_EXT = 5,
+    VK_DEVICE_FAULT_ADDRESS_TYPE_INSTRUCTION_POINTER_FAULT_EXT = 6,
+    VK_DEVICE_FAULT_ADDRESS_TYPE_EXT_MAX_ENUM = 0x7fffffff,
+} VkDeviceFaultAddressTypeEXT;
+
+typedef enum VkDeviceFaultVendorBinaryHeaderVersionEXT
+{
+    VK_DEVICE_FAULT_VENDOR_BINARY_HEADER_VERSION_ONE_EXT = 1,
+    VK_DEVICE_FAULT_VENDOR_BINARY_HEADER_VERSION_EXT_MAX_ENUM = 0x7fffffff,
+} VkDeviceFaultVendorBinaryHeaderVersionEXT;
+
 typedef enum VkDeviceGroupPresentModeFlagBitsKHR
 {
     VK_DEVICE_GROUP_PRESENT_MODE_LOCAL_BIT_KHR = 0x00000001,
@@ -1640,6 +1727,37 @@ typedef enum VkDynamicState
     VK_DYNAMIC_STATE_LOGIC_OP_EXT = 1000377003,
     VK_DYNAMIC_STATE_PRIMITIVE_RESTART_ENABLE = 1000377004,
     VK_DYNAMIC_STATE_COLOR_WRITE_ENABLE_EXT = 1000381000,
+    VK_DYNAMIC_STATE_TESSELLATION_DOMAIN_ORIGIN_EXT = 1000455002,
+    VK_DYNAMIC_STATE_DEPTH_CLAMP_ENABLE_EXT = 1000455003,
+    VK_DYNAMIC_STATE_POLYGON_MODE_EXT = 1000455004,
+    VK_DYNAMIC_STATE_RASTERIZATION_SAMPLES_EXT = 1000455005,
+    VK_DYNAMIC_STATE_SAMPLE_MASK_EXT = 1000455006,
+    VK_DYNAMIC_STATE_ALPHA_TO_COVERAGE_ENABLE_EXT = 1000455007,
+    VK_DYNAMIC_STATE_ALPHA_TO_ONE_ENABLE_EXT = 1000455008,
+    VK_DYNAMIC_STATE_LOGIC_OP_ENABLE_EXT = 1000455009,
+    VK_DYNAMIC_STATE_COLOR_BLEND_ENABLE_EXT = 1000455010,
+    VK_DYNAMIC_STATE_COLOR_BLEND_EQUATION_EXT = 1000455011,
+    VK_DYNAMIC_STATE_COLOR_WRITE_MASK_EXT = 1000455012,
+    VK_DYNAMIC_STATE_RASTERIZATION_STREAM_EXT = 1000455013,
+    VK_DYNAMIC_STATE_CONSERVATIVE_RASTERIZATION_MODE_EXT = 1000455014,
+    VK_DYNAMIC_STATE_EXTRA_PRIMITIVE_OVERESTIMATION_SIZE_EXT = 1000455015,
+    VK_DYNAMIC_STATE_DEPTH_CLIP_ENABLE_EXT = 1000455016,
+    VK_DYNAMIC_STATE_SAMPLE_LOCATIONS_ENABLE_EXT = 1000455017,
+    VK_DYNAMIC_STATE_COLOR_BLEND_ADVANCED_EXT = 1000455018,
+    VK_DYNAMIC_STATE_PROVOKING_VERTEX_MODE_EXT = 1000455019,
+    VK_DYNAMIC_STATE_LINE_RASTERIZATION_MODE_EXT = 1000455020,
+    VK_DYNAMIC_STATE_LINE_STIPPLE_ENABLE_EXT = 1000455021,
+    VK_DYNAMIC_STATE_DEPTH_CLIP_NEGATIVE_ONE_TO_ONE_EXT = 1000455022,
+    VK_DYNAMIC_STATE_VIEWPORT_W_SCALING_ENABLE_NV = 1000455023,
+    VK_DYNAMIC_STATE_VIEWPORT_SWIZZLE_NV = 1000455024,
+    VK_DYNAMIC_STATE_COVERAGE_TO_COLOR_ENABLE_NV = 1000455025,
+    VK_DYNAMIC_STATE_COVERAGE_TO_COLOR_LOCATION_NV = 1000455026,
+    VK_DYNAMIC_STATE_COVERAGE_MODULATION_MODE_NV = 1000455027,
+    VK_DYNAMIC_STATE_COVERAGE_MODULATION_TABLE_ENABLE_NV = 1000455028,
+    VK_DYNAMIC_STATE_COVERAGE_MODULATION_TABLE_NV = 1000455029,
+    VK_DYNAMIC_STATE_SHADING_RATE_IMAGE_ENABLE_NV = 1000455030,
+    VK_DYNAMIC_STATE_REPRESENTATIVE_FRAGMENT_TEST_ENABLE_NV = 1000455031,
+    VK_DYNAMIC_STATE_COVERAGE_REDUCTION_MODE_NV = 1000455032,
     VK_DYNAMIC_STATE_CULL_MODE_EXT = VK_DYNAMIC_STATE_CULL_MODE,
     VK_DYNAMIC_STATE_FRONT_FACE_EXT = VK_DYNAMIC_STATE_FRONT_FACE,
     VK_DYNAMIC_STATE_PRIMITIVE_TOPOLOGY_EXT = VK_DYNAMIC_STATE_PRIMITIVE_TOPOLOGY,
@@ -2022,6 +2140,7 @@ typedef enum VkFormat
     VK_FORMAT_G16_B16R16_2PLANE_444_UNORM = 1000330003,
     VK_FORMAT_A4R4G4B4_UNORM_PACK16 = 1000340000,
     VK_FORMAT_A4B4G4R4_UNORM_PACK16 = 1000340001,
+    VK_FORMAT_R16G16_S10_5_NV = 1000464000,
     VK_FORMAT_ASTC_4x4_SFLOAT_BLOCK_EXT = VK_FORMAT_ASTC_4x4_SFLOAT_BLOCK,
     VK_FORMAT_ASTC_5x4_SFLOAT_BLOCK_EXT = VK_FORMAT_ASTC_5x4_SFLOAT_BLOCK,
     VK_FORMAT_ASTC_5x5_SFLOAT_BLOCK_EXT = VK_FORMAT_ASTC_5x5_SFLOAT_BLOCK,
@@ -2186,6 +2305,9 @@ static const VkFormatFeatureFlagBits2 VK_FORMAT_FEATURE_2_WEIGHT_SAMPLED_IMAGE_B
 static const VkFormatFeatureFlagBits2 VK_FORMAT_FEATURE_2_BLOCK_MATCHING_BIT_QCOM = 0x1000000000ull;
 static const VkFormatFeatureFlagBits2 VK_FORMAT_FEATURE_2_BOX_FILTER_SAMPLED_BIT_QCOM = 0x2000000000ull;
 static const VkFormatFeatureFlagBits2 VK_FORMAT_FEATURE_2_LINEAR_COLOR_ATTACHMENT_BIT_NV = 0x4000000000ull;
+static const VkFormatFeatureFlagBits2 VK_FORMAT_FEATURE_2_OPTICAL_FLOW_IMAGE_BIT_NV = 0x10000000000ull;
+static const VkFormatFeatureFlagBits2 VK_FORMAT_FEATURE_2_OPTICAL_FLOW_VECTOR_BIT_NV = 0x20000000000ull;
+static const VkFormatFeatureFlagBits2 VK_FORMAT_FEATURE_2_OPTICAL_FLOW_COST_BIT_NV = 0x40000000000ull;
 typedef VkFormatFeatureFlagBits2 VkFormatFeatureFlagBits2KHR;

typedef enum VkFragmentShadingRateCombinerOpKHR
@@ -2252,6 +2374,8 @@ typedef enum VkGeometryInstanceFlagBitsKHR
     VK_GEOMETRY_INSTANCE_TRIANGLE_FLIP_FACING_BIT_KHR = 0x00000002,
     VK_GEOMETRY_INSTANCE_FORCE_OPAQUE_BIT_KHR = 0x00000004,
     VK_GEOMETRY_INSTANCE_FORCE_NO_OPAQUE_BIT_KHR = 0x00000008,
+    VK_GEOMETRY_INSTANCE_FORCE_OPACITY_MICROMAP_2_STATE_EXT = 0x00000010,
+    VK_GEOMETRY_INSTANCE_DISABLE_OPACITY_MICROMAPS_EXT = 0x00000020,
     VK_GEOMETRY_INSTANCE_TRIANGLE_FRONT_COUNTERCLOCKWISE_BIT_KHR = VK_GEOMETRY_INSTANCE_TRIANGLE_FLIP_FACING_BIT_KHR,
     VK_GEOMETRY_INSTANCE_TRIANGLE_CULL_DISABLE_BIT_NV = VK_GEOMETRY_INSTANCE_TRIANGLE_FACING_CULL_DISABLE_BIT_KHR,
     VK_GEOMETRY_INSTANCE_TRIANGLE_FRONT_COUNTERCLOCKWISE_BIT_NV = VK_GEOMETRY_INSTANCE_TRIANGLE_FRONT_COUNTERCLOCKWISE_BIT_KHR,
@@ -2576,6 +2700,18 @@ typedef enum VkMemoryPropertyFlagBits
     VK_MEMORY_PROPERTY_FLAG_BITS_MAX_ENUM = 0x7fffffff,
 } VkMemoryPropertyFlagBits;

+typedef enum VkMicromapCreateFlagBitsEXT
+{
+    VK_MICROMAP_CREATE_DEVICE_ADDRESS_CAPTURE_REPLAY_BIT_EXT = 0x00000001,
+    VK_MICROMAP_CREATE_FLAG_BITS_EXT_MAX_ENUM = 0x7fffffff,
+} VkMicromapCreateFlagBitsEXT;
+
+typedef enum VkMicromapTypeEXT
+{
+    VK_MICROMAP_TYPE_OPACITY_MICROMAP_EXT = 0,
+    VK_MICROMAP_TYPE_EXT_MAX_ENUM = 0x7fffffff,
+} VkMicromapTypeEXT;
+
 typedef enum VkObjectType
 {
     VK_OBJECT_TYPE_UNKNOWN = 0,
@@ -2619,12 +2755,90 @@ typedef enum VkObjectType
     VK_OBJECT_TYPE_DEFERRED_OPERATION_KHR = 1000268000,
     VK_OBJECT_TYPE_INDIRECT_COMMANDS_LAYOUT_NV = 1000277000,
     VK_OBJECT_TYPE_PRIVATE_DATA_SLOT = 1000295000,
+    VK_OBJECT_TYPE_MICROMAP_EXT = 1000396000,
+    VK_OBJECT_TYPE_OPTICAL_FLOW_SESSION_NV = 1000464000,
     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,
     VK_OBJECT_TYPE_MAX_ENUM = 0x7fffffff,
 } VkObjectType;

+typedef enum VkOpacityMicromapFormatEXT
+{
+    VK_OPACITY_MICROMAP_FORMAT_2_STATE_EXT = 1,
+    VK_OPACITY_MICROMAP_FORMAT_4_STATE_EXT = 2,
+    VK_OPACITY_MICROMAP_FORMAT_EXT_MAX_ENUM = 0x7fffffff,
+} VkOpacityMicromapFormatEXT;
+
+typedef enum VkOpacityMicromapSpecialIndexEXT
+{
+    VK_OPACITY_MICROMAP_SPECIAL_INDEX_FULLY_UNKNOWN_OPAQUE_EXT = -4,
+    VK_OPACITY_MICROMAP_SPECIAL_INDEX_FULLY_UNKNOWN_TRANSPARENT_EXT = -3,
+    VK_OPACITY_MICROMAP_SPECIAL_INDEX_FULLY_OPAQUE_EXT = -2,
+    VK_OPACITY_MICROMAP_SPECIAL_INDEX_FULLY_TRANSPARENT_EXT = -1,
+    VK_OPACITY_MICROMAP_SPECIAL_INDEX_EXT_MAX_ENUM = 0x7fffffff,
+} VkOpacityMicromapSpecialIndexEXT;
+
+typedef enum VkOpticalFlowExecuteFlagBitsNV
+{
+    VK_OPTICAL_FLOW_EXECUTE_DISABLE_TEMPORAL_HINTS_BIT_NV = 0x00000001,
+    VK_OPTICAL_FLOW_EXECUTE_FLAG_BITS_NV_MAX_ENUM = 0x7fffffff,
+} VkOpticalFlowExecuteFlagBitsNV;
+
+typedef enum VkOpticalFlowGridSizeFlagBitsNV
+{
+    VK_OPTICAL_FLOW_GRID_SIZE_UNKNOWN_NV = 0,
+    VK_OPTICAL_FLOW_GRID_SIZE_1X1_BIT_NV = 0x00000001,
+    VK_OPTICAL_FLOW_GRID_SIZE_2X2_BIT_NV = 0x00000002,
+    VK_OPTICAL_FLOW_GRID_SIZE_4X4_BIT_NV = 0x00000004,
+    VK_OPTICAL_FLOW_GRID_SIZE_8X8_BIT_NV = 0x00000008,
+    VK_OPTICAL_FLOW_GRID_SIZE_FLAG_BITS_NV_MAX_ENUM = 0x7fffffff,
+} VkOpticalFlowGridSizeFlagBitsNV;
+
+typedef enum VkOpticalFlowPerformanceLevelNV
+{
+    VK_OPTICAL_FLOW_PERFORMANCE_LEVEL_UNKNOWN_NV = 0,
+    VK_OPTICAL_FLOW_PERFORMANCE_LEVEL_SLOW_NV = 1,
+    VK_OPTICAL_FLOW_PERFORMANCE_LEVEL_MEDIUM_NV = 2,
+    VK_OPTICAL_FLOW_PERFORMANCE_LEVEL_FAST_NV = 3,
+    VK_OPTICAL_FLOW_PERFORMANCE_LEVEL_NV_MAX_ENUM = 0x7fffffff,
+} VkOpticalFlowPerformanceLevelNV;
+
+typedef enum VkOpticalFlowSessionBindingPointNV
+{
+    VK_OPTICAL_FLOW_SESSION_BINDING_POINT_UNKNOWN_NV = 0,
+    VK_OPTICAL_FLOW_SESSION_BINDING_POINT_INPUT_NV = 1,
+    VK_OPTICAL_FLOW_SESSION_BINDING_POINT_REFERENCE_NV = 2,
+    VK_OPTICAL_FLOW_SESSION_BINDING_POINT_HINT_NV = 3,
+    VK_OPTICAL_FLOW_SESSION_BINDING_POINT_FLOW_VECTOR_NV = 4,
+    VK_OPTICAL_FLOW_SESSION_BINDING_POINT_BACKWARD_FLOW_VECTOR_NV = 5,
+    VK_OPTICAL_FLOW_SESSION_BINDING_POINT_COST_NV = 6,
+    VK_OPTICAL_FLOW_SESSION_BINDING_POINT_BACKWARD_COST_NV = 7,
+    VK_OPTICAL_FLOW_SESSION_BINDING_POINT_GLOBAL_FLOW_NV = 8,
+    VK_OPTICAL_FLOW_SESSION_BINDING_POINT_NV_MAX_ENUM = 0x7fffffff,
+} VkOpticalFlowSessionBindingPointNV;
+
+typedef enum VkOpticalFlowSessionCreateFlagBitsNV
+{
+    VK_OPTICAL_FLOW_SESSION_CREATE_ENABLE_HINT_BIT_NV = 0x00000001,
+    VK_OPTICAL_FLOW_SESSION_CREATE_ENABLE_COST_BIT_NV = 0x00000002,
+    VK_OPTICAL_FLOW_SESSION_CREATE_ENABLE_GLOBAL_FLOW_BIT_NV = 0x00000004,
+    VK_OPTICAL_FLOW_SESSION_CREATE_ALLOW_REGIONS_BIT_NV = 0x00000008,
+    VK_OPTICAL_FLOW_SESSION_CREATE_BOTH_DIRECTIONS_BIT_NV = 0x00000010,
+    VK_OPTICAL_FLOW_SESSION_CREATE_FLAG_BITS_NV_MAX_ENUM = 0x7fffffff,
+} VkOpticalFlowSessionCreateFlagBitsNV;
+
+typedef enum VkOpticalFlowUsageFlagBitsNV
+{
+    VK_OPTICAL_FLOW_USAGE_UNKNOWN_NV = 0,
+    VK_OPTICAL_FLOW_USAGE_INPUT_BIT_NV = 0x00000001,
+    VK_OPTICAL_FLOW_USAGE_OUTPUT_BIT_NV = 0x00000002,
+    VK_OPTICAL_FLOW_USAGE_HINT_BIT_NV = 0x00000004,
+    VK_OPTICAL_FLOW_USAGE_COST_BIT_NV = 0x00000008,
+    VK_OPTICAL_FLOW_USAGE_GLOBAL_FLOW_BIT_NV = 0x00000010,
+    VK_OPTICAL_FLOW_USAGE_FLAG_BITS_NV_MAX_ENUM = 0x7fffffff,
+} VkOpticalFlowUsageFlagBitsNV;
+
 typedef enum VkPeerMemoryFeatureFlagBits
 {
     VK_PEER_MEMORY_FEATURE_COPY_SRC_BIT = 0x00000001,
@@ -2787,8 +3001,11 @@ typedef enum VkPipelineCreateFlagBits
     VK_PIPELINE_CREATE_RENDERING_FRAGMENT_SHADING_RATE_ATTACHMENT_BIT_KHR = 0x00200000,
     VK_PIPELINE_CREATE_RENDERING_FRAGMENT_DENSITY_MAP_ATTACHMENT_BIT_EXT = 0x00400000,
     VK_PIPELINE_CREATE_RETAIN_LINK_TIME_OPTIMIZATION_INFO_BIT_EXT = 0x00800000,
+    VK_PIPELINE_CREATE_RAY_TRACING_OPACITY_MICROMAP_BIT_EXT = 0x01000000,
     VK_PIPELINE_CREATE_COLOR_ATTACHMENT_FEEDBACK_LOOP_BIT_EXT = 0x02000000,
     VK_PIPELINE_CREATE_DEPTH_STENCIL_ATTACHMENT_FEEDBACK_LOOP_BIT_EXT = 0x04000000,
+    VK_PIPELINE_CREATE_NO_PROTECTED_ACCESS_BIT_EXT = 0x08000000,
+    VK_PIPELINE_CREATE_PROTECTED_ACCESS_ONLY_BIT_EXT = 0x40000000,
     VK_PIPELINE_CREATE_DISPATCH_BASE = VK_PIPELINE_CREATE_DISPATCH_BASE_BIT,
     VK_PIPELINE_RASTERIZATION_STATE_CREATE_FRAGMENT_SHADING_RATE_ATTACHMENT_BIT_KHR = VK_PIPELINE_CREATE_RENDERING_FRAGMENT_SHADING_RATE_ATTACHMENT_BIT_KHR,
     VK_PIPELINE_RASTERIZATION_STATE_CREATE_FRAGMENT_DENSITY_MAP_ATTACHMENT_BIT_EXT = VK_PIPELINE_CREATE_RENDERING_FRAGMENT_DENSITY_MAP_ATTACHMENT_BIT_EXT,
@@ -2955,6 +3172,8 @@ static const VkPipelineStageFlagBits2 VK_PIPELINE_STAGE_2_TRANSFORM_FEEDBACK_BIT
 static const VkPipelineStageFlagBits2 VK_PIPELINE_STAGE_2_ACCELERATION_STRUCTURE_BUILD_BIT_KHR = 0x02000000ull;
 static const VkPipelineStageFlagBits2 VK_PIPELINE_STAGE_2_ACCELERATION_STRUCTURE_BUILD_BIT_NV = 0x02000000ull;
 static const VkPipelineStageFlagBits2 VK_PIPELINE_STAGE_2_ACCELERATION_STRUCTURE_COPY_BIT_KHR = 0x10000000ull;
+static const VkPipelineStageFlagBits2 VK_PIPELINE_STAGE_2_OPTICAL_FLOW_BIT_NV = 0x20000000ull;
+static const VkPipelineStageFlagBits2 VK_PIPELINE_STAGE_2_MICROMAP_BUILD_BIT_EXT = 0x40000000ull;
 static const VkPipelineStageFlagBits2 VK_PIPELINE_STAGE_2_COPY_BIT = 0x100000000ull;
 static const VkPipelineStageFlagBits2 VK_PIPELINE_STAGE_2_COPY_BIT_KHR = 0x100000000ull;
 static const VkPipelineStageFlagBits2 VK_PIPELINE_STAGE_2_RESOLVE_BIT = 0x200000000ull;
@@ -3078,6 +3297,8 @@ typedef enum VkQueryType
     VK_QUERY_TYPE_PRIMITIVES_GENERATED_EXT = 1000382000,
     VK_QUERY_TYPE_ACCELERATION_STRUCTURE_SERIALIZATION_BOTTOM_LEVEL_POINTERS_KHR = 1000386000,
     VK_QUERY_TYPE_ACCELERATION_STRUCTURE_SIZE_KHR = 1000386001,
+    VK_QUERY_TYPE_MICROMAP_SERIALIZATION_SIZE_EXT = 1000396000,
+    VK_QUERY_TYPE_MICROMAP_COMPACTED_SIZE_EXT = 1000396001,
     VK_QUERY_TYPE_MAX_ENUM = 0x7fffffff,
 } VkQueryType;

@@ -3088,6 +3309,7 @@ typedef enum VkQueueFlagBits
     VK_QUEUE_TRANSFER_BIT = 0x00000004,
     VK_QUEUE_SPARSE_BINDING_BIT = 0x00000008,
     VK_QUEUE_PROTECTED_BIT = 0x00000010,
+    VK_QUEUE_OPTICAL_FLOW_BIT_NV = 0x00000100,
     VK_QUEUE_FLAG_BITS_MAX_ENUM = 0x7fffffff,
 } VkQueueFlagBits;

@@ -3842,6 +4064,9 @@ typedef enum VkStructureType
     VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_CUSTOM_BORDER_COLOR_PROPERTIES_EXT = 1000287001,
     VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_CUSTOM_BORDER_COLOR_FEATURES_EXT = 1000287002,
     VK_STRUCTURE_TYPE_PIPELINE_LIBRARY_CREATE_INFO_KHR = 1000290000,
+    VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PRESENT_BARRIER_FEATURES_NV = 1000292000,
+    VK_STRUCTURE_TYPE_SURFACE_CAPABILITIES_PRESENT_BARRIER_NV = 1000292001,
+    VK_STRUCTURE_TYPE_SWAPCHAIN_PRESENT_BARRIER_CREATE_INFO_NV = 1000292002,
     VK_STRUCTURE_TYPE_PRESENT_ID_KHR = 1000294000,
     VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PRESENT_ID_FEATURES_KHR = 1000294001,
     VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PRIVATE_DATA_FEATURES = 1000295000,
@@ -3899,6 +4124,9 @@ typedef enum VkStructureType
     VK_STRUCTURE_TYPE_IMAGE_COMPRESSION_PROPERTIES_EXT = 1000338004,
     VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ATTACHMENT_FEEDBACK_LOOP_LAYOUT_FEATURES_EXT = 1000339000,
     VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_4444_FORMATS_FEATURES_EXT = 1000340000,
+    VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FAULT_FEATURES_EXT = 1000341000,
+    VK_STRUCTURE_TYPE_DEVICE_FAULT_COUNTS_EXT = 1000341001,
+    VK_STRUCTURE_TYPE_DEVICE_FAULT_INFO_EXT = 1000341002,
     VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RASTERIZATION_ORDER_ATTACHMENT_ACCESS_FEATURES_EXT = 1000342000,
     VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RGBA10X6_FORMATS_FEATURES_EXT = 1000344000,
     VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RAY_TRACING_PIPELINE_FEATURES_KHR = 1000347000,
@@ -3909,6 +4137,8 @@ typedef enum VkStructureType
     VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VERTEX_INPUT_DYNAMIC_STATE_FEATURES_EXT = 1000352000,
     VK_STRUCTURE_TYPE_VERTEX_INPUT_BINDING_DESCRIPTION_2_EXT = 1000352001,
     VK_STRUCTURE_TYPE_VERTEX_INPUT_ATTRIBUTE_DESCRIPTION_2_EXT = 1000352002,
+    VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ADDRESS_BINDING_REPORT_FEATURES_EXT = 1000354000,
+    VK_STRUCTURE_TYPE_DEVICE_ADDRESS_BINDING_CALLBACK_DATA_EXT = 1000354001,
     VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DEPTH_CLIP_CONTROL_FEATURES_EXT = 1000355000,
     VK_STRUCTURE_TYPE_PIPELINE_VIEWPORT_DEPTH_CLIP_CONTROL_CREATE_INFO_EXT = 1000355001,
     VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PRIMITIVE_TOPOLOGY_LIST_RESTART_FEATURES_EXT = 1000356000,
@@ -3934,6 +4164,16 @@ typedef enum VkStructureType
     VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MULTI_DRAW_FEATURES_EXT = 1000392000,
     VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MULTI_DRAW_PROPERTIES_EXT = 1000392001,
     VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_2D_VIEW_OF_3D_FEATURES_EXT = 1000393000,
+    VK_STRUCTURE_TYPE_MICROMAP_BUILD_INFO_EXT = 1000396000,
+    VK_STRUCTURE_TYPE_MICROMAP_VERSION_INFO_EXT = 1000396001,
+    VK_STRUCTURE_TYPE_COPY_MICROMAP_INFO_EXT = 1000396002,
+    VK_STRUCTURE_TYPE_COPY_MICROMAP_TO_MEMORY_INFO_EXT = 1000396003,
+    VK_STRUCTURE_TYPE_COPY_MEMORY_TO_MICROMAP_INFO_EXT = 1000396004,
+    VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_OPACITY_MICROMAP_FEATURES_EXT = 1000396005,
+    VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_OPACITY_MICROMAP_PROPERTIES_EXT = 1000396006,
+    VK_STRUCTURE_TYPE_MICROMAP_CREATE_INFO_EXT = 1000396007,
+    VK_STRUCTURE_TYPE_MICROMAP_BUILD_SIZES_INFO_EXT = 1000396008,
+    VK_STRUCTURE_TYPE_ACCELERATION_STRUCTURE_TRIANGLES_OPACITY_MICROMAP_EXT = 1000396009,
     VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_BORDER_COLOR_SWIZZLE_FEATURES_EXT = 1000411000,
     VK_STRUCTURE_TYPE_SAMPLER_BORDER_COLOR_COMPONENT_MAPPING_CREATE_INFO_EXT = 1000411001,
     VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PAGEABLE_DEVICE_LOCAL_MEMORY_FEATURES_EXT = 1000412000,
@@ -3954,6 +4194,8 @@ typedef enum VkStructureType
     VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_PROCESSING_FEATURES_QCOM = 1000440000,
     VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_PROCESSING_PROPERTIES_QCOM = 1000440001,
     VK_STRUCTURE_TYPE_IMAGE_VIEW_SAMPLE_WEIGHT_CREATE_INFO_QCOM = 1000440002,
+    VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTENDED_DYNAMIC_STATE_3_FEATURES_EXT = 1000455000,
+    VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTENDED_DYNAMIC_STATE_3_PROPERTIES_EXT = 1000455001,
     VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SUBPASS_MERGE_FEEDBACK_FEATURES_EXT = 1000458000,
     VK_STRUCTURE_TYPE_RENDER_PASS_CREATION_CONTROL_EXT = 1000458001,
     VK_STRUCTURE_TYPE_RENDER_PASS_CREATION_FEEDBACK_CREATE_INFO_EXT = 1000458002,
@@ -3962,7 +4204,15 @@ typedef enum VkStructureType
     VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_MODULE_IDENTIFIER_PROPERTIES_EXT = 1000462001,
     VK_STRUCTURE_TYPE_PIPELINE_SHADER_STAGE_MODULE_IDENTIFIER_CREATE_INFO_EXT = 1000462002,
     VK_STRUCTURE_TYPE_SHADER_MODULE_IDENTIFIER_EXT = 1000462003,
+    VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_OPTICAL_FLOW_FEATURES_NV = 1000464000,
+    VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_OPTICAL_FLOW_PROPERTIES_NV = 1000464001,
+    VK_STRUCTURE_TYPE_OPTICAL_FLOW_IMAGE_FORMAT_INFO_NV = 1000464002,
+    VK_STRUCTURE_TYPE_OPTICAL_FLOW_IMAGE_FORMAT_PROPERTIES_NV = 1000464003,
+    VK_STRUCTURE_TYPE_OPTICAL_FLOW_SESSION_CREATE_INFO_NV = 1000464004,
+    VK_STRUCTURE_TYPE_OPTICAL_FLOW_EXECUTE_INFO_NV = 1000464005,
+    VK_STRUCTURE_TYPE_OPTICAL_FLOW_SESSION_CREATE_PRIVATE_DATA_INFO_NV = 1000464010,
     VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_LEGACY_DITHERING_FEATURES_EXT = 1000465000,
+    VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PIPELINE_PROTECTED_ACCESS_FEATURES_EXT = 1000466000,
     VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TILE_PROPERTIES_FEATURES_QCOM = 1000484000,
     VK_STRUCTURE_TYPE_TILE_PROPERTIES_QCOM = 1000484001,
     VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VARIABLE_POINTER_FEATURES = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VARIABLE_POINTERS_FEATURES,
@@ -4807,6 +5057,25 @@ typedef struct VkCoarseSampleOrderCustomNV
     const VkCoarseSampleLocationNV *pSampleLocations;
 } VkCoarseSampleOrderCustomNV;

+typedef struct VkColorBlendAdvancedEXT
+{
+    VkBlendOp advancedBlendOp;
+    VkBool32 srcPremultiplied;
+    VkBool32 dstPremultiplied;
+    VkBlendOverlapEXT blendOverlap;
+    VkBool32 clampResults;
+} VkColorBlendAdvancedEXT;
+
+typedef struct VkColorBlendEquationEXT
+{
+    VkBlendFactor srcColorBlendFactor;
+    VkBlendFactor dstColorBlendFactor;
+    VkBlendOp colorBlendOp;
+    VkBlendFactor srcAlphaBlendFactor;
+    VkBlendFactor dstAlphaBlendFactor;
+    VkBlendOp alphaBlendOp;
+} VkColorBlendEquationEXT;
+
 typedef struct VkCommandBufferAllocateInfo
 {
     VkStructureType sType;
@@ -4946,6 +5215,15 @@ typedef struct VkCopyDescriptorSet
     uint32_t descriptorCount;
 } VkCopyDescriptorSet;

+typedef struct VkCopyMicromapInfoEXT
+{
+    VkStructureType sType;
+    const void *pNext;
+    VkMicromapEXT WINE_VK_ALIGN(8) src;
+    VkMicromapEXT WINE_VK_ALIGN(8) dst;
+    VkCopyMicromapModeEXT mode;
+} VkCopyMicromapInfoEXT;
+
 typedef struct VkCuFunctionCreateInfoNVX
 {
     VkStructureType sType;
@@ -5194,6 +5472,16 @@ typedef struct VkDescriptorUpdateTemplateEntry
 } VkDescriptorUpdateTemplateEntry;
 typedef VkDescriptorUpdateTemplateEntry VkDescriptorUpdateTemplateEntryKHR;

+typedef struct VkDeviceAddressBindingCallbackDataEXT
+{
+    VkStructureType sType;
+    void *pNext;
+    VkDeviceAddressBindingFlagsEXT flags;
+    VkDeviceAddress baseAddress;
+    VkDeviceSize WINE_VK_ALIGN(8) size;
+    VkDeviceAddressBindingTypeEXT bindingType;
+} VkDeviceAddressBindingCallbackDataEXT;
+
 typedef struct VkDeviceBufferMemoryRequirements
 {
     VkStructureType sType;
@@ -5209,6 +5497,42 @@ typedef struct VkDeviceDiagnosticsConfigCreateInfoNV
     VkDeviceDiagnosticsConfigFlagsNV flags;
 } VkDeviceDiagnosticsConfigCreateInfoNV;

+typedef struct VkDeviceFaultAddressInfoEXT
+{
+    VkDeviceFaultAddressTypeEXT addressType;
+    VkDeviceAddress reportedAddress;
+    VkDeviceSize WINE_VK_ALIGN(8) addressPrecision;
+} VkDeviceFaultAddressInfoEXT;
+
+typedef struct VkDeviceFaultCountsEXT
+{
+    VkStructureType sType;
+    void *pNext;
+    uint32_t addressInfoCount;
+    uint32_t vendorInfoCount;
+    VkDeviceSize WINE_VK_ALIGN(8) vendorBinarySize;
+} VkDeviceFaultCountsEXT;
+
+typedef struct VkDeviceFaultVendorBinaryHeaderVersionOneEXT
+{
+    uint32_t headerSize;
+    VkDeviceFaultVendorBinaryHeaderVersionEXT headerVersion;
+    uint32_t vendorID;
+    uint32_t deviceID;
+    uint32_t driverVersion;
+    uint8_t pipelineCacheUUID[VK_UUID_SIZE];
+    uint32_t applicationNameOffset;
+    uint32_t applicationVersion;
+    uint32_t engineNameOffset;
+} VkDeviceFaultVendorBinaryHeaderVersionOneEXT;
+
+typedef struct VkDeviceFaultVendorInfoEXT
+{
+    char description[VK_MAX_DESCRIPTION_SIZE];
+    uint64_t WINE_VK_ALIGN(8) vendorFaultCode;
+    uint64_t WINE_VK_ALIGN(8) vendorFaultData;
+} VkDeviceFaultVendorInfoEXT;
+
 typedef struct VkDeviceGroupBindSparseInfo
 {
     VkStructureType sType;
@@ -6000,6 +6324,48 @@ typedef struct VkMemoryWin32HandlePropertiesKHR
     uint32_t memoryTypeBits;
 } VkMemoryWin32HandlePropertiesKHR;

+typedef struct VkMicromapBuildSizesInfoEXT
+{
+    VkStructureType sType;
+    const void *pNext;
+    VkDeviceSize WINE_VK_ALIGN(8) micromapSize;
+    VkDeviceSize WINE_VK_ALIGN(8) buildScratchSize;
+    VkBool32 discardable;
+} VkMicromapBuildSizesInfoEXT;
+
+typedef struct VkMicromapCreateInfoEXT
+{
+    VkStructureType sType;
+    const void *pNext;
+    VkMicromapCreateFlagsEXT createFlags;
+    VkBuffer WINE_VK_ALIGN(8) buffer;
+    VkDeviceSize WINE_VK_ALIGN(8) offset;
+    VkDeviceSize WINE_VK_ALIGN(8) size;
+    VkMicromapTypeEXT type;
+    VkDeviceAddress deviceAddress;
+} VkMicromapCreateInfoEXT;
+
+typedef struct VkMicromapTriangleEXT
+{
+    uint32_t dataOffset;
+    uint16_t subdivisionLevel;
+    uint16_t format;
+} VkMicromapTriangleEXT;
+
+typedef struct VkMicromapUsageEXT
+{
+    uint32_t count;
+    uint32_t subdivisionLevel;
+    uint32_t format;
+} VkMicromapUsageEXT;
+
+typedef struct VkMicromapVersionInfoEXT
+{
+    VkStructureType sType;
+    const void *pNext;
+    const uint8_t *pVersionData;
+} VkMicromapVersionInfoEXT;
+
 typedef struct VkMultiDrawIndexedInfoEXT
 {
     uint32_t firstIndex;
@@ -6056,6 +6422,44 @@ typedef struct VkOffset3D
     int32_t z;
 } VkOffset3D;

+typedef struct VkOpticalFlowImageFormatInfoNV
+{
+    VkStructureType sType;
+    const void *pNext;
+    VkOpticalFlowUsageFlagsNV usage;
+} VkOpticalFlowImageFormatInfoNV;
+
+typedef struct VkOpticalFlowImageFormatPropertiesNV
+{
+    VkStructureType sType;
+    const void *pNext;
+    VkFormat format;
+} VkOpticalFlowImageFormatPropertiesNV;
+
+typedef struct VkOpticalFlowSessionCreateInfoNV
+{
+    VkStructureType sType;
+    void *pNext;
+    uint32_t width;
+    uint32_t height;
+    VkFormat imageFormat;
+    VkFormat flowVectorFormat;
+    VkFormat costFormat;
+    VkOpticalFlowGridSizeFlagsNV outputGridSize;
+    VkOpticalFlowGridSizeFlagsNV hintGridSize;
+    VkOpticalFlowPerformanceLevelNV performanceLevel;
+    VkOpticalFlowSessionCreateFlagsNV flags;
+} VkOpticalFlowSessionCreateInfoNV;
+
+typedef struct VkOpticalFlowSessionCreatePrivateDataInfoNV
+{
+    VkStructureType sType;
+    void *pNext;
+    uint32_t id;
+    uint32_t size;
+    const void *pPrivateData;
+} VkOpticalFlowSessionCreatePrivateDataInfoNV;
+
 typedef struct VkPerformanceConfigurationAcquireInfoINTEL
 {
     VkStructureType sType;
@@ -6199,6 +6603,13 @@ typedef struct VkPhysicalDeviceAccelerationStructurePropertiesKHR
     uint32_t minAccelerationStructureScratchOffsetAlignment;
 } VkPhysicalDeviceAccelerationStructurePropertiesKHR;

+typedef struct VkPhysicalDeviceAddressBindingReportFeaturesEXT
+{
+    VkStructureType sType;
+    void *pNext;
+    VkBool32 reportAddressBinding;
+} VkPhysicalDeviceAddressBindingReportFeaturesEXT;
+
 typedef struct VkPhysicalDeviceAttachmentFeedbackLoopLayoutFeaturesEXT
 {
     VkStructureType sType;
@@ -6516,6 +6927,50 @@ typedef struct VkPhysicalDeviceExtendedDynamicState2FeaturesEXT
     VkBool32 extendedDynamicState2PatchControlPoints;
 } VkPhysicalDeviceExtendedDynamicState2FeaturesEXT;

+typedef struct VkPhysicalDeviceExtendedDynamicState3FeaturesEXT
+{
+    VkStructureType sType;
+    void *pNext;
+    VkBool32 extendedDynamicState3TessellationDomainOrigin;
+    VkBool32 extendedDynamicState3DepthClampEnable;
+    VkBool32 extendedDynamicState3PolygonMode;
+    VkBool32 extendedDynamicState3RasterizationSamples;
+    VkBool32 extendedDynamicState3SampleMask;
+    VkBool32 extendedDynamicState3AlphaToCoverageEnable;
+    VkBool32 extendedDynamicState3AlphaToOneEnable;
+    VkBool32 extendedDynamicState3LogicOpEnable;
+    VkBool32 extendedDynamicState3ColorBlendEnable;
+    VkBool32 extendedDynamicState3ColorBlendEquation;
+    VkBool32 extendedDynamicState3ColorWriteMask;
+    VkBool32 extendedDynamicState3RasterizationStream;
+    VkBool32 extendedDynamicState3ConservativeRasterizationMode;
+    VkBool32 extendedDynamicState3ExtraPrimitiveOverestimationSize;
+    VkBool32 extendedDynamicState3DepthClipEnable;
+    VkBool32 extendedDynamicState3SampleLocationsEnable;
+    VkBool32 extendedDynamicState3ColorBlendAdvanced;
+    VkBool32 extendedDynamicState3ProvokingVertexMode;
+    VkBool32 extendedDynamicState3LineRasterizationMode;
+    VkBool32 extendedDynamicState3LineStippleEnable;
+    VkBool32 extendedDynamicState3DepthClipNegativeOneToOne;
+    VkBool32 extendedDynamicState3ViewportWScalingEnable;
+    VkBool32 extendedDynamicState3ViewportSwizzle;
+    VkBool32 extendedDynamicState3CoverageToColorEnable;
+    VkBool32 extendedDynamicState3CoverageToColorLocation;
+    VkBool32 extendedDynamicState3CoverageModulationMode;
+    VkBool32 extendedDynamicState3CoverageModulationTableEnable;
+    VkBool32 extendedDynamicState3CoverageModulationTable;
+    VkBool32 extendedDynamicState3CoverageReductionMode;
+    VkBool32 extendedDynamicState3RepresentativeFragmentTestEnable;
+    VkBool32 extendedDynamicState3ShadingRateImageEnable;
+} VkPhysicalDeviceExtendedDynamicState3FeaturesEXT;
+
+typedef struct VkPhysicalDeviceExtendedDynamicState3PropertiesEXT
+{
+    VkStructureType sType;
+    void *pNext;
+    VkBool32 dynamicPrimitiveTopologyUnrestricted;
+} VkPhysicalDeviceExtendedDynamicState3PropertiesEXT;
+
 typedef struct VkPhysicalDeviceExtendedDynamicStateFeaturesEXT
 {
     VkStructureType sType;
@@ -6564,6 +7019,14 @@ typedef struct VkPhysicalDeviceExternalSemaphoreInfo
 } VkPhysicalDeviceExternalSemaphoreInfo;
 typedef VkPhysicalDeviceExternalSemaphoreInfo VkPhysicalDeviceExternalSemaphoreInfoKHR;

+typedef struct VkPhysicalDeviceFaultFeaturesEXT
+{
+    VkStructureType sType;
+    void *pNext;
+    VkBool32 deviceFault;
+    VkBool32 deviceFaultVendorBinary;
+} VkPhysicalDeviceFaultFeaturesEXT;
+
 typedef struct VkPhysicalDeviceFeatures
 {
     VkBool32 robustBufferAccess;
@@ -7288,6 +7751,47 @@ typedef struct VkPhysicalDeviceNonSeamlessCubeMapFeaturesEXT
     VkBool32 nonSeamlessCubeMap;
 } VkPhysicalDeviceNonSeamlessCubeMapFeaturesEXT;

+typedef struct VkPhysicalDeviceOpacityMicromapFeaturesEXT
+{
+    VkStructureType sType;
+    void *pNext;
+    VkBool32 micromap;
+    VkBool32 micromapCaptureReplay;
+    VkBool32 micromapHostCommands;
+} VkPhysicalDeviceOpacityMicromapFeaturesEXT;
+
+typedef struct VkPhysicalDeviceOpacityMicromapPropertiesEXT
+{
+    VkStructureType sType;
+    void *pNext;
+    uint32_t maxOpacity2StateSubdivisionLevel;
+    uint32_t maxOpacity4StateSubdivisionLevel;
+} VkPhysicalDeviceOpacityMicromapPropertiesEXT;
+
+typedef struct VkPhysicalDeviceOpticalFlowFeaturesNV
+{
+    VkStructureType sType;
+    void *pNext;
+    VkBool32 opticalFlow;
+} VkPhysicalDeviceOpticalFlowFeaturesNV;
+
+typedef struct VkPhysicalDeviceOpticalFlowPropertiesNV
+{
+    VkStructureType sType;
+    void *pNext;
+    VkOpticalFlowGridSizeFlagsNV supportedOutputGridSizes;
+    VkOpticalFlowGridSizeFlagsNV supportedHintGridSizes;
+    VkBool32 hintSupported;
+    VkBool32 costSupported;
+    VkBool32 bidirectionalFlowSupported;
+    VkBool32 globalFlowSupported;
+    uint32_t minWidth;
+    uint32_t minHeight;
+    uint32_t maxWidth;
+    uint32_t maxHeight;
+    uint32_t maxNumRegionsOfInterest;
+} VkPhysicalDeviceOpticalFlowPropertiesNV;
+
 typedef struct VkPhysicalDevicePCIBusInfoPropertiesEXT
 {
     VkStructureType sType;
@@ -7342,6 +7846,13 @@ typedef struct VkPhysicalDevicePipelinePropertiesFeaturesEXT
     VkBool32 pipelinePropertiesIdentifier;
 } VkPhysicalDevicePipelinePropertiesFeaturesEXT;

+typedef struct VkPhysicalDevicePipelineProtectedAccessFeaturesEXT
+{
+    VkStructureType sType;
+    void *pNext;
+    VkBool32 pipelineProtectedAccess;
+} VkPhysicalDevicePipelineProtectedAccessFeaturesEXT;
+
 typedef struct VkPhysicalDevicePipelineRobustnessFeaturesEXT
 {
     VkStructureType sType;
@@ -7367,6 +7878,13 @@ typedef struct VkPhysicalDevicePointClippingProperties
 } VkPhysicalDevicePointClippingProperties;
 typedef VkPhysicalDevicePointClippingProperties VkPhysicalDevicePointClippingPropertiesKHR;

+typedef struct VkPhysicalDevicePresentBarrierFeaturesNV
+{
+    VkStructureType sType;
+    void *pNext;
+    VkBool32 presentBarrier;
+} VkPhysicalDevicePresentBarrierFeaturesNV;
+
 typedef struct VkPhysicalDevicePresentIdFeaturesKHR
 {
     VkStructureType sType;
@@ -9423,6 +9941,13 @@ typedef struct VkSurfaceCapabilitiesKHR
     VkImageUsageFlags supportedUsageFlags;
 } VkSurfaceCapabilitiesKHR;

+typedef struct VkSurfaceCapabilitiesPresentBarrierNV
+{
+    VkStructureType sType;
+    void *pNext;
+    VkBool32 presentBarrierSupported;
+} VkSurfaceCapabilitiesPresentBarrierNV;
+
 typedef struct VkSurfaceFormatKHR
 {
     VkFormat format;
@@ -9451,6 +9976,13 @@ typedef struct VkSwapchainCreateInfoKHR
     VkSwapchainKHR WINE_VK_ALIGN(8) oldSwapchain;
 } VkSwapchainCreateInfoKHR;

+typedef struct VkSwapchainPresentBarrierCreateInfoNV
+{
+    VkStructureType sType;
+    void *pNext;
+    VkBool32 presentBarrierEnable;
+} VkSwapchainPresentBarrierCreateInfoNV;
+
 typedef struct VkTextureLODGatherFormatPropertiesAMD
 {
     VkStructureType sType;
@@ -9718,6 +10250,20 @@ typedef struct VkAccelerationStructureSRTMotionInstanceNV
     uint64_t WINE_VK_ALIGN(8) accelerationStructureReference;
 } VkAccelerationStructureSRTMotionInstanceNV;

+typedef struct VkAccelerationStructureTrianglesOpacityMicromapEXT
+{
+    VkStructureType sType;
+    void *pNext;
+    VkIndexType indexType;
+    VkDeviceOrHostAddressConstKHR indexBuffer;
+    VkDeviceSize WINE_VK_ALIGN(8) indexStride;
+    uint32_t baseTriangle;
+    uint32_t usageCountsCount;
+    const VkMicromapUsageEXT *pUsageCounts;
+    const VkMicromapUsageEXT * const*ppUsageCounts;
+    VkMicromapEXT WINE_VK_ALIGN(8) micromap;
+} VkAccelerationStructureTrianglesOpacityMicromapEXT;
+
 typedef struct VkAttachmentSampleLocationsEXT
 {
     uint32_t attachmentIndex;
@@ -9839,6 +10385,24 @@ typedef struct VkCopyMemoryToAccelerationStructureInfoKHR
     VkCopyAccelerationStructureModeKHR mode;
 } VkCopyMemoryToAccelerationStructureInfoKHR;

+typedef struct VkCopyMemoryToMicromapInfoEXT
+{
+    VkStructureType sType;
+    const void *pNext;
+    VkDeviceOrHostAddressConstKHR src;
+    VkMicromapEXT WINE_VK_ALIGN(8) dst;
+    VkCopyMicromapModeEXT mode;
+} VkCopyMemoryToMicromapInfoEXT;
+
+typedef struct VkCopyMicromapToMemoryInfoEXT
+{
+    VkStructureType sType;
+    const void *pNext;
+    VkMicromapEXT WINE_VK_ALIGN(8) src;
+    VkDeviceOrHostAddressKHR dst;
+    VkCopyMicromapModeEXT mode;
+} VkCopyMicromapToMemoryInfoEXT;
+
 typedef struct VkDebugUtilsMessengerCallbackDataEXT
 {
     VkStructureType sType;
@@ -9894,6 +10458,16 @@ typedef struct VkDeviceCreateInfo
     const VkPhysicalDeviceFeatures *pEnabledFeatures;
 } VkDeviceCreateInfo;

+typedef struct VkDeviceFaultInfoEXT
+{
+    VkStructureType sType;
+    void *pNext;
+    char description[VK_MAX_DESCRIPTION_SIZE];
+    VkDeviceFaultAddressInfoEXT *pAddressInfos;
+    VkDeviceFaultVendorInfoEXT *pVendorInfos;
+    void *pVendorBinaryData;
+} VkDeviceFaultInfoEXT;
+
 typedef struct VkDeviceGroupRenderPassBeginInfo
 {
     VkStructureType sType;
@@ -10076,6 +10650,23 @@ typedef struct VkIndirectCommandsLayoutCreateInfoNV
     const uint32_t *pStreamStrides;
 } VkIndirectCommandsLayoutCreateInfoNV;

+typedef struct VkMicromapBuildInfoEXT
+{
+    VkStructureType sType;
+    const void *pNext;
+    VkMicromapTypeEXT type;
+    VkBuildMicromapFlagsEXT flags;
+    VkBuildMicromapModeEXT mode;
+    VkMicromapEXT WINE_VK_ALIGN(8) dstMicromap;
+    uint32_t usageCountsCount;
+    const VkMicromapUsageEXT *pUsageCounts;
+    const VkMicromapUsageEXT * const*ppUsageCounts;
+    VkDeviceOrHostAddressConstKHR data;
+    VkDeviceOrHostAddressKHR scratchData;
+    VkDeviceOrHostAddressConstKHR triangleArray;
+    VkDeviceSize WINE_VK_ALIGN(8) triangleArrayStride;
+} VkMicromapBuildInfoEXT;
+
 typedef struct VkMutableDescriptorTypeCreateInfoEXT
 {
     VkStructureType sType;
@@ -10085,6 +10676,15 @@ typedef struct VkMutableDescriptorTypeCreateInfoEXT
 } VkMutableDescriptorTypeCreateInfoEXT;
 typedef VkMutableDescriptorTypeCreateInfoEXT VkMutableDescriptorTypeCreateInfoVALVE;

+typedef struct VkOpticalFlowExecuteInfoNV
+{
+    VkStructureType sType;
+    void *pNext;
+    VkOpticalFlowExecuteFlagsNV flags;
+    uint32_t regionCount;
+    const VkRect2D *pRegions;
+} VkOpticalFlowExecuteInfoNV;
+
 typedef struct VkPhysicalDeviceProperties
 {
     uint32_t apiVersion;
@@ -10576,7 +11176,9 @@ typedef VkResult (VKAPI_PTR *PFN_vkBindBufferMemory2KHR)(VkDevice, uint32_t, con
 typedef VkResult (VKAPI_PTR *PFN_vkBindImageMemory)(VkDevice, VkImage, VkDeviceMemory, VkDeviceSize);
 typedef VkResult (VKAPI_PTR *PFN_vkBindImageMemory2)(VkDevice, uint32_t, const VkBindImageMemoryInfo *);
 typedef VkResult (VKAPI_PTR *PFN_vkBindImageMemory2KHR)(VkDevice, uint32_t, const VkBindImageMemoryInfo *);
+typedef VkResult (VKAPI_PTR *PFN_vkBindOpticalFlowSessionImageNV)(VkDevice, VkOpticalFlowSessionNV, VkOpticalFlowSessionBindingPointNV, VkImageView, VkImageLayout);
 typedef VkResult (VKAPI_PTR *PFN_vkBuildAccelerationStructuresKHR)(VkDevice, VkDeferredOperationKHR, uint32_t, const VkAccelerationStructureBuildGeometryInfoKHR *, const VkAccelerationStructureBuildRangeInfoKHR * const*);
+typedef VkResult (VKAPI_PTR *PFN_vkBuildMicromapsEXT)(VkDevice, VkDeferredOperationKHR, uint32_t, const VkMicromapBuildInfoEXT *);
 typedef void (VKAPI_PTR *PFN_vkCmdBeginConditionalRenderingEXT)(VkCommandBuffer, const VkConditionalRenderingBeginInfoEXT *);
 typedef void (VKAPI_PTR *PFN_vkCmdBeginDebugUtilsLabelEXT)(VkCommandBuffer, const VkDebugUtilsLabelEXT *);
 typedef void (VKAPI_PTR *PFN_vkCmdBeginQuery)(VkCommandBuffer, VkQueryPool, uint32_t, VkQueryControlFlags);
@@ -10603,6 +11205,7 @@ typedef void (VKAPI_PTR *PFN_vkCmdBlitImage2KHR)(VkCommandBuffer, const VkBlitIm
 typedef void (VKAPI_PTR *PFN_vkCmdBuildAccelerationStructureNV)(VkCommandBuffer, const VkAccelerationStructureInfoNV *, VkBuffer, VkDeviceSize, VkBool32, VkAccelerationStructureNV, VkAccelerationStructureNV, VkBuffer, VkDeviceSize);
 typedef void (VKAPI_PTR *PFN_vkCmdBuildAccelerationStructuresIndirectKHR)(VkCommandBuffer, uint32_t, const VkAccelerationStructureBuildGeometryInfoKHR *, const VkDeviceAddress *, const uint32_t *, const uint32_t * const*);
 typedef void (VKAPI_PTR *PFN_vkCmdBuildAccelerationStructuresKHR)(VkCommandBuffer, uint32_t, const VkAccelerationStructureBuildGeometryInfoKHR *, const VkAccelerationStructureBuildRangeInfoKHR * const*);
+typedef void (VKAPI_PTR *PFN_vkCmdBuildMicromapsEXT)(VkCommandBuffer, uint32_t, const VkMicromapBuildInfoEXT *);
 typedef void (VKAPI_PTR *PFN_vkCmdClearAttachments)(VkCommandBuffer, uint32_t, const VkClearAttachment *, uint32_t, const VkClearRect *);
 typedef void (VKAPI_PTR *PFN_vkCmdClearColorImage)(VkCommandBuffer, VkImage, VkImageLayout, const VkClearColorValue *, uint32_t, const VkImageSubresourceRange *);
 typedef void (VKAPI_PTR *PFN_vkCmdClearDepthStencilImage)(VkCommandBuffer, VkImage, VkImageLayout, const VkClearDepthStencilValue *, uint32_t, const VkImageSubresourceRange *);
@@ -10622,6 +11225,9 @@ typedef void (VKAPI_PTR *PFN_vkCmdCopyImageToBuffer)(VkCommandBuffer, VkImage, V
 typedef void (VKAPI_PTR *PFN_vkCmdCopyImageToBuffer2)(VkCommandBuffer, const VkCopyImageToBufferInfo2 *);
 typedef void (VKAPI_PTR *PFN_vkCmdCopyImageToBuffer2KHR)(VkCommandBuffer, const VkCopyImageToBufferInfo2 *);
 typedef void (VKAPI_PTR *PFN_vkCmdCopyMemoryToAccelerationStructureKHR)(VkCommandBuffer, const VkCopyMemoryToAccelerationStructureInfoKHR *);
+typedef void (VKAPI_PTR *PFN_vkCmdCopyMemoryToMicromapEXT)(VkCommandBuffer, const VkCopyMemoryToMicromapInfoEXT *);
+typedef void (VKAPI_PTR *PFN_vkCmdCopyMicromapEXT)(VkCommandBuffer, const VkCopyMicromapInfoEXT *);
+typedef void (VKAPI_PTR *PFN_vkCmdCopyMicromapToMemoryEXT)(VkCommandBuffer, const VkCopyMicromapToMemoryInfoEXT *);
 typedef void (VKAPI_PTR *PFN_vkCmdCopyQueryPoolResults)(VkCommandBuffer, VkQueryPool, uint32_t, uint32_t, VkBuffer, VkDeviceSize, VkDeviceSize, VkQueryResultFlags);
 typedef void (VKAPI_PTR *PFN_vkCmdCuLaunchKernelNVX)(VkCommandBuffer, const VkCuLaunchInfoNVX *);
 typedef void (VKAPI_PTR *PFN_vkCmdDebugMarkerBeginEXT)(VkCommandBuffer, const VkDebugMarkerMarkerInfoEXT *);
@@ -10667,6 +11273,7 @@ typedef void (VKAPI_PTR *PFN_vkCmdInsertDebugUtilsLabelEXT)(VkCommandBuffer, con
 typedef void (VKAPI_PTR *PFN_vkCmdNextSubpass)(VkCommandBuffer, VkSubpassContents);
 typedef void (VKAPI_PTR *PFN_vkCmdNextSubpass2)(VkCommandBuffer, const VkSubpassBeginInfo *, const VkSubpassEndInfo *);
 typedef void (VKAPI_PTR *PFN_vkCmdNextSubpass2KHR)(VkCommandBuffer, const VkSubpassBeginInfo *, const VkSubpassEndInfo *);
+typedef void (VKAPI_PTR *PFN_vkCmdOpticalFlowExecuteNV)(VkCommandBuffer, VkOpticalFlowSessionNV, const VkOpticalFlowExecuteInfoNV *);
 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 *);
@@ -10681,10 +11288,23 @@ typedef void (VKAPI_PTR *PFN_vkCmdResetQueryPool)(VkCommandBuffer, VkQueryPool,
 typedef void (VKAPI_PTR *PFN_vkCmdResolveImage)(VkCommandBuffer, VkImage, VkImageLayout, VkImage, VkImageLayout, uint32_t, const VkImageResolve *);
 typedef void (VKAPI_PTR *PFN_vkCmdResolveImage2)(VkCommandBuffer, const VkResolveImageInfo2 *);
 typedef void (VKAPI_PTR *PFN_vkCmdResolveImage2KHR)(VkCommandBuffer, const VkResolveImageInfo2 *);
+typedef void (VKAPI_PTR *PFN_vkCmdSetAlphaToCoverageEnableEXT)(VkCommandBuffer, VkBool32);
+typedef void (VKAPI_PTR *PFN_vkCmdSetAlphaToOneEnableEXT)(VkCommandBuffer, VkBool32);
 typedef void (VKAPI_PTR *PFN_vkCmdSetBlendConstants)(VkCommandBuffer, const float[4]);
 typedef void (VKAPI_PTR *PFN_vkCmdSetCheckpointNV)(VkCommandBuffer, const void *);
 typedef void (VKAPI_PTR *PFN_vkCmdSetCoarseSampleOrderNV)(VkCommandBuffer, VkCoarseSampleOrderTypeNV, uint32_t, const VkCoarseSampleOrderCustomNV *);
+typedef void (VKAPI_PTR *PFN_vkCmdSetColorBlendAdvancedEXT)(VkCommandBuffer, uint32_t, uint32_t, const VkColorBlendAdvancedEXT *);
+typedef void (VKAPI_PTR *PFN_vkCmdSetColorBlendEnableEXT)(VkCommandBuffer, uint32_t, uint32_t, const VkBool32 *);
+typedef void (VKAPI_PTR *PFN_vkCmdSetColorBlendEquationEXT)(VkCommandBuffer, uint32_t, uint32_t, const VkColorBlendEquationEXT *);
 typedef void (VKAPI_PTR *PFN_vkCmdSetColorWriteEnableEXT)(VkCommandBuffer, uint32_t, const VkBool32 *);
+typedef void (VKAPI_PTR *PFN_vkCmdSetColorWriteMaskEXT)(VkCommandBuffer, uint32_t, uint32_t, const VkColorComponentFlags *);
+typedef void (VKAPI_PTR *PFN_vkCmdSetConservativeRasterizationModeEXT)(VkCommandBuffer, VkConservativeRasterizationModeEXT);
+typedef void (VKAPI_PTR *PFN_vkCmdSetCoverageModulationModeNV)(VkCommandBuffer, VkCoverageModulationModeNV);
+typedef void (VKAPI_PTR *PFN_vkCmdSetCoverageModulationTableEnableNV)(VkCommandBuffer, VkBool32);
+typedef void (VKAPI_PTR *PFN_vkCmdSetCoverageModulationTableNV)(VkCommandBuffer, uint32_t, const float *);
+typedef void (VKAPI_PTR *PFN_vkCmdSetCoverageReductionModeNV)(VkCommandBuffer, VkCoverageReductionModeNV);
+typedef void (VKAPI_PTR *PFN_vkCmdSetCoverageToColorEnableNV)(VkCommandBuffer, VkBool32);
+typedef void (VKAPI_PTR *PFN_vkCmdSetCoverageToColorLocationNV)(VkCommandBuffer, uint32_t);
 typedef void (VKAPI_PTR *PFN_vkCmdSetCullMode)(VkCommandBuffer, VkCullModeFlags);
 typedef void (VKAPI_PTR *PFN_vkCmdSetCullModeEXT)(VkCommandBuffer, VkCullModeFlags);
 typedef void (VKAPI_PTR *PFN_vkCmdSetDepthBias)(VkCommandBuffer, float, float, float);
@@ -10693,6 +11313,9 @@ typedef void (VKAPI_PTR *PFN_vkCmdSetDepthBiasEnableEXT)(VkCommandBuffer, VkBool
 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_vkCmdSetDepthClipEnableEXT)(VkCommandBuffer, VkBool32);
+typedef void (VKAPI_PTR *PFN_vkCmdSetDepthClipNegativeOneToOneEXT)(VkCommandBuffer, VkBool32);
 typedef void (VKAPI_PTR *PFN_vkCmdSetDepthCompareOp)(VkCommandBuffer, VkCompareOp);
 typedef void (VKAPI_PTR *PFN_vkCmdSetDepthCompareOpEXT)(VkCommandBuffer, VkCompareOp);
 typedef void (VKAPI_PTR *PFN_vkCmdSetDepthTestEnable)(VkCommandBuffer, VkBool32);
@@ -10706,28 +11329,40 @@ typedef void (VKAPI_PTR *PFN_vkCmdSetEvent)(VkCommandBuffer, VkEvent, VkPipeline
 typedef void (VKAPI_PTR *PFN_vkCmdSetEvent2)(VkCommandBuffer, VkEvent, const VkDependencyInfo *);
 typedef void (VKAPI_PTR *PFN_vkCmdSetEvent2KHR)(VkCommandBuffer, VkEvent, const VkDependencyInfo *);
 typedef void (VKAPI_PTR *PFN_vkCmdSetExclusiveScissorNV)(VkCommandBuffer, uint32_t, uint32_t, const VkRect2D *);
+typedef void (VKAPI_PTR *PFN_vkCmdSetExtraPrimitiveOverestimationSizeEXT)(VkCommandBuffer, float);
 typedef void (VKAPI_PTR *PFN_vkCmdSetFragmentShadingRateEnumNV)(VkCommandBuffer, VkFragmentShadingRateNV, const VkFragmentShadingRateCombinerOpKHR[2]);
 typedef void (VKAPI_PTR *PFN_vkCmdSetFragmentShadingRateKHR)(VkCommandBuffer, const VkExtent2D *, const VkFragmentShadingRateCombinerOpKHR[2]);
 typedef void (VKAPI_PTR *PFN_vkCmdSetFrontFace)(VkCommandBuffer, VkFrontFace);
 typedef void (VKAPI_PTR *PFN_vkCmdSetFrontFaceEXT)(VkCommandBuffer, VkFrontFace);
+typedef void (VKAPI_PTR *PFN_vkCmdSetLineRasterizationModeEXT)(VkCommandBuffer, VkLineRasterizationModeEXT);
 typedef void (VKAPI_PTR *PFN_vkCmdSetLineStippleEXT)(VkCommandBuffer, uint32_t, uint16_t);
+typedef void (VKAPI_PTR *PFN_vkCmdSetLineStippleEnableEXT)(VkCommandBuffer, VkBool32);
 typedef void (VKAPI_PTR *PFN_vkCmdSetLineWidth)(VkCommandBuffer, float);
 typedef void (VKAPI_PTR *PFN_vkCmdSetLogicOpEXT)(VkCommandBuffer, VkLogicOp);
+typedef void (VKAPI_PTR *PFN_vkCmdSetLogicOpEnableEXT)(VkCommandBuffer, VkBool32);
 typedef void (VKAPI_PTR *PFN_vkCmdSetPatchControlPointsEXT)(VkCommandBuffer, uint32_t);
 typedef VkResult (VKAPI_PTR *PFN_vkCmdSetPerformanceMarkerINTEL)(VkCommandBuffer, const VkPerformanceMarkerInfoINTEL *);
 typedef VkResult (VKAPI_PTR *PFN_vkCmdSetPerformanceOverrideINTEL)(VkCommandBuffer, const VkPerformanceOverrideInfoINTEL *);
 typedef VkResult (VKAPI_PTR *PFN_vkCmdSetPerformanceStreamMarkerINTEL)(VkCommandBuffer, const VkPerformanceStreamMarkerInfoINTEL *);
+typedef void (VKAPI_PTR *PFN_vkCmdSetPolygonModeEXT)(VkCommandBuffer, VkPolygonMode);
 typedef void (VKAPI_PTR *PFN_vkCmdSetPrimitiveRestartEnable)(VkCommandBuffer, VkBool32);
 typedef void (VKAPI_PTR *PFN_vkCmdSetPrimitiveRestartEnableEXT)(VkCommandBuffer, VkBool32);
 typedef void (VKAPI_PTR *PFN_vkCmdSetPrimitiveTopology)(VkCommandBuffer, VkPrimitiveTopology);
 typedef void (VKAPI_PTR *PFN_vkCmdSetPrimitiveTopologyEXT)(VkCommandBuffer, VkPrimitiveTopology);
+typedef void (VKAPI_PTR *PFN_vkCmdSetProvokingVertexModeEXT)(VkCommandBuffer, VkProvokingVertexModeEXT);
+typedef void (VKAPI_PTR *PFN_vkCmdSetRasterizationSamplesEXT)(VkCommandBuffer, VkSampleCountFlagBits);
+typedef void (VKAPI_PTR *PFN_vkCmdSetRasterizationStreamEXT)(VkCommandBuffer, uint32_t);
 typedef void (VKAPI_PTR *PFN_vkCmdSetRasterizerDiscardEnable)(VkCommandBuffer, VkBool32);
 typedef void (VKAPI_PTR *PFN_vkCmdSetRasterizerDiscardEnableEXT)(VkCommandBuffer, VkBool32);
 typedef void (VKAPI_PTR *PFN_vkCmdSetRayTracingPipelineStackSizeKHR)(VkCommandBuffer, uint32_t);
+typedef void (VKAPI_PTR *PFN_vkCmdSetRepresentativeFragmentTestEnableNV)(VkCommandBuffer, VkBool32);
 typedef void (VKAPI_PTR *PFN_vkCmdSetSampleLocationsEXT)(VkCommandBuffer, const VkSampleLocationsInfoEXT *);
+typedef void (VKAPI_PTR *PFN_vkCmdSetSampleLocationsEnableEXT)(VkCommandBuffer, VkBool32);
+typedef void (VKAPI_PTR *PFN_vkCmdSetSampleMaskEXT)(VkCommandBuffer, VkSampleCountFlagBits, const VkSampleMask *);
 typedef void (VKAPI_PTR *PFN_vkCmdSetScissor)(VkCommandBuffer, uint32_t, uint32_t, const VkRect2D *);
 typedef void (VKAPI_PTR *PFN_vkCmdSetScissorWithCount)(VkCommandBuffer, uint32_t, const VkRect2D *);
 typedef void (VKAPI_PTR *PFN_vkCmdSetScissorWithCountEXT)(VkCommandBuffer, uint32_t, const VkRect2D *);
+typedef void (VKAPI_PTR *PFN_vkCmdSetShadingRateImageEnableNV)(VkCommandBuffer, VkBool32);
 typedef void (VKAPI_PTR *PFN_vkCmdSetStencilCompareMask)(VkCommandBuffer, VkStencilFaceFlags, uint32_t);
 typedef void (VKAPI_PTR *PFN_vkCmdSetStencilOp)(VkCommandBuffer, VkStencilFaceFlags, VkStencilOp, VkStencilOp, VkStencilOp, VkCompareOp);
 typedef void (VKAPI_PTR *PFN_vkCmdSetStencilOpEXT)(VkCommandBuffer, VkStencilFaceFlags, VkStencilOp, VkStencilOp, VkStencilOp, VkCompareOp);
@@ -10735,9 +11370,12 @@ typedef void (VKAPI_PTR *PFN_vkCmdSetStencilReference)(VkCommandBuffer, VkStenci
 typedef void (VKAPI_PTR *PFN_vkCmdSetStencilTestEnable)(VkCommandBuffer, VkBool32);
 typedef void (VKAPI_PTR *PFN_vkCmdSetStencilTestEnableEXT)(VkCommandBuffer, VkBool32);
 typedef void (VKAPI_PTR *PFN_vkCmdSetStencilWriteMask)(VkCommandBuffer, VkStencilFaceFlags, uint32_t);
+typedef void (VKAPI_PTR *PFN_vkCmdSetTessellationDomainOriginEXT)(VkCommandBuffer, VkTessellationDomainOrigin);
 typedef void (VKAPI_PTR *PFN_vkCmdSetVertexInputEXT)(VkCommandBuffer, uint32_t, const VkVertexInputBindingDescription2EXT *, uint32_t, const VkVertexInputAttributeDescription2EXT *);
 typedef void (VKAPI_PTR *PFN_vkCmdSetViewport)(VkCommandBuffer, uint32_t, uint32_t, const VkViewport *);
 typedef void (VKAPI_PTR *PFN_vkCmdSetViewportShadingRatePaletteNV)(VkCommandBuffer, uint32_t, uint32_t, const VkShadingRatePaletteNV *);
+typedef void (VKAPI_PTR *PFN_vkCmdSetViewportSwizzleNV)(VkCommandBuffer, uint32_t, uint32_t, const VkViewportSwizzleNV *);
+typedef void (VKAPI_PTR *PFN_vkCmdSetViewportWScalingEnableNV)(VkCommandBuffer, VkBool32);
 typedef void (VKAPI_PTR *PFN_vkCmdSetViewportWScalingNV)(VkCommandBuffer, uint32_t, uint32_t, const VkViewportWScalingNV *);
 typedef void (VKAPI_PTR *PFN_vkCmdSetViewportWithCount)(VkCommandBuffer, uint32_t, const VkViewport *);
 typedef void (VKAPI_PTR *PFN_vkCmdSetViewportWithCountEXT)(VkCommandBuffer, uint32_t, const VkViewport *);
@@ -10754,6 +11392,7 @@ typedef void (VKAPI_PTR *PFN_vkCmdWriteAccelerationStructuresPropertiesKHR)(VkCo
 typedef void (VKAPI_PTR *PFN_vkCmdWriteAccelerationStructuresPropertiesNV)(VkCommandBuffer, uint32_t, const VkAccelerationStructureNV *, VkQueryType, VkQueryPool, uint32_t);
 typedef void (VKAPI_PTR *PFN_vkCmdWriteBufferMarker2AMD)(VkCommandBuffer, VkPipelineStageFlags2, VkBuffer, VkDeviceSize, uint32_t);
 typedef void (VKAPI_PTR *PFN_vkCmdWriteBufferMarkerAMD)(VkCommandBuffer, VkPipelineStageFlagBits, VkBuffer, VkDeviceSize, uint32_t);
+typedef void (VKAPI_PTR *PFN_vkCmdWriteMicromapsPropertiesEXT)(VkCommandBuffer, uint32_t, const VkMicromapEXT *, VkQueryType, VkQueryPool, uint32_t);
 typedef void (VKAPI_PTR *PFN_vkCmdWriteTimestamp)(VkCommandBuffer, VkPipelineStageFlagBits, VkQueryPool, uint32_t);
 typedef void (VKAPI_PTR *PFN_vkCmdWriteTimestamp2)(VkCommandBuffer, VkPipelineStageFlags2, VkQueryPool, uint32_t);
 typedef void (VKAPI_PTR *PFN_vkCmdWriteTimestamp2KHR)(VkCommandBuffer, VkPipelineStageFlags2, VkQueryPool, uint32_t);
@@ -10761,6 +11400,9 @@ typedef VkResult (VKAPI_PTR *PFN_vkCompileDeferredNV)(VkDevice, VkPipeline, uint
 typedef VkResult (VKAPI_PTR *PFN_vkCopyAccelerationStructureKHR)(VkDevice, VkDeferredOperationKHR, const VkCopyAccelerationStructureInfoKHR *);
 typedef VkResult (VKAPI_PTR *PFN_vkCopyAccelerationStructureToMemoryKHR)(VkDevice, VkDeferredOperationKHR, const VkCopyAccelerationStructureToMemoryInfoKHR *);
 typedef VkResult (VKAPI_PTR *PFN_vkCopyMemoryToAccelerationStructureKHR)(VkDevice, VkDeferredOperationKHR, const VkCopyMemoryToAccelerationStructureInfoKHR *);
+typedef VkResult (VKAPI_PTR *PFN_vkCopyMemoryToMicromapEXT)(VkDevice, VkDeferredOperationKHR, const VkCopyMemoryToMicromapInfoEXT *);
+typedef VkResult (VKAPI_PTR *PFN_vkCopyMicromapEXT)(VkDevice, VkDeferredOperationKHR, const VkCopyMicromapInfoEXT *);
+typedef VkResult (VKAPI_PTR *PFN_vkCopyMicromapToMemoryEXT)(VkDevice, VkDeferredOperationKHR, const VkCopyMicromapToMemoryInfoEXT *);
 typedef VkResult (VKAPI_PTR *PFN_vkCreateAccelerationStructureKHR)(VkDevice, const VkAccelerationStructureCreateInfoKHR *, const VkAllocationCallbacks *, VkAccelerationStructureKHR *);
 typedef VkResult (VKAPI_PTR *PFN_vkCreateAccelerationStructureNV)(VkDevice, const VkAccelerationStructureCreateInfoNV *, const VkAllocationCallbacks *, VkAccelerationStructureNV *);
 typedef VkResult (VKAPI_PTR *PFN_vkCreateBuffer)(VkDevice, const VkBufferCreateInfo *, const VkAllocationCallbacks *, VkBuffer *);
@@ -10785,6 +11427,8 @@ typedef VkResult (VKAPI_PTR *PFN_vkCreateImage)(VkDevice, const VkImageCreateInf
 typedef VkResult (VKAPI_PTR *PFN_vkCreateImageView)(VkDevice, const VkImageViewCreateInfo *, const VkAllocationCallbacks *, VkImageView *);
 typedef VkResult (VKAPI_PTR *PFN_vkCreateIndirectCommandsLayoutNV)(VkDevice, const VkIndirectCommandsLayoutCreateInfoNV *, const VkAllocationCallbacks *, VkIndirectCommandsLayoutNV *);
 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 *);
 typedef VkResult (VKAPI_PTR *PFN_vkCreatePipelineCache)(VkDevice, const VkPipelineCacheCreateInfo *, const VkAllocationCallbacks *, VkPipelineCache *);
 typedef VkResult (VKAPI_PTR *PFN_vkCreatePipelineLayout)(VkDevice, const VkPipelineLayoutCreateInfo *, const VkAllocationCallbacks *, VkPipelineLayout *);
 typedef VkResult (VKAPI_PTR *PFN_vkCreatePrivateDataSlot)(VkDevice, const VkPrivateDataSlotCreateInfo *, const VkAllocationCallbacks *, VkPrivateDataSlot *);
@@ -10829,6 +11473,8 @@ typedef void (VKAPI_PTR *PFN_vkDestroyImage)(VkDevice, VkImage, const VkAllocati
 typedef void (VKAPI_PTR *PFN_vkDestroyImageView)(VkDevice, VkImageView, const VkAllocationCallbacks *);
 typedef void (VKAPI_PTR *PFN_vkDestroyIndirectCommandsLayoutNV)(VkDevice, VkIndirectCommandsLayoutNV, 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 *);
 typedef void (VKAPI_PTR *PFN_vkDestroyPipeline)(VkDevice, VkPipeline, const VkAllocationCallbacks *);
 typedef void (VKAPI_PTR *PFN_vkDestroyPipelineCache)(VkDevice, VkPipelineCache, const VkAllocationCallbacks *);
 typedef void (VKAPI_PTR *PFN_vkDestroyPipelineLayout)(VkDevice, VkPipelineLayout, const VkAllocationCallbacks *);
@@ -10881,6 +11527,7 @@ typedef void (VKAPI_PTR *PFN_vkGetDescriptorSetLayoutSupportKHR)(VkDevice, const
 typedef void (VKAPI_PTR *PFN_vkGetDeviceAccelerationStructureCompatibilityKHR)(VkDevice, const VkAccelerationStructureVersionInfoKHR *, VkAccelerationStructureCompatibilityKHR *);
 typedef void (VKAPI_PTR *PFN_vkGetDeviceBufferMemoryRequirements)(VkDevice, const VkDeviceBufferMemoryRequirements *, VkMemoryRequirements2 *);
 typedef void (VKAPI_PTR *PFN_vkGetDeviceBufferMemoryRequirementsKHR)(VkDevice, const VkDeviceBufferMemoryRequirements *, VkMemoryRequirements2 *);
+typedef VkResult (VKAPI_PTR *PFN_vkGetDeviceFaultInfoEXT)(VkDevice, VkDeviceFaultCountsEXT *, VkDeviceFaultInfoEXT *);
 typedef void (VKAPI_PTR *PFN_vkGetDeviceGroupPeerMemoryFeatures)(VkDevice, uint32_t, uint32_t, uint32_t, VkPeerMemoryFeatureFlags *);
 typedef void (VKAPI_PTR *PFN_vkGetDeviceGroupPeerMemoryFeaturesKHR)(VkDevice, uint32_t, uint32_t, uint32_t, VkPeerMemoryFeatureFlags *);
 typedef VkResult (VKAPI_PTR *PFN_vkGetDeviceGroupPresentCapabilitiesKHR)(VkDevice, VkDeviceGroupPresentCapabilitiesKHR *);
@@ -10892,6 +11539,7 @@ typedef void (VKAPI_PTR *PFN_vkGetDeviceImageSparseMemoryRequirementsKHR)(VkDevi
 typedef void (VKAPI_PTR *PFN_vkGetDeviceMemoryCommitment)(VkDevice, VkDeviceMemory, VkDeviceSize *);
 typedef uint64_t (VKAPI_PTR *PFN_vkGetDeviceMemoryOpaqueCaptureAddress)(VkDevice, const VkDeviceMemoryOpaqueCaptureAddressInfo *);
 typedef uint64_t (VKAPI_PTR *PFN_vkGetDeviceMemoryOpaqueCaptureAddressKHR)(VkDevice, const VkDeviceMemoryOpaqueCaptureAddressInfo *);
+typedef void (VKAPI_PTR *PFN_vkGetDeviceMicromapCompatibilityEXT)(VkDevice, const VkMicromapVersionInfoEXT *, VkAccelerationStructureCompatibilityKHR *);
 typedef PFN_vkVoidFunction (VKAPI_PTR *PFN_vkGetDeviceProcAddr)(VkDevice, const char *);
 typedef void (VKAPI_PTR *PFN_vkGetDeviceQueue)(VkDevice, uint32_t, uint32_t, VkQueue *);
 typedef void (VKAPI_PTR *PFN_vkGetDeviceQueue2)(VkDevice, const VkDeviceQueueInfo2 *, VkQueue *);
@@ -10915,6 +11563,7 @@ typedef PFN_vkVoidFunction (VKAPI_PTR *PFN_vkGetInstanceProcAddr)(VkInstance, co
 typedef VkResult (VKAPI_PTR *PFN_vkGetMemoryHostPointerPropertiesEXT)(VkDevice, VkExternalMemoryHandleTypeFlagBits, const void *, VkMemoryHostPointerPropertiesEXT *);
 typedef VkResult (VKAPI_PTR *PFN_vkGetMemoryWin32HandleKHR)(VkDevice, const VkMemoryGetWin32HandleInfoKHR *, HANDLE *);
 typedef VkResult (VKAPI_PTR *PFN_vkGetMemoryWin32HandlePropertiesKHR)(VkDevice, VkExternalMemoryHandleTypeFlagBits, HANDLE, VkMemoryWin32HandlePropertiesKHR *);
+typedef void (VKAPI_PTR *PFN_vkGetMicromapBuildSizesEXT)(VkDevice, VkAccelerationStructureBuildTypeKHR, const VkMicromapBuildInfoEXT *, VkMicromapBuildSizesInfoEXT *);
 typedef VkResult (VKAPI_PTR *PFN_vkGetPerformanceParameterINTEL)(VkDevice, VkPerformanceParameterTypeINTEL, VkPerformanceValueINTEL *);
 typedef VkResult (VKAPI_PTR *PFN_vkGetPhysicalDeviceCalibrateableTimeDomainsEXT)(VkPhysicalDevice, uint32_t *, VkTimeDomainEXT *);
 typedef VkResult (VKAPI_PTR *PFN_vkGetPhysicalDeviceCooperativeMatrixPropertiesNV)(VkPhysicalDevice, uint32_t *, VkCooperativeMatrixPropertiesNV *);
@@ -10938,6 +11587,7 @@ typedef void (VKAPI_PTR *PFN_vkGetPhysicalDeviceMemoryProperties)(VkPhysicalDevi
 typedef void (VKAPI_PTR *PFN_vkGetPhysicalDeviceMemoryProperties2)(VkPhysicalDevice, VkPhysicalDeviceMemoryProperties2 *);
 typedef void (VKAPI_PTR *PFN_vkGetPhysicalDeviceMemoryProperties2KHR)(VkPhysicalDevice, VkPhysicalDeviceMemoryProperties2 *);
 typedef void (VKAPI_PTR *PFN_vkGetPhysicalDeviceMultisamplePropertiesEXT)(VkPhysicalDevice, VkSampleCountFlagBits, VkMultisamplePropertiesEXT *);
+typedef VkResult (VKAPI_PTR *PFN_vkGetPhysicalDeviceOpticalFlowImageFormatsNV)(VkPhysicalDevice, const VkOpticalFlowImageFormatInfoNV *, uint32_t *, VkOpticalFlowImageFormatPropertiesNV *);
 typedef VkResult (VKAPI_PTR *PFN_vkGetPhysicalDevicePresentRectanglesKHR)(VkPhysicalDevice, VkSurfaceKHR, uint32_t *, VkRect2D *);
 typedef void (VKAPI_PTR *PFN_vkGetPhysicalDeviceProperties)(VkPhysicalDevice, VkPhysicalDeviceProperties *);
 typedef void (VKAPI_PTR *PFN_vkGetPhysicalDeviceProperties2)(VkPhysicalDevice, VkPhysicalDeviceProperties2 *);
@@ -11026,6 +11676,7 @@ typedef VkResult (VKAPI_PTR *PFN_vkWaitForPresentKHR)(VkDevice, VkSwapchainKHR,
 typedef VkResult (VKAPI_PTR *PFN_vkWaitSemaphores)(VkDevice, const VkSemaphoreWaitInfo *, uint64_t);
 typedef VkResult (VKAPI_PTR *PFN_vkWaitSemaphoresKHR)(VkDevice, const VkSemaphoreWaitInfo *, uint64_t);
 typedef VkResult (VKAPI_PTR *PFN_vkWriteAccelerationStructuresPropertiesKHR)(VkDevice, uint32_t, const VkAccelerationStructureKHR *, VkQueryType, size_t, void *, size_t);
+typedef VkResult (VKAPI_PTR *PFN_vkWriteMicromapsPropertiesEXT)(VkDevice, uint32_t, const VkMicromapEXT *, VkQueryType, size_t, void *, size_t);

#ifndef VK_NO_PROTOTYPES
 VkResult VKAPI_CALL vkAcquireNextImage2KHR(VkDevice device, const VkAcquireNextImageInfoKHR *pAcquireInfo, uint32_t *pImageIndex);
@@ -11043,7 +11694,9 @@ VkResult VKAPI_CALL vkBindBufferMemory2KHR(VkDevice device, uint32_t bindInfoCou
 VkResult VKAPI_CALL vkBindImageMemory(VkDevice device, VkImage image, VkDeviceMemory memory, VkDeviceSize memoryOffset);
 VkResult VKAPI_CALL vkBindImageMemory2(VkDevice device, uint32_t bindInfoCount, const VkBindImageMemoryInfo *pBindInfos);
 VkResult VKAPI_CALL vkBindImageMemory2KHR(VkDevice device, uint32_t bindInfoCount, const VkBindImageMemoryInfo *pBindInfos);
+VkResult VKAPI_CALL vkBindOpticalFlowSessionImageNV(VkDevice device, VkOpticalFlowSessionNV session, VkOpticalFlowSessionBindingPointNV bindingPoint, VkImageView view, VkImageLayout layout);
 VkResult VKAPI_CALL vkBuildAccelerationStructuresKHR(VkDevice device, VkDeferredOperationKHR deferredOperation, uint32_t infoCount, const VkAccelerationStructureBuildGeometryInfoKHR *pInfos, const VkAccelerationStructureBuildRangeInfoKHR * const*ppBuildRangeInfos);
+VkResult VKAPI_CALL vkBuildMicromapsEXT(VkDevice device, VkDeferredOperationKHR deferredOperation, uint32_t infoCount, const VkMicromapBuildInfoEXT *pInfos);
 void VKAPI_CALL vkCmdBeginConditionalRenderingEXT(VkCommandBuffer commandBuffer, const VkConditionalRenderingBeginInfoEXT *pConditionalRenderingBegin);
 void VKAPI_CALL vkCmdBeginDebugUtilsLabelEXT(VkCommandBuffer commandBuffer, const VkDebugUtilsLabelEXT *pLabelInfo);
 void VKAPI_CALL vkCmdBeginQuery(VkCommandBuffer commandBuffer, VkQueryPool queryPool, uint32_t query, VkQueryControlFlags flags);
@@ -11070,6 +11723,7 @@ void VKAPI_CALL vkCmdBlitImage2KHR(VkCommandBuffer commandBuffer, const VkBlitIm
 void VKAPI_CALL vkCmdBuildAccelerationStructureNV(VkCommandBuffer commandBuffer, const VkAccelerationStructureInfoNV *pInfo, VkBuffer instanceData, VkDeviceSize instanceOffset, VkBool32 update, VkAccelerationStructureNV dst, VkAccelerationStructureNV src, VkBuffer scratch, VkDeviceSize scratchOffset);
 void VKAPI_CALL vkCmdBuildAccelerationStructuresIndirectKHR(VkCommandBuffer commandBuffer, uint32_t infoCount, const VkAccelerationStructureBuildGeometryInfoKHR *pInfos, const VkDeviceAddress *pIndirectDeviceAddresses, const uint32_t *pIndirectStrides, const uint32_t * const*ppMaxPrimitiveCounts);
 void VKAPI_CALL vkCmdBuildAccelerationStructuresKHR(VkCommandBuffer commandBuffer, uint32_t infoCount, const VkAccelerationStructureBuildGeometryInfoKHR *pInfos, const VkAccelerationStructureBuildRangeInfoKHR * const*ppBuildRangeInfos);
+void VKAPI_CALL vkCmdBuildMicromapsEXT(VkCommandBuffer commandBuffer, uint32_t infoCount, const VkMicromapBuildInfoEXT *pInfos);
 void VKAPI_CALL vkCmdClearAttachments(VkCommandBuffer commandBuffer, uint32_t attachmentCount, const VkClearAttachment *pAttachments, uint32_t rectCount, const VkClearRect *pRects);
 void VKAPI_CALL vkCmdClearColorImage(VkCommandBuffer commandBuffer, VkImage image, VkImageLayout imageLayout, const VkClearColorValue *pColor, uint32_t rangeCount, const VkImageSubresourceRange *pRanges);
 void VKAPI_CALL vkCmdClearDepthStencilImage(VkCommandBuffer commandBuffer, VkImage image, VkImageLayout imageLayout, const VkClearDepthStencilValue *pDepthStencil, uint32_t rangeCount, const VkImageSubresourceRange *pRanges);
@@ -11089,6 +11743,9 @@ void VKAPI_CALL vkCmdCopyImageToBuffer(VkCommandBuffer commandBuffer, VkImage sr
 void VKAPI_CALL vkCmdCopyImageToBuffer2(VkCommandBuffer commandBuffer, const VkCopyImageToBufferInfo2 *pCopyImageToBufferInfo);
 void VKAPI_CALL vkCmdCopyImageToBuffer2KHR(VkCommandBuffer commandBuffer, const VkCopyImageToBufferInfo2 *pCopyImageToBufferInfo);
 void VKAPI_CALL vkCmdCopyMemoryToAccelerationStructureKHR(VkCommandBuffer commandBuffer, const VkCopyMemoryToAccelerationStructureInfoKHR *pInfo);
+void VKAPI_CALL vkCmdCopyMemoryToMicromapEXT(VkCommandBuffer commandBuffer, const VkCopyMemoryToMicromapInfoEXT *pInfo);
+void VKAPI_CALL vkCmdCopyMicromapEXT(VkCommandBuffer commandBuffer, const VkCopyMicromapInfoEXT *pInfo);
+void VKAPI_CALL vkCmdCopyMicromapToMemoryEXT(VkCommandBuffer commandBuffer, const VkCopyMicromapToMemoryInfoEXT *pInfo);
 void VKAPI_CALL vkCmdCopyQueryPoolResults(VkCommandBuffer commandBuffer, VkQueryPool queryPool, uint32_t firstQuery, uint32_t queryCount, VkBuffer dstBuffer, VkDeviceSize dstOffset, VkDeviceSize stride, VkQueryResultFlags flags);
 void VKAPI_CALL vkCmdCuLaunchKernelNVX(VkCommandBuffer commandBuffer, const VkCuLaunchInfoNVX *pLaunchInfo);
 void VKAPI_CALL vkCmdDebugMarkerBeginEXT(VkCommandBuffer commandBuffer, const VkDebugMarkerMarkerInfoEXT *pMarkerInfo);
@@ -11134,6 +11791,7 @@ void VKAPI_CALL vkCmdInsertDebugUtilsLabelEXT(VkCommandBuffer commandBuffer, con
 void VKAPI_CALL vkCmdNextSubpass(VkCommandBuffer commandBuffer, VkSubpassContents contents);
 void VKAPI_CALL vkCmdNextSubpass2(VkCommandBuffer commandBuffer, const VkSubpassBeginInfo *pSubpassBeginInfo, const VkSubpassEndInfo *pSubpassEndInfo);
 void VKAPI_CALL vkCmdNextSubpass2KHR(VkCommandBuffer commandBuffer, const VkSubpassBeginInfo *pSubpassBeginInfo, const VkSubpassEndInfo *pSubpassEndInfo);
+void VKAPI_CALL vkCmdOpticalFlowExecuteNV(VkCommandBuffer commandBuffer, VkOpticalFlowSessionNV session, const VkOpticalFlowExecuteInfoNV *pExecuteInfo);
 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);
@@ -11148,10 +11806,23 @@ void VKAPI_CALL vkCmdResetQueryPool(VkCommandBuffer commandBuffer, VkQueryPool q
 void VKAPI_CALL vkCmdResolveImage(VkCommandBuffer commandBuffer, VkImage srcImage, VkImageLayout srcImageLayout, VkImage dstImage, VkImageLayout dstImageLayout, uint32_t regionCount, const VkImageResolve *pRegions);
 void VKAPI_CALL vkCmdResolveImage2(VkCommandBuffer commandBuffer, const VkResolveImageInfo2 *pResolveImageInfo);
 void VKAPI_CALL vkCmdResolveImage2KHR(VkCommandBuffer commandBuffer, const VkResolveImageInfo2 *pResolveImageInfo);
+void VKAPI_CALL vkCmdSetAlphaToCoverageEnableEXT(VkCommandBuffer commandBuffer, VkBool32 alphaToCoverageEnable);
+void VKAPI_CALL vkCmdSetAlphaToOneEnableEXT(VkCommandBuffer commandBuffer, VkBool32 alphaToOneEnable);
 void VKAPI_CALL vkCmdSetBlendConstants(VkCommandBuffer commandBuffer, const float blendConstants[4]);
 void VKAPI_CALL vkCmdSetCheckpointNV(VkCommandBuffer commandBuffer, const void *pCheckpointMarker);
 void VKAPI_CALL vkCmdSetCoarseSampleOrderNV(VkCommandBuffer commandBuffer, VkCoarseSampleOrderTypeNV sampleOrderType, uint32_t customSampleOrderCount, const VkCoarseSampleOrderCustomNV *pCustomSampleOrders);
+void VKAPI_CALL vkCmdSetColorBlendAdvancedEXT(VkCommandBuffer commandBuffer, uint32_t firstAttachment, uint32_t attachmentCount, const VkColorBlendAdvancedEXT *pColorBlendAdvanced);
+void VKAPI_CALL vkCmdSetColorBlendEnableEXT(VkCommandBuffer commandBuffer, uint32_t firstAttachment, uint32_t attachmentCount, const VkBool32 *pColorBlendEnables);
+void VKAPI_CALL vkCmdSetColorBlendEquationEXT(VkCommandBuffer commandBuffer, uint32_t firstAttachment, uint32_t attachmentCount, const VkColorBlendEquationEXT *pColorBlendEquations);
 void VKAPI_CALL vkCmdSetColorWriteEnableEXT(VkCommandBuffer commandBuffer, uint32_t attachmentCount, const VkBool32 *pColorWriteEnables);
+void VKAPI_CALL vkCmdSetColorWriteMaskEXT(VkCommandBuffer commandBuffer, uint32_t firstAttachment, uint32_t attachmentCount, const VkColorComponentFlags *pColorWriteMasks);
+void VKAPI_CALL vkCmdSetConservativeRasterizationModeEXT(VkCommandBuffer commandBuffer, VkConservativeRasterizationModeEXT conservativeRasterizationMode);
+void VKAPI_CALL vkCmdSetCoverageModulationModeNV(VkCommandBuffer commandBuffer, VkCoverageModulationModeNV coverageModulationMode);
+void VKAPI_CALL vkCmdSetCoverageModulationTableEnableNV(VkCommandBuffer commandBuffer, VkBool32 coverageModulationTableEnable);
+void VKAPI_CALL vkCmdSetCoverageModulationTableNV(VkCommandBuffer commandBuffer, uint32_t coverageModulationTableCount, const float *pCoverageModulationTable);
+void VKAPI_CALL vkCmdSetCoverageReductionModeNV(VkCommandBuffer commandBuffer, VkCoverageReductionModeNV coverageReductionMode);
+void VKAPI_CALL vkCmdSetCoverageToColorEnableNV(VkCommandBuffer commandBuffer, VkBool32 coverageToColorEnable);
+void VKAPI_CALL vkCmdSetCoverageToColorLocationNV(VkCommandBuffer commandBuffer, uint32_t coverageToColorLocation);
 void VKAPI_CALL vkCmdSetCullMode(VkCommandBuffer commandBuffer, VkCullModeFlags cullMode);
 void VKAPI_CALL vkCmdSetCullModeEXT(VkCommandBuffer commandBuffer, VkCullModeFlags cullMode);
 void VKAPI_CALL vkCmdSetDepthBias(VkCommandBuffer commandBuffer, float depthBiasConstantFactor, float depthBiasClamp, float depthBiasSlopeFactor);
@@ -11160,6 +11831,9 @@ void VKAPI_CALL vkCmdSetDepthBiasEnableEXT(VkCommandBuffer commandBuffer, VkBool
 void VKAPI_CALL vkCmdSetDepthBounds(VkCommandBuffer commandBuffer, float minDepthBounds, float maxDepthBounds);
 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 vkCmdSetDepthClipEnableEXT(VkCommandBuffer commandBuffer, VkBool32 depthClipEnable);
+void VKAPI_CALL vkCmdSetDepthClipNegativeOneToOneEXT(VkCommandBuffer commandBuffer, VkBool32 negativeOneToOne);
 void VKAPI_CALL vkCmdSetDepthCompareOp(VkCommandBuffer commandBuffer, VkCompareOp depthCompareOp);
 void VKAPI_CALL vkCmdSetDepthCompareOpEXT(VkCommandBuffer commandBuffer, VkCompareOp depthCompareOp);
 void VKAPI_CALL vkCmdSetDepthTestEnable(VkCommandBuffer commandBuffer, VkBool32 depthTestEnable);
@@ -11173,28 +11847,40 @@ void VKAPI_CALL vkCmdSetEvent(VkCommandBuffer commandBuffer, VkEvent event, VkPi
 void VKAPI_CALL vkCmdSetEvent2(VkCommandBuffer commandBuffer, VkEvent event, const VkDependencyInfo *pDependencyInfo);
 void VKAPI_CALL vkCmdSetEvent2KHR(VkCommandBuffer commandBuffer, VkEvent event, const VkDependencyInfo *pDependencyInfo);
 void VKAPI_CALL vkCmdSetExclusiveScissorNV(VkCommandBuffer commandBuffer, uint32_t firstExclusiveScissor, uint32_t exclusiveScissorCount, const VkRect2D *pExclusiveScissors);
+void VKAPI_CALL vkCmdSetExtraPrimitiveOverestimationSizeEXT(VkCommandBuffer commandBuffer, float extraPrimitiveOverestimationSize);
 void VKAPI_CALL vkCmdSetFragmentShadingRateEnumNV(VkCommandBuffer commandBuffer, VkFragmentShadingRateNV shadingRate, const VkFragmentShadingRateCombinerOpKHR combinerOps[2]);
 void VKAPI_CALL vkCmdSetFragmentShadingRateKHR(VkCommandBuffer commandBuffer, const VkExtent2D *pFragmentSize, const VkFragmentShadingRateCombinerOpKHR combinerOps[2]);
 void VKAPI_CALL vkCmdSetFrontFace(VkCommandBuffer commandBuffer, VkFrontFace frontFace);
 void VKAPI_CALL vkCmdSetFrontFaceEXT(VkCommandBuffer commandBuffer, VkFrontFace frontFace);
+void VKAPI_CALL vkCmdSetLineRasterizationModeEXT(VkCommandBuffer commandBuffer, VkLineRasterizationModeEXT lineRasterizationMode);
 void VKAPI_CALL vkCmdSetLineStippleEXT(VkCommandBuffer commandBuffer, uint32_t lineStippleFactor, uint16_t lineStipplePattern);
+void VKAPI_CALL vkCmdSetLineStippleEnableEXT(VkCommandBuffer commandBuffer, VkBool32 stippledLineEnable);
 void VKAPI_CALL vkCmdSetLineWidth(VkCommandBuffer commandBuffer, float lineWidth);
 void VKAPI_CALL vkCmdSetLogicOpEXT(VkCommandBuffer commandBuffer, VkLogicOp logicOp);
+void VKAPI_CALL vkCmdSetLogicOpEnableEXT(VkCommandBuffer commandBuffer, VkBool32 logicOpEnable);
 void VKAPI_CALL vkCmdSetPatchControlPointsEXT(VkCommandBuffer commandBuffer, uint32_t patchControlPoints);
 VkResult VKAPI_CALL vkCmdSetPerformanceMarkerINTEL(VkCommandBuffer commandBuffer, const VkPerformanceMarkerInfoINTEL *pMarkerInfo);
 VkResult VKAPI_CALL vkCmdSetPerformanceOverrideINTEL(VkCommandBuffer commandBuffer, const VkPerformanceOverrideInfoINTEL *pOverrideInfo);
 VkResult VKAPI_CALL vkCmdSetPerformanceStreamMarkerINTEL(VkCommandBuffer commandBuffer, const VkPerformanceStreamMarkerInfoINTEL *pMarkerInfo);
+void VKAPI_CALL vkCmdSetPolygonModeEXT(VkCommandBuffer commandBuffer, VkPolygonMode polygonMode);
 void VKAPI_CALL vkCmdSetPrimitiveRestartEnable(VkCommandBuffer commandBuffer, VkBool32 primitiveRestartEnable);
 void VKAPI_CALL vkCmdSetPrimitiveRestartEnableEXT(VkCommandBuffer commandBuffer, VkBool32 primitiveRestartEnable);
 void VKAPI_CALL vkCmdSetPrimitiveTopology(VkCommandBuffer commandBuffer, VkPrimitiveTopology primitiveTopology);
 void VKAPI_CALL vkCmdSetPrimitiveTopologyEXT(VkCommandBuffer commandBuffer, VkPrimitiveTopology primitiveTopology);
+void VKAPI_CALL vkCmdSetProvokingVertexModeEXT(VkCommandBuffer commandBuffer, VkProvokingVertexModeEXT provokingVertexMode);
+void VKAPI_CALL vkCmdSetRasterizationSamplesEXT(VkCommandBuffer commandBuffer, VkSampleCountFlagBits rasterizationSamples);
+void VKAPI_CALL vkCmdSetRasterizationStreamEXT(VkCommandBuffer commandBuffer, uint32_t rasterizationStream);
 void VKAPI_CALL vkCmdSetRasterizerDiscardEnable(VkCommandBuffer commandBuffer, VkBool32 rasterizerDiscardEnable);
 void VKAPI_CALL vkCmdSetRasterizerDiscardEnableEXT(VkCommandBuffer commandBuffer, VkBool32 rasterizerDiscardEnable);
 void VKAPI_CALL vkCmdSetRayTracingPipelineStackSizeKHR(VkCommandBuffer commandBuffer, uint32_t pipelineStackSize);
+void VKAPI_CALL vkCmdSetRepresentativeFragmentTestEnableNV(VkCommandBuffer commandBuffer, VkBool32 representativeFragmentTestEnable);
 void VKAPI_CALL vkCmdSetSampleLocationsEXT(VkCommandBuffer commandBuffer, const VkSampleLocationsInfoEXT *pSampleLocationsInfo);
+void VKAPI_CALL vkCmdSetSampleLocationsEnableEXT(VkCommandBuffer commandBuffer, VkBool32 sampleLocationsEnable);
+void VKAPI_CALL vkCmdSetSampleMaskEXT(VkCommandBuffer commandBuffer, VkSampleCountFlagBits samples, const VkSampleMask *pSampleMask);
 void VKAPI_CALL vkCmdSetScissor(VkCommandBuffer commandBuffer, uint32_t firstScissor, uint32_t scissorCount, const VkRect2D *pScissors);
 void VKAPI_CALL vkCmdSetScissorWithCount(VkCommandBuffer commandBuffer, uint32_t scissorCount, const VkRect2D *pScissors);
 void VKAPI_CALL vkCmdSetScissorWithCountEXT(VkCommandBuffer commandBuffer, uint32_t scissorCount, const VkRect2D *pScissors);
+void VKAPI_CALL vkCmdSetShadingRateImageEnableNV(VkCommandBuffer commandBuffer, VkBool32 shadingRateImageEnable);
 void VKAPI_CALL vkCmdSetStencilCompareMask(VkCommandBuffer commandBuffer, VkStencilFaceFlags faceMask, uint32_t compareMask);
 void VKAPI_CALL vkCmdSetStencilOp(VkCommandBuffer commandBuffer, VkStencilFaceFlags faceMask, VkStencilOp failOp, VkStencilOp passOp, VkStencilOp depthFailOp, VkCompareOp compareOp);
 void VKAPI_CALL vkCmdSetStencilOpEXT(VkCommandBuffer commandBuffer, VkStencilFaceFlags faceMask, VkStencilOp failOp, VkStencilOp passOp, VkStencilOp depthFailOp, VkCompareOp compareOp);
@@ -11202,9 +11888,12 @@ void VKAPI_CALL vkCmdSetStencilReference(VkCommandBuffer commandBuffer, VkStenci
 void VKAPI_CALL vkCmdSetStencilTestEnable(VkCommandBuffer commandBuffer, VkBool32 stencilTestEnable);
 void VKAPI_CALL vkCmdSetStencilTestEnableEXT(VkCommandBuffer commandBuffer, VkBool32 stencilTestEnable);
 void VKAPI_CALL vkCmdSetStencilWriteMask(VkCommandBuffer commandBuffer, VkStencilFaceFlags faceMask, uint32_t writeMask);
+void VKAPI_CALL vkCmdSetTessellationDomainOriginEXT(VkCommandBuffer commandBuffer, VkTessellationDomainOrigin domainOrigin);
 void VKAPI_CALL vkCmdSetVertexInputEXT(VkCommandBuffer commandBuffer, uint32_t vertexBindingDescriptionCount, const VkVertexInputBindingDescription2EXT *pVertexBindingDescriptions, uint32_t vertexAttributeDescriptionCount, const VkVertexInputAttributeDescription2EXT *pVertexAttributeDescriptions);
 void VKAPI_CALL vkCmdSetViewport(VkCommandBuffer commandBuffer, uint32_t firstViewport, uint32_t viewportCount, const VkViewport *pViewports);
 void VKAPI_CALL vkCmdSetViewportShadingRatePaletteNV(VkCommandBuffer commandBuffer, uint32_t firstViewport, uint32_t viewportCount, const VkShadingRatePaletteNV *pShadingRatePalettes);
+void VKAPI_CALL vkCmdSetViewportSwizzleNV(VkCommandBuffer commandBuffer, uint32_t firstViewport, uint32_t viewportCount, const VkViewportSwizzleNV *pViewportSwizzles);
+void VKAPI_CALL vkCmdSetViewportWScalingEnableNV(VkCommandBuffer commandBuffer, VkBool32 viewportWScalingEnable);
 void VKAPI_CALL vkCmdSetViewportWScalingNV(VkCommandBuffer commandBuffer, uint32_t firstViewport, uint32_t viewportCount, const VkViewportWScalingNV *pViewportWScalings);
 void VKAPI_CALL vkCmdSetViewportWithCount(VkCommandBuffer commandBuffer, uint32_t viewportCount, const VkViewport *pViewports);
 void VKAPI_CALL vkCmdSetViewportWithCountEXT(VkCommandBuffer commandBuffer, uint32_t viewportCount, const VkViewport *pViewports);
@@ -11221,6 +11910,7 @@ void VKAPI_CALL vkCmdWriteAccelerationStructuresPropertiesKHR(VkCommandBuffer co
 void VKAPI_CALL vkCmdWriteAccelerationStructuresPropertiesNV(VkCommandBuffer commandBuffer, uint32_t accelerationStructureCount, const VkAccelerationStructureNV *pAccelerationStructures, VkQueryType queryType, VkQueryPool queryPool, uint32_t firstQuery);
 void VKAPI_CALL vkCmdWriteBufferMarker2AMD(VkCommandBuffer commandBuffer, VkPipelineStageFlags2 stage, VkBuffer dstBuffer, VkDeviceSize dstOffset, uint32_t marker);
 void VKAPI_CALL vkCmdWriteBufferMarkerAMD(VkCommandBuffer commandBuffer, VkPipelineStageFlagBits pipelineStage, VkBuffer dstBuffer, VkDeviceSize dstOffset, uint32_t marker);
+void VKAPI_CALL vkCmdWriteMicromapsPropertiesEXT(VkCommandBuffer commandBuffer, uint32_t micromapCount, const VkMicromapEXT *pMicromaps, VkQueryType queryType, VkQueryPool queryPool, uint32_t firstQuery);
 void VKAPI_CALL vkCmdWriteTimestamp(VkCommandBuffer commandBuffer, VkPipelineStageFlagBits pipelineStage, VkQueryPool queryPool, uint32_t query);
 void VKAPI_CALL vkCmdWriteTimestamp2(VkCommandBuffer commandBuffer, VkPipelineStageFlags2 stage, VkQueryPool queryPool, uint32_t query);
 void VKAPI_CALL vkCmdWriteTimestamp2KHR(VkCommandBuffer commandBuffer, VkPipelineStageFlags2 stage, VkQueryPool queryPool, uint32_t query);
@@ -11228,6 +11918,9 @@ VkResult VKAPI_CALL vkCompileDeferredNV(VkDevice device, VkPipeline pipeline, ui
 VkResult VKAPI_CALL vkCopyAccelerationStructureKHR(VkDevice device, VkDeferredOperationKHR deferredOperation, const VkCopyAccelerationStructureInfoKHR *pInfo);
 VkResult VKAPI_CALL vkCopyAccelerationStructureToMemoryKHR(VkDevice device, VkDeferredOperationKHR deferredOperation, const VkCopyAccelerationStructureToMemoryInfoKHR *pInfo);
 VkResult VKAPI_CALL vkCopyMemoryToAccelerationStructureKHR(VkDevice device, VkDeferredOperationKHR deferredOperation, const VkCopyMemoryToAccelerationStructureInfoKHR *pInfo);
+VkResult VKAPI_CALL vkCopyMemoryToMicromapEXT(VkDevice device, VkDeferredOperationKHR deferredOperation, const VkCopyMemoryToMicromapInfoEXT *pInfo);
+VkResult VKAPI_CALL vkCopyMicromapEXT(VkDevice device, VkDeferredOperationKHR deferredOperation, const VkCopyMicromapInfoEXT *pInfo);
+VkResult VKAPI_CALL vkCopyMicromapToMemoryEXT(VkDevice device, VkDeferredOperationKHR deferredOperation, const VkCopyMicromapToMemoryInfoEXT *pInfo);
 VkResult VKAPI_CALL vkCreateAccelerationStructureKHR(VkDevice device, const VkAccelerationStructureCreateInfoKHR *pCreateInfo, const VkAllocationCallbacks *pAllocator, VkAccelerationStructureKHR *pAccelerationStructure);
 VkResult VKAPI_CALL vkCreateAccelerationStructureNV(VkDevice device, const VkAccelerationStructureCreateInfoNV *pCreateInfo, const VkAllocationCallbacks *pAllocator, VkAccelerationStructureNV *pAccelerationStructure);
 VkResult VKAPI_CALL vkCreateBuffer(VkDevice device, const VkBufferCreateInfo *pCreateInfo, const VkAllocationCallbacks *pAllocator, VkBuffer *pBuffer);
@@ -11252,6 +11945,8 @@ VkResult VKAPI_CALL vkCreateImage(VkDevice device, const VkImageCreateInfo *pCre
 VkResult VKAPI_CALL vkCreateImageView(VkDevice device, const VkImageViewCreateInfo *pCreateInfo, const VkAllocationCallbacks *pAllocator, VkImageView *pView);
 VkResult VKAPI_CALL vkCreateIndirectCommandsLayoutNV(VkDevice device, const VkIndirectCommandsLayoutCreateInfoNV *pCreateInfo, const VkAllocationCallbacks *pAllocator, VkIndirectCommandsLayoutNV *pIndirectCommandsLayout);
 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);
 VkResult VKAPI_CALL vkCreatePipelineCache(VkDevice device, const VkPipelineCacheCreateInfo *pCreateInfo, const VkAllocationCallbacks *pAllocator, VkPipelineCache *pPipelineCache);
 VkResult VKAPI_CALL vkCreatePipelineLayout(VkDevice device, const VkPipelineLayoutCreateInfo *pCreateInfo, const VkAllocationCallbacks *pAllocator, VkPipelineLayout *pPipelineLayout);
 VkResult VKAPI_CALL vkCreatePrivateDataSlot(VkDevice device, const VkPrivateDataSlotCreateInfo *pCreateInfo, const VkAllocationCallbacks *pAllocator, VkPrivateDataSlot *pPrivateDataSlot);
@@ -11296,6 +11991,8 @@ void VKAPI_CALL vkDestroyImage(VkDevice device, VkImage image, const VkAllocatio
 void VKAPI_CALL vkDestroyImageView(VkDevice device, VkImageView imageView, const VkAllocationCallbacks *pAllocator);
 void VKAPI_CALL vkDestroyIndirectCommandsLayoutNV(VkDevice device, VkIndirectCommandsLayoutNV indirectCommandsLayout, 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);
 void VKAPI_CALL vkDestroyPipeline(VkDevice device, VkPipeline pipeline, const VkAllocationCallbacks *pAllocator);
 void VKAPI_CALL vkDestroyPipelineCache(VkDevice device, VkPipelineCache pipelineCache, const VkAllocationCallbacks *pAllocator);
 void VKAPI_CALL vkDestroyPipelineLayout(VkDevice device, VkPipelineLayout pipelineLayout, const VkAllocationCallbacks *pAllocator);
@@ -11348,6 +12045,7 @@ void VKAPI_CALL vkGetDescriptorSetLayoutSupportKHR(VkDevice device, const VkDesc
 void VKAPI_CALL vkGetDeviceAccelerationStructureCompatibilityKHR(VkDevice device, const VkAccelerationStructureVersionInfoKHR *pVersionInfo, VkAccelerationStructureCompatibilityKHR *pCompatibility);
 void VKAPI_CALL vkGetDeviceBufferMemoryRequirements(VkDevice device, const VkDeviceBufferMemoryRequirements *pInfo, VkMemoryRequirements2 *pMemoryRequirements);
 void VKAPI_CALL vkGetDeviceBufferMemoryRequirementsKHR(VkDevice device, const VkDeviceBufferMemoryRequirements *pInfo, VkMemoryRequirements2 *pMemoryRequirements);
+VkResult VKAPI_CALL vkGetDeviceFaultInfoEXT(VkDevice device, VkDeviceFaultCountsEXT *pFaultCounts, VkDeviceFaultInfoEXT *pFaultInfo);
 void VKAPI_CALL vkGetDeviceGroupPeerMemoryFeatures(VkDevice device, uint32_t heapIndex, uint32_t localDeviceIndex, uint32_t remoteDeviceIndex, VkPeerMemoryFeatureFlags *pPeerMemoryFeatures);
 void VKAPI_CALL vkGetDeviceGroupPeerMemoryFeaturesKHR(VkDevice device, uint32_t heapIndex, uint32_t localDeviceIndex, uint32_t remoteDeviceIndex, VkPeerMemoryFeatureFlags *pPeerMemoryFeatures);
 VkResult VKAPI_CALL vkGetDeviceGroupPresentCapabilitiesKHR(VkDevice device, VkDeviceGroupPresentCapabilitiesKHR *pDeviceGroupPresentCapabilities);
@@ -11359,6 +12057,7 @@ void VKAPI_CALL vkGetDeviceImageSparseMemoryRequirementsKHR(VkDevice device, con
 void VKAPI_CALL vkGetDeviceMemoryCommitment(VkDevice device, VkDeviceMemory memory, VkDeviceSize *pCommittedMemoryInBytes);
 uint64_t VKAPI_CALL vkGetDeviceMemoryOpaqueCaptureAddress(VkDevice device, const VkDeviceMemoryOpaqueCaptureAddressInfo *pInfo);
 uint64_t VKAPI_CALL vkGetDeviceMemoryOpaqueCaptureAddressKHR(VkDevice device, const VkDeviceMemoryOpaqueCaptureAddressInfo *pInfo);
+void VKAPI_CALL vkGetDeviceMicromapCompatibilityEXT(VkDevice device, const VkMicromapVersionInfoEXT *pVersionInfo, VkAccelerationStructureCompatibilityKHR *pCompatibility);
 PFN_vkVoidFunction VKAPI_CALL vkGetDeviceProcAddr(VkDevice device, const char *pName);
 void VKAPI_CALL vkGetDeviceQueue(VkDevice device, uint32_t queueFamilyIndex, uint32_t queueIndex, VkQueue *pQueue);
 void VKAPI_CALL vkGetDeviceQueue2(VkDevice device, const VkDeviceQueueInfo2 *pQueueInfo, VkQueue *pQueue);
@@ -11382,6 +12081,7 @@ PFN_vkVoidFunction VKAPI_CALL vkGetInstanceProcAddr(VkInstance instance, const c
 VkResult VKAPI_CALL vkGetMemoryHostPointerPropertiesEXT(VkDevice device, VkExternalMemoryHandleTypeFlagBits handleType, const void *pHostPointer, VkMemoryHostPointerPropertiesEXT *pMemoryHostPointerProperties);
 VkResult VKAPI_CALL vkGetMemoryWin32HandleKHR(VkDevice device, const VkMemoryGetWin32HandleInfoKHR *pGetWin32HandleInfo, HANDLE *pHandle);
 VkResult VKAPI_CALL vkGetMemoryWin32HandlePropertiesKHR(VkDevice device, VkExternalMemoryHandleTypeFlagBits handleType, HANDLE handle, VkMemoryWin32HandlePropertiesKHR *pMemoryWin32HandleProperties);
+void VKAPI_CALL vkGetMicromapBuildSizesEXT(VkDevice device, VkAccelerationStructureBuildTypeKHR buildType, const VkMicromapBuildInfoEXT *pBuildInfo, VkMicromapBuildSizesInfoEXT *pSizeInfo);
 VkResult VKAPI_CALL vkGetPerformanceParameterINTEL(VkDevice device, VkPerformanceParameterTypeINTEL parameter, VkPerformanceValueINTEL *pValue);
 VkResult VKAPI_CALL vkGetPhysicalDeviceCalibrateableTimeDomainsEXT(VkPhysicalDevice physicalDevice, uint32_t *pTimeDomainCount, VkTimeDomainEXT *pTimeDomains);
 VkResult VKAPI_CALL vkGetPhysicalDeviceCooperativeMatrixPropertiesNV(VkPhysicalDevice physicalDevice, uint32_t *pPropertyCount, VkCooperativeMatrixPropertiesNV *pProperties);
@@ -11405,6 +12105,7 @@ void VKAPI_CALL vkGetPhysicalDeviceMemoryProperties(VkPhysicalDevice physicalDev
 void VKAPI_CALL vkGetPhysicalDeviceMemoryProperties2(VkPhysicalDevice physicalDevice, VkPhysicalDeviceMemoryProperties2 *pMemoryProperties);
 void VKAPI_CALL vkGetPhysicalDeviceMemoryProperties2KHR(VkPhysicalDevice physicalDevice, VkPhysicalDeviceMemoryProperties2 *pMemoryProperties);
 void VKAPI_CALL vkGetPhysicalDeviceMultisamplePropertiesEXT(VkPhysicalDevice physicalDevice, VkSampleCountFlagBits samples, VkMultisamplePropertiesEXT *pMultisampleProperties);
+VkResult VKAPI_CALL vkGetPhysicalDeviceOpticalFlowImageFormatsNV(VkPhysicalDevice physicalDevice, const VkOpticalFlowImageFormatInfoNV *pOpticalFlowImageFormatInfo, uint32_t *pFormatCount, VkOpticalFlowImageFormatPropertiesNV *pImageFormatProperties);
 VkResult VKAPI_CALL vkGetPhysicalDevicePresentRectanglesKHR(VkPhysicalDevice physicalDevice, VkSurfaceKHR surface, uint32_t *pRectCount, VkRect2D *pRects);
 void VKAPI_CALL vkGetPhysicalDeviceProperties(VkPhysicalDevice physicalDevice, VkPhysicalDeviceProperties *pProperties);
 void VKAPI_CALL vkGetPhysicalDeviceProperties2(VkPhysicalDevice physicalDevice, VkPhysicalDeviceProperties2 *pProperties);
@@ -11493,6 +12194,7 @@ VkResult VKAPI_CALL vkWaitForPresentKHR(VkDevice device, VkSwapchainKHR swapchai
 VkResult VKAPI_CALL vkWaitSemaphores(VkDevice device, const VkSemaphoreWaitInfo *pWaitInfo, uint64_t timeout);
 VkResult VKAPI_CALL vkWaitSemaphoresKHR(VkDevice device, const VkSemaphoreWaitInfo *pWaitInfo, uint64_t timeout);
 VkResult VKAPI_CALL vkWriteAccelerationStructuresPropertiesKHR(VkDevice device, uint32_t accelerationStructureCount, const VkAccelerationStructureKHR *pAccelerationStructures, VkQueryType queryType, size_t dataSize, void *pData, size_t stride);
+VkResult VKAPI_CALL vkWriteMicromapsPropertiesEXT(VkDevice device, uint32_t micromapCount, const VkMicromapEXT *pMicromaps, VkQueryType queryType, size_t dataSize, void *pData, size_t stride);
 #endif /* VK_NO_PROTOTYPES */

#endif /* __WINE_VULKAN_H */