[PATCH 0/1] MR959: winevulkan: Update to VK spec version 1.3.230.
From: Georg Lehmann <dadschoorse(a)gmail.com> --- 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, ¶ms); + return params.result; +} + VkResult WINAPI vkBuildAccelerationStructuresKHR(VkDevice device, VkDeferredOperationKHR deferredOperation, uint32_t infoCount, const VkAccelerationStructureBuildGeometryInfoKHR *pInfos, const VkAccelerationStructureBuildRangeInfoKHR * const*ppBuildRangeInfos) { struct vkBuildAccelerationStructuresKHR_params params; @@ -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, ¶ms); + 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, ¶ms); } +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, ¶ms); +} + 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, ¶ms); } +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, ¶ms); +} + +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, ¶ms); +} + +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, ¶ms); +} + 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, ¶ms); } +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, ¶ms); +} + 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, ¶ms); } +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, ¶ms); +} + +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, ¶ms); +} + 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, ¶ms); } +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, ¶ms); +} + +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, ¶ms); +} + +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, ¶ms); +} + 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, ¶ms); } +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, ¶ms); +} + +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, ¶ms); +} + +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, ¶ms); +} + +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, ¶ms); +} + +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, ¶ms); +} + +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, ¶ms); +} + +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, ¶ms); +} + +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, ¶ms); +} + 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, ¶ms); } +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, ¶ms); +} + +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, ¶ms); +} + +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, ¶ms); +} + 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, ¶ms); } +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, ¶ms); +} + 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, ¶ms); } +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, ¶ms); +} + 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, ¶ms); } +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, ¶ms); +} + 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, ¶ms); } +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, ¶ms); +} + 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, ¶ms); +} + 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, ¶ms); } +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, ¶ms); +} + +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, ¶ms); +} + +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, ¶ms); +} + 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, ¶ms); } +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, ¶ms); +} + 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, ¶ms); } +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, ¶ms); +} + +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, ¶ms); +} + 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, ¶ms); } +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, ¶ms); +} + 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, ¶ms); } +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, ¶ms); +} + 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, ¶ms); } +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, ¶ms); +} + +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, ¶ms); +} + 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, ¶ms); } +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, ¶ms); +} + 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, ¶ms); + 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, ¶ms); + 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, ¶ms); + 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, ¶ms); + 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, ¶ms); + 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, ¶ms); } +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, ¶ms); +} + +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, ¶ms); +} + 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, ¶ms); } +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, ¶ms); + 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, ¶ms); +} + 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, ¶ms); +} + 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, ¶ms); } +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, ¶ms); + 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, ¶ms); + 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 */ -- GitLab https://gitlab.winehq.org/wine/wine/-/merge_requests/959
This merge request was approved by Jacek Caban. -- https://gitlab.winehq.org/wine/wine/-/merge_requests/959
participants (3)
-
Georg Lehmann -
Georg Lehmann (＠DadSchoorse)
-
Jacek Caban (＠jacek)