diff --git a/src/vulkan/runtime/vk_cmd_copy.c b/src/vulkan/runtime/vk_cmd_copy.c index 9fcb0c23d6e..5e9df8171ed 100644 --- a/src/vulkan/runtime/vk_cmd_copy.c +++ b/src/vulkan/runtime/vk_cmd_copy.c @@ -37,19 +37,19 @@ vk_common_CmdCopyBuffer(VkCommandBuffer commandBuffer, */ struct vk_object_base *disp = (struct vk_object_base *)commandBuffer; - STACK_ARRAY(VkBufferCopy2KHR, region2s, regionCount); + STACK_ARRAY(VkBufferCopy2, region2s, regionCount); for (uint32_t r = 0; r < regionCount; r++) { - region2s[r] = (VkBufferCopy2KHR) { - .sType = VK_STRUCTURE_TYPE_BUFFER_COPY_2_KHR, + region2s[r] = (VkBufferCopy2) { + .sType = VK_STRUCTURE_TYPE_BUFFER_COPY_2, .srcOffset = pRegions[r].srcOffset, .dstOffset = pRegions[r].dstOffset, .size = pRegions[r].size, }; } - VkCopyBufferInfo2KHR info = { - .sType = VK_STRUCTURE_TYPE_COPY_BUFFER_INFO_2_KHR, + VkCopyBufferInfo2 info = { + .sType = VK_STRUCTURE_TYPE_COPY_BUFFER_INFO_2, .srcBuffer = srcBuffer, .dstBuffer = dstBuffer, .regionCount = regionCount, @@ -75,11 +75,11 @@ vk_common_CmdCopyImage(VkCommandBuffer commandBuffer, */ struct vk_object_base *disp = (struct vk_object_base *)commandBuffer; - STACK_ARRAY(VkImageCopy2KHR, region2s, regionCount); + STACK_ARRAY(VkImageCopy2, region2s, regionCount); for (uint32_t r = 0; r < regionCount; r++) { - region2s[r] = (VkImageCopy2KHR) { - .sType = VK_STRUCTURE_TYPE_IMAGE_COPY_2_KHR, + region2s[r] = (VkImageCopy2) { + .sType = VK_STRUCTURE_TYPE_IMAGE_COPY_2, .srcSubresource = pRegions[r].srcSubresource, .srcOffset = pRegions[r].srcOffset, .dstSubresource = pRegions[r].dstSubresource, @@ -88,8 +88,8 @@ vk_common_CmdCopyImage(VkCommandBuffer commandBuffer, }; } - VkCopyImageInfo2KHR info = { - .sType = VK_STRUCTURE_TYPE_COPY_IMAGE_INFO_2_KHR, + VkCopyImageInfo2 info = { + .sType = VK_STRUCTURE_TYPE_COPY_IMAGE_INFO_2, .srcImage = srcImage, .srcImageLayout = srcImageLayout, .dstImage = dstImage, @@ -116,11 +116,11 @@ vk_common_CmdCopyBufferToImage(VkCommandBuffer commandBuffer, */ struct vk_object_base *disp = (struct vk_object_base *)commandBuffer; - STACK_ARRAY(VkBufferImageCopy2KHR, region2s, regionCount); + STACK_ARRAY(VkBufferImageCopy2, region2s, regionCount); for (uint32_t r = 0; r < regionCount; r++) { - region2s[r] = (VkBufferImageCopy2KHR) { - .sType = VK_STRUCTURE_TYPE_BUFFER_IMAGE_COPY_2_KHR, + region2s[r] = (VkBufferImageCopy2) { + .sType = VK_STRUCTURE_TYPE_BUFFER_IMAGE_COPY_2, .bufferOffset = pRegions[r].bufferOffset, .bufferRowLength = pRegions[r].bufferRowLength, .bufferImageHeight = pRegions[r].bufferImageHeight, @@ -130,8 +130,8 @@ vk_common_CmdCopyBufferToImage(VkCommandBuffer commandBuffer, }; } - VkCopyBufferToImageInfo2KHR info = { - .sType = VK_STRUCTURE_TYPE_COPY_BUFFER_TO_IMAGE_INFO_2_KHR, + VkCopyBufferToImageInfo2 info = { + .sType = VK_STRUCTURE_TYPE_COPY_BUFFER_TO_IMAGE_INFO_2, .srcBuffer = srcBuffer, .dstImage = dstImage, .dstImageLayout = dstImageLayout, @@ -157,11 +157,11 @@ vk_common_CmdCopyImageToBuffer(VkCommandBuffer commandBuffer, */ struct vk_object_base *disp = (struct vk_object_base *)commandBuffer; - STACK_ARRAY(VkBufferImageCopy2KHR, region2s, regionCount); + STACK_ARRAY(VkBufferImageCopy2, region2s, regionCount); for (uint32_t r = 0; r < regionCount; r++) { - region2s[r] = (VkBufferImageCopy2KHR) { - .sType = VK_STRUCTURE_TYPE_BUFFER_IMAGE_COPY_2_KHR, + region2s[r] = (VkBufferImageCopy2) { + .sType = VK_STRUCTURE_TYPE_BUFFER_IMAGE_COPY_2, .bufferOffset = pRegions[r].bufferOffset, .bufferRowLength = pRegions[r].bufferRowLength, .bufferImageHeight = pRegions[r].bufferImageHeight, @@ -171,8 +171,8 @@ vk_common_CmdCopyImageToBuffer(VkCommandBuffer commandBuffer, }; } - VkCopyImageToBufferInfo2KHR info = { - .sType = VK_STRUCTURE_TYPE_COPY_IMAGE_TO_BUFFER_INFO_2_KHR, + VkCopyImageToBufferInfo2 info = { + .sType = VK_STRUCTURE_TYPE_COPY_IMAGE_TO_BUFFER_INFO_2, .srcImage = srcImage, .srcImageLayout = srcImageLayout, .dstBuffer = dstBuffer, @@ -200,11 +200,11 @@ vk_common_CmdBlitImage(VkCommandBuffer commandBuffer, */ struct vk_object_base *disp = (struct vk_object_base *)commandBuffer; - STACK_ARRAY(VkImageBlit2KHR, region2s, regionCount); + STACK_ARRAY(VkImageBlit2, region2s, regionCount); for (uint32_t r = 0; r < regionCount; r++) { - region2s[r] = (VkImageBlit2KHR) { - .sType = VK_STRUCTURE_TYPE_IMAGE_BLIT_2_KHR, + region2s[r] = (VkImageBlit2) { + .sType = VK_STRUCTURE_TYPE_IMAGE_BLIT_2, .srcSubresource = pRegions[r].srcSubresource, .srcOffsets = { pRegions[r].srcOffsets[0], @@ -218,8 +218,8 @@ vk_common_CmdBlitImage(VkCommandBuffer commandBuffer, }; } - VkBlitImageInfo2KHR info = { - .sType = VK_STRUCTURE_TYPE_BLIT_IMAGE_INFO_2_KHR, + VkBlitImageInfo2 info = { + .sType = VK_STRUCTURE_TYPE_BLIT_IMAGE_INFO_2, .srcImage = srcImage, .srcImageLayout = srcImageLayout, .dstImage = dstImage, @@ -248,11 +248,11 @@ vk_common_CmdResolveImage(VkCommandBuffer commandBuffer, */ struct vk_object_base *disp = (struct vk_object_base *)commandBuffer; - STACK_ARRAY(VkImageResolve2KHR, region2s, regionCount); + STACK_ARRAY(VkImageResolve2, region2s, regionCount); for (uint32_t r = 0; r < regionCount; r++) { - region2s[r] = (VkImageResolve2KHR) { - .sType = VK_STRUCTURE_TYPE_IMAGE_RESOLVE_2_KHR, + region2s[r] = (VkImageResolve2) { + .sType = VK_STRUCTURE_TYPE_IMAGE_RESOLVE_2, .srcSubresource = pRegions[r].srcSubresource, .srcOffset = pRegions[r].srcOffset, .dstSubresource = pRegions[r].dstSubresource, @@ -261,8 +261,8 @@ vk_common_CmdResolveImage(VkCommandBuffer commandBuffer, }; } - VkResolveImageInfo2KHR info = { - .sType = VK_STRUCTURE_TYPE_RESOLVE_IMAGE_INFO_2_KHR, + VkResolveImageInfo2 info = { + .sType = VK_STRUCTURE_TYPE_RESOLVE_IMAGE_INFO_2, .srcImage = srcImage, .srcImageLayout = srcImageLayout, .dstImage = dstImage, diff --git a/src/vulkan/runtime/vk_device.c b/src/vulkan/runtime/vk_device.c index fd30bf748b9..57883a2ac83 100644 --- a/src/vulkan/runtime/vk_device.c +++ b/src/vulkan/runtime/vk_device.c @@ -599,24 +599,24 @@ vk_get_physical_device_core_1_2_feature_ext(struct VkBaseOutStructure *ext, { switch (ext->sType) { - case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_8BIT_STORAGE_FEATURES_KHR: { - VkPhysicalDevice8BitStorageFeaturesKHR *features = (void *)ext; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_8BIT_STORAGE_FEATURES: { + VkPhysicalDevice8BitStorageFeatures *features = (void *)ext; CORE_FEATURE(storageBuffer8BitAccess); CORE_FEATURE(uniformAndStorageBuffer8BitAccess); CORE_FEATURE(storagePushConstant8); return true; } - case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_BUFFER_DEVICE_ADDRESS_FEATURES_KHR: { - VkPhysicalDeviceBufferDeviceAddressFeaturesKHR *features = (void *)ext; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_BUFFER_DEVICE_ADDRESS_FEATURES: { + VkPhysicalDeviceBufferDeviceAddressFeatures *features = (void *)ext; CORE_FEATURE(bufferDeviceAddress); CORE_FEATURE(bufferDeviceAddressCaptureReplay); CORE_FEATURE(bufferDeviceAddressMultiDevice); return true; } - case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DESCRIPTOR_INDEXING_FEATURES_EXT: { - VkPhysicalDeviceDescriptorIndexingFeaturesEXT *features = (void *)ext; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DESCRIPTOR_INDEXING_FEATURES: { + VkPhysicalDeviceDescriptorIndexingFeatures *features = (void *)ext; CORE_FEATURE(shaderInputAttachmentArrayDynamicIndexing); CORE_FEATURE(shaderUniformTexelBufferArrayDynamicIndexing); CORE_FEATURE(shaderStorageTexelBufferArrayDynamicIndexing); @@ -640,64 +640,64 @@ vk_get_physical_device_core_1_2_feature_ext(struct VkBaseOutStructure *ext, return true; } - case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FLOAT16_INT8_FEATURES_KHR: { - VkPhysicalDeviceFloat16Int8FeaturesKHR *features = (void *)ext; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_FLOAT16_INT8_FEATURES: { + VkPhysicalDeviceShaderFloat16Int8Features *features = (void *)ext; CORE_FEATURE(shaderFloat16); CORE_FEATURE(shaderInt8); return true; } - case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_HOST_QUERY_RESET_FEATURES_EXT: { - VkPhysicalDeviceHostQueryResetFeaturesEXT *features = (void *)ext; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_HOST_QUERY_RESET_FEATURES: { + VkPhysicalDeviceHostQueryResetFeatures *features = (void *)ext; CORE_FEATURE(hostQueryReset); return true; } - case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGELESS_FRAMEBUFFER_FEATURES_KHR: { - VkPhysicalDeviceImagelessFramebufferFeaturesKHR *features = (void *)ext; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGELESS_FRAMEBUFFER_FEATURES: { + VkPhysicalDeviceImagelessFramebufferFeatures *features = (void *)ext; CORE_FEATURE(imagelessFramebuffer); return true; } - case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SCALAR_BLOCK_LAYOUT_FEATURES_EXT: { - VkPhysicalDeviceScalarBlockLayoutFeaturesEXT *features =(void *)ext; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SCALAR_BLOCK_LAYOUT_FEATURES: { + VkPhysicalDeviceScalarBlockLayoutFeatures *features =(void *)ext; CORE_FEATURE(scalarBlockLayout); return true; } - case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SEPARATE_DEPTH_STENCIL_LAYOUTS_FEATURES_KHR: { - VkPhysicalDeviceSeparateDepthStencilLayoutsFeaturesKHR *features = (void *)ext; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SEPARATE_DEPTH_STENCIL_LAYOUTS_FEATURES: { + VkPhysicalDeviceSeparateDepthStencilLayoutsFeatures *features = (void *)ext; CORE_FEATURE(separateDepthStencilLayouts); return true; } - case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_ATOMIC_INT64_FEATURES_KHR: { - VkPhysicalDeviceShaderAtomicInt64FeaturesKHR *features = (void *)ext; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_ATOMIC_INT64_FEATURES: { + VkPhysicalDeviceShaderAtomicInt64Features *features = (void *)ext; CORE_FEATURE(shaderBufferInt64Atomics); CORE_FEATURE(shaderSharedInt64Atomics); return true; } - case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_SUBGROUP_EXTENDED_TYPES_FEATURES_KHR: { - VkPhysicalDeviceShaderSubgroupExtendedTypesFeaturesKHR *features = (void *)ext; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_SUBGROUP_EXTENDED_TYPES_FEATURES: { + VkPhysicalDeviceShaderSubgroupExtendedTypesFeatures *features = (void *)ext; CORE_FEATURE(shaderSubgroupExtendedTypes); return true; } - case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TIMELINE_SEMAPHORE_FEATURES_KHR: { - VkPhysicalDeviceTimelineSemaphoreFeaturesKHR *features = (void *) ext; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TIMELINE_SEMAPHORE_FEATURES: { + VkPhysicalDeviceTimelineSemaphoreFeatures *features = (void *) ext; CORE_FEATURE(timelineSemaphore); return true; } - case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_UNIFORM_BUFFER_STANDARD_LAYOUT_FEATURES_KHR: { - VkPhysicalDeviceUniformBufferStandardLayoutFeaturesKHR *features = (void *)ext; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_UNIFORM_BUFFER_STANDARD_LAYOUT_FEATURES: { + VkPhysicalDeviceUniformBufferStandardLayoutFeatures *features = (void *)ext; CORE_FEATURE(uniformBufferStandardLayout); return true; } - case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_MEMORY_MODEL_FEATURES_KHR: { - VkPhysicalDeviceVulkanMemoryModelFeaturesKHR *features = (void *)ext; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_MEMORY_MODEL_FEATURES: { + VkPhysicalDeviceVulkanMemoryModelFeatures *features = (void *)ext; CORE_FEATURE(vulkanMemoryModel); CORE_FEATURE(vulkanMemoryModelDeviceScope); CORE_FEATURE(vulkanMemoryModelAvailabilityVisibilityChains); @@ -718,82 +718,82 @@ vk_get_physical_device_core_1_3_feature_ext(struct VkBaseOutStructure *ext, const VkPhysicalDeviceVulkan13Features *core) { switch (ext->sType) { - case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DYNAMIC_RENDERING_FEATURES_KHR: { - VkPhysicalDeviceDynamicRenderingFeaturesKHR *features = (void *)ext; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DYNAMIC_RENDERING_FEATURES: { + VkPhysicalDeviceDynamicRenderingFeatures *features = (void *)ext; CORE_FEATURE(dynamicRendering); return true; } - case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_ROBUSTNESS_FEATURES_EXT: { - VkPhysicalDeviceImageRobustnessFeaturesEXT *features = (void *)ext; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_ROBUSTNESS_FEATURES: { + VkPhysicalDeviceImageRobustnessFeatures *features = (void *)ext; CORE_FEATURE(robustImageAccess); return true; } - case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_INLINE_UNIFORM_BLOCK_FEATURES_EXT: { - VkPhysicalDeviceInlineUniformBlockFeaturesEXT *features = (void *)ext; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_INLINE_UNIFORM_BLOCK_FEATURES: { + VkPhysicalDeviceInlineUniformBlockFeatures *features = (void *)ext; CORE_FEATURE(inlineUniformBlock); CORE_FEATURE(descriptorBindingInlineUniformBlockUpdateAfterBind); return true; } - case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MAINTENANCE_4_FEATURES_KHR: { - VkPhysicalDeviceMaintenance4FeaturesKHR *features = (void *)ext; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MAINTENANCE_4_FEATURES: { + VkPhysicalDeviceMaintenance4Features *features = (void *)ext; CORE_FEATURE(maintenance4); return true; } - case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PIPELINE_CREATION_CACHE_CONTROL_FEATURES_EXT: { - VkPhysicalDevicePipelineCreationCacheControlFeaturesEXT *features = (void *)ext; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PIPELINE_CREATION_CACHE_CONTROL_FEATURES: { + VkPhysicalDevicePipelineCreationCacheControlFeatures *features = (void *)ext; CORE_FEATURE(pipelineCreationCacheControl); return true; } - case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PRIVATE_DATA_FEATURES_EXT: { - VkPhysicalDevicePrivateDataFeaturesEXT *features = (void *)ext; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PRIVATE_DATA_FEATURES: { + VkPhysicalDevicePrivateDataFeatures *features = (void *)ext; CORE_FEATURE(privateData); return true; } - case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_DEMOTE_TO_HELPER_INVOCATION_FEATURES_EXT: { - VkPhysicalDeviceShaderDemoteToHelperInvocationFeaturesEXT *features = (void *)ext; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_DEMOTE_TO_HELPER_INVOCATION_FEATURES: { + VkPhysicalDeviceShaderDemoteToHelperInvocationFeatures *features = (void *)ext; CORE_FEATURE(shaderDemoteToHelperInvocation); return true; } - case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_INTEGER_DOT_PRODUCT_FEATURES_KHR: { - VkPhysicalDeviceShaderIntegerDotProductFeaturesKHR *features = (void *)ext; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_INTEGER_DOT_PRODUCT_FEATURES: { + VkPhysicalDeviceShaderIntegerDotProductFeatures *features = (void *)ext; CORE_FEATURE(shaderIntegerDotProduct); return true; }; - case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_TERMINATE_INVOCATION_FEATURES_KHR: { - VkPhysicalDeviceShaderTerminateInvocationFeaturesKHR *features = (void *)ext; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_TERMINATE_INVOCATION_FEATURES: { + VkPhysicalDeviceShaderTerminateInvocationFeatures *features = (void *)ext; CORE_FEATURE(shaderTerminateInvocation); return true; } - case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SUBGROUP_SIZE_CONTROL_FEATURES_EXT: { - VkPhysicalDeviceSubgroupSizeControlFeaturesEXT *features = (void *)ext; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SUBGROUP_SIZE_CONTROL_FEATURES: { + VkPhysicalDeviceSubgroupSizeControlFeatures *features = (void *)ext; CORE_FEATURE(subgroupSizeControl); CORE_FEATURE(computeFullSubgroups); return true; } - case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SYNCHRONIZATION_2_FEATURES_KHR: { - VkPhysicalDeviceSynchronization2FeaturesKHR *features = (void *)ext; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SYNCHRONIZATION_2_FEATURES: { + VkPhysicalDeviceSynchronization2Features *features = (void *)ext; CORE_FEATURE(synchronization2); return true; } - case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TEXTURE_COMPRESSION_ASTC_HDR_FEATURES_EXT: { - VkPhysicalDeviceTextureCompressionASTCHDRFeaturesEXT *features = (void *)ext; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TEXTURE_COMPRESSION_ASTC_HDR_FEATURES: { + VkPhysicalDeviceTextureCompressionASTCHDRFeatures *features = (void *)ext; CORE_FEATURE(textureCompressionASTC_HDR); return true; } - case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ZERO_INITIALIZE_WORKGROUP_MEMORY_FEATURES_KHR: { - VkPhysicalDeviceZeroInitializeWorkgroupMemoryFeaturesKHR *features = (void *)ext; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ZERO_INITIALIZE_WORKGROUP_MEMORY_FEATURES: { + VkPhysicalDeviceZeroInitializeWorkgroupMemoryFeatures *features = (void *)ext; CORE_FEATURE(shaderZeroInitializeWorkgroupMemory); return true; } @@ -881,8 +881,8 @@ vk_get_physical_device_core_1_2_property_ext(struct VkBaseOutStructure *ext, const VkPhysicalDeviceVulkan12Properties *core) { switch (ext->sType) { - case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DEPTH_STENCIL_RESOLVE_PROPERTIES_KHR: { - VkPhysicalDeviceDepthStencilResolvePropertiesKHR *properties = (void *)ext; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DEPTH_STENCIL_RESOLVE_PROPERTIES: { + VkPhysicalDeviceDepthStencilResolveProperties *properties = (void *)ext; CORE_PROPERTY(supportedDepthResolveModes); CORE_PROPERTY(supportedStencilResolveModes); CORE_PROPERTY(independentResolveNone); @@ -890,8 +890,8 @@ vk_get_physical_device_core_1_2_property_ext(struct VkBaseOutStructure *ext, return true; } - case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DESCRIPTOR_INDEXING_PROPERTIES_EXT: { - VkPhysicalDeviceDescriptorIndexingPropertiesEXT *properties = (void *)ext; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DESCRIPTOR_INDEXING_PROPERTIES: { + VkPhysicalDeviceDescriptorIndexingProperties *properties = (void *)ext; CORE_PROPERTY(maxUpdateAfterBindDescriptorsInAllPools); CORE_PROPERTY(shaderUniformBufferArrayNonUniformIndexingNative); CORE_PROPERTY(shaderSampledImageArrayNonUniformIndexingNative); @@ -918,8 +918,8 @@ vk_get_physical_device_core_1_2_property_ext(struct VkBaseOutStructure *ext, return true; } - case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DRIVER_PROPERTIES_KHR: { - VkPhysicalDeviceDriverPropertiesKHR *properties = (void *) ext; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DRIVER_PROPERTIES: { + VkPhysicalDeviceDriverProperties *properties = (void *) ext; CORE_PROPERTY(driverID); CORE_PROPERTY(driverName); CORE_PROPERTY(driverInfo); @@ -927,15 +927,15 @@ vk_get_physical_device_core_1_2_property_ext(struct VkBaseOutStructure *ext, return true; } - case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SAMPLER_FILTER_MINMAX_PROPERTIES_EXT: { - VkPhysicalDeviceSamplerFilterMinmaxPropertiesEXT *properties = (void *)ext; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SAMPLER_FILTER_MINMAX_PROPERTIES: { + VkPhysicalDeviceSamplerFilterMinmaxProperties *properties = (void *)ext; CORE_PROPERTY(filterMinmaxImageComponentMapping); CORE_PROPERTY(filterMinmaxSingleComponentFormats); return true; } - case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FLOAT_CONTROLS_PROPERTIES_KHR : { - VkPhysicalDeviceFloatControlsPropertiesKHR *properties = (void *)ext; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FLOAT_CONTROLS_PROPERTIES : { + VkPhysicalDeviceFloatControlsProperties *properties = (void *)ext; CORE_PROPERTY(denormBehaviorIndependence); CORE_PROPERTY(roundingModeIndependence); CORE_PROPERTY(shaderDenormFlushToZeroFloat16); @@ -956,8 +956,8 @@ vk_get_physical_device_core_1_2_property_ext(struct VkBaseOutStructure *ext, return true; } - case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TIMELINE_SEMAPHORE_PROPERTIES_KHR: { - VkPhysicalDeviceTimelineSemaphorePropertiesKHR *properties = (void *) ext; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TIMELINE_SEMAPHORE_PROPERTIES: { + VkPhysicalDeviceTimelineSemaphoreProperties *properties = (void *) ext; CORE_PROPERTY(maxTimelineSemaphoreValueDifference); return true; } @@ -976,8 +976,8 @@ vk_get_physical_device_core_1_3_property_ext(struct VkBaseOutStructure *ext, const VkPhysicalDeviceVulkan13Properties *core) { switch (ext->sType) { - case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_INLINE_UNIFORM_BLOCK_PROPERTIES_EXT: { - VkPhysicalDeviceInlineUniformBlockPropertiesEXT *properties = (void *)ext; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_INLINE_UNIFORM_BLOCK_PROPERTIES: { + VkPhysicalDeviceInlineUniformBlockProperties *properties = (void *)ext; CORE_PROPERTY(maxInlineUniformBlockSize); CORE_PROPERTY(maxPerStageDescriptorInlineUniformBlocks); CORE_PROPERTY(maxPerStageDescriptorUpdateAfterBindInlineUniformBlocks); @@ -986,14 +986,14 @@ vk_get_physical_device_core_1_3_property_ext(struct VkBaseOutStructure *ext, return true; } - case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MAINTENANCE_4_PROPERTIES_KHR: { - VkPhysicalDeviceMaintenance4PropertiesKHR *properties = (void *)ext; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MAINTENANCE_4_PROPERTIES: { + VkPhysicalDeviceMaintenance4Properties *properties = (void *)ext; CORE_PROPERTY(maxBufferSize); return true; } - case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_INTEGER_DOT_PRODUCT_PROPERTIES_KHR: { - VkPhysicalDeviceShaderIntegerDotProductPropertiesKHR *properties = (void *)ext; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_INTEGER_DOT_PRODUCT_PROPERTIES: { + VkPhysicalDeviceShaderIntegerDotProductProperties *properties = (void *)ext; #define IDP_PROPERTY(x) CORE_PROPERTY(integerDotProduct##x) IDP_PROPERTY(8BitUnsignedAccelerated); @@ -1030,8 +1030,8 @@ vk_get_physical_device_core_1_3_property_ext(struct VkBaseOutStructure *ext, return true; } - case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SUBGROUP_SIZE_CONTROL_PROPERTIES_EXT: { - VkPhysicalDeviceSubgroupSizeControlPropertiesEXT *properties = (void *)ext; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SUBGROUP_SIZE_CONTROL_PROPERTIES: { + VkPhysicalDeviceSubgroupSizeControlProperties *properties = (void *)ext; CORE_PROPERTY(minSubgroupSize); CORE_PROPERTY(maxSubgroupSize); CORE_PROPERTY(maxComputeWorkgroupSubgroups); @@ -1039,8 +1039,8 @@ vk_get_physical_device_core_1_3_property_ext(struct VkBaseOutStructure *ext, return true; } - case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TEXEL_BUFFER_ALIGNMENT_PROPERTIES_EXT: { - VkPhysicalDeviceTexelBufferAlignmentPropertiesEXT *properties = (void *)ext; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TEXEL_BUFFER_ALIGNMENT_PROPERTIES: { + VkPhysicalDeviceTexelBufferAlignmentProperties *properties = (void *)ext; CORE_PROPERTY(storageTexelBufferOffsetAlignmentBytes); CORE_PROPERTY(storageTexelBufferOffsetSingleTexelAlignment); CORE_PROPERTY(uniformTexelBufferOffsetAlignmentBytes); diff --git a/src/vulkan/runtime/vk_fence.c b/src/vulkan/runtime/vk_fence.c index 89402bf0fe4..bcb2b11d840 100644 --- a/src/vulkan/runtime/vk_fence.c +++ b/src/vulkan/runtime/vk_fence.c @@ -268,7 +268,7 @@ vk_common_WaitForFences(VkDevice _device, VK_FROM_HANDLE(vk_fence, fence, pFences[i]); waits[i] = (struct vk_sync_wait) { .sync = vk_fence_get_active_sync(fence), - .stage_mask = ~(VkPipelineStageFlags2KHR)0, + .stage_mask = ~(VkPipelineStageFlags2)0, }; } diff --git a/src/vulkan/runtime/vk_framebuffer.c b/src/vulkan/runtime/vk_framebuffer.c index c76ab96f098..f28dce1ffb1 100644 --- a/src/vulkan/runtime/vk_framebuffer.c +++ b/src/vulkan/runtime/vk_framebuffer.c @@ -41,10 +41,10 @@ vk_common_CreateFramebuffer(VkDevice _device, /* VK_KHR_imageless_framebuffer extension says: * - * If flags includes VK_FRAMEBUFFER_CREATE_IMAGELESS_BIT_KHR, + * If flags includes VK_FRAMEBUFFER_CREATE_IMAGELESS_BIT, * parameter pAttachments is ignored. */ - if (!(pCreateInfo->flags & VK_FRAMEBUFFER_CREATE_IMAGELESS_BIT_KHR)) + if (!(pCreateInfo->flags & VK_FRAMEBUFFER_CREATE_IMAGELESS_BIT)) size += sizeof(VkImageView) * pCreateInfo->attachmentCount; framebuffer = vk_object_alloc(device, pAllocator, size, @@ -57,7 +57,7 @@ vk_common_CreateFramebuffer(VkDevice _device, framebuffer->height = pCreateInfo->height; framebuffer->layers = pCreateInfo->layers; - if (!(pCreateInfo->flags & VK_FRAMEBUFFER_CREATE_IMAGELESS_BIT_KHR)) { + if (!(pCreateInfo->flags & VK_FRAMEBUFFER_CREATE_IMAGELESS_BIT)) { for (uint32_t i = 0; i < pCreateInfo->attachmentCount; i++) framebuffer->attachments[i] = pCreateInfo->pAttachments[i]; framebuffer->attachment_count = pCreateInfo->attachmentCount; diff --git a/src/vulkan/runtime/vk_image.c b/src/vulkan/runtime/vk_image.c index c42ecaf2dc3..7763ec1b5e8 100644 --- a/src/vulkan/runtime/vk_image.c +++ b/src/vulkan/runtime/vk_image.c @@ -85,9 +85,9 @@ vk_image_init(struct vk_device *device, image->usage = pCreateInfo->usage; if (image->aspects & VK_IMAGE_ASPECT_STENCIL_BIT) { - const VkImageStencilUsageCreateInfoEXT *stencil_usage_info = + const VkImageStencilUsageCreateInfo *stencil_usage_info = vk_find_struct_const(pCreateInfo->pNext, - IMAGE_STENCIL_USAGE_CREATE_INFO_EXT); + IMAGE_STENCIL_USAGE_CREATE_INFO); image->stencil_usage = stencil_usage_info ? stencil_usage_info->stencilUsage : pCreateInfo->usage; @@ -286,7 +286,7 @@ vk_image_offset_to_elements(const struct vk_image *image, VkOffset3D offset) struct vk_image_buffer_layout vk_image_buffer_copy_layout(const struct vk_image *image, - const VkBufferImageCopy2KHR* region) + const VkBufferImageCopy2* region) { VkExtent3D extent = vk_image_sanitize_extent(image, region->imageExtent); @@ -555,7 +555,7 @@ vk_image_layout_is_read_only(VkImageLayout layout, case VK_IMAGE_LAYOUT_SHARED_PRESENT_KHR: case VK_IMAGE_LAYOUT_DEPTH_ATTACHMENT_OPTIMAL: case VK_IMAGE_LAYOUT_STENCIL_ATTACHMENT_OPTIMAL: - case VK_IMAGE_LAYOUT_ATTACHMENT_OPTIMAL_KHR: + case VK_IMAGE_LAYOUT_ATTACHMENT_OPTIMAL: #ifdef __GNUC__ #pragma GCC diagnostic push #pragma GCC diagnostic ignored "-Wswitch" @@ -570,11 +570,11 @@ vk_image_layout_is_read_only(VkImageLayout layout, case VK_IMAGE_LAYOUT_SHADER_READ_ONLY_OPTIMAL: case VK_IMAGE_LAYOUT_TRANSFER_SRC_OPTIMAL: case VK_IMAGE_LAYOUT_PRESENT_SRC_KHR: - case VK_IMAGE_LAYOUT_SHADING_RATE_OPTIMAL_NV: + case VK_IMAGE_LAYOUT_FRAGMENT_SHADING_RATE_ATTACHMENT_OPTIMAL_KHR: case VK_IMAGE_LAYOUT_FRAGMENT_DENSITY_MAP_OPTIMAL_EXT: case VK_IMAGE_LAYOUT_DEPTH_READ_ONLY_OPTIMAL: case VK_IMAGE_LAYOUT_STENCIL_READ_ONLY_OPTIMAL: - case VK_IMAGE_LAYOUT_READ_ONLY_OPTIMAL_KHR: + case VK_IMAGE_LAYOUT_READ_ONLY_OPTIMAL: return true; case VK_IMAGE_LAYOUT_DEPTH_READ_ONLY_STENCIL_ATTACHMENT_OPTIMAL: @@ -620,7 +620,7 @@ vk_image_layout_is_depth_only(VkImageLayout layout) * all relevant image aspects." */ VkImageLayout -vk_att_ref_stencil_layout(const VkAttachmentReference2KHR *att_ref, +vk_att_ref_stencil_layout(const VkAttachmentReference2 *att_ref, const VkAttachmentDescription2 *attachments) { /* From VUID-VkAttachmentReference2-attachment-04755: @@ -632,8 +632,8 @@ vk_att_ref_stencil_layout(const VkAttachmentReference2KHR *att_ref, !vk_format_has_stencil(attachments[att_ref->attachment].format)) return VK_IMAGE_LAYOUT_UNDEFINED; - const VkAttachmentReferenceStencilLayoutKHR *stencil_ref = - vk_find_struct_const(att_ref->pNext, ATTACHMENT_REFERENCE_STENCIL_LAYOUT_KHR); + const VkAttachmentReferenceStencilLayout *stencil_ref = + vk_find_struct_const(att_ref->pNext, ATTACHMENT_REFERENCE_STENCIL_LAYOUT); if (stencil_ref) return stencil_ref->stencilLayout; @@ -670,14 +670,13 @@ vk_att_ref_stencil_layout(const VkAttachmentReference2KHR *att_ref, * the pNext chain." */ VkImageLayout -vk_att_desc_stencil_layout(const VkAttachmentDescription2KHR *att_desc, - bool final) +vk_att_desc_stencil_layout(const VkAttachmentDescription2 *att_desc, bool final) { if (!vk_format_has_stencil(att_desc->format)) return VK_IMAGE_LAYOUT_UNDEFINED; - const VkAttachmentDescriptionStencilLayoutKHR *stencil_desc = - vk_find_struct_const(att_desc->pNext, ATTACHMENT_DESCRIPTION_STENCIL_LAYOUT_KHR); + const VkAttachmentDescriptionStencilLayout *stencil_desc = + vk_find_struct_const(att_desc->pNext, ATTACHMENT_DESCRIPTION_STENCIL_LAYOUT); if (stencil_desc) { return final ? @@ -801,15 +800,15 @@ vk_image_layout_to_usage_flags(VkImageLayout layout, assert(aspect == VK_IMAGE_ASPECT_COLOR_BIT); return vk_image_layout_to_usage_flags(VK_IMAGE_LAYOUT_GENERAL, aspect); - case VK_IMAGE_LAYOUT_SHADING_RATE_OPTIMAL_NV: + case VK_IMAGE_LAYOUT_FRAGMENT_SHADING_RATE_ATTACHMENT_OPTIMAL_KHR: assert(aspect == VK_IMAGE_ASPECT_COLOR_BIT); - return VK_IMAGE_USAGE_SHADING_RATE_IMAGE_BIT_NV; + return VK_IMAGE_USAGE_FRAGMENT_SHADING_RATE_ATTACHMENT_BIT_KHR; case VK_IMAGE_LAYOUT_FRAGMENT_DENSITY_MAP_OPTIMAL_EXT: assert(aspect == VK_IMAGE_ASPECT_COLOR_BIT); return VK_IMAGE_USAGE_FRAGMENT_DENSITY_MAP_BIT_EXT; - case VK_IMAGE_LAYOUT_ATTACHMENT_OPTIMAL_KHR: + case VK_IMAGE_LAYOUT_ATTACHMENT_OPTIMAL: if (aspect == VK_IMAGE_ASPECT_DEPTH_BIT || aspect == VK_IMAGE_ASPECT_STENCIL_BIT) { return VK_IMAGE_USAGE_DEPTH_STENCIL_ATTACHMENT_BIT; @@ -818,7 +817,7 @@ vk_image_layout_to_usage_flags(VkImageLayout layout, return VK_IMAGE_USAGE_COLOR_ATTACHMENT_BIT; } - case VK_IMAGE_LAYOUT_READ_ONLY_OPTIMAL_KHR: + case VK_IMAGE_LAYOUT_READ_ONLY_OPTIMAL: return VK_IMAGE_USAGE_SAMPLED_BIT | VK_IMAGE_USAGE_INPUT_ATTACHMENT_BIT; diff --git a/src/vulkan/runtime/vk_image.h b/src/vulkan/runtime/vk_image.h index 236c06937ac..2077c3b0cdd 100644 --- a/src/vulkan/runtime/vk_image.h +++ b/src/vulkan/runtime/vk_image.h @@ -165,14 +165,14 @@ vk_image_offset_to_elements(const struct vk_image *image, VkOffset3D offset); struct vk_image_buffer_layout { /** - * VkBufferImageCopy2KHR::bufferRowLength or - * VkBufferImageCopy2KHR::extent::width as needed. + * VkBufferImageCopy2::bufferRowLength or + * VkBufferImageCopy2::extent::width as needed. */ uint32_t row_length; /** - * VkBufferImageCopy2KHR::bufferImageHeight or - * VkBufferImageCopy2KHR::extent::height as needed. + * VkBufferImageCopy2::bufferImageHeight or + * VkBufferImageCopy2::extent::height as needed. */ uint32_t image_height; @@ -193,7 +193,7 @@ struct vk_image_buffer_layout { struct vk_image_buffer_layout vk_image_buffer_copy_layout(const struct vk_image *image, - const VkBufferImageCopy2KHR* region); + const VkBufferImageCopy2* region); struct vk_image_view { struct vk_object_base base; @@ -320,9 +320,9 @@ bool vk_image_layout_is_depth_only(VkImageLayout layout); VkImageUsageFlags vk_image_layout_to_usage_flags(VkImageLayout layout, VkImageAspectFlagBits aspect); -VkImageLayout vk_att_ref_stencil_layout(const VkAttachmentReference2KHR *att_ref, +VkImageLayout vk_att_ref_stencil_layout(const VkAttachmentReference2 *att_ref, const VkAttachmentDescription2 *attachments); -VkImageLayout vk_att_desc_stencil_layout(const VkAttachmentDescription2KHR *att_desc, +VkImageLayout vk_att_desc_stencil_layout(const VkAttachmentDescription2 *att_desc, bool final); #ifdef __cplusplus diff --git a/src/vulkan/runtime/vk_object.c b/src/vulkan/runtime/vk_object.c index 24a33030721..4fe0db7c89e 100644 --- a/src/vulkan/runtime/vk_object.c +++ b/src/vulkan/runtime/vk_object.c @@ -127,9 +127,9 @@ vk_object_free(struct vk_device *device, VkResult vk_private_data_slot_create(struct vk_device *device, - const VkPrivateDataSlotCreateInfoEXT* pCreateInfo, + const VkPrivateDataSlotCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, - VkPrivateDataSlotEXT* pPrivateDataSlot) + VkPrivateDataSlot* pPrivateDataSlot) { struct vk_private_data_slot *slot = vk_alloc2(&device->alloc, pAllocator, sizeof(*slot), 8, @@ -138,7 +138,7 @@ vk_private_data_slot_create(struct vk_device *device, return VK_ERROR_OUT_OF_HOST_MEMORY; vk_object_base_init(device, &slot->base, - VK_OBJECT_TYPE_PRIVATE_DATA_SLOT_EXT); + VK_OBJECT_TYPE_PRIVATE_DATA_SLOT); slot->index = p_atomic_inc_return(&device->private_data_next_index); *pPrivateDataSlot = vk_private_data_slot_to_handle(slot); @@ -148,7 +148,7 @@ vk_private_data_slot_create(struct vk_device *device, void vk_private_data_slot_destroy(struct vk_device *device, - VkPrivateDataSlotEXT privateDataSlot, + VkPrivateDataSlot privateDataSlot, const VkAllocationCallbacks *pAllocator) { VK_FROM_HANDLE(vk_private_data_slot, slot, privateDataSlot); @@ -202,7 +202,7 @@ static VkResult vk_object_base_private_data(struct vk_device *device, VkObjectType objectType, uint64_t objectHandle, - VkPrivateDataSlotEXT privateDataSlot, + VkPrivateDataSlot privateDataSlot, uint64_t **private_data) { VK_FROM_HANDLE(vk_private_data_slot, slot, privateDataSlot); @@ -236,7 +236,7 @@ VkResult vk_object_base_set_private_data(struct vk_device *device, VkObjectType objectType, uint64_t objectHandle, - VkPrivateDataSlotEXT privateDataSlot, + VkPrivateDataSlot privateDataSlot, uint64_t data) { uint64_t *private_data; @@ -255,7 +255,7 @@ void vk_object_base_get_private_data(struct vk_device *device, VkObjectType objectType, uint64_t objectHandle, - VkPrivateDataSlotEXT privateDataSlot, + VkPrivateDataSlot privateDataSlot, uint64_t *pData) { uint64_t *private_data; @@ -272,9 +272,9 @@ vk_object_base_get_private_data(struct vk_device *device, VKAPI_ATTR VkResult VKAPI_CALL vk_common_CreatePrivateDataSlotEXT(VkDevice _device, - const VkPrivateDataSlotCreateInfoEXT *pCreateInfo, + const VkPrivateDataSlotCreateInfo *pCreateInfo, const VkAllocationCallbacks *pAllocator, - VkPrivateDataSlotEXT *pPrivateDataSlot) + VkPrivateDataSlot *pPrivateDataSlot) { VK_FROM_HANDLE(vk_device, device, _device); return vk_private_data_slot_create(device, pCreateInfo, pAllocator, @@ -283,7 +283,7 @@ vk_common_CreatePrivateDataSlotEXT(VkDevice _device, VKAPI_ATTR void VKAPI_CALL vk_common_DestroyPrivateDataSlotEXT(VkDevice _device, - VkPrivateDataSlotEXT privateDataSlot, + VkPrivateDataSlot privateDataSlot, const VkAllocationCallbacks *pAllocator) { VK_FROM_HANDLE(vk_device, device, _device); @@ -294,7 +294,7 @@ VKAPI_ATTR VkResult VKAPI_CALL vk_common_SetPrivateDataEXT(VkDevice _device, VkObjectType objectType, uint64_t objectHandle, - VkPrivateDataSlotEXT privateDataSlot, + VkPrivateDataSlot privateDataSlot, uint64_t data) { VK_FROM_HANDLE(vk_device, device, _device); @@ -307,7 +307,7 @@ VKAPI_ATTR void VKAPI_CALL vk_common_GetPrivateDataEXT(VkDevice _device, VkObjectType objectType, uint64_t objectHandle, - VkPrivateDataSlotEXT privateDataSlot, + VkPrivateDataSlot privateDataSlot, uint64_t *pData) { VK_FROM_HANDLE(vk_device, device, _device); diff --git a/src/vulkan/runtime/vk_object.h b/src/vulkan/runtime/vk_object.h index 63d55f954f3..f60c2005f4e 100644 --- a/src/vulkan/runtime/vk_object.h +++ b/src/vulkan/runtime/vk_object.h @@ -229,29 +229,29 @@ struct vk_private_data_slot { uint32_t index; }; VK_DEFINE_NONDISP_HANDLE_CASTS(vk_private_data_slot, base, - VkPrivateDataSlotEXT, - VK_OBJECT_TYPE_PRIVATE_DATA_SLOT_EXT); + VkPrivateDataSlot, + VK_OBJECT_TYPE_PRIVATE_DATA_SLOT); VkResult vk_private_data_slot_create(struct vk_device *device, - const VkPrivateDataSlotCreateInfoEXT* pCreateInfo, + const VkPrivateDataSlotCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, - VkPrivateDataSlotEXT* pPrivateDataSlot); + VkPrivateDataSlot* pPrivateDataSlot); void vk_private_data_slot_destroy(struct vk_device *device, - VkPrivateDataSlotEXT privateDataSlot, + VkPrivateDataSlot privateDataSlot, const VkAllocationCallbacks *pAllocator); VkResult vk_object_base_set_private_data(struct vk_device *device, VkObjectType objectType, uint64_t objectHandle, - VkPrivateDataSlotEXT privateDataSlot, + VkPrivateDataSlot privateDataSlot, uint64_t data); void vk_object_base_get_private_data(struct vk_device *device, VkObjectType objectType, uint64_t objectHandle, - VkPrivateDataSlotEXT privateDataSlot, + VkPrivateDataSlot privateDataSlot, uint64_t *pData); const char * diff --git a/src/vulkan/runtime/vk_pipeline.c b/src/vulkan/runtime/vk_pipeline.c index da3e0da77dc..e4183f38ed3 100644 --- a/src/vulkan/runtime/vk_pipeline.c +++ b/src/vulkan/runtime/vk_pipeline.c @@ -50,9 +50,9 @@ vk_pipeline_shader_stage_is_null(const VkPipelineShaderStageCreateInfo *info) static uint32_t get_required_subgroup_size(const VkPipelineShaderStageCreateInfo *info) { - const VkPipelineShaderStageRequiredSubgroupSizeCreateInfoEXT *rss_info = + const VkPipelineShaderStageRequiredSubgroupSizeCreateInfo *rss_info = vk_find_struct_const(info->pNext, - PIPELINE_SHADER_STAGE_REQUIRED_SUBGROUP_SIZE_CREATE_INFO_EXT); + PIPELINE_SHADER_STAGE_REQUIRED_SUBGROUP_SIZE_CREATE_INFO); return rss_info != NULL ? rss_info->requiredSubgroupSize : 0; } @@ -110,11 +110,11 @@ vk_pipeline_shader_stage_to_nir(struct vk_device *device, assert(util_is_power_of_two_nonzero(req_subgroup_size)); assert(req_subgroup_size >= 8 && req_subgroup_size <= 128); subgroup_size = req_subgroup_size; - } else if (info->flags & VK_PIPELINE_SHADER_STAGE_CREATE_ALLOW_VARYING_SUBGROUP_SIZE_BIT_EXT || + } else if (info->flags & VK_PIPELINE_SHADER_STAGE_CREATE_ALLOW_VARYING_SUBGROUP_SIZE_BIT || vk_spirv_version(spirv_data, spirv_size) >= 0x10600) { /* Starting with SPIR-V 1.6, varying subgroup size the default */ subgroup_size = SUBGROUP_SIZE_VARYING; - } else if (info->flags & VK_PIPELINE_SHADER_STAGE_CREATE_REQUIRE_FULL_SUBGROUPS_BIT_EXT) { + } else if (info->flags & VK_PIPELINE_SHADER_STAGE_CREATE_REQUIRE_FULL_SUBGROUPS_BIT) { assert(stage == MESA_SHADER_COMPUTE); subgroup_size = SUBGROUP_SIZE_FULL_SUBGROUPS; } else { diff --git a/src/vulkan/runtime/vk_pipeline_cache.c b/src/vulkan/runtime/vk_pipeline_cache.c index ab9379ac4c4..6fa9b3ff632 100644 --- a/src/vulkan/runtime/vk_pipeline_cache.c +++ b/src/vulkan/runtime/vk_pipeline_cache.c @@ -144,14 +144,14 @@ static void vk_pipeline_cache_lock(struct vk_pipeline_cache *cache) { - if (!(cache->flags & VK_PIPELINE_CACHE_CREATE_EXTERNALLY_SYNCHRONIZED_BIT_EXT)) + if (!(cache->flags & VK_PIPELINE_CACHE_CREATE_EXTERNALLY_SYNCHRONIZED_BIT)) simple_mtx_lock(&cache->lock); } static void vk_pipeline_cache_unlock(struct vk_pipeline_cache *cache) { - if (!(cache->flags & VK_PIPELINE_CACHE_CREATE_EXTERNALLY_SYNCHRONIZED_BIT_EXT)) + if (!(cache->flags & VK_PIPELINE_CACHE_CREATE_EXTERNALLY_SYNCHRONIZED_BIT)) simple_mtx_unlock(&cache->lock); } diff --git a/src/vulkan/runtime/vk_queue.c b/src/vulkan/runtime/vk_queue.c index cdfbf718489..edc57cb234d 100644 --- a/src/vulkan/runtime/vk_queue.c +++ b/src/vulkan/runtime/vk_queue.c @@ -571,13 +571,13 @@ struct vulkan_submit_info { const void *pNext; uint32_t command_buffer_count; - const VkCommandBufferSubmitInfoKHR *command_buffers; + const VkCommandBufferSubmitInfo *command_buffers; uint32_t wait_count; - const VkSemaphoreSubmitInfoKHR *waits; + const VkSemaphoreSubmitInfo *waits; uint32_t signal_count; - const VkSemaphoreSubmitInfoKHR *signals; + const VkSemaphoreSubmitInfo *signals; uint32_t buffer_bind_count; const VkSparseBufferMemoryBindInfo *buffer_binds; @@ -1043,7 +1043,7 @@ vk_queue_wait_before_present(struct vk_queue *queue, waits[i] = (struct vk_sync_wait) { .sync = vk_semaphore_get_active_sync(semaphore), - .stage_mask = ~(VkPipelineStageFlags2KHR)0, + .stage_mask = ~(VkPipelineStageFlags2)0, }; } @@ -1125,7 +1125,7 @@ vk_queue_finish(struct vk_queue *queue) VKAPI_ATTR VkResult VKAPI_CALL vk_common_QueueSubmit2KHR(VkQueue _queue, uint32_t submitCount, - const VkSubmitInfo2KHR *pSubmits, + const VkSubmitInfo2 *pSubmits, VkFence _fence) { VK_FROM_HANDLE(vk_queue, queue, _queue); @@ -1215,9 +1215,9 @@ vk_common_QueueBindSparse(VkQueue _queue, signal_values = timeline_info->pSignalSemaphoreValues; } - STACK_ARRAY(VkSemaphoreSubmitInfoKHR, wait_semaphore_infos, + STACK_ARRAY(VkSemaphoreSubmitInfo, wait_semaphore_infos, pBindInfo[i].waitSemaphoreCount); - STACK_ARRAY(VkSemaphoreSubmitInfoKHR, signal_semaphore_infos, + STACK_ARRAY(VkSemaphoreSubmitInfo, signal_semaphore_infos, pBindInfo[i].signalSemaphoreCount); if (!wait_semaphore_infos || !signal_semaphore_infos) { @@ -1227,16 +1227,16 @@ vk_common_QueueBindSparse(VkQueue _queue, } for (uint32_t j = 0; j < pBindInfo[i].waitSemaphoreCount; j++) { - wait_semaphore_infos[j] = (VkSemaphoreSubmitInfoKHR) { - .sType = VK_STRUCTURE_TYPE_SEMAPHORE_SUBMIT_INFO_KHR, + wait_semaphore_infos[j] = (VkSemaphoreSubmitInfo) { + .sType = VK_STRUCTURE_TYPE_SEMAPHORE_SUBMIT_INFO, .semaphore = pBindInfo[i].pWaitSemaphores[j], .value = wait_values ? wait_values[j] : 0, }; } for (uint32_t j = 0; j < pBindInfo[i].signalSemaphoreCount; j++) { - signal_semaphore_infos[j] = (VkSemaphoreSubmitInfoKHR) { - .sType = VK_STRUCTURE_TYPE_SEMAPHORE_SUBMIT_INFO_KHR, + signal_semaphore_infos[j] = (VkSemaphoreSubmitInfo) { + .sType = VK_STRUCTURE_TYPE_SEMAPHORE_SUBMIT_INFO, .semaphore = pBindInfo[i].pSignalSemaphores[j], .value = signal_values ? signal_values[j] : 0, }; diff --git a/src/vulkan/runtime/vk_render_pass.c b/src/vulkan/runtime/vk_render_pass.c index f09cd044134..a6b299d6c55 100644 --- a/src/vulkan/runtime/vk_render_pass.c +++ b/src/vulkan/runtime/vk_render_pass.c @@ -903,7 +903,7 @@ vk_get_command_buffer_inheritance_as_rendering_resume( const struct vk_subpass *subpass = &pass->subpasses[inheritance->subpass]; VK_FROM_HANDLE(vk_framebuffer, fb, inheritance->framebuffer); - if (fb == NULL || (fb->flags & VK_FRAMEBUFFER_CREATE_IMAGELESS_BIT_KHR)) + if (fb == NULL || (fb->flags & VK_FRAMEBUFFER_CREATE_IMAGELESS_BIT)) return NULL; data->rendering = (VkRenderingInfo) { @@ -1170,7 +1170,7 @@ stage_access_for_layout(VkImageLayout layout, VkImageAspectFlags aspects) access |= VK_ACCESS_2_DEPTH_STENCIL_ATTACHMENT_WRITE_BIT; /* It might be a resolve attachment */ - stages |= VK_PIPELINE_STAGE_2_TRANSFER_BIT; + stages |= VK_PIPELINE_STAGE_2_ALL_TRANSFER_BIT; access |= VK_ACCESS_2_TRANSFER_WRITE_BIT; } } else { @@ -1182,7 +1182,7 @@ stage_access_for_layout(VkImageLayout layout, VkImageAspectFlags aspects) VK_ACCESS_2_COLOR_ATTACHMENT_WRITE_BIT; /* It might be a resolve attachment */ - stages |= VK_PIPELINE_STAGE_2_TRANSFER_BIT; + stages |= VK_PIPELINE_STAGE_2_ALL_TRANSFER_BIT; access |= VK_ACCESS_2_TRANSFER_WRITE_BIT; } } @@ -1797,11 +1797,11 @@ begin_subpass(struct vk_command_buffer *cmd_buffer, * that, if we resolve to the wrong aspect, we will still consider * it bound and clear it if requested. */ - VkResolveModeFlagBitsKHR depth_resolve_mode = VK_RESOLVE_MODE_NONE; + VkResolveModeFlagBits depth_resolve_mode = VK_RESOLVE_MODE_NONE; if (res_rp_att->aspects & VK_IMAGE_ASPECT_DEPTH_BIT) depth_resolve_mode = subpass->depth_resolve_mode; - VkResolveModeFlagBitsKHR stencil_resolve_mode = VK_RESOLVE_MODE_NONE; + VkResolveModeFlagBits stencil_resolve_mode = VK_RESOLVE_MODE_NONE; if (res_rp_att->aspects & VK_IMAGE_ASPECT_STENCIL_BIT) stencil_resolve_mode = subpass->stencil_resolve_mode; diff --git a/src/vulkan/runtime/vk_render_pass.h b/src/vulkan/runtime/vk_render_pass.h index 1a758f15c4e..b9d65294bbf 100644 --- a/src/vulkan/runtime/vk_render_pass.h +++ b/src/vulkan/runtime/vk_render_pass.h @@ -165,10 +165,10 @@ struct vk_subpass { uint32_t view_mask; /** VkSubpassDescriptionDepthStencilResolve::depthResolveMode */ - VkResolveModeFlagBitsKHR depth_resolve_mode; + VkResolveModeFlagBits depth_resolve_mode; /** VkSubpassDescriptionDepthStencilResolve::stencilResolveMode */ - VkResolveModeFlagBitsKHR stencil_resolve_mode; + VkResolveModeFlagBits stencil_resolve_mode; /** VkFragmentShadingRateAttachmentInfoKHR::shadingRateAttachmentTexelSize */ VkExtent2D fragment_shading_rate_attachment_texel_size; diff --git a/src/vulkan/runtime/vk_semaphore.c b/src/vulkan/runtime/vk_semaphore.c index b5295fb12cc..a008384272b 100644 --- a/src/vulkan/runtime/vk_semaphore.c +++ b/src/vulkan/runtime/vk_semaphore.c @@ -313,7 +313,7 @@ vk_common_WaitSemaphores(VkDevice _device, waits[i] = (struct vk_sync_wait) { .sync = vk_semaphore_get_active_sync(semaphore), - .stage_mask = ~(VkPipelineStageFlags2KHR)0, + .stage_mask = ~(VkPipelineStageFlags2)0, .wait_value = pWaitInfo->pValues[i], }; } diff --git a/src/vulkan/runtime/vk_sync.c b/src/vulkan/runtime/vk_sync.c index 21604186cd4..83322ac5d6d 100644 --- a/src/vulkan/runtime/vk_sync.c +++ b/src/vulkan/runtime/vk_sync.c @@ -228,7 +228,7 @@ __vk_sync_wait(struct vk_device *device, } else { struct vk_sync_wait wait = { .sync = sync, - .stage_mask = ~(VkPipelineStageFlags2KHR)0, + .stage_mask = ~(VkPipelineStageFlags2)0, .wait_value = wait_value, }; return sync->type->wait_many(device, 1, &wait, wait_flags, diff --git a/src/vulkan/runtime/vk_sync.h b/src/vulkan/runtime/vk_sync.h index ff493bd62c9..bb5b204d2ad 100644 --- a/src/vulkan/runtime/vk_sync.h +++ b/src/vulkan/runtime/vk_sync.h @@ -290,17 +290,17 @@ struct vk_sync { enum vk_sync_flags flags; }; -/* See VkSemaphoreSubmitInfoKHR */ +/* See VkSemaphoreSubmitInfo */ struct vk_sync_wait { struct vk_sync *sync; - VkPipelineStageFlags2KHR stage_mask; + VkPipelineStageFlags2 stage_mask; uint64_t wait_value; }; -/* See VkSemaphoreSubmitInfoKHR */ +/* See VkSemaphoreSubmitInfo */ struct vk_sync_signal { struct vk_sync *sync; - VkPipelineStageFlags2KHR stage_mask; + VkPipelineStageFlags2 stage_mask; uint64_t signal_value; }; diff --git a/src/vulkan/runtime/vk_synchronization2.c b/src/vulkan/runtime/vk_synchronization2.c index 870f93ce1cb..8c291091bac 100644 --- a/src/vulkan/runtime/vk_synchronization2.c +++ b/src/vulkan/runtime/vk_synchronization2.c @@ -40,36 +40,36 @@ vk_common_CmdWriteTimestamp( struct vk_device *device = cmd_buffer->base.device; device->dispatch_table.CmdWriteTimestamp2KHR(commandBuffer, - (VkPipelineStageFlags2KHR) pipelineStage, + (VkPipelineStageFlags2) pipelineStage, queryPool, query); } -static VkMemoryBarrier2KHR +static VkMemoryBarrier2 upgrade_memory_barrier(const VkMemoryBarrier *barrier, - VkPipelineStageFlags2KHR src_stage_mask2, - VkPipelineStageFlags2KHR dst_stage_mask2) + VkPipelineStageFlags2 src_stage_mask2, + VkPipelineStageFlags2 dst_stage_mask2) { - return (VkMemoryBarrier2KHR) { - .sType = VK_STRUCTURE_TYPE_MEMORY_BARRIER_2_KHR, + return (VkMemoryBarrier2) { + .sType = VK_STRUCTURE_TYPE_MEMORY_BARRIER_2, .srcStageMask = src_stage_mask2, - .srcAccessMask = (VkAccessFlags2KHR) barrier->srcAccessMask, + .srcAccessMask = (VkAccessFlags2) barrier->srcAccessMask, .dstStageMask = dst_stage_mask2, - .dstAccessMask = (VkAccessFlags2KHR) barrier->dstAccessMask, + .dstAccessMask = (VkAccessFlags2) barrier->dstAccessMask, }; } -static VkBufferMemoryBarrier2KHR +static VkBufferMemoryBarrier2 upgrade_buffer_memory_barrier(const VkBufferMemoryBarrier *barrier, - VkPipelineStageFlags2KHR src_stage_mask2, - VkPipelineStageFlags2KHR dst_stage_mask2) + VkPipelineStageFlags2 src_stage_mask2, + VkPipelineStageFlags2 dst_stage_mask2) { - return (VkBufferMemoryBarrier2KHR) { - .sType = VK_STRUCTURE_TYPE_BUFFER_MEMORY_BARRIER_2_KHR, + return (VkBufferMemoryBarrier2) { + .sType = VK_STRUCTURE_TYPE_BUFFER_MEMORY_BARRIER_2, .srcStageMask = src_stage_mask2, - .srcAccessMask = (VkAccessFlags2KHR) barrier->srcAccessMask, + .srcAccessMask = (VkAccessFlags2) barrier->srcAccessMask, .dstStageMask = dst_stage_mask2, - .dstAccessMask = (VkAccessFlags2KHR) barrier->dstAccessMask, + .dstAccessMask = (VkAccessFlags2) barrier->dstAccessMask, .srcQueueFamilyIndex = barrier->srcQueueFamilyIndex, .dstQueueFamilyIndex = barrier->dstQueueFamilyIndex, .buffer = barrier->buffer, @@ -78,17 +78,17 @@ upgrade_buffer_memory_barrier(const VkBufferMemoryBarrier *barrier, }; } -static VkImageMemoryBarrier2KHR +static VkImageMemoryBarrier2 upgrade_image_memory_barrier(const VkImageMemoryBarrier *barrier, - VkPipelineStageFlags2KHR src_stage_mask2, - VkPipelineStageFlags2KHR dst_stage_mask2) + VkPipelineStageFlags2 src_stage_mask2, + VkPipelineStageFlags2 dst_stage_mask2) { - return (VkImageMemoryBarrier2KHR) { - .sType = VK_STRUCTURE_TYPE_IMAGE_MEMORY_BARRIER_2_KHR, + return (VkImageMemoryBarrier2) { + .sType = VK_STRUCTURE_TYPE_IMAGE_MEMORY_BARRIER_2, .srcStageMask = src_stage_mask2, - .srcAccessMask = (VkAccessFlags2KHR) barrier->srcAccessMask, + .srcAccessMask = (VkAccessFlags2) barrier->srcAccessMask, .dstStageMask = dst_stage_mask2, - .dstAccessMask = (VkAccessFlags2KHR) barrier->dstAccessMask, + .dstAccessMask = (VkAccessFlags2) barrier->dstAccessMask, .oldLayout = barrier->oldLayout, .newLayout = barrier->newLayout, .srcQueueFamilyIndex = barrier->srcQueueFamilyIndex, @@ -114,12 +114,12 @@ vk_common_CmdPipelineBarrier( VK_FROM_HANDLE(vk_command_buffer, cmd_buffer, commandBuffer); struct vk_device *device = cmd_buffer->base.device; - STACK_ARRAY(VkMemoryBarrier2KHR, memory_barriers, memoryBarrierCount); - STACK_ARRAY(VkBufferMemoryBarrier2KHR, buffer_barriers, bufferMemoryBarrierCount); - STACK_ARRAY(VkImageMemoryBarrier2KHR, image_barriers, imageMemoryBarrierCount); + STACK_ARRAY(VkMemoryBarrier2, memory_barriers, memoryBarrierCount); + STACK_ARRAY(VkBufferMemoryBarrier2, buffer_barriers, bufferMemoryBarrierCount); + STACK_ARRAY(VkImageMemoryBarrier2, image_barriers, imageMemoryBarrierCount); - VkPipelineStageFlags2KHR src_stage_mask2 = (VkPipelineStageFlags2KHR) srcStageMask; - VkPipelineStageFlags2KHR dst_stage_mask2 = (VkPipelineStageFlags2KHR) dstStageMask; + VkPipelineStageFlags2 src_stage_mask2 = (VkPipelineStageFlags2) srcStageMask; + VkPipelineStageFlags2 dst_stage_mask2 = (VkPipelineStageFlags2) dstStageMask; for (uint32_t i = 0; i < memoryBarrierCount; i++) { memory_barriers[i] = upgrade_memory_barrier(&pMemoryBarriers[i], @@ -137,8 +137,8 @@ vk_common_CmdPipelineBarrier( dst_stage_mask2); } - VkDependencyInfoKHR dep_info = { - .sType = VK_STRUCTURE_TYPE_DEPENDENCY_INFO_KHR, + VkDependencyInfo dep_info = { + .sType = VK_STRUCTURE_TYPE_DEPENDENCY_INFO, .memoryBarrierCount = memoryBarrierCount, .pMemoryBarriers = memory_barriers, .bufferMemoryBarrierCount = bufferMemoryBarrierCount, @@ -163,13 +163,13 @@ vk_common_CmdSetEvent( VK_FROM_HANDLE(vk_command_buffer, cmd_buffer, commandBuffer); struct vk_device *device = cmd_buffer->base.device; - VkMemoryBarrier2KHR mem_barrier = { - .sType = VK_STRUCTURE_TYPE_MEMORY_BARRIER_2_KHR, - .srcStageMask = (VkPipelineStageFlags2KHR) stageMask, - .dstStageMask = (VkPipelineStageFlags2KHR) stageMask, + VkMemoryBarrier2 mem_barrier = { + .sType = VK_STRUCTURE_TYPE_MEMORY_BARRIER_2, + .srcStageMask = (VkPipelineStageFlags2) stageMask, + .dstStageMask = (VkPipelineStageFlags2) stageMask, }; - VkDependencyInfoKHR dep_info = { - .sType = VK_STRUCTURE_TYPE_DEPENDENCY_INFO_KHR, + VkDependencyInfo dep_info = { + .sType = VK_STRUCTURE_TYPE_DEPENDENCY_INFO, .memoryBarrierCount = 1, .pMemoryBarriers = &mem_barrier, }; @@ -188,7 +188,7 @@ vk_common_CmdResetEvent( device->dispatch_table.CmdResetEvent2KHR(commandBuffer, event, - (VkPipelineStageFlags2KHR) stageMask); + (VkPipelineStageFlags2) stageMask); } VKAPI_ATTR void VKAPI_CALL @@ -208,22 +208,22 @@ vk_common_CmdWaitEvents( VK_FROM_HANDLE(vk_command_buffer, cmd_buffer, commandBuffer); struct vk_device *device = cmd_buffer->base.device; - STACK_ARRAY(VkDependencyInfoKHR, deps, eventCount); + STACK_ARRAY(VkDependencyInfo, deps, eventCount); /* Note that dstStageMask and srcStageMask in the CmdWaitEvent2() call * are the same. This is to match the CmdSetEvent2() call from * vk_common_CmdSetEvent(). The actual src->dst stage barrier will * happen as part of the CmdPipelineBarrier() call below. */ - VkMemoryBarrier2KHR stage_barrier = { - .sType = VK_STRUCTURE_TYPE_MEMORY_BARRIER_2_KHR, + VkMemoryBarrier2 stage_barrier = { + .sType = VK_STRUCTURE_TYPE_MEMORY_BARRIER_2, .srcStageMask = srcStageMask, .dstStageMask = srcStageMask, }; for (uint32_t i = 0; i < eventCount; i++) { - deps[i] = (VkDependencyInfoKHR) { - .sType = VK_STRUCTURE_TYPE_DEPENDENCY_INFO_KHR, + deps[i] = (VkDependencyInfo) { + .sType = VK_STRUCTURE_TYPE_DEPENDENCY_INFO, .memoryBarrierCount = 1, .pMemoryBarriers = &stage_barrier, }; @@ -265,7 +265,7 @@ vk_common_CmdWriteBufferMarkerAMD( struct vk_device *device = cmd_buffer->base.device; device->dispatch_table.CmdWriteBufferMarker2AMD(commandBuffer, - (VkPipelineStageFlags2KHR) pipelineStage, + (VkPipelineStageFlags2) pipelineStage, dstBuffer, dstOffset, marker); @@ -290,7 +290,7 @@ vk_common_QueueSubmit( VK_FROM_HANDLE(vk_queue, queue, _queue); struct vk_device *device = queue->base.device; - STACK_ARRAY(VkSubmitInfo2KHR, submit_info_2, submitCount); + STACK_ARRAY(VkSubmitInfo2, submit_info_2, submitCount); STACK_ARRAY(VkPerformanceQuerySubmitInfoKHR, perf_query_submit_info, submitCount); STACK_ARRAY(struct wsi_memory_signal_submit_info, wsi_mem_submit_info, submitCount); @@ -303,18 +303,18 @@ vk_common_QueueSubmit( n_signal_semaphores += pSubmits[s].signalSemaphoreCount; } - STACK_ARRAY(VkSemaphoreSubmitInfoKHR, wait_semaphores, n_wait_semaphores); - STACK_ARRAY(VkCommandBufferSubmitInfoKHR, command_buffers, n_command_buffers); - STACK_ARRAY(VkSemaphoreSubmitInfoKHR, signal_semaphores, n_signal_semaphores); + STACK_ARRAY(VkSemaphoreSubmitInfo, wait_semaphores, n_wait_semaphores); + STACK_ARRAY(VkCommandBufferSubmitInfo, command_buffers, n_command_buffers); + STACK_ARRAY(VkSemaphoreSubmitInfo, signal_semaphores, n_signal_semaphores); n_wait_semaphores = 0; n_command_buffers = 0; n_signal_semaphores = 0; for (uint32_t s = 0; s < submitCount; s++) { - const VkTimelineSemaphoreSubmitInfoKHR *timeline_info = + const VkTimelineSemaphoreSubmitInfo *timeline_info = vk_find_struct_const(pSubmits[s].pNext, - TIMELINE_SEMAPHORE_SUBMIT_INFO_KHR); + TIMELINE_SEMAPHORE_SUBMIT_INFO); const uint64_t *wait_values = NULL; const uint64_t *signal_values = NULL; @@ -350,8 +350,8 @@ vk_common_QueueSubmit( vk_find_struct_const(pSubmits[s].pNext, DEVICE_GROUP_SUBMIT_INFO); for (uint32_t i = 0; i < pSubmits[s].waitSemaphoreCount; i++) { - wait_semaphores[n_wait_semaphores + i] = (VkSemaphoreSubmitInfoKHR) { - .sType = VK_STRUCTURE_TYPE_SEMAPHORE_SUBMIT_INFO_KHR, + wait_semaphores[n_wait_semaphores + i] = (VkSemaphoreSubmitInfo) { + .sType = VK_STRUCTURE_TYPE_SEMAPHORE_SUBMIT_INFO, .semaphore = pSubmits[s].pWaitSemaphores[i], .value = wait_values ? wait_values[i] : 0, .stageMask = pSubmits[s].pWaitDstStageMask[i], @@ -359,15 +359,15 @@ vk_common_QueueSubmit( }; } for (uint32_t i = 0; i < pSubmits[s].commandBufferCount; i++) { - command_buffers[n_command_buffers + i] = (VkCommandBufferSubmitInfoKHR) { - .sType = VK_STRUCTURE_TYPE_COMMAND_BUFFER_SUBMIT_INFO_KHR, + command_buffers[n_command_buffers + i] = (VkCommandBufferSubmitInfo) { + .sType = VK_STRUCTURE_TYPE_COMMAND_BUFFER_SUBMIT_INFO, .commandBuffer = pSubmits[s].pCommandBuffers[i], .deviceMask = group_info ? group_info->pCommandBufferDeviceMasks[i] : 0, }; } for (uint32_t i = 0; i < pSubmits[s].signalSemaphoreCount; i++) { - signal_semaphores[n_signal_semaphores + i] = (VkSemaphoreSubmitInfoKHR) { - .sType = VK_STRUCTURE_TYPE_SEMAPHORE_SUBMIT_INFO_KHR, + signal_semaphores[n_signal_semaphores + i] = (VkSemaphoreSubmitInfo) { + .sType = VK_STRUCTURE_TYPE_SEMAPHORE_SUBMIT_INFO, .semaphore = pSubmits[s].pSignalSemaphores[i], .value = signal_values ? signal_values[i] : 0, .stageMask = VK_PIPELINE_STAGE_2_ALL_COMMANDS_BIT, @@ -378,10 +378,10 @@ vk_common_QueueSubmit( const VkProtectedSubmitInfo *protected_info = vk_find_struct_const(pSubmits[s].pNext, PROTECTED_SUBMIT_INFO); - submit_info_2[s] = (VkSubmitInfo2KHR) { - .sType = VK_STRUCTURE_TYPE_SUBMIT_INFO_2_KHR, + submit_info_2[s] = (VkSubmitInfo2) { + .sType = VK_STRUCTURE_TYPE_SUBMIT_INFO_2, .flags = ((protected_info && protected_info->protectedSubmit) ? - VK_SUBMIT_PROTECTED_BIT_KHR : 0), + VK_SUBMIT_PROTECTED_BIT : 0), .waitSemaphoreInfoCount = pSubmits[s].waitSemaphoreCount, .pWaitSemaphoreInfos = &wait_semaphores[n_wait_semaphores], .commandBufferInfoCount = pSubmits[s].commandBufferCount,