OpenHarmony/third_party_mesa3d
2
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

vulkan/runtime: use updated tokens from vk.xml

Browse Source 
Signed-off-by: Eric Engestrom <eric@igalia.com>
Reviewed-by: Jason Ekstrand <jason.ekstrand@collabora.com>
Part-of: <https://gitlab.freedesktop.org/mesa/mesa/-/merge_requests/17342>
This commit is contained in:
Eric Engestrom
2022-07-01 13:02:59 +01:00
committed by Marge Bot
parent 66af355a00
commit c3d8395a14
17 changed files with 237 additions and 238 deletions
Download Patch File Download Diff File Expand all files Collapse all files

60
src/vulkan/runtime/vk_cmd_copy.c
View File

@@ -37,19 +37,19 @@ vk_common_CmdCopyBuffer(VkCommandBuffer commandBuffer,
*/ */
struct vk_object_base *disp = (struct vk_object_base *)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++) { for (uint32_t r = 0; r < regionCount; r++) {
region2s[r] = (VkBufferCopy2KHR) { region2s[r] = (VkBufferCopy2) {
.sType = VK_STRUCTURE_TYPE_BUFFER_COPY_2_KHR, .sType = VK_STRUCTURE_TYPE_BUFFER_COPY_2,
.srcOffset = pRegions[r].srcOffset, .srcOffset = pRegions[r].srcOffset,
.dstOffset = pRegions[r].dstOffset, .dstOffset = pRegions[r].dstOffset,
.size = pRegions[r].size, .size = pRegions[r].size,
}; };
} }
VkCopyBufferInfo2KHR info = { VkCopyBufferInfo2 info = {
.sType = VK_STRUCTURE_TYPE_COPY_BUFFER_INFO_2_KHR, .sType = VK_STRUCTURE_TYPE_COPY_BUFFER_INFO_2,
.srcBuffer = srcBuffer, .srcBuffer = srcBuffer,
.dstBuffer = dstBuffer, .dstBuffer = dstBuffer,
.regionCount = regionCount, .regionCount = regionCount,
@@ -75,11 +75,11 @@ vk_common_CmdCopyImage(VkCommandBuffer commandBuffer,
*/ */
struct vk_object_base *disp = (struct vk_object_base *)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++) { for (uint32_t r = 0; r < regionCount; r++) {
region2s[r] = (VkImageCopy2KHR) { region2s[r] = (VkImageCopy2) {
.sType = VK_STRUCTURE_TYPE_IMAGE_COPY_2_KHR, .sType = VK_STRUCTURE_TYPE_IMAGE_COPY_2,
.srcSubresource = pRegions[r].srcSubresource, .srcSubresource = pRegions[r].srcSubresource,
.srcOffset = pRegions[r].srcOffset, .srcOffset = pRegions[r].srcOffset,
.dstSubresource = pRegions[r].dstSubresource, .dstSubresource = pRegions[r].dstSubresource,
@@ -88,8 +88,8 @@ vk_common_CmdCopyImage(VkCommandBuffer commandBuffer,
}; };
} }
VkCopyImageInfo2KHR info = { VkCopyImageInfo2 info = {
.sType = VK_STRUCTURE_TYPE_COPY_IMAGE_INFO_2_KHR, .sType = VK_STRUCTURE_TYPE_COPY_IMAGE_INFO_2,
.srcImage = srcImage, .srcImage = srcImage,
.srcImageLayout = srcImageLayout, .srcImageLayout = srcImageLayout,
.dstImage = dstImage, .dstImage = dstImage,
@@ -116,11 +116,11 @@ vk_common_CmdCopyBufferToImage(VkCommandBuffer commandBuffer,
*/ */
struct vk_object_base *disp = (struct vk_object_base *)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++) { for (uint32_t r = 0; r < regionCount; r++) {
region2s[r] = (VkBufferImageCopy2KHR) { region2s[r] = (VkBufferImageCopy2) {
.sType = VK_STRUCTURE_TYPE_BUFFER_IMAGE_COPY_2_KHR, .sType = VK_STRUCTURE_TYPE_BUFFER_IMAGE_COPY_2,
.bufferOffset = pRegions[r].bufferOffset, .bufferOffset = pRegions[r].bufferOffset,
.bufferRowLength = pRegions[r].bufferRowLength, .bufferRowLength = pRegions[r].bufferRowLength,
.bufferImageHeight = pRegions[r].bufferImageHeight, .bufferImageHeight = pRegions[r].bufferImageHeight,
@@ -130,8 +130,8 @@ vk_common_CmdCopyBufferToImage(VkCommandBuffer commandBuffer,
}; };
} }
VkCopyBufferToImageInfo2KHR info = { VkCopyBufferToImageInfo2 info = {
.sType = VK_STRUCTURE_TYPE_COPY_BUFFER_TO_IMAGE_INFO_2_KHR, .sType = VK_STRUCTURE_TYPE_COPY_BUFFER_TO_IMAGE_INFO_2,
.srcBuffer = srcBuffer, .srcBuffer = srcBuffer,
.dstImage = dstImage, .dstImage = dstImage,
.dstImageLayout = dstImageLayout, .dstImageLayout = dstImageLayout,
@@ -157,11 +157,11 @@ vk_common_CmdCopyImageToBuffer(VkCommandBuffer commandBuffer,
*/ */
struct vk_object_base *disp = (struct vk_object_base *)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++) { for (uint32_t r = 0; r < regionCount; r++) {
region2s[r] = (VkBufferImageCopy2KHR) { region2s[r] = (VkBufferImageCopy2) {
.sType = VK_STRUCTURE_TYPE_BUFFER_IMAGE_COPY_2_KHR, .sType = VK_STRUCTURE_TYPE_BUFFER_IMAGE_COPY_2,
.bufferOffset = pRegions[r].bufferOffset, .bufferOffset = pRegions[r].bufferOffset,
.bufferRowLength = pRegions[r].bufferRowLength, .bufferRowLength = pRegions[r].bufferRowLength,
.bufferImageHeight = pRegions[r].bufferImageHeight, .bufferImageHeight = pRegions[r].bufferImageHeight,
@@ -171,8 +171,8 @@ vk_common_CmdCopyImageToBuffer(VkCommandBuffer commandBuffer,
}; };
} }
VkCopyImageToBufferInfo2KHR info = { VkCopyImageToBufferInfo2 info = {
.sType = VK_STRUCTURE_TYPE_COPY_IMAGE_TO_BUFFER_INFO_2_KHR, .sType = VK_STRUCTURE_TYPE_COPY_IMAGE_TO_BUFFER_INFO_2,
.srcImage = srcImage, .srcImage = srcImage,
.srcImageLayout = srcImageLayout, .srcImageLayout = srcImageLayout,
.dstBuffer = dstBuffer, .dstBuffer = dstBuffer,
@@ -200,11 +200,11 @@ vk_common_CmdBlitImage(VkCommandBuffer commandBuffer,
*/ */
struct vk_object_base *disp = (struct vk_object_base *)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++) { for (uint32_t r = 0; r < regionCount; r++) {
region2s[r] = (VkImageBlit2KHR) { region2s[r] = (VkImageBlit2) {
.sType = VK_STRUCTURE_TYPE_IMAGE_BLIT_2_KHR, .sType = VK_STRUCTURE_TYPE_IMAGE_BLIT_2,
.srcSubresource = pRegions[r].srcSubresource, .srcSubresource = pRegions[r].srcSubresource,
.srcOffsets = { .srcOffsets = {
pRegions[r].srcOffsets[0], pRegions[r].srcOffsets[0],
@@ -218,8 +218,8 @@ vk_common_CmdBlitImage(VkCommandBuffer commandBuffer,
}; };
} }
VkBlitImageInfo2KHR info = { VkBlitImageInfo2 info = {
.sType = VK_STRUCTURE_TYPE_BLIT_IMAGE_INFO_2_KHR, .sType = VK_STRUCTURE_TYPE_BLIT_IMAGE_INFO_2,
.srcImage = srcImage, .srcImage = srcImage,
.srcImageLayout = srcImageLayout, .srcImageLayout = srcImageLayout,
.dstImage = dstImage, .dstImage = dstImage,
@@ -248,11 +248,11 @@ vk_common_CmdResolveImage(VkCommandBuffer commandBuffer,
*/ */
struct vk_object_base *disp = (struct vk_object_base *)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++) { for (uint32_t r = 0; r < regionCount; r++) {
region2s[r] = (VkImageResolve2KHR) { region2s[r] = (VkImageResolve2) {
.sType = VK_STRUCTURE_TYPE_IMAGE_RESOLVE_2_KHR, .sType = VK_STRUCTURE_TYPE_IMAGE_RESOLVE_2,
.srcSubresource = pRegions[r].srcSubresource, .srcSubresource = pRegions[r].srcSubresource,
.srcOffset = pRegions[r].srcOffset, .srcOffset = pRegions[r].srcOffset,
.dstSubresource = pRegions[r].dstSubresource, .dstSubresource = pRegions[r].dstSubresource,
@@ -261,8 +261,8 @@ vk_common_CmdResolveImage(VkCommandBuffer commandBuffer,
}; };
} }
VkResolveImageInfo2KHR info = { VkResolveImageInfo2 info = {
.sType = VK_STRUCTURE_TYPE_RESOLVE_IMAGE_INFO_2_KHR, .sType = VK_STRUCTURE_TYPE_RESOLVE_IMAGE_INFO_2,
.srcImage = srcImage, .srcImage = srcImage,
.srcImageLayout = srcImageLayout, .srcImageLayout = srcImageLayout,
.dstImage = dstImage, .dstImage = dstImage,

148
src/vulkan/runtime/vk_device.c
View File

@@ -599,24 +599,24 @@ vk_get_physical_device_core_1_2_feature_ext(struct VkBaseOutStructure *ext,
{ {
switch (ext->sType) { switch (ext->sType) {
case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_8BIT_STORAGE_FEATURES_KHR: { case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_8BIT_STORAGE_FEATURES: {
VkPhysicalDevice8BitStorageFeaturesKHR *features = (void *)ext; VkPhysicalDevice8BitStorageFeatures *features = (void *)ext;
CORE_FEATURE(storageBuffer8BitAccess); CORE_FEATURE(storageBuffer8BitAccess);
CORE_FEATURE(uniformAndStorageBuffer8BitAccess); CORE_FEATURE(uniformAndStorageBuffer8BitAccess);
CORE_FEATURE(storagePushConstant8); CORE_FEATURE(storagePushConstant8);
return true; return true;
} }
case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_BUFFER_DEVICE_ADDRESS_FEATURES_KHR: { case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_BUFFER_DEVICE_ADDRESS_FEATURES: {
VkPhysicalDeviceBufferDeviceAddressFeaturesKHR *features = (void *)ext; VkPhysicalDeviceBufferDeviceAddressFeatures *features = (void *)ext;
CORE_FEATURE(bufferDeviceAddress); CORE_FEATURE(bufferDeviceAddress);
CORE_FEATURE(bufferDeviceAddressCaptureReplay); CORE_FEATURE(bufferDeviceAddressCaptureReplay);
CORE_FEATURE(bufferDeviceAddressMultiDevice); CORE_FEATURE(bufferDeviceAddressMultiDevice);
return true; return true;
} }
case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DESCRIPTOR_INDEXING_FEATURES_EXT: { case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DESCRIPTOR_INDEXING_FEATURES: {
VkPhysicalDeviceDescriptorIndexingFeaturesEXT *features = (void *)ext; VkPhysicalDeviceDescriptorIndexingFeatures *features = (void *)ext;
CORE_FEATURE(shaderInputAttachmentArrayDynamicIndexing); CORE_FEATURE(shaderInputAttachmentArrayDynamicIndexing);
CORE_FEATURE(shaderUniformTexelBufferArrayDynamicIndexing); CORE_FEATURE(shaderUniformTexelBufferArrayDynamicIndexing);
CORE_FEATURE(shaderStorageTexelBufferArrayDynamicIndexing); CORE_FEATURE(shaderStorageTexelBufferArrayDynamicIndexing);
@@ -640,64 +640,64 @@ vk_get_physical_device_core_1_2_feature_ext(struct VkBaseOutStructure *ext,
return true; return true;
} }
case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FLOAT16_INT8_FEATURES_KHR: { case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_FLOAT16_INT8_FEATURES: {
VkPhysicalDeviceFloat16Int8FeaturesKHR *features = (void *)ext; VkPhysicalDeviceShaderFloat16Int8Features *features = (void *)ext;
CORE_FEATURE(shaderFloat16); CORE_FEATURE(shaderFloat16);
CORE_FEATURE(shaderInt8); CORE_FEATURE(shaderInt8);
return true; return true;
} }
case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_HOST_QUERY_RESET_FEATURES_EXT: { case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_HOST_QUERY_RESET_FEATURES: {
VkPhysicalDeviceHostQueryResetFeaturesEXT *features = (void *)ext; VkPhysicalDeviceHostQueryResetFeatures *features = (void *)ext;
CORE_FEATURE(hostQueryReset); CORE_FEATURE(hostQueryReset);
return true; return true;
} }
case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGELESS_FRAMEBUFFER_FEATURES_KHR: { case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGELESS_FRAMEBUFFER_FEATURES: {
VkPhysicalDeviceImagelessFramebufferFeaturesKHR *features = (void *)ext; VkPhysicalDeviceImagelessFramebufferFeatures *features = (void *)ext;
CORE_FEATURE(imagelessFramebuffer); CORE_FEATURE(imagelessFramebuffer);
return true; return true;
} }
case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SCALAR_BLOCK_LAYOUT_FEATURES_EXT: { case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SCALAR_BLOCK_LAYOUT_FEATURES: {
VkPhysicalDeviceScalarBlockLayoutFeaturesEXT *features =(void *)ext; VkPhysicalDeviceScalarBlockLayoutFeatures *features =(void *)ext;
CORE_FEATURE(scalarBlockLayout); CORE_FEATURE(scalarBlockLayout);
return true; return true;
} }
case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SEPARATE_DEPTH_STENCIL_LAYOUTS_FEATURES_KHR: { case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SEPARATE_DEPTH_STENCIL_LAYOUTS_FEATURES: {
VkPhysicalDeviceSeparateDepthStencilLayoutsFeaturesKHR *features = (void *)ext; VkPhysicalDeviceSeparateDepthStencilLayoutsFeatures *features = (void *)ext;
CORE_FEATURE(separateDepthStencilLayouts); CORE_FEATURE(separateDepthStencilLayouts);
return true; return true;
} }
case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_ATOMIC_INT64_FEATURES_KHR: { case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_ATOMIC_INT64_FEATURES: {
VkPhysicalDeviceShaderAtomicInt64FeaturesKHR *features = (void *)ext; VkPhysicalDeviceShaderAtomicInt64Features *features = (void *)ext;
CORE_FEATURE(shaderBufferInt64Atomics); CORE_FEATURE(shaderBufferInt64Atomics);
CORE_FEATURE(shaderSharedInt64Atomics); CORE_FEATURE(shaderSharedInt64Atomics);
return true; return true;
} }
case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_SUBGROUP_EXTENDED_TYPES_FEATURES_KHR: { case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_SUBGROUP_EXTENDED_TYPES_FEATURES: {
VkPhysicalDeviceShaderSubgroupExtendedTypesFeaturesKHR *features = (void *)ext; VkPhysicalDeviceShaderSubgroupExtendedTypesFeatures *features = (void *)ext;
CORE_FEATURE(shaderSubgroupExtendedTypes); CORE_FEATURE(shaderSubgroupExtendedTypes);
return true; return true;
} }
case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TIMELINE_SEMAPHORE_FEATURES_KHR: { case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TIMELINE_SEMAPHORE_FEATURES: {
VkPhysicalDeviceTimelineSemaphoreFeaturesKHR *features = (void *) ext; VkPhysicalDeviceTimelineSemaphoreFeatures *features = (void *) ext;
CORE_FEATURE(timelineSemaphore); CORE_FEATURE(timelineSemaphore);
return true; return true;
} }
case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_UNIFORM_BUFFER_STANDARD_LAYOUT_FEATURES_KHR: { case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_UNIFORM_BUFFER_STANDARD_LAYOUT_FEATURES: {
VkPhysicalDeviceUniformBufferStandardLayoutFeaturesKHR *features = (void *)ext; VkPhysicalDeviceUniformBufferStandardLayoutFeatures *features = (void *)ext;
CORE_FEATURE(uniformBufferStandardLayout); CORE_FEATURE(uniformBufferStandardLayout);
return true; return true;
} }
case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_MEMORY_MODEL_FEATURES_KHR: { case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_MEMORY_MODEL_FEATURES: {
VkPhysicalDeviceVulkanMemoryModelFeaturesKHR *features = (void *)ext; VkPhysicalDeviceVulkanMemoryModelFeatures *features = (void *)ext;
CORE_FEATURE(vulkanMemoryModel); CORE_FEATURE(vulkanMemoryModel);
CORE_FEATURE(vulkanMemoryModelDeviceScope); CORE_FEATURE(vulkanMemoryModelDeviceScope);
CORE_FEATURE(vulkanMemoryModelAvailabilityVisibilityChains); CORE_FEATURE(vulkanMemoryModelAvailabilityVisibilityChains);
@@ -718,82 +718,82 @@ vk_get_physical_device_core_1_3_feature_ext(struct VkBaseOutStructure *ext,
const VkPhysicalDeviceVulkan13Features *core) const VkPhysicalDeviceVulkan13Features *core)
{ {
switch (ext->sType) { switch (ext->sType) {
case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DYNAMIC_RENDERING_FEATURES_KHR: { case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DYNAMIC_RENDERING_FEATURES: {
VkPhysicalDeviceDynamicRenderingFeaturesKHR *features = (void *)ext; VkPhysicalDeviceDynamicRenderingFeatures *features = (void *)ext;
CORE_FEATURE(dynamicRendering); CORE_FEATURE(dynamicRendering);
return true; return true;
} }
case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_ROBUSTNESS_FEATURES_EXT: { case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_ROBUSTNESS_FEATURES: {
VkPhysicalDeviceImageRobustnessFeaturesEXT *features = (void *)ext; VkPhysicalDeviceImageRobustnessFeatures *features = (void *)ext;
CORE_FEATURE(robustImageAccess); CORE_FEATURE(robustImageAccess);
return true; return true;
} }
case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_INLINE_UNIFORM_BLOCK_FEATURES_EXT: { case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_INLINE_UNIFORM_BLOCK_FEATURES: {
VkPhysicalDeviceInlineUniformBlockFeaturesEXT *features = (void *)ext; VkPhysicalDeviceInlineUniformBlockFeatures *features = (void *)ext;
CORE_FEATURE(inlineUniformBlock); CORE_FEATURE(inlineUniformBlock);
CORE_FEATURE(descriptorBindingInlineUniformBlockUpdateAfterBind); CORE_FEATURE(descriptorBindingInlineUniformBlockUpdateAfterBind);
return true; return true;
} }
case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MAINTENANCE_4_FEATURES_KHR: { case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MAINTENANCE_4_FEATURES: {
VkPhysicalDeviceMaintenance4FeaturesKHR *features = (void *)ext; VkPhysicalDeviceMaintenance4Features *features = (void *)ext;
CORE_FEATURE(maintenance4); CORE_FEATURE(maintenance4);
return true; return true;
} }
case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PIPELINE_CREATION_CACHE_CONTROL_FEATURES_EXT: { case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PIPELINE_CREATION_CACHE_CONTROL_FEATURES: {
VkPhysicalDevicePipelineCreationCacheControlFeaturesEXT *features = (void *)ext; VkPhysicalDevicePipelineCreationCacheControlFeatures *features = (void *)ext;
CORE_FEATURE(pipelineCreationCacheControl); CORE_FEATURE(pipelineCreationCacheControl);
return true; return true;
} }
case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PRIVATE_DATA_FEATURES_EXT: { case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PRIVATE_DATA_FEATURES: {
VkPhysicalDevicePrivateDataFeaturesEXT *features = (void *)ext; VkPhysicalDevicePrivateDataFeatures *features = (void *)ext;
CORE_FEATURE(privateData); CORE_FEATURE(privateData);
return true; return true;
} }
case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_DEMOTE_TO_HELPER_INVOCATION_FEATURES_EXT: { case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_DEMOTE_TO_HELPER_INVOCATION_FEATURES: {
VkPhysicalDeviceShaderDemoteToHelperInvocationFeaturesEXT *features = (void *)ext; VkPhysicalDeviceShaderDemoteToHelperInvocationFeatures *features = (void *)ext;
CORE_FEATURE(shaderDemoteToHelperInvocation); CORE_FEATURE(shaderDemoteToHelperInvocation);
return true; return true;
} }
case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_INTEGER_DOT_PRODUCT_FEATURES_KHR: { case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_INTEGER_DOT_PRODUCT_FEATURES: {
VkPhysicalDeviceShaderIntegerDotProductFeaturesKHR *features = (void *)ext; VkPhysicalDeviceShaderIntegerDotProductFeatures *features = (void *)ext;
CORE_FEATURE(shaderIntegerDotProduct); CORE_FEATURE(shaderIntegerDotProduct);
return true; return true;
}; };
case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_TERMINATE_INVOCATION_FEATURES_KHR: { case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_TERMINATE_INVOCATION_FEATURES: {
VkPhysicalDeviceShaderTerminateInvocationFeaturesKHR *features = (void *)ext; VkPhysicalDeviceShaderTerminateInvocationFeatures *features = (void *)ext;
CORE_FEATURE(shaderTerminateInvocation); CORE_FEATURE(shaderTerminateInvocation);
return true; return true;
} }
case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SUBGROUP_SIZE_CONTROL_FEATURES_EXT: { case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SUBGROUP_SIZE_CONTROL_FEATURES: {
VkPhysicalDeviceSubgroupSizeControlFeaturesEXT *features = (void *)ext; VkPhysicalDeviceSubgroupSizeControlFeatures *features = (void *)ext;
CORE_FEATURE(subgroupSizeControl); CORE_FEATURE(subgroupSizeControl);
CORE_FEATURE(computeFullSubgroups); CORE_FEATURE(computeFullSubgroups);
return true; return true;
} }
case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SYNCHRONIZATION_2_FEATURES_KHR: { case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SYNCHRONIZATION_2_FEATURES: {
VkPhysicalDeviceSynchronization2FeaturesKHR *features = (void *)ext; VkPhysicalDeviceSynchronization2Features *features = (void *)ext;
CORE_FEATURE(synchronization2); CORE_FEATURE(synchronization2);
return true; return true;
} }
case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TEXTURE_COMPRESSION_ASTC_HDR_FEATURES_EXT: { case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TEXTURE_COMPRESSION_ASTC_HDR_FEATURES: {
VkPhysicalDeviceTextureCompressionASTCHDRFeaturesEXT *features = (void *)ext; VkPhysicalDeviceTextureCompressionASTCHDRFeatures *features = (void *)ext;
CORE_FEATURE(textureCompressionASTC_HDR); CORE_FEATURE(textureCompressionASTC_HDR);
return true; return true;
} }
case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ZERO_INITIALIZE_WORKGROUP_MEMORY_FEATURES_KHR: { case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ZERO_INITIALIZE_WORKGROUP_MEMORY_FEATURES: {
VkPhysicalDeviceZeroInitializeWorkgroupMemoryFeaturesKHR *features = (void *)ext; VkPhysicalDeviceZeroInitializeWorkgroupMemoryFeatures *features = (void *)ext;
CORE_FEATURE(shaderZeroInitializeWorkgroupMemory); CORE_FEATURE(shaderZeroInitializeWorkgroupMemory);
return true; return true;
} }
@@ -881,8 +881,8 @@ vk_get_physical_device_core_1_2_property_ext(struct VkBaseOutStructure *ext,
const VkPhysicalDeviceVulkan12Properties *core) const VkPhysicalDeviceVulkan12Properties *core)
{ {
switch (ext->sType) { switch (ext->sType) {
case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DEPTH_STENCIL_RESOLVE_PROPERTIES_KHR: { case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DEPTH_STENCIL_RESOLVE_PROPERTIES: {
VkPhysicalDeviceDepthStencilResolvePropertiesKHR *properties = (void *)ext; VkPhysicalDeviceDepthStencilResolveProperties *properties = (void *)ext;
CORE_PROPERTY(supportedDepthResolveModes); CORE_PROPERTY(supportedDepthResolveModes);
CORE_PROPERTY(supportedStencilResolveModes); CORE_PROPERTY(supportedStencilResolveModes);
CORE_PROPERTY(independentResolveNone); CORE_PROPERTY(independentResolveNone);
@@ -890,8 +890,8 @@ vk_get_physical_device_core_1_2_property_ext(struct VkBaseOutStructure *ext,
return true; return true;
} }
case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DESCRIPTOR_INDEXING_PROPERTIES_EXT: { case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DESCRIPTOR_INDEXING_PROPERTIES: {
VkPhysicalDeviceDescriptorIndexingPropertiesEXT *properties = (void *)ext; VkPhysicalDeviceDescriptorIndexingProperties *properties = (void *)ext;
CORE_PROPERTY(maxUpdateAfterBindDescriptorsInAllPools); CORE_PROPERTY(maxUpdateAfterBindDescriptorsInAllPools);
CORE_PROPERTY(shaderUniformBufferArrayNonUniformIndexingNative); CORE_PROPERTY(shaderUniformBufferArrayNonUniformIndexingNative);
CORE_PROPERTY(shaderSampledImageArrayNonUniformIndexingNative); CORE_PROPERTY(shaderSampledImageArrayNonUniformIndexingNative);
@@ -918,8 +918,8 @@ vk_get_physical_device_core_1_2_property_ext(struct VkBaseOutStructure *ext,
return true; return true;
} }
case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DRIVER_PROPERTIES_KHR: { case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DRIVER_PROPERTIES: {
VkPhysicalDeviceDriverPropertiesKHR *properties = (void *) ext; VkPhysicalDeviceDriverProperties *properties = (void *) ext;
CORE_PROPERTY(driverID); CORE_PROPERTY(driverID);
CORE_PROPERTY(driverName); CORE_PROPERTY(driverName);
CORE_PROPERTY(driverInfo); CORE_PROPERTY(driverInfo);
@@ -927,15 +927,15 @@ vk_get_physical_device_core_1_2_property_ext(struct VkBaseOutStructure *ext,
return true; return true;
} }
case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SAMPLER_FILTER_MINMAX_PROPERTIES_EXT: { case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SAMPLER_FILTER_MINMAX_PROPERTIES: {
VkPhysicalDeviceSamplerFilterMinmaxPropertiesEXT *properties = (void *)ext; VkPhysicalDeviceSamplerFilterMinmaxProperties *properties = (void *)ext;
CORE_PROPERTY(filterMinmaxImageComponentMapping); CORE_PROPERTY(filterMinmaxImageComponentMapping);
CORE_PROPERTY(filterMinmaxSingleComponentFormats); CORE_PROPERTY(filterMinmaxSingleComponentFormats);
return true; return true;
} }
case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FLOAT_CONTROLS_PROPERTIES_KHR : { case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FLOAT_CONTROLS_PROPERTIES : {
VkPhysicalDeviceFloatControlsPropertiesKHR *properties = (void *)ext; VkPhysicalDeviceFloatControlsProperties *properties = (void *)ext;
CORE_PROPERTY(denormBehaviorIndependence); CORE_PROPERTY(denormBehaviorIndependence);
CORE_PROPERTY(roundingModeIndependence); CORE_PROPERTY(roundingModeIndependence);
CORE_PROPERTY(shaderDenormFlushToZeroFloat16); CORE_PROPERTY(shaderDenormFlushToZeroFloat16);
@@ -956,8 +956,8 @@ vk_get_physical_device_core_1_2_property_ext(struct VkBaseOutStructure *ext,
return true; return true;
} }
case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TIMELINE_SEMAPHORE_PROPERTIES_KHR: { case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TIMELINE_SEMAPHORE_PROPERTIES: {
VkPhysicalDeviceTimelineSemaphorePropertiesKHR *properties = (void *) ext; VkPhysicalDeviceTimelineSemaphoreProperties *properties = (void *) ext;
CORE_PROPERTY(maxTimelineSemaphoreValueDifference); CORE_PROPERTY(maxTimelineSemaphoreValueDifference);
return true; return true;
} }
@@ -976,8 +976,8 @@ vk_get_physical_device_core_1_3_property_ext(struct VkBaseOutStructure *ext,
const VkPhysicalDeviceVulkan13Properties *core) const VkPhysicalDeviceVulkan13Properties *core)
{ {
switch (ext->sType) { switch (ext->sType) {
case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_INLINE_UNIFORM_BLOCK_PROPERTIES_EXT: { case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_INLINE_UNIFORM_BLOCK_PROPERTIES: {
VkPhysicalDeviceInlineUniformBlockPropertiesEXT *properties = (void *)ext; VkPhysicalDeviceInlineUniformBlockProperties *properties = (void *)ext;
CORE_PROPERTY(maxInlineUniformBlockSize); CORE_PROPERTY(maxInlineUniformBlockSize);
CORE_PROPERTY(maxPerStageDescriptorInlineUniformBlocks); CORE_PROPERTY(maxPerStageDescriptorInlineUniformBlocks);
CORE_PROPERTY(maxPerStageDescriptorUpdateAfterBindInlineUniformBlocks); CORE_PROPERTY(maxPerStageDescriptorUpdateAfterBindInlineUniformBlocks);
@@ -986,14 +986,14 @@ vk_get_physical_device_core_1_3_property_ext(struct VkBaseOutStructure *ext,
return true; return true;
} }
case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MAINTENANCE_4_PROPERTIES_KHR: { case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MAINTENANCE_4_PROPERTIES: {
VkPhysicalDeviceMaintenance4PropertiesKHR *properties = (void *)ext; VkPhysicalDeviceMaintenance4Properties *properties = (void *)ext;
CORE_PROPERTY(maxBufferSize); CORE_PROPERTY(maxBufferSize);
return true; return true;
} }
case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_INTEGER_DOT_PRODUCT_PROPERTIES_KHR: { case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_INTEGER_DOT_PRODUCT_PROPERTIES: {
VkPhysicalDeviceShaderIntegerDotProductPropertiesKHR *properties = (void *)ext; VkPhysicalDeviceShaderIntegerDotProductProperties *properties = (void *)ext;
#define IDP_PROPERTY(x) CORE_PROPERTY(integerDotProduct##x) #define IDP_PROPERTY(x) CORE_PROPERTY(integerDotProduct##x)
IDP_PROPERTY(8BitUnsignedAccelerated); IDP_PROPERTY(8BitUnsignedAccelerated);
@@ -1030,8 +1030,8 @@ vk_get_physical_device_core_1_3_property_ext(struct VkBaseOutStructure *ext,
return true; return true;
} }
case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SUBGROUP_SIZE_CONTROL_PROPERTIES_EXT: { case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SUBGROUP_SIZE_CONTROL_PROPERTIES: {
VkPhysicalDeviceSubgroupSizeControlPropertiesEXT *properties = (void *)ext; VkPhysicalDeviceSubgroupSizeControlProperties *properties = (void *)ext;
CORE_PROPERTY(minSubgroupSize); CORE_PROPERTY(minSubgroupSize);
CORE_PROPERTY(maxSubgroupSize); CORE_PROPERTY(maxSubgroupSize);
CORE_PROPERTY(maxComputeWorkgroupSubgroups); CORE_PROPERTY(maxComputeWorkgroupSubgroups);
@@ -1039,8 +1039,8 @@ vk_get_physical_device_core_1_3_property_ext(struct VkBaseOutStructure *ext,
return true; return true;
} }
case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TEXEL_BUFFER_ALIGNMENT_PROPERTIES_EXT: { case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TEXEL_BUFFER_ALIGNMENT_PROPERTIES: {
VkPhysicalDeviceTexelBufferAlignmentPropertiesEXT *properties = (void *)ext; VkPhysicalDeviceTexelBufferAlignmentProperties *properties = (void *)ext;
CORE_PROPERTY(storageTexelBufferOffsetAlignmentBytes); CORE_PROPERTY(storageTexelBufferOffsetAlignmentBytes);
CORE_PROPERTY(storageTexelBufferOffsetSingleTexelAlignment); CORE_PROPERTY(storageTexelBufferOffsetSingleTexelAlignment);
CORE_PROPERTY(uniformTexelBufferOffsetAlignmentBytes); CORE_PROPERTY(uniformTexelBufferOffsetAlignmentBytes);

2
src/vulkan/runtime/vk_fence.c
View File

@@ -268,7 +268,7 @@ vk_common_WaitForFences(VkDevice _device,
VK_FROM_HANDLE(vk_fence, fence, pFences[i]); VK_FROM_HANDLE(vk_fence, fence, pFences[i]);
waits[i] = (struct vk_sync_wait) { waits[i] = (struct vk_sync_wait) {
.sync = vk_fence_get_active_sync(fence), .sync = vk_fence_get_active_sync(fence),
.stage_mask = ~(VkPipelineStageFlags2KHR)0, .stage_mask = ~(VkPipelineStageFlags2)0,
}; };
} }

6
src/vulkan/runtime/vk_framebuffer.c
View File

@@ -41,10 +41,10 @@ vk_common_CreateFramebuffer(VkDevice _device,
/* VK_KHR_imageless_framebuffer extension says: /* 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. * 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; size += sizeof(VkImageView) * pCreateInfo->attachmentCount;
framebuffer = vk_object_alloc(device, pAllocator, size, framebuffer = vk_object_alloc(device, pAllocator, size,
@@ -57,7 +57,7 @@ vk_common_CreateFramebuffer(VkDevice _device,
framebuffer->height = pCreateInfo->height; framebuffer->height = pCreateInfo->height;
framebuffer->layers = pCreateInfo->layers; 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++) for (uint32_t i = 0; i < pCreateInfo->attachmentCount; i++)
framebuffer->attachments[i] = pCreateInfo->pAttachments[i]; framebuffer->attachments[i] = pCreateInfo->pAttachments[i];
framebuffer->attachment_count = pCreateInfo->attachmentCount; framebuffer->attachment_count = pCreateInfo->attachmentCount;

33
src/vulkan/runtime/vk_image.c
View File

@@ -85,9 +85,9 @@ vk_image_init(struct vk_device *device,
image->usage = pCreateInfo->usage; image->usage = pCreateInfo->usage;
if (image->aspects & VK_IMAGE_ASPECT_STENCIL_BIT) { if (image->aspects & VK_IMAGE_ASPECT_STENCIL_BIT) {
const VkImageStencilUsageCreateInfoEXT *stencil_usage_info = const VkImageStencilUsageCreateInfo *stencil_usage_info =
vk_find_struct_const(pCreateInfo->pNext, vk_find_struct_const(pCreateInfo->pNext,
IMAGE_STENCIL_USAGE_CREATE_INFO_EXT); IMAGE_STENCIL_USAGE_CREATE_INFO);
image->stencil_usage = image->stencil_usage =
stencil_usage_info ? stencil_usage_info->stencilUsage : stencil_usage_info ? stencil_usage_info->stencilUsage :
pCreateInfo->usage; pCreateInfo->usage;
@@ -286,7 +286,7 @@ vk_image_offset_to_elements(const struct vk_image *image, VkOffset3D offset)
struct vk_image_buffer_layout struct vk_image_buffer_layout
vk_image_buffer_copy_layout(const struct vk_image *image, 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); 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_SHARED_PRESENT_KHR:
case VK_IMAGE_LAYOUT_DEPTH_ATTACHMENT_OPTIMAL: case VK_IMAGE_LAYOUT_DEPTH_ATTACHMENT_OPTIMAL:
case VK_IMAGE_LAYOUT_STENCIL_ATTACHMENT_OPTIMAL: case VK_IMAGE_LAYOUT_STENCIL_ATTACHMENT_OPTIMAL:
case VK_IMAGE_LAYOUT_ATTACHMENT_OPTIMAL_KHR: case VK_IMAGE_LAYOUT_ATTACHMENT_OPTIMAL:
#ifdef __GNUC__ #ifdef __GNUC__
#pragma GCC diagnostic push #pragma GCC diagnostic push
#pragma GCC diagnostic ignored "-Wswitch" #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_SHADER_READ_ONLY_OPTIMAL:
case VK_IMAGE_LAYOUT_TRANSFER_SRC_OPTIMAL: case VK_IMAGE_LAYOUT_TRANSFER_SRC_OPTIMAL:
case VK_IMAGE_LAYOUT_PRESENT_SRC_KHR: 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_FRAGMENT_DENSITY_MAP_OPTIMAL_EXT:
case VK_IMAGE_LAYOUT_DEPTH_READ_ONLY_OPTIMAL: case VK_IMAGE_LAYOUT_DEPTH_READ_ONLY_OPTIMAL:
case VK_IMAGE_LAYOUT_STENCIL_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; return true;
case VK_IMAGE_LAYOUT_DEPTH_READ_ONLY_STENCIL_ATTACHMENT_OPTIMAL: 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." * all relevant image aspects."
*/ */
VkImageLayout VkImageLayout
vk_att_ref_stencil_layout(const VkAttachmentReference2KHR *att_ref, vk_att_ref_stencil_layout(const VkAttachmentReference2 *att_ref,
const VkAttachmentDescription2 *attachments) const VkAttachmentDescription2 *attachments)
{ {
/* From VUID-VkAttachmentReference2-attachment-04755: /* 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)) !vk_format_has_stencil(attachments[att_ref->attachment].format))
return VK_IMAGE_LAYOUT_UNDEFINED; return VK_IMAGE_LAYOUT_UNDEFINED;
const VkAttachmentReferenceStencilLayoutKHR *stencil_ref = const VkAttachmentReferenceStencilLayout *stencil_ref =
vk_find_struct_const(att_ref->pNext, ATTACHMENT_REFERENCE_STENCIL_LAYOUT_KHR); vk_find_struct_const(att_ref->pNext, ATTACHMENT_REFERENCE_STENCIL_LAYOUT);
if (stencil_ref) if (stencil_ref)
return stencil_ref->stencilLayout; return stencil_ref->stencilLayout;
@@ -670,14 +670,13 @@ vk_att_ref_stencil_layout(const VkAttachmentReference2KHR *att_ref,
* the pNext chain." * the pNext chain."
*/ */
VkImageLayout VkImageLayout
vk_att_desc_stencil_layout(const VkAttachmentDescription2KHR *att_desc, vk_att_desc_stencil_layout(const VkAttachmentDescription2 *att_desc, bool final)
bool final)
{ {
if (!vk_format_has_stencil(att_desc->format)) if (!vk_format_has_stencil(att_desc->format))
return VK_IMAGE_LAYOUT_UNDEFINED; return VK_IMAGE_LAYOUT_UNDEFINED;
const VkAttachmentDescriptionStencilLayoutKHR *stencil_desc = const VkAttachmentDescriptionStencilLayout *stencil_desc =
vk_find_struct_const(att_desc->pNext, ATTACHMENT_DESCRIPTION_STENCIL_LAYOUT_KHR); vk_find_struct_const(att_desc->pNext, ATTACHMENT_DESCRIPTION_STENCIL_LAYOUT);
if (stencil_desc) { if (stencil_desc) {
return final ? return final ?
@@ -801,15 +800,15 @@ vk_image_layout_to_usage_flags(VkImageLayout layout,
assert(aspect == VK_IMAGE_ASPECT_COLOR_BIT); assert(aspect == VK_IMAGE_ASPECT_COLOR_BIT);
return vk_image_layout_to_usage_flags(VK_IMAGE_LAYOUT_GENERAL, aspect); 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); 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: case VK_IMAGE_LAYOUT_FRAGMENT_DENSITY_MAP_OPTIMAL_EXT:
assert(aspect == VK_IMAGE_ASPECT_COLOR_BIT); assert(aspect == VK_IMAGE_ASPECT_COLOR_BIT);
return VK_IMAGE_USAGE_FRAGMENT_DENSITY_MAP_BIT_EXT; 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 || if (aspect == VK_IMAGE_ASPECT_DEPTH_BIT ||
aspect == VK_IMAGE_ASPECT_STENCIL_BIT) { aspect == VK_IMAGE_ASPECT_STENCIL_BIT) {
return VK_IMAGE_USAGE_DEPTH_STENCIL_ATTACHMENT_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; 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 | return VK_IMAGE_USAGE_SAMPLED_BIT |
VK_IMAGE_USAGE_INPUT_ATTACHMENT_BIT; VK_IMAGE_USAGE_INPUT_ATTACHMENT_BIT;

14
src/vulkan/runtime/vk_image.h
View File

@@ -165,14 +165,14 @@ vk_image_offset_to_elements(const struct vk_image *image, VkOffset3D offset);
struct vk_image_buffer_layout { struct vk_image_buffer_layout {
/** /**
* VkBufferImageCopy2KHR::bufferRowLength or * VkBufferImageCopy2::bufferRowLength or
* VkBufferImageCopy2KHR::extent::width as needed. * VkBufferImageCopy2::extent::width as needed.
*/ */
uint32_t row_length; uint32_t row_length;
/** /**
* VkBufferImageCopy2KHR::bufferImageHeight or * VkBufferImageCopy2::bufferImageHeight or
* VkBufferImageCopy2KHR::extent::height as needed. * VkBufferImageCopy2::extent::height as needed.
*/ */
uint32_t image_height; uint32_t image_height;
@@ -193,7 +193,7 @@ struct vk_image_buffer_layout {
struct vk_image_buffer_layout struct vk_image_buffer_layout
vk_image_buffer_copy_layout(const struct vk_image *image, vk_image_buffer_copy_layout(const struct vk_image *image,
const VkBufferImageCopy2KHR* region); const VkBufferImageCopy2* region);
struct vk_image_view { struct vk_image_view {
struct vk_object_base base; 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, VkImageUsageFlags vk_image_layout_to_usage_flags(VkImageLayout layout,
VkImageAspectFlagBits aspect); 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); 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); bool final);
#ifdef __cplusplus #ifdef __cplusplus

24
src/vulkan/runtime/vk_object.c
View File

@@ -127,9 +127,9 @@ vk_object_free(struct vk_device *device,
VkResult VkResult
vk_private_data_slot_create(struct vk_device *device, vk_private_data_slot_create(struct vk_device *device,
const VkPrivateDataSlotCreateInfoEXT* pCreateInfo, const VkPrivateDataSlotCreateInfo* pCreateInfo,
const VkAllocationCallbacks* pAllocator, const VkAllocationCallbacks* pAllocator,
VkPrivateDataSlotEXT* pPrivateDataSlot) VkPrivateDataSlot* pPrivateDataSlot)
{ {
struct vk_private_data_slot *slot = struct vk_private_data_slot *slot =
vk_alloc2(&device->alloc, pAllocator, sizeof(*slot), 8, 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; return VK_ERROR_OUT_OF_HOST_MEMORY;
vk_object_base_init(device, &slot->base, 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); slot->index = p_atomic_inc_return(&device->private_data_next_index);
*pPrivateDataSlot = vk_private_data_slot_to_handle(slot); *pPrivateDataSlot = vk_private_data_slot_to_handle(slot);
@@ -148,7 +148,7 @@ vk_private_data_slot_create(struct vk_device *device,
void void
vk_private_data_slot_destroy(struct vk_device *device, vk_private_data_slot_destroy(struct vk_device *device,
VkPrivateDataSlotEXT privateDataSlot, VkPrivateDataSlot privateDataSlot,
const VkAllocationCallbacks *pAllocator) const VkAllocationCallbacks *pAllocator)
{ {
VK_FROM_HANDLE(vk_private_data_slot, slot, privateDataSlot); VK_FROM_HANDLE(vk_private_data_slot, slot, privateDataSlot);
@@ -202,7 +202,7 @@ static VkResult
vk_object_base_private_data(struct vk_device *device, vk_object_base_private_data(struct vk_device *device,
VkObjectType objectType, VkObjectType objectType,
uint64_t objectHandle, uint64_t objectHandle,
VkPrivateDataSlotEXT privateDataSlot, VkPrivateDataSlot privateDataSlot,
uint64_t **private_data) uint64_t **private_data)
{ {
VK_FROM_HANDLE(vk_private_data_slot, slot, privateDataSlot); VK_FROM_HANDLE(vk_private_data_slot, slot, privateDataSlot);
@@ -236,7 +236,7 @@ VkResult
vk_object_base_set_private_data(struct vk_device *device, vk_object_base_set_private_data(struct vk_device *device,
VkObjectType objectType, VkObjectType objectType,
uint64_t objectHandle, uint64_t objectHandle,
VkPrivateDataSlotEXT privateDataSlot, VkPrivateDataSlot privateDataSlot,
uint64_t data) uint64_t data)
{ {
uint64_t *private_data; uint64_t *private_data;
@@ -255,7 +255,7 @@ void
vk_object_base_get_private_data(struct vk_device *device, vk_object_base_get_private_data(struct vk_device *device,
VkObjectType objectType, VkObjectType objectType,
uint64_t objectHandle, uint64_t objectHandle,
VkPrivateDataSlotEXT privateDataSlot, VkPrivateDataSlot privateDataSlot,
uint64_t *pData) uint64_t *pData)
{ {
uint64_t *private_data; uint64_t *private_data;
@@ -272,9 +272,9 @@ vk_object_base_get_private_data(struct vk_device *device,
VKAPI_ATTR VkResult VKAPI_CALL VKAPI_ATTR VkResult VKAPI_CALL
vk_common_CreatePrivateDataSlotEXT(VkDevice _device, vk_common_CreatePrivateDataSlotEXT(VkDevice _device,
const VkPrivateDataSlotCreateInfoEXT *pCreateInfo, const VkPrivateDataSlotCreateInfo *pCreateInfo,
const VkAllocationCallbacks *pAllocator, const VkAllocationCallbacks *pAllocator,
VkPrivateDataSlotEXT *pPrivateDataSlot) VkPrivateDataSlot *pPrivateDataSlot)
{ {
VK_FROM_HANDLE(vk_device, device, _device); VK_FROM_HANDLE(vk_device, device, _device);
return vk_private_data_slot_create(device, pCreateInfo, pAllocator, return vk_private_data_slot_create(device, pCreateInfo, pAllocator,
@@ -283,7 +283,7 @@ vk_common_CreatePrivateDataSlotEXT(VkDevice _device,
VKAPI_ATTR void VKAPI_CALL VKAPI_ATTR void VKAPI_CALL
vk_common_DestroyPrivateDataSlotEXT(VkDevice _device, vk_common_DestroyPrivateDataSlotEXT(VkDevice _device,
VkPrivateDataSlotEXT privateDataSlot, VkPrivateDataSlot privateDataSlot,
const VkAllocationCallbacks *pAllocator) const VkAllocationCallbacks *pAllocator)
{ {
VK_FROM_HANDLE(vk_device, device, _device); VK_FROM_HANDLE(vk_device, device, _device);
@@ -294,7 +294,7 @@ VKAPI_ATTR VkResult VKAPI_CALL
vk_common_SetPrivateDataEXT(VkDevice _device, vk_common_SetPrivateDataEXT(VkDevice _device,
VkObjectType objectType, VkObjectType objectType,
uint64_t objectHandle, uint64_t objectHandle,
VkPrivateDataSlotEXT privateDataSlot, VkPrivateDataSlot privateDataSlot,
uint64_t data) uint64_t data)
{ {
VK_FROM_HANDLE(vk_device, device, _device); VK_FROM_HANDLE(vk_device, device, _device);
@@ -307,7 +307,7 @@ VKAPI_ATTR void VKAPI_CALL
vk_common_GetPrivateDataEXT(VkDevice _device, vk_common_GetPrivateDataEXT(VkDevice _device,
VkObjectType objectType, VkObjectType objectType,
uint64_t objectHandle, uint64_t objectHandle,
VkPrivateDataSlotEXT privateDataSlot, VkPrivateDataSlot privateDataSlot,
uint64_t *pData) uint64_t *pData)
{ {
VK_FROM_HANDLE(vk_device, device, _device); VK_FROM_HANDLE(vk_device, device, _device);

14
src/vulkan/runtime/vk_object.h
View File

@@ -229,29 +229,29 @@ struct vk_private_data_slot {
uint32_t index; uint32_t index;
}; };
VK_DEFINE_NONDISP_HANDLE_CASTS(vk_private_data_slot, base, VK_DEFINE_NONDISP_HANDLE_CASTS(vk_private_data_slot, base,
VkPrivateDataSlotEXT, VkPrivateDataSlot,
VK_OBJECT_TYPE_PRIVATE_DATA_SLOT_EXT); VK_OBJECT_TYPE_PRIVATE_DATA_SLOT);
VkResult VkResult
vk_private_data_slot_create(struct vk_device *device, vk_private_data_slot_create(struct vk_device *device,
const VkPrivateDataSlotCreateInfoEXT* pCreateInfo, const VkPrivateDataSlotCreateInfo* pCreateInfo,
const VkAllocationCallbacks* pAllocator, const VkAllocationCallbacks* pAllocator,
VkPrivateDataSlotEXT* pPrivateDataSlot); VkPrivateDataSlot* pPrivateDataSlot);
void void
vk_private_data_slot_destroy(struct vk_device *device, vk_private_data_slot_destroy(struct vk_device *device,
VkPrivateDataSlotEXT privateDataSlot, VkPrivateDataSlot privateDataSlot,
const VkAllocationCallbacks *pAllocator); const VkAllocationCallbacks *pAllocator);
VkResult VkResult
vk_object_base_set_private_data(struct vk_device *device, vk_object_base_set_private_data(struct vk_device *device,
VkObjectType objectType, VkObjectType objectType,
uint64_t objectHandle, uint64_t objectHandle,
VkPrivateDataSlotEXT privateDataSlot, VkPrivateDataSlot privateDataSlot,
uint64_t data); uint64_t data);
void void
vk_object_base_get_private_data(struct vk_device *device, vk_object_base_get_private_data(struct vk_device *device,
VkObjectType objectType, VkObjectType objectType,
uint64_t objectHandle, uint64_t objectHandle,
VkPrivateDataSlotEXT privateDataSlot, VkPrivateDataSlot privateDataSlot,
uint64_t *pData); uint64_t *pData);
const char * const char *

8
src/vulkan/runtime/vk_pipeline.c
View File

@@ -50,9 +50,9 @@ vk_pipeline_shader_stage_is_null(const VkPipelineShaderStageCreateInfo *info)
static uint32_t static uint32_t
get_required_subgroup_size(const VkPipelineShaderStageCreateInfo *info) get_required_subgroup_size(const VkPipelineShaderStageCreateInfo *info)
{ {
const VkPipelineShaderStageRequiredSubgroupSizeCreateInfoEXT *rss_info = const VkPipelineShaderStageRequiredSubgroupSizeCreateInfo *rss_info =
vk_find_struct_const(info->pNext, 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; 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(util_is_power_of_two_nonzero(req_subgroup_size));
assert(req_subgroup_size >= 8 && req_subgroup_size <= 128); assert(req_subgroup_size >= 8 && req_subgroup_size <= 128);
subgroup_size = req_subgroup_size; 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) { vk_spirv_version(spirv_data, spirv_size) >= 0x10600) {
/* Starting with SPIR-V 1.6, varying subgroup size the default */ /* Starting with SPIR-V 1.6, varying subgroup size the default */
subgroup_size = SUBGROUP_SIZE_VARYING; 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); assert(stage == MESA_SHADER_COMPUTE);
subgroup_size = SUBGROUP_SIZE_FULL_SUBGROUPS; subgroup_size = SUBGROUP_SIZE_FULL_SUBGROUPS;
} else { } else {

4
src/vulkan/runtime/vk_pipeline_cache.c
View File

@@ -144,14 +144,14 @@ static void
vk_pipeline_cache_lock(struct vk_pipeline_cache *cache) 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); simple_mtx_lock(&cache->lock);
} }
static void static void
vk_pipeline_cache_unlock(struct vk_pipeline_cache *cache) 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); simple_mtx_unlock(&cache->lock);
} }

22
src/vulkan/runtime/vk_queue.c
View File

@@ -571,13 +571,13 @@ struct vulkan_submit_info {
const void *pNext; const void *pNext;
uint32_t command_buffer_count; uint32_t command_buffer_count;
const VkCommandBufferSubmitInfoKHR *command_buffers; const VkCommandBufferSubmitInfo *command_buffers;
uint32_t wait_count; uint32_t wait_count;
const VkSemaphoreSubmitInfoKHR *waits; const VkSemaphoreSubmitInfo *waits;
uint32_t signal_count; uint32_t signal_count;
const VkSemaphoreSubmitInfoKHR *signals; const VkSemaphoreSubmitInfo *signals;
uint32_t buffer_bind_count; uint32_t buffer_bind_count;
const VkSparseBufferMemoryBindInfo *buffer_binds; const VkSparseBufferMemoryBindInfo *buffer_binds;
@@ -1043,7 +1043,7 @@ vk_queue_wait_before_present(struct vk_queue *queue,
waits[i] = (struct vk_sync_wait) { waits[i] = (struct vk_sync_wait) {
.sync = vk_semaphore_get_active_sync(semaphore), .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 VKAPI_ATTR VkResult VKAPI_CALL
vk_common_QueueSubmit2KHR(VkQueue _queue, vk_common_QueueSubmit2KHR(VkQueue _queue,
uint32_t submitCount, uint32_t submitCount,
const VkSubmitInfo2KHR *pSubmits, const VkSubmitInfo2 *pSubmits,
VkFence _fence) VkFence _fence)
{ {
VK_FROM_HANDLE(vk_queue, queue, _queue); VK_FROM_HANDLE(vk_queue, queue, _queue);
@@ -1215,9 +1215,9 @@ vk_common_QueueBindSparse(VkQueue _queue,
signal_values = timeline_info->pSignalSemaphoreValues; signal_values = timeline_info->pSignalSemaphoreValues;
} }
STACK_ARRAY(VkSemaphoreSubmitInfoKHR, wait_semaphore_infos, STACK_ARRAY(VkSemaphoreSubmitInfo, wait_semaphore_infos,
pBindInfo[i].waitSemaphoreCount); pBindInfo[i].waitSemaphoreCount);
STACK_ARRAY(VkSemaphoreSubmitInfoKHR, signal_semaphore_infos, STACK_ARRAY(VkSemaphoreSubmitInfo, signal_semaphore_infos,
pBindInfo[i].signalSemaphoreCount); pBindInfo[i].signalSemaphoreCount);
if (!wait_semaphore_infos || !signal_semaphore_infos) { 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++) { for (uint32_t j = 0; j < pBindInfo[i].waitSemaphoreCount; j++) {
wait_semaphore_infos[j] = (VkSemaphoreSubmitInfoKHR) { wait_semaphore_infos[j] = (VkSemaphoreSubmitInfo) {
.sType = VK_STRUCTURE_TYPE_SEMAPHORE_SUBMIT_INFO_KHR, .sType = VK_STRUCTURE_TYPE_SEMAPHORE_SUBMIT_INFO,
.semaphore = pBindInfo[i].pWaitSemaphores[j], .semaphore = pBindInfo[i].pWaitSemaphores[j],
.value = wait_values ? wait_values[j] : 0, .value = wait_values ? wait_values[j] : 0,
}; };
} }
for (uint32_t j = 0; j < pBindInfo[i].signalSemaphoreCount; j++) { for (uint32_t j = 0; j < pBindInfo[i].signalSemaphoreCount; j++) {
signal_semaphore_infos[j] = (VkSemaphoreSubmitInfoKHR) { signal_semaphore_infos[j] = (VkSemaphoreSubmitInfo) {
.sType = VK_STRUCTURE_TYPE_SEMAPHORE_SUBMIT_INFO_KHR, .sType = VK_STRUCTURE_TYPE_SEMAPHORE_SUBMIT_INFO,
.semaphore = pBindInfo[i].pSignalSemaphores[j], .semaphore = pBindInfo[i].pSignalSemaphores[j],
.value = signal_values ? signal_values[j] : 0, .value = signal_values ? signal_values[j] : 0,
}; };

10
src/vulkan/runtime/vk_render_pass.c
View File

@@ -903,7 +903,7 @@ vk_get_command_buffer_inheritance_as_rendering_resume(
const struct vk_subpass *subpass = &pass->subpasses[inheritance->subpass]; const struct vk_subpass *subpass = &pass->subpasses[inheritance->subpass];
VK_FROM_HANDLE(vk_framebuffer, fb, inheritance->framebuffer); 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; return NULL;
data->rendering = (VkRenderingInfo) { data->rendering = (VkRenderingInfo) {
@@ -1170,7 +1170,7 @@ stage_access_for_layout(VkImageLayout layout, VkImageAspectFlags aspects)
access |= VK_ACCESS_2_DEPTH_STENCIL_ATTACHMENT_WRITE_BIT; access |= VK_ACCESS_2_DEPTH_STENCIL_ATTACHMENT_WRITE_BIT;
/* It might be a resolve attachment */ /* 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; access |= VK_ACCESS_2_TRANSFER_WRITE_BIT;
} }
} else { } else {
@@ -1182,7 +1182,7 @@ stage_access_for_layout(VkImageLayout layout, VkImageAspectFlags aspects)
VK_ACCESS_2_COLOR_ATTACHMENT_WRITE_BIT; VK_ACCESS_2_COLOR_ATTACHMENT_WRITE_BIT;
/* It might be a resolve attachment */ /* 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; 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 * that, if we resolve to the wrong aspect, we will still consider
* it bound and clear it if requested. * 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) if (res_rp_att->aspects & VK_IMAGE_ASPECT_DEPTH_BIT)
depth_resolve_mode = subpass->depth_resolve_mode; 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) if (res_rp_att->aspects & VK_IMAGE_ASPECT_STENCIL_BIT)
stencil_resolve_mode = subpass->stencil_resolve_mode; stencil_resolve_mode = subpass->stencil_resolve_mode;

4
src/vulkan/runtime/vk_render_pass.h
View File

@@ -165,10 +165,10 @@ struct vk_subpass {
uint32_t view_mask; uint32_t view_mask;
/** VkSubpassDescriptionDepthStencilResolve::depthResolveMode */ /** VkSubpassDescriptionDepthStencilResolve::depthResolveMode */
VkResolveModeFlagBitsKHR depth_resolve_mode; VkResolveModeFlagBits depth_resolve_mode;
/** VkSubpassDescriptionDepthStencilResolve::stencilResolveMode */ /** VkSubpassDescriptionDepthStencilResolve::stencilResolveMode */
VkResolveModeFlagBitsKHR stencil_resolve_mode; VkResolveModeFlagBits stencil_resolve_mode;
/** VkFragmentShadingRateAttachmentInfoKHR::shadingRateAttachmentTexelSize */ /** VkFragmentShadingRateAttachmentInfoKHR::shadingRateAttachmentTexelSize */
VkExtent2D fragment_shading_rate_attachment_texel_size; VkExtent2D fragment_shading_rate_attachment_texel_size;

2
src/vulkan/runtime/vk_semaphore.c
View File

@@ -313,7 +313,7 @@ vk_common_WaitSemaphores(VkDevice _device,
waits[i] = (struct vk_sync_wait) { waits[i] = (struct vk_sync_wait) {
.sync = vk_semaphore_get_active_sync(semaphore), .sync = vk_semaphore_get_active_sync(semaphore),
.stage_mask = ~(VkPipelineStageFlags2KHR)0, .stage_mask = ~(VkPipelineStageFlags2)0,
.wait_value = pWaitInfo->pValues[i], .wait_value = pWaitInfo->pValues[i],
}; };
} }

2
src/vulkan/runtime/vk_sync.c
View File

@@ -228,7 +228,7 @@ __vk_sync_wait(struct vk_device *device,
} else { } else {
struct vk_sync_wait wait = { struct vk_sync_wait wait = {
.sync = sync, .sync = sync,
.stage_mask = ~(VkPipelineStageFlags2KHR)0, .stage_mask = ~(VkPipelineStageFlags2)0,
.wait_value = wait_value, .wait_value = wait_value,
}; };
return sync->type->wait_many(device, 1, &wait, wait_flags, return sync->type->wait_many(device, 1, &wait, wait_flags,

8
src/vulkan/runtime/vk_sync.h
View File

@@ -290,17 +290,17 @@ struct vk_sync {
enum vk_sync_flags flags; enum vk_sync_flags flags;
}; };
/* See VkSemaphoreSubmitInfoKHR */ /* See VkSemaphoreSubmitInfo */
struct vk_sync_wait { struct vk_sync_wait {
struct vk_sync *sync; struct vk_sync *sync;
VkPipelineStageFlags2KHR stage_mask; VkPipelineStageFlags2 stage_mask;
uint64_t wait_value; uint64_t wait_value;
}; };
/* See VkSemaphoreSubmitInfoKHR */ /* See VkSemaphoreSubmitInfo */
struct vk_sync_signal { struct vk_sync_signal {
struct vk_sync *sync; struct vk_sync *sync;
VkPipelineStageFlags2KHR stage_mask; VkPipelineStageFlags2 stage_mask;
uint64_t signal_value; uint64_t signal_value;
}; };

114
src/vulkan/runtime/vk_synchronization2.c
View File

@@ -40,36 +40,36 @@ vk_common_CmdWriteTimestamp(
struct vk_device *device = cmd_buffer->base.device; struct vk_device *device = cmd_buffer->base.device;
device->dispatch_table.CmdWriteTimestamp2KHR(commandBuffer, device->dispatch_table.CmdWriteTimestamp2KHR(commandBuffer,
(VkPipelineStageFlags2KHR) pipelineStage, (VkPipelineStageFlags2) pipelineStage,
queryPool, queryPool,
query); query);
} }
static VkMemoryBarrier2KHR static VkMemoryBarrier2
upgrade_memory_barrier(const VkMemoryBarrier *barrier, upgrade_memory_barrier(const VkMemoryBarrier *barrier,
VkPipelineStageFlags2KHR src_stage_mask2, VkPipelineStageFlags2 src_stage_mask2,
VkPipelineStageFlags2KHR dst_stage_mask2) VkPipelineStageFlags2 dst_stage_mask2)
{ {
return (VkMemoryBarrier2KHR) { return (VkMemoryBarrier2) {
.sType = VK_STRUCTURE_TYPE_MEMORY_BARRIER_2_KHR, .sType = VK_STRUCTURE_TYPE_MEMORY_BARRIER_2,
.srcStageMask = src_stage_mask2, .srcStageMask = src_stage_mask2,
.srcAccessMask = (VkAccessFlags2KHR) barrier->srcAccessMask, .srcAccessMask = (VkAccessFlags2) barrier->srcAccessMask,
.dstStageMask = dst_stage_mask2, .dstStageMask = dst_stage_mask2,
.dstAccessMask = (VkAccessFlags2KHR) barrier->dstAccessMask, .dstAccessMask = (VkAccessFlags2) barrier->dstAccessMask,
}; };
} }
static VkBufferMemoryBarrier2KHR static VkBufferMemoryBarrier2
upgrade_buffer_memory_barrier(const VkBufferMemoryBarrier *barrier, upgrade_buffer_memory_barrier(const VkBufferMemoryBarrier *barrier,
VkPipelineStageFlags2KHR src_stage_mask2, VkPipelineStageFlags2 src_stage_mask2,
VkPipelineStageFlags2KHR dst_stage_mask2) VkPipelineStageFlags2 dst_stage_mask2)
{ {
return (VkBufferMemoryBarrier2KHR) { return (VkBufferMemoryBarrier2) {
.sType = VK_STRUCTURE_TYPE_BUFFER_MEMORY_BARRIER_2_KHR, .sType = VK_STRUCTURE_TYPE_BUFFER_MEMORY_BARRIER_2,
.srcStageMask = src_stage_mask2, .srcStageMask = src_stage_mask2,
.srcAccessMask = (VkAccessFlags2KHR) barrier->srcAccessMask, .srcAccessMask = (VkAccessFlags2) barrier->srcAccessMask,
.dstStageMask = dst_stage_mask2, .dstStageMask = dst_stage_mask2,
.dstAccessMask = (VkAccessFlags2KHR) barrier->dstAccessMask, .dstAccessMask = (VkAccessFlags2) barrier->dstAccessMask,
.srcQueueFamilyIndex = barrier->srcQueueFamilyIndex, .srcQueueFamilyIndex = barrier->srcQueueFamilyIndex,
.dstQueueFamilyIndex = barrier->dstQueueFamilyIndex, .dstQueueFamilyIndex = barrier->dstQueueFamilyIndex,
.buffer = barrier->buffer, .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, upgrade_image_memory_barrier(const VkImageMemoryBarrier *barrier,
VkPipelineStageFlags2KHR src_stage_mask2, VkPipelineStageFlags2 src_stage_mask2,
VkPipelineStageFlags2KHR dst_stage_mask2) VkPipelineStageFlags2 dst_stage_mask2)
{ {
return (VkImageMemoryBarrier2KHR) { return (VkImageMemoryBarrier2) {
.sType = VK_STRUCTURE_TYPE_IMAGE_MEMORY_BARRIER_2_KHR, .sType = VK_STRUCTURE_TYPE_IMAGE_MEMORY_BARRIER_2,
.srcStageMask = src_stage_mask2, .srcStageMask = src_stage_mask2,
.srcAccessMask = (VkAccessFlags2KHR) barrier->srcAccessMask, .srcAccessMask = (VkAccessFlags2) barrier->srcAccessMask,
.dstStageMask = dst_stage_mask2, .dstStageMask = dst_stage_mask2,
.dstAccessMask = (VkAccessFlags2KHR) barrier->dstAccessMask, .dstAccessMask = (VkAccessFlags2) barrier->dstAccessMask,
.oldLayout = barrier->oldLayout, .oldLayout = barrier->oldLayout,
.newLayout = barrier->newLayout, .newLayout = barrier->newLayout,
.srcQueueFamilyIndex = barrier->srcQueueFamilyIndex, .srcQueueFamilyIndex = barrier->srcQueueFamilyIndex,
@@ -114,12 +114,12 @@ vk_common_CmdPipelineBarrier(
VK_FROM_HANDLE(vk_command_buffer, cmd_buffer, commandBuffer); VK_FROM_HANDLE(vk_command_buffer, cmd_buffer, commandBuffer);
struct vk_device *device = cmd_buffer->base.device; struct vk_device *device = cmd_buffer->base.device;
STACK_ARRAY(VkMemoryBarrier2KHR, memory_barriers, memoryBarrierCount); STACK_ARRAY(VkMemoryBarrier2, memory_barriers, memoryBarrierCount);
STACK_ARRAY(VkBufferMemoryBarrier2KHR, buffer_barriers, bufferMemoryBarrierCount); STACK_ARRAY(VkBufferMemoryBarrier2, buffer_barriers, bufferMemoryBarrierCount);
STACK_ARRAY(VkImageMemoryBarrier2KHR, image_barriers, imageMemoryBarrierCount); STACK_ARRAY(VkImageMemoryBarrier2, image_barriers, imageMemoryBarrierCount);
VkPipelineStageFlags2KHR src_stage_mask2 = (VkPipelineStageFlags2KHR) srcStageMask; VkPipelineStageFlags2 src_stage_mask2 = (VkPipelineStageFlags2) srcStageMask;
VkPipelineStageFlags2KHR dst_stage_mask2 = (VkPipelineStageFlags2KHR) dstStageMask; VkPipelineStageFlags2 dst_stage_mask2 = (VkPipelineStageFlags2) dstStageMask;
for (uint32_t i = 0; i < memoryBarrierCount; i++) { for (uint32_t i = 0; i < memoryBarrierCount; i++) {
memory_barriers[i] = upgrade_memory_barrier(&pMemoryBarriers[i], memory_barriers[i] = upgrade_memory_barrier(&pMemoryBarriers[i],
@@ -137,8 +137,8 @@ vk_common_CmdPipelineBarrier(
dst_stage_mask2); dst_stage_mask2);
} }
VkDependencyInfoKHR dep_info = { VkDependencyInfo dep_info = {
.sType = VK_STRUCTURE_TYPE_DEPENDENCY_INFO_KHR, .sType = VK_STRUCTURE_TYPE_DEPENDENCY_INFO,
.memoryBarrierCount = memoryBarrierCount, .memoryBarrierCount = memoryBarrierCount,
.pMemoryBarriers = memory_barriers, .pMemoryBarriers = memory_barriers,
.bufferMemoryBarrierCount = bufferMemoryBarrierCount, .bufferMemoryBarrierCount = bufferMemoryBarrierCount,
@@ -163,13 +163,13 @@ vk_common_CmdSetEvent(
VK_FROM_HANDLE(vk_command_buffer, cmd_buffer, commandBuffer); VK_FROM_HANDLE(vk_command_buffer, cmd_buffer, commandBuffer);
struct vk_device *device = cmd_buffer->base.device; struct vk_device *device = cmd_buffer->base.device;
VkMemoryBarrier2KHR mem_barrier = { VkMemoryBarrier2 mem_barrier = {
.sType = VK_STRUCTURE_TYPE_MEMORY_BARRIER_2_KHR, .sType = VK_STRUCTURE_TYPE_MEMORY_BARRIER_2,
.srcStageMask = (VkPipelineStageFlags2KHR) stageMask, .srcStageMask = (VkPipelineStageFlags2) stageMask,
.dstStageMask = (VkPipelineStageFlags2KHR) stageMask, .dstStageMask = (VkPipelineStageFlags2) stageMask,
}; };
VkDependencyInfoKHR dep_info = { VkDependencyInfo dep_info = {
.sType = VK_STRUCTURE_TYPE_DEPENDENCY_INFO_KHR, .sType = VK_STRUCTURE_TYPE_DEPENDENCY_INFO,
.memoryBarrierCount = 1, .memoryBarrierCount = 1,
.pMemoryBarriers = &mem_barrier, .pMemoryBarriers = &mem_barrier,
}; };
@@ -188,7 +188,7 @@ vk_common_CmdResetEvent(
device->dispatch_table.CmdResetEvent2KHR(commandBuffer, device->dispatch_table.CmdResetEvent2KHR(commandBuffer,
event, event,
(VkPipelineStageFlags2KHR) stageMask); (VkPipelineStageFlags2) stageMask);
} }
VKAPI_ATTR void VKAPI_CALL VKAPI_ATTR void VKAPI_CALL
@@ -208,22 +208,22 @@ vk_common_CmdWaitEvents(
VK_FROM_HANDLE(vk_command_buffer, cmd_buffer, commandBuffer); VK_FROM_HANDLE(vk_command_buffer, cmd_buffer, commandBuffer);
struct vk_device *device = cmd_buffer->base.device; 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 /* Note that dstStageMask and srcStageMask in the CmdWaitEvent2() call
* are the same. This is to match the CmdSetEvent2() call from * are the same. This is to match the CmdSetEvent2() call from
* vk_common_CmdSetEvent(). The actual src->dst stage barrier will * vk_common_CmdSetEvent(). The actual src->dst stage barrier will
* happen as part of the CmdPipelineBarrier() call below. * happen as part of the CmdPipelineBarrier() call below.
*/ */
VkMemoryBarrier2KHR stage_barrier = { VkMemoryBarrier2 stage_barrier = {
.sType = VK_STRUCTURE_TYPE_MEMORY_BARRIER_2_KHR, .sType = VK_STRUCTURE_TYPE_MEMORY_BARRIER_2,
.srcStageMask = srcStageMask, .srcStageMask = srcStageMask,
.dstStageMask = srcStageMask, .dstStageMask = srcStageMask,
}; };
for (uint32_t i = 0; i < eventCount; i++) { for (uint32_t i = 0; i < eventCount; i++) {
deps[i] = (VkDependencyInfoKHR) { deps[i] = (VkDependencyInfo) {
.sType = VK_STRUCTURE_TYPE_DEPENDENCY_INFO_KHR, .sType = VK_STRUCTURE_TYPE_DEPENDENCY_INFO,
.memoryBarrierCount = 1, .memoryBarrierCount = 1,
.pMemoryBarriers = &stage_barrier, .pMemoryBarriers = &stage_barrier,
}; };
@@ -265,7 +265,7 @@ vk_common_CmdWriteBufferMarkerAMD(
struct vk_device *device = cmd_buffer->base.device; struct vk_device *device = cmd_buffer->base.device;
device->dispatch_table.CmdWriteBufferMarker2AMD(commandBuffer, device->dispatch_table.CmdWriteBufferMarker2AMD(commandBuffer,
(VkPipelineStageFlags2KHR) pipelineStage, (VkPipelineStageFlags2) pipelineStage,
dstBuffer, dstBuffer,
dstOffset, dstOffset,
marker); marker);
@@ -290,7 +290,7 @@ vk_common_QueueSubmit(
VK_FROM_HANDLE(vk_queue, queue, _queue); VK_FROM_HANDLE(vk_queue, queue, _queue);
struct vk_device *device = queue->base.device; 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(VkPerformanceQuerySubmitInfoKHR, perf_query_submit_info, submitCount);
STACK_ARRAY(struct wsi_memory_signal_submit_info, wsi_mem_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; n_signal_semaphores += pSubmits[s].signalSemaphoreCount;
} }
STACK_ARRAY(VkSemaphoreSubmitInfoKHR, wait_semaphores, n_wait_semaphores); STACK_ARRAY(VkSemaphoreSubmitInfo, wait_semaphores, n_wait_semaphores);
STACK_ARRAY(VkCommandBufferSubmitInfoKHR, command_buffers, n_command_buffers); STACK_ARRAY(VkCommandBufferSubmitInfo, command_buffers, n_command_buffers);
STACK_ARRAY(VkSemaphoreSubmitInfoKHR, signal_semaphores, n_signal_semaphores); STACK_ARRAY(VkSemaphoreSubmitInfo, signal_semaphores, n_signal_semaphores);
n_wait_semaphores = 0; n_wait_semaphores = 0;
n_command_buffers = 0; n_command_buffers = 0;
n_signal_semaphores = 0; n_signal_semaphores = 0;
for (uint32_t s = 0; s < submitCount; s++) { for (uint32_t s = 0; s < submitCount; s++) {
const VkTimelineSemaphoreSubmitInfoKHR *timeline_info = const VkTimelineSemaphoreSubmitInfo *timeline_info =
vk_find_struct_const(pSubmits[s].pNext, 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 *wait_values = NULL;
const uint64_t *signal_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); vk_find_struct_const(pSubmits[s].pNext, DEVICE_GROUP_SUBMIT_INFO);
for (uint32_t i = 0; i < pSubmits[s].waitSemaphoreCount; i++) { for (uint32_t i = 0; i < pSubmits[s].waitSemaphoreCount; i++) {
wait_semaphores[n_wait_semaphores + i] = (VkSemaphoreSubmitInfoKHR) { wait_semaphores[n_wait_semaphores + i] = (VkSemaphoreSubmitInfo) {
.sType = VK_STRUCTURE_TYPE_SEMAPHORE_SUBMIT_INFO_KHR, .sType = VK_STRUCTURE_TYPE_SEMAPHORE_SUBMIT_INFO,
.semaphore = pSubmits[s].pWaitSemaphores[i], .semaphore = pSubmits[s].pWaitSemaphores[i],
.value = wait_values ? wait_values[i] : 0, .value = wait_values ? wait_values[i] : 0,
.stageMask = pSubmits[s].pWaitDstStageMask[i], .stageMask = pSubmits[s].pWaitDstStageMask[i],
@@ -359,15 +359,15 @@ vk_common_QueueSubmit(
}; };
} }
for (uint32_t i = 0; i < pSubmits[s].commandBufferCount; i++) { for (uint32_t i = 0; i < pSubmits[s].commandBufferCount; i++) {
command_buffers[n_command_buffers + i] = (VkCommandBufferSubmitInfoKHR) { command_buffers[n_command_buffers + i] = (VkCommandBufferSubmitInfo) {
.sType = VK_STRUCTURE_TYPE_COMMAND_BUFFER_SUBMIT_INFO_KHR, .sType = VK_STRUCTURE_TYPE_COMMAND_BUFFER_SUBMIT_INFO,
.commandBuffer = pSubmits[s].pCommandBuffers[i], .commandBuffer = pSubmits[s].pCommandBuffers[i],
.deviceMask = group_info ? group_info->pCommandBufferDeviceMasks[i] : 0, .deviceMask = group_info ? group_info->pCommandBufferDeviceMasks[i] : 0,
}; };
} }
for (uint32_t i = 0; i < pSubmits[s].signalSemaphoreCount; i++) { for (uint32_t i = 0; i < pSubmits[s].signalSemaphoreCount; i++) {
signal_semaphores[n_signal_semaphores + i] = (VkSemaphoreSubmitInfoKHR) { signal_semaphores[n_signal_semaphores + i] = (VkSemaphoreSubmitInfo) {
.sType = VK_STRUCTURE_TYPE_SEMAPHORE_SUBMIT_INFO_KHR, .sType = VK_STRUCTURE_TYPE_SEMAPHORE_SUBMIT_INFO,
.semaphore = pSubmits[s].pSignalSemaphores[i], .semaphore = pSubmits[s].pSignalSemaphores[i],
.value = signal_values ? signal_values[i] : 0, .value = signal_values ? signal_values[i] : 0,
.stageMask = VK_PIPELINE_STAGE_2_ALL_COMMANDS_BIT, .stageMask = VK_PIPELINE_STAGE_2_ALL_COMMANDS_BIT,
@@ -378,10 +378,10 @@ vk_common_QueueSubmit(
const VkProtectedSubmitInfo *protected_info = const VkProtectedSubmitInfo *protected_info =
vk_find_struct_const(pSubmits[s].pNext, PROTECTED_SUBMIT_INFO); vk_find_struct_const(pSubmits[s].pNext, PROTECTED_SUBMIT_INFO);
submit_info_2[s] = (VkSubmitInfo2KHR) { submit_info_2[s] = (VkSubmitInfo2) {
.sType = VK_STRUCTURE_TYPE_SUBMIT_INFO_2_KHR, .sType = VK_STRUCTURE_TYPE_SUBMIT_INFO_2,
.flags = ((protected_info && protected_info->protectedSubmit) ? .flags = ((protected_info && protected_info->protectedSubmit) ?
VK_SUBMIT_PROTECTED_BIT_KHR : 0), VK_SUBMIT_PROTECTED_BIT : 0),
.waitSemaphoreInfoCount = pSubmits[s].waitSemaphoreCount, .waitSemaphoreInfoCount = pSubmits[s].waitSemaphoreCount,
.pWaitSemaphoreInfos = &wait_semaphores[n_wait_semaphores], .pWaitSemaphoreInfos = &wait_semaphores[n_wait_semaphores],
.commandBufferInfoCount = pSubmits[s].commandBufferCount, .commandBufferInfoCount = pSubmits[s].commandBufferCount,