diff --git a/CMakeLists.txt b/CMakeLists.txt index a7eb886be66..be05514704a 100644 --- a/CMakeLists.txt +++ b/CMakeLists.txt @@ -19,7 +19,7 @@ cmake_minimum_required(VERSION 3.22.1) # The VERSION field is generated with the "--generated-version" flag in the generate_source.py script # # If working with unreleased extensions, make sure the header and validation version are all on the same header version -project(VVL VERSION 1.4.341 LANGUAGES CXX) +project(VVL VERSION 1.4.342 LANGUAGES CXX) # This variable enables downstream users to customize the target API # variant (e.g. Vulkan SC) diff --git a/layers/VkLayer_khronos_validation.json.in b/layers/VkLayer_khronos_validation.json.in index 8abad50ce8a..7a23f6ea10c 100644 --- a/layers/VkLayer_khronos_validation.json.in +++ b/layers/VkLayer_khronos_validation.json.in @@ -5,7 +5,7 @@ "prefix": "vvl", "type": "GLOBAL", "library_path": "@JSON_LIBRARY_PATH@", - "api_version": "1.4.341", + "api_version": "1.4.342", "implementation_version": "1", "description": "Khronos Validation Layer", "introduction": "The main, comprehensive Khronos validation layer.\n\nVulkan is an Explicit API, enabling direct control over how GPUs actually work. By design, minimal error checking is done inside a Vulkan driver. Applications have full control and responsibility for correct operation. Any errors in how Vulkan is used can result in a crash. \n\nThe Khronos Validation Layer can be enabled to assist development by enabling developers to verify their applications correctly use the Vulkan API.", diff --git a/layers/vulkan/generated/device_features.cpp b/layers/vulkan/generated/device_features.cpp index 5aac6d66d64..02e4f8043d0 100644 --- a/layers/vulkan/generated/device_features.cpp +++ b/layers/vulkan/generated/device_features.cpp @@ -915,6 +915,12 @@ void GetEnabledDeviceFeatures(const VkDeviceCreateInfo *pCreateInfo, DeviceFeatu features->representativeFragmentTest |= enabled->representativeFragmentTest == VK_TRUE; break; } + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COOPERATIVE_MATRIX_CONVERSION_FEATURES_QCOM: { + const VkPhysicalDeviceCooperativeMatrixConversionFeaturesQCOM *enabled = + reinterpret_cast(pNext); + features->cooperativeMatrixConversion |= enabled->cooperativeMatrixConversion == VK_TRUE; + break; + } case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MESH_SHADER_FEATURES_NV: { const VkPhysicalDeviceMeshShaderFeaturesNV *enabled = reinterpret_cast(pNext); diff --git a/layers/vulkan/generated/device_features.h b/layers/vulkan/generated/device_features.h index 15bd81c8b3b..58d3a28ff62 100644 --- a/layers/vulkan/generated/device_features.h +++ b/layers/vulkan/generated/device_features.h @@ -124,6 +124,8 @@ struct DeviceFeatures { bool cooperativeMatrixTensorAddressing; // VkPhysicalDeviceCooperativeMatrix2FeaturesNV bool cooperativeMatrixWorkgroupScope; + // VkPhysicalDeviceCooperativeMatrixConversionFeaturesQCOM + bool cooperativeMatrixConversion; // VkPhysicalDeviceCooperativeMatrixFeaturesKHR, VkPhysicalDeviceCooperativeMatrixFeaturesNV bool cooperativeMatrix; // VkPhysicalDeviceCooperativeMatrixFeaturesKHR, VkPhysicalDeviceCooperativeMatrixFeaturesNV diff --git a/layers/vulkan/generated/enum_flag_bits.h b/layers/vulkan/generated/enum_flag_bits.h index bc3080847c2..e59896a48ab 100644 --- a/layers/vulkan/generated/enum_flag_bits.h +++ b/layers/vulkan/generated/enum_flag_bits.h @@ -24,7 +24,7 @@ #include #include "vulkan/vulkan.h" // clang-format off -const uint32_t GeneratedVulkanHeaderVersion = 341; +const uint32_t GeneratedVulkanHeaderVersion = 342; const VkAccessFlags AllVkAccessFlagBits = VK_ACCESS_INDIRECT_COMMAND_READ_BIT|VK_ACCESS_INDEX_READ_BIT|VK_ACCESS_VERTEX_ATTRIBUTE_READ_BIT|VK_ACCESS_UNIFORM_READ_BIT|VK_ACCESS_INPUT_ATTACHMENT_READ_BIT|VK_ACCESS_SHADER_READ_BIT|VK_ACCESS_SHADER_WRITE_BIT|VK_ACCESS_COLOR_ATTACHMENT_READ_BIT|VK_ACCESS_COLOR_ATTACHMENT_WRITE_BIT|VK_ACCESS_DEPTH_STENCIL_ATTACHMENT_READ_BIT|VK_ACCESS_DEPTH_STENCIL_ATTACHMENT_WRITE_BIT|VK_ACCESS_TRANSFER_READ_BIT|VK_ACCESS_TRANSFER_WRITE_BIT|VK_ACCESS_HOST_READ_BIT|VK_ACCESS_HOST_WRITE_BIT|VK_ACCESS_MEMORY_READ_BIT|VK_ACCESS_MEMORY_WRITE_BIT|VK_ACCESS_NONE|VK_ACCESS_TRANSFORM_FEEDBACK_WRITE_BIT_EXT|VK_ACCESS_TRANSFORM_FEEDBACK_COUNTER_READ_BIT_EXT|VK_ACCESS_TRANSFORM_FEEDBACK_COUNTER_WRITE_BIT_EXT|VK_ACCESS_CONDITIONAL_RENDERING_READ_BIT_EXT|VK_ACCESS_COLOR_ATTACHMENT_READ_NONCOHERENT_BIT_EXT|VK_ACCESS_ACCELERATION_STRUCTURE_READ_BIT_KHR|VK_ACCESS_ACCELERATION_STRUCTURE_WRITE_BIT_KHR|VK_ACCESS_FRAGMENT_DENSITY_MAP_READ_BIT_EXT|VK_ACCESS_FRAGMENT_SHADING_RATE_ATTACHMENT_READ_BIT_KHR|VK_ACCESS_COMMAND_PREPROCESS_READ_BIT_EXT|VK_ACCESS_COMMAND_PREPROCESS_WRITE_BIT_EXT; const VkImageAspectFlags AllVkImageAspectFlagBits = VK_IMAGE_ASPECT_COLOR_BIT|VK_IMAGE_ASPECT_DEPTH_BIT|VK_IMAGE_ASPECT_STENCIL_BIT|VK_IMAGE_ASPECT_METADATA_BIT|VK_IMAGE_ASPECT_PLANE_0_BIT|VK_IMAGE_ASPECT_PLANE_1_BIT|VK_IMAGE_ASPECT_PLANE_2_BIT|VK_IMAGE_ASPECT_NONE|VK_IMAGE_ASPECT_MEMORY_PLANE_0_BIT_EXT|VK_IMAGE_ASPECT_MEMORY_PLANE_1_BIT_EXT|VK_IMAGE_ASPECT_MEMORY_PLANE_2_BIT_EXT|VK_IMAGE_ASPECT_MEMORY_PLANE_3_BIT_EXT; const VkInstanceCreateFlags AllVkInstanceCreateFlagBits = VK_INSTANCE_CREATE_ENUMERATE_PORTABILITY_BIT_KHR; diff --git a/layers/vulkan/generated/error_location_helper.cpp b/layers/vulkan/generated/error_location_helper.cpp index 508bf2e7fc7..97cea74ef99 100644 --- a/layers/vulkan/generated/error_location_helper.cpp +++ b/layers/vulkan/generated/error_location_helper.cpp @@ -1410,6 +1410,7 @@ const char* String(Struct structure) { {"VkPhysicalDeviceConservativeRasterizationPropertiesEXT", 55}, {"VkPhysicalDeviceCooperativeMatrix2FeaturesNV", 45}, {"VkPhysicalDeviceCooperativeMatrix2PropertiesNV", 47}, + {"VkPhysicalDeviceCooperativeMatrixConversionFeaturesQCOM", 56}, {"VkPhysicalDeviceCooperativeMatrixFeaturesKHR", 45}, {"VkPhysicalDeviceCooperativeMatrixFeaturesNV", 44}, {"VkPhysicalDeviceCooperativeMatrixPropertiesKHR", 47}, @@ -2438,6 +2439,7 @@ const char* String(Field field) { {"conversion", 11}, {"cooperativeMatrix", 18}, {"cooperativeMatrixBlockLoads", 28}, + {"cooperativeMatrixConversion", 28}, {"cooperativeMatrixConversions", 29}, {"cooperativeMatrixFlexibleDimensions", 36}, {"cooperativeMatrixFlexibleDimensionsMaxDimension", 48}, @@ -6177,6 +6179,7 @@ const char* String(Extension extension) { {"VK_NV_win32_keyed_mutex", 24}, {"VK_OHOS_external_memory", 24}, {"VK_OHOS_surface", 16}, + {"VK_QCOM_cooperative_matrix_conversion", 38}, {"VK_QCOM_data_graph_model", 25}, {"VK_QCOM_filter_cubic_clamp", 27}, {"VK_QCOM_filter_cubic_weights", 29}, @@ -8125,6 +8128,8 @@ Struct StypeToStruct(VkStructureType stype) { return Struct::VkPhysicalDeviceImageViewImageFormatInfoEXT; case VK_STRUCTURE_TYPE_FILTER_CUBIC_IMAGE_VIEW_IMAGE_FORMAT_PROPERTIES_EXT: return Struct::VkFilterCubicImageViewImageFormatPropertiesEXT; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COOPERATIVE_MATRIX_CONVERSION_FEATURES_QCOM: + return Struct::VkPhysicalDeviceCooperativeMatrixConversionFeaturesQCOM; case VK_STRUCTURE_TYPE_IMPORT_MEMORY_HOST_POINTER_INFO_EXT: return Struct::VkImportMemoryHostPointerInfoEXT; case VK_STRUCTURE_TYPE_MEMORY_HOST_POINTER_PROPERTIES_EXT: diff --git a/layers/vulkan/generated/error_location_helper.h b/layers/vulkan/generated/error_location_helper.h index 46777159d81..9f2df3faea9 100644 --- a/layers/vulkan/generated/error_location_helper.h +++ b/layers/vulkan/generated/error_location_helper.h @@ -1404,6 +1404,7 @@ enum class Struct { VkPhysicalDeviceConservativeRasterizationPropertiesEXT, VkPhysicalDeviceCooperativeMatrix2FeaturesNV, VkPhysicalDeviceCooperativeMatrix2PropertiesNV, + VkPhysicalDeviceCooperativeMatrixConversionFeaturesQCOM, VkPhysicalDeviceCooperativeMatrixFeaturesKHR, VkPhysicalDeviceCooperativeMatrixFeaturesNV, VkPhysicalDeviceCooperativeMatrixPropertiesKHR, @@ -2429,6 +2430,7 @@ enum class Field { conversion, cooperativeMatrix, cooperativeMatrixBlockLoads, + cooperativeMatrixConversion, cooperativeMatrixConversions, cooperativeMatrixFlexibleDimensions, cooperativeMatrixFlexibleDimensionsMaxDimension, @@ -6159,6 +6161,7 @@ enum class Extension { _VK_NV_win32_keyed_mutex, _VK_OHOS_external_memory, _VK_OHOS_surface, + _VK_QCOM_cooperative_matrix_conversion, _VK_QCOM_data_graph_model, _VK_QCOM_filter_cubic_clamp, _VK_QCOM_filter_cubic_weights, diff --git a/layers/vulkan/generated/feature_not_present.cpp b/layers/vulkan/generated/feature_not_present.cpp index 2ed5a33e70c..337ed6a29c5 100644 --- a/layers/vulkan/generated/feature_not_present.cpp +++ b/layers/vulkan/generated/feature_not_present.cpp @@ -537,6 +537,17 @@ void Instance::ReportErrorFeatureNotPresent(VkPhysicalDevice gpu, const VkDevice } break; } + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COOPERATIVE_MATRIX_CONVERSION_FEATURES_QCOM: { + VkPhysicalDeviceCooperativeMatrixConversionFeaturesQCOM supported = vku::InitStructHelper(); + features_2.pNext = &supported; + DispatchGetPhysicalDeviceFeatures2(gpu, &features_2); + const VkPhysicalDeviceCooperativeMatrixConversionFeaturesQCOM *enabling = + reinterpret_cast(current); + if (enabling->cooperativeMatrixConversion && !supported.cooperativeMatrixConversion) { + ss << "VkPhysicalDeviceCooperativeMatrixConversionFeaturesQCOM::cooperativeMatrixConversion is not supported\n"; + } + break; + } case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COOPERATIVE_MATRIX_FEATURES_KHR: { VkPhysicalDeviceCooperativeMatrixFeaturesKHR supported = vku::InitStructHelper(); features_2.pNext = &supported; diff --git a/layers/vulkan/generated/feature_requirements_helper.cpp b/layers/vulkan/generated/feature_requirements_helper.cpp index cca107c6796..a9969f07a71 100644 --- a/layers/vulkan/generated/feature_requirements_helper.cpp +++ b/layers/vulkan/generated/feature_requirements_helper.cpp @@ -851,6 +851,22 @@ FeatureAndName AddFeature(APIVersion api_version, vkt::Feature feature, void **i "VkPhysicalDeviceCooperativeMatrix2FeaturesNV::cooperativeMatrixWorkgroupScope"}; } + case Feature::cooperativeMatrixConversion: { + auto vk_struct = const_cast( + vku::FindStructInPNextChain(*inout_pnext_chain)); + if (!vk_struct) { + vk_struct = new VkPhysicalDeviceCooperativeMatrixConversionFeaturesQCOM; + *vk_struct = vku::InitStructHelper(); + if (*inout_pnext_chain) { + vvl::PnextChainAdd(*inout_pnext_chain, vk_struct); + } else { + *inout_pnext_chain = vk_struct; + } + } + return {&vk_struct->cooperativeMatrixConversion, + "VkPhysicalDeviceCooperativeMatrixConversionFeaturesQCOM::cooperativeMatrixConversion"}; + } + case Feature::cooperativeMatrix: { auto vk_struct = const_cast( vku::FindStructInPNextChain(*inout_pnext_chain)); @@ -4779,21 +4795,21 @@ FeatureAndName AddFeature(APIVersion api_version, vkt::Feature feature, void **i } #ifdef VK_ENABLE_BETA_EXTENSIONS - case Feature::constantAlphaColorBlendFactors: { - auto vk_struct = const_cast( - vku::FindStructInPNextChain(*inout_pnext_chain)); - if (!vk_struct) { - vk_struct = new VkPhysicalDevicePortabilitySubsetFeaturesKHR; - *vk_struct = vku::InitStructHelper(); - if (*inout_pnext_chain) { - vvl::PnextChainAdd(*inout_pnext_chain, vk_struct); - } else { - *inout_pnext_chain = vk_struct; + case Feature::constantAlphaColorBlendFactors : { + auto vk_struct = const_cast( + vku::FindStructInPNextChain(*inout_pnext_chain)); + if (!vk_struct) { + vk_struct = new VkPhysicalDevicePortabilitySubsetFeaturesKHR; + *vk_struct = vku::InitStructHelper(); + if (*inout_pnext_chain) { + vvl::PnextChainAdd(*inout_pnext_chain, vk_struct); + } else { + *inout_pnext_chain = vk_struct; + } } + return {&vk_struct->constantAlphaColorBlendFactors, + "VkPhysicalDevicePortabilitySubsetFeaturesKHR::constantAlphaColorBlendFactors"}; } - return {&vk_struct->constantAlphaColorBlendFactors, - "VkPhysicalDevicePortabilitySubsetFeaturesKHR::constantAlphaColorBlendFactors"}; - } #endif // VK_ENABLE_BETA_EXTENSIONS #ifdef VK_ENABLE_BETA_EXTENSIONS diff --git a/layers/vulkan/generated/feature_requirements_helper.h b/layers/vulkan/generated/feature_requirements_helper.h index 6245d9687a7..cc9f61c0e00 100644 --- a/layers/vulkan/generated/feature_requirements_helper.h +++ b/layers/vulkan/generated/feature_requirements_helper.h @@ -116,6 +116,8 @@ enum class Feature { cooperativeMatrixTensorAddressing, // VkPhysicalDeviceCooperativeMatrix2FeaturesNV cooperativeMatrixWorkgroupScope, + // VkPhysicalDeviceCooperativeMatrixConversionFeaturesQCOM + cooperativeMatrixConversion, // VkPhysicalDeviceCooperativeMatrixFeaturesKHR, VkPhysicalDeviceCooperativeMatrixFeaturesNV cooperativeMatrix, // VkPhysicalDeviceCooperativeMatrixFeaturesKHR, VkPhysicalDeviceCooperativeMatrixFeaturesNV diff --git a/layers/vulkan/generated/legacy.cpp b/layers/vulkan/generated/legacy.cpp index 553f0ccd837..f06d68b9d47 100644 --- a/layers/vulkan/generated/legacy.cpp +++ b/layers/vulkan/generated/legacy.cpp @@ -206,6 +206,180 @@ bool Instance::PreCallValidateGetPhysicalDeviceSparseImageFormatProperties(VkPhy return false; } +bool Device::PreCallValidateCreateBufferView(VkDevice device, const VkBufferViewCreateInfo* pCreateInfo, + const VkAllocationCallbacks* pAllocator, VkBufferView* pView, + const ErrorObject& error_obj) const { + static bool reported = false; + if (reported) return false; + + if (IsExtEnabled(extensions.vk_ext_descriptor_heap)) { + reported = true; + LogWarning("WARNING-legacy-resource-objects", device, error_obj.location, + "vkCreateBufferView is a legacy command and this VkDevice enabled the VK_EXT_descriptor_heap extension which " + "contains the new feature to replace it.\nSee more information about this legacy in the specification: " + "https://docs.vulkan.org/spec/latest/appendices/legacy.html#legacy-resource-objects"); + } + return false; +} + +bool Device::PreCallValidateCreatePipelineLayout(VkDevice device, const VkPipelineLayoutCreateInfo* pCreateInfo, + const VkAllocationCallbacks* pAllocator, VkPipelineLayout* pPipelineLayout, + const ErrorObject& error_obj) const { + static bool reported = false; + if (reported) return false; + + if (IsExtEnabled(extensions.vk_ext_descriptor_heap)) { + reported = true; + LogWarning("WARNING-legacy-descriptor-sets", device, error_obj.location, + "vkCreatePipelineLayout is a legacy command and this VkDevice enabled the VK_EXT_descriptor_heap extension " + "which contains the new feature to replace it.\nSee more information about this legacy in the specification: " + "https://docs.vulkan.org/spec/latest/appendices/legacy.html#legacy-descriptor-sets"); + } + return false; +} + +bool Device::PreCallValidateCreateSampler(VkDevice device, const VkSamplerCreateInfo* pCreateInfo, + const VkAllocationCallbacks* pAllocator, VkSampler* pSampler, + const ErrorObject& error_obj) const { + static bool reported = false; + if (reported) return false; + + if (IsExtEnabled(extensions.vk_ext_descriptor_heap)) { + reported = true; + LogWarning("WARNING-legacy-resource-objects", device, error_obj.location, + "vkCreateSampler is a legacy command and this VkDevice enabled the VK_EXT_descriptor_heap extension which " + "contains the new feature to replace it.\nSee more information about this legacy in the specification: " + "https://docs.vulkan.org/spec/latest/appendices/legacy.html#legacy-resource-objects"); + } + return false; +} + +bool Device::PreCallValidateCreateDescriptorSetLayout(VkDevice device, const VkDescriptorSetLayoutCreateInfo* pCreateInfo, + const VkAllocationCallbacks* pAllocator, VkDescriptorSetLayout* pSetLayout, + const ErrorObject& error_obj) const { + static bool reported = false; + if (reported) return false; + + if (IsExtEnabled(extensions.vk_ext_descriptor_heap)) { + reported = true; + LogWarning("WARNING-legacy-descriptor-sets", device, error_obj.location, + "vkCreateDescriptorSetLayout is a legacy command and this VkDevice enabled the VK_EXT_descriptor_heap extension " + "which contains the new feature to replace it.\nSee more information about this legacy in the specification: " + "https://docs.vulkan.org/spec/latest/appendices/legacy.html#legacy-descriptor-sets"); + } + return false; +} + +bool Device::PreCallValidateCreateDescriptorPool(VkDevice device, const VkDescriptorPoolCreateInfo* pCreateInfo, + const VkAllocationCallbacks* pAllocator, VkDescriptorPool* pDescriptorPool, + const ErrorObject& error_obj) const { + static bool reported = false; + if (reported) return false; + + if (IsExtEnabled(extensions.vk_ext_descriptor_heap)) { + reported = true; + LogWarning("WARNING-legacy-descriptor-sets", device, error_obj.location, + "vkCreateDescriptorPool is a legacy command and this VkDevice enabled the VK_EXT_descriptor_heap extension " + "which contains the new feature to replace it.\nSee more information about this legacy in the specification: " + "https://docs.vulkan.org/spec/latest/appendices/legacy.html#legacy-descriptor-sets"); + } + return false; +} + +bool Device::PreCallValidateResetDescriptorPool(VkDevice device, VkDescriptorPool descriptorPool, VkDescriptorPoolResetFlags flags, + const ErrorObject& error_obj) const { + static bool reported = false; + if (reported) return false; + + if (IsExtEnabled(extensions.vk_ext_descriptor_heap)) { + reported = true; + LogWarning("WARNING-legacy-descriptor-sets", device, error_obj.location, + "vkResetDescriptorPool is a legacy command and this VkDevice enabled the VK_EXT_descriptor_heap extension which " + "contains the new feature to replace it.\nSee more information about this legacy in the specification: " + "https://docs.vulkan.org/spec/latest/appendices/legacy.html#legacy-descriptor-sets"); + } + return false; +} + +bool Device::PreCallValidateAllocateDescriptorSets(VkDevice device, const VkDescriptorSetAllocateInfo* pAllocateInfo, + VkDescriptorSet* pDescriptorSets, const ErrorObject& error_obj) const { + static bool reported = false; + if (reported) return false; + + if (IsExtEnabled(extensions.vk_ext_descriptor_heap)) { + reported = true; + LogWarning("WARNING-legacy-descriptor-sets", device, error_obj.location, + "vkAllocateDescriptorSets is a legacy command and this VkDevice enabled the VK_EXT_descriptor_heap extension " + "which contains the new feature to replace it.\nSee more information about this legacy in the specification: " + "https://docs.vulkan.org/spec/latest/appendices/legacy.html#legacy-descriptor-sets"); + } + return false; +} + +bool Device::PreCallValidateFreeDescriptorSets(VkDevice device, VkDescriptorPool descriptorPool, uint32_t descriptorSetCount, + const VkDescriptorSet* pDescriptorSets, const ErrorObject& error_obj) const { + static bool reported = false; + if (reported) return false; + + if (IsExtEnabled(extensions.vk_ext_descriptor_heap)) { + reported = true; + LogWarning("WARNING-legacy-descriptor-sets", device, error_obj.location, + "vkFreeDescriptorSets is a legacy command and this VkDevice enabled the VK_EXT_descriptor_heap extension which " + "contains the new feature to replace it.\nSee more information about this legacy in the specification: " + "https://docs.vulkan.org/spec/latest/appendices/legacy.html#legacy-descriptor-sets"); + } + return false; +} + +bool Device::PreCallValidateUpdateDescriptorSets(VkDevice device, uint32_t descriptorWriteCount, + const VkWriteDescriptorSet* pDescriptorWrites, uint32_t descriptorCopyCount, + const VkCopyDescriptorSet* pDescriptorCopies, const ErrorObject& error_obj) const { + static bool reported = false; + if (reported) return false; + + if (IsExtEnabled(extensions.vk_ext_descriptor_heap)) { + reported = true; + LogWarning("WARNING-legacy-descriptor-sets", device, error_obj.location, + "vkUpdateDescriptorSets is a legacy command and this VkDevice enabled the VK_EXT_descriptor_heap extension " + "which contains the new feature to replace it.\nSee more information about this legacy in the specification: " + "https://docs.vulkan.org/spec/latest/appendices/legacy.html#legacy-descriptor-sets"); + } + return false; +} + +bool Device::PreCallValidateCmdBindDescriptorSets(VkCommandBuffer commandBuffer, VkPipelineBindPoint pipelineBindPoint, + VkPipelineLayout layout, uint32_t firstSet, uint32_t descriptorSetCount, + const VkDescriptorSet* pDescriptorSets, uint32_t dynamicOffsetCount, + const uint32_t* pDynamicOffsets, const ErrorObject& error_obj) const { + static bool reported = false; + if (reported) return false; + + if (IsExtEnabled(extensions.vk_ext_descriptor_heap)) { + reported = true; + LogWarning("WARNING-legacy-descriptor-sets", device, error_obj.location, + "vkCmdBindDescriptorSets is a legacy command and this VkDevice enabled the VK_EXT_descriptor_heap extension " + "which contains the new feature to replace it.\nSee more information about this legacy in the specification: " + "https://docs.vulkan.org/spec/latest/appendices/legacy.html#legacy-descriptor-sets"); + } + return false; +} + +bool Device::PreCallValidateCmdPushConstants(VkCommandBuffer commandBuffer, VkPipelineLayout layout, VkShaderStageFlags stageFlags, + uint32_t offset, uint32_t size, const void* pValues, + const ErrorObject& error_obj) const { + static bool reported = false; + if (reported) return false; + + if (IsExtEnabled(extensions.vk_ext_descriptor_heap)) { + reported = true; + LogWarning("WARNING-legacy-descriptor-sets", device, error_obj.location, + "vkCmdPushConstants is a legacy command and this VkDevice enabled the VK_EXT_descriptor_heap extension which " + "contains the new feature to replace it.\nSee more information about this legacy in the specification: " + "https://docs.vulkan.org/spec/latest/appendices/legacy.html#legacy-descriptor-sets"); + } + return false; +} + bool Device::PreCallValidateCreateFramebuffer(VkDevice device, const VkFramebufferCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkFramebuffer* pFramebuffer, const ErrorObject& error_obj) const { @@ -419,6 +593,252 @@ bool Device::PreCallValidateCmdEndRenderPass2(VkCommandBuffer commandBuffer, con return false; } +bool Device::PreCallValidateCmdBindDescriptorSets2(VkCommandBuffer commandBuffer, + const VkBindDescriptorSetsInfo* pBindDescriptorSetsInfo, + const ErrorObject& error_obj) const { + static bool reported = false; + if (reported) return false; + + if (IsExtEnabled(extensions.vk_ext_descriptor_heap)) { + reported = true; + LogWarning("WARNING-legacy-descriptor-sets", device, error_obj.location, + "vkCmdBindDescriptorSets2 is a legacy command and this VkDevice enabled the VK_EXT_descriptor_heap extension " + "which contains the new feature to replace it.\nSee more information about this legacy in the specification: " + "https://docs.vulkan.org/spec/latest/appendices/legacy.html#legacy-descriptor-sets"); + } + return false; +} + +bool Device::PreCallValidateCmdPushConstants2(VkCommandBuffer commandBuffer, const VkPushConstantsInfo* pPushConstantsInfo, + const ErrorObject& error_obj) const { + static bool reported = false; + if (reported) return false; + + if (IsExtEnabled(extensions.vk_ext_descriptor_heap)) { + reported = true; + LogWarning("WARNING-legacy-descriptor-sets", device, error_obj.location, + "vkCmdPushConstants2 is a legacy command and this VkDevice enabled the VK_EXT_descriptor_heap extension which " + "contains the new feature to replace it.\nSee more information about this legacy in the specification: " + "https://docs.vulkan.org/spec/latest/appendices/legacy.html#legacy-descriptor-sets"); + } + return false; +} + +bool Device::PreCallValidateCmdSetDescriptorBufferOffsets2EXT( + VkCommandBuffer commandBuffer, const VkSetDescriptorBufferOffsetsInfoEXT* pSetDescriptorBufferOffsetsInfo, + const ErrorObject& error_obj) const { + static bool reported = false; + if (reported) return false; + + if (IsExtEnabled(extensions.vk_ext_descriptor_heap)) { + reported = true; + LogWarning("WARNING-legacy-descriptor-sets", device, error_obj.location, + "vkCmdSetDescriptorBufferOffsets2EXT is a legacy command and this VkDevice enabled the VK_EXT_descriptor_heap " + "extension which contains the new feature to replace it.\nSee more information about this legacy in the " + "specification: https://docs.vulkan.org/spec/latest/appendices/legacy.html#legacy-descriptor-sets"); + } + return false; +} + +bool Device::PreCallValidateCmdBindDescriptorBufferEmbeddedSamplers2EXT( + VkCommandBuffer commandBuffer, const VkBindDescriptorBufferEmbeddedSamplersInfoEXT* pBindDescriptorBufferEmbeddedSamplersInfo, + const ErrorObject& error_obj) const { + static bool reported = false; + if (reported) return false; + + if (IsExtEnabled(extensions.vk_ext_descriptor_heap)) { + reported = true; + LogWarning( + "WARNING-legacy-descriptor-sets", device, error_obj.location, + "vkCmdBindDescriptorBufferEmbeddedSamplers2EXT is a legacy command and this VkDevice enabled the " + "VK_EXT_descriptor_heap extension which contains the new feature to replace it.\nSee more information about this " + "legacy in the specification: https://docs.vulkan.org/spec/latest/appendices/legacy.html#legacy-descriptor-sets"); + } + return false; +} + +bool Device::PreCallValidateGetDescriptorSetLayoutSizeEXT(VkDevice device, VkDescriptorSetLayout layout, + VkDeviceSize* pLayoutSizeInBytes, const ErrorObject& error_obj) const { + static bool reported = false; + if (reported) return false; + + if (IsExtEnabled(extensions.vk_ext_descriptor_heap)) { + reported = true; + LogWarning("WARNING-legacy-descriptor-sets", device, error_obj.location, + "vkGetDescriptorSetLayoutSizeEXT is a legacy command and this VkDevice enabled the VK_EXT_descriptor_heap " + "extension which contains the new feature to replace it.\nSee more information about this legacy in the " + "specification: https://docs.vulkan.org/spec/latest/appendices/legacy.html#legacy-descriptor-sets"); + } + return false; +} + +bool Device::PreCallValidateGetDescriptorSetLayoutBindingOffsetEXT(VkDevice device, VkDescriptorSetLayout layout, uint32_t binding, + VkDeviceSize* pOffset, const ErrorObject& error_obj) const { + static bool reported = false; + if (reported) return false; + + if (IsExtEnabled(extensions.vk_ext_descriptor_heap)) { + reported = true; + LogWarning( + "WARNING-legacy-descriptor-sets", device, error_obj.location, + "vkGetDescriptorSetLayoutBindingOffsetEXT is a legacy command and this VkDevice enabled the VK_EXT_descriptor_heap " + "extension which contains the new feature to replace it.\nSee more information about this legacy in the specification: " + "https://docs.vulkan.org/spec/latest/appendices/legacy.html#legacy-descriptor-sets"); + } + return false; +} + +bool Device::PreCallValidateGetDescriptorEXT(VkDevice device, const VkDescriptorGetInfoEXT* pDescriptorInfo, size_t dataSize, + void* pDescriptor, const ErrorObject& error_obj) const { + static bool reported = false; + if (reported) return false; + + if (IsExtEnabled(extensions.vk_ext_descriptor_heap)) { + reported = true; + LogWarning("WARNING-legacy-descriptor-sets", device, error_obj.location, + "vkGetDescriptorEXT is a legacy command and this VkDevice enabled the VK_EXT_descriptor_heap extension which " + "contains the new feature to replace it.\nSee more information about this legacy in the specification: " + "https://docs.vulkan.org/spec/latest/appendices/legacy.html#legacy-descriptor-sets"); + } + return false; +} + +bool Device::PreCallValidateCmdBindDescriptorBuffersEXT(VkCommandBuffer commandBuffer, uint32_t bufferCount, + const VkDescriptorBufferBindingInfoEXT* pBindingInfos, + const ErrorObject& error_obj) const { + static bool reported = false; + if (reported) return false; + + if (IsExtEnabled(extensions.vk_ext_descriptor_heap)) { + reported = true; + LogWarning("WARNING-legacy-descriptor-sets", device, error_obj.location, + "vkCmdBindDescriptorBuffersEXT is a legacy command and this VkDevice enabled the VK_EXT_descriptor_heap " + "extension which contains the new feature to replace it.\nSee more information about this legacy in the " + "specification: https://docs.vulkan.org/spec/latest/appendices/legacy.html#legacy-descriptor-sets"); + } + return false; +} + +bool Device::PreCallValidateCmdSetDescriptorBufferOffsetsEXT(VkCommandBuffer commandBuffer, VkPipelineBindPoint pipelineBindPoint, + VkPipelineLayout layout, uint32_t firstSet, uint32_t setCount, + const uint32_t* pBufferIndices, const VkDeviceSize* pOffsets, + const ErrorObject& error_obj) const { + static bool reported = false; + if (reported) return false; + + if (IsExtEnabled(extensions.vk_ext_descriptor_heap)) { + reported = true; + LogWarning("WARNING-legacy-descriptor-sets", device, error_obj.location, + "vkCmdSetDescriptorBufferOffsetsEXT is a legacy command and this VkDevice enabled the VK_EXT_descriptor_heap " + "extension which contains the new feature to replace it.\nSee more information about this legacy in the " + "specification: https://docs.vulkan.org/spec/latest/appendices/legacy.html#legacy-descriptor-sets"); + } + return false; +} + +bool Device::PreCallValidateCmdBindDescriptorBufferEmbeddedSamplersEXT(VkCommandBuffer commandBuffer, + VkPipelineBindPoint pipelineBindPoint, + VkPipelineLayout layout, uint32_t set, + const ErrorObject& error_obj) const { + static bool reported = false; + if (reported) return false; + + if (IsExtEnabled(extensions.vk_ext_descriptor_heap)) { + reported = true; + LogWarning( + "WARNING-legacy-descriptor-sets", device, error_obj.location, + "vkCmdBindDescriptorBufferEmbeddedSamplersEXT is a legacy command and this VkDevice enabled the VK_EXT_descriptor_heap " + "extension which contains the new feature to replace it.\nSee more information about this legacy in the specification: " + "https://docs.vulkan.org/spec/latest/appendices/legacy.html#legacy-descriptor-sets"); + } + return false; +} + +bool Device::PreCallValidateGetBufferOpaqueCaptureDescriptorDataEXT(VkDevice device, + const VkBufferCaptureDescriptorDataInfoEXT* pInfo, void* pData, + const ErrorObject& error_obj) const { + static bool reported = false; + if (reported) return false; + + if (IsExtEnabled(extensions.vk_ext_descriptor_heap)) { + reported = true; + LogWarning( + "WARNING-legacy-descriptor-sets", device, error_obj.location, + "vkGetBufferOpaqueCaptureDescriptorDataEXT is a legacy command and this VkDevice enabled the VK_EXT_descriptor_heap " + "extension which contains the new feature to replace it.\nSee more information about this legacy in the specification: " + "https://docs.vulkan.org/spec/latest/appendices/legacy.html#legacy-descriptor-sets"); + } + return false; +} + +bool Device::PreCallValidateGetImageOpaqueCaptureDescriptorDataEXT(VkDevice device, + const VkImageCaptureDescriptorDataInfoEXT* pInfo, void* pData, + const ErrorObject& error_obj) const { + static bool reported = false; + if (reported) return false; + + if (IsExtEnabled(extensions.vk_ext_descriptor_heap)) { + reported = true; + LogWarning( + "WARNING-legacy-descriptor-sets", device, error_obj.location, + "vkGetImageOpaqueCaptureDescriptorDataEXT is a legacy command and this VkDevice enabled the VK_EXT_descriptor_heap " + "extension which contains the new feature to replace it.\nSee more information about this legacy in the specification: " + "https://docs.vulkan.org/spec/latest/appendices/legacy.html#legacy-descriptor-sets"); + } + return false; +} + +bool Device::PreCallValidateGetImageViewOpaqueCaptureDescriptorDataEXT(VkDevice device, + const VkImageViewCaptureDescriptorDataInfoEXT* pInfo, + void* pData, const ErrorObject& error_obj) const { + static bool reported = false; + if (reported) return false; + + if (IsExtEnabled(extensions.vk_ext_descriptor_heap)) { + reported = true; + LogWarning( + "WARNING-legacy-descriptor-sets", device, error_obj.location, + "vkGetImageViewOpaqueCaptureDescriptorDataEXT is a legacy command and this VkDevice enabled the VK_EXT_descriptor_heap " + "extension which contains the new feature to replace it.\nSee more information about this legacy in the specification: " + "https://docs.vulkan.org/spec/latest/appendices/legacy.html#legacy-descriptor-sets"); + } + return false; +} + +bool Device::PreCallValidateGetSamplerOpaqueCaptureDescriptorDataEXT(VkDevice device, + const VkSamplerCaptureDescriptorDataInfoEXT* pInfo, + void* pData, const ErrorObject& error_obj) const { + static bool reported = false; + if (reported) return false; + + if (IsExtEnabled(extensions.vk_ext_descriptor_heap)) { + reported = true; + LogWarning( + "WARNING-legacy-descriptor-sets", device, error_obj.location, + "vkGetSamplerOpaqueCaptureDescriptorDataEXT is a legacy command and this VkDevice enabled the VK_EXT_descriptor_heap " + "extension which contains the new feature to replace it.\nSee more information about this legacy in the specification: " + "https://docs.vulkan.org/spec/latest/appendices/legacy.html#legacy-descriptor-sets"); + } + return false; +} + +bool Device::PreCallValidateGetAccelerationStructureOpaqueCaptureDescriptorDataEXT( + VkDevice device, const VkAccelerationStructureCaptureDescriptorDataInfoEXT* pInfo, void* pData, + const ErrorObject& error_obj) const { + static bool reported = false; + if (reported) return false; + + if (IsExtEnabled(extensions.vk_ext_descriptor_heap)) { + reported = true; + LogWarning( + "WARNING-legacy-descriptor-sets", device, error_obj.location, + "vkGetAccelerationStructureOpaqueCaptureDescriptorDataEXT is a legacy command and this VkDevice enabled the " + "VK_EXT_descriptor_heap extension which contains the new feature to replace it.\nSee more information about this " + "legacy in the specification: https://docs.vulkan.org/spec/latest/appendices/legacy.html#legacy-descriptor-sets"); + } + return false; +} + ExtensionData GetExtensionData(vvl::Extension extension_name) { static const ExtensionData empty_data{Reason::Empty, vvl::Extension::Empty}; static const vvl::unordered_map legacy_extensions = { @@ -540,6 +960,7 @@ ExtensionData GetExtensionData(vvl::Extension extension_name) { {vvl::Extension::_VK_EXT_robustness2, {Reason::Promoted, {vvl::Extension::_VK_KHR_robustness2}}}, {vvl::Extension::_VK_EXT_private_data, {Reason::Promoted, {vvl::Version::_VK_VERSION_1_3}}}, {vvl::Extension::_VK_EXT_pipeline_creation_cache_control, {Reason::Promoted, {vvl::Version::_VK_VERSION_1_3}}}, + {vvl::Extension::_VK_EXT_descriptor_buffer, {Reason::Superseded, {vvl::Extension::_VK_EXT_descriptor_heap}}}, {vvl::Extension::_VK_EXT_ycbcr_2plane_444_formats, {Reason::Promoted, {vvl::Version::_VK_VERSION_1_3}}}, {vvl::Extension::_VK_EXT_image_robustness, {Reason::Promoted, {vvl::Version::_VK_VERSION_1_3}}}, {vvl::Extension::_VK_EXT_4444_formats, {Reason::Promoted, {vvl::Version::_VK_VERSION_1_3}}}, diff --git a/layers/vulkan/generated/legacy.h b/layers/vulkan/generated/legacy.h index 9144a49b1f7..91a4b5568cf 100644 --- a/layers/vulkan/generated/legacy.h +++ b/layers/vulkan/generated/legacy.h @@ -96,6 +96,38 @@ class Device : public vvl::base::Device { ~Device() {} Instance* instance; + bool PreCallValidateCreateBufferView(VkDevice device, const VkBufferViewCreateInfo* pCreateInfo, + const VkAllocationCallbacks* pAllocator, VkBufferView* pView, + const ErrorObject& error_obj) const override; + bool PreCallValidateCreatePipelineLayout(VkDevice device, const VkPipelineLayoutCreateInfo* pCreateInfo, + const VkAllocationCallbacks* pAllocator, VkPipelineLayout* pPipelineLayout, + const ErrorObject& error_obj) const override; + bool PreCallValidateCreateSampler(VkDevice device, const VkSamplerCreateInfo* pCreateInfo, + const VkAllocationCallbacks* pAllocator, VkSampler* pSampler, + const ErrorObject& error_obj) const override; + bool PreCallValidateCreateDescriptorSetLayout(VkDevice device, const VkDescriptorSetLayoutCreateInfo* pCreateInfo, + const VkAllocationCallbacks* pAllocator, VkDescriptorSetLayout* pSetLayout, + const ErrorObject& error_obj) const override; + bool PreCallValidateCreateDescriptorPool(VkDevice device, const VkDescriptorPoolCreateInfo* pCreateInfo, + const VkAllocationCallbacks* pAllocator, VkDescriptorPool* pDescriptorPool, + const ErrorObject& error_obj) const override; + bool PreCallValidateResetDescriptorPool(VkDevice device, VkDescriptorPool descriptorPool, VkDescriptorPoolResetFlags flags, + const ErrorObject& error_obj) const override; + bool PreCallValidateAllocateDescriptorSets(VkDevice device, const VkDescriptorSetAllocateInfo* pAllocateInfo, + VkDescriptorSet* pDescriptorSets, const ErrorObject& error_obj) const override; + bool PreCallValidateFreeDescriptorSets(VkDevice device, VkDescriptorPool descriptorPool, uint32_t descriptorSetCount, + const VkDescriptorSet* pDescriptorSets, const ErrorObject& error_obj) const override; + bool PreCallValidateUpdateDescriptorSets(VkDevice device, uint32_t descriptorWriteCount, + const VkWriteDescriptorSet* pDescriptorWrites, uint32_t descriptorCopyCount, + const VkCopyDescriptorSet* pDescriptorCopies, + const ErrorObject& error_obj) const override; + bool PreCallValidateCmdBindDescriptorSets(VkCommandBuffer commandBuffer, VkPipelineBindPoint pipelineBindPoint, + VkPipelineLayout layout, uint32_t firstSet, uint32_t descriptorSetCount, + const VkDescriptorSet* pDescriptorSets, uint32_t dynamicOffsetCount, + const uint32_t* pDynamicOffsets, const ErrorObject& error_obj) const override; + bool PreCallValidateCmdPushConstants(VkCommandBuffer commandBuffer, VkPipelineLayout layout, VkShaderStageFlags stageFlags, + uint32_t offset, uint32_t size, const void* pValues, + const ErrorObject& error_obj) const override; bool PreCallValidateCreateFramebuffer(VkDevice device, const VkFramebufferCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkFramebuffer* pFramebuffer, const ErrorObject& error_obj) const override; @@ -119,6 +151,48 @@ class Device : public vvl::base::Device { const VkSubpassEndInfo* pSubpassEndInfo, const ErrorObject& error_obj) const override; bool PreCallValidateCmdEndRenderPass2(VkCommandBuffer commandBuffer, const VkSubpassEndInfo* pSubpassEndInfo, const ErrorObject& error_obj) const override; + bool PreCallValidateCmdBindDescriptorSets2(VkCommandBuffer commandBuffer, + const VkBindDescriptorSetsInfo* pBindDescriptorSetsInfo, + const ErrorObject& error_obj) const override; + bool PreCallValidateCmdPushConstants2(VkCommandBuffer commandBuffer, const VkPushConstantsInfo* pPushConstantsInfo, + const ErrorObject& error_obj) const override; + bool PreCallValidateCmdSetDescriptorBufferOffsets2EXT( + VkCommandBuffer commandBuffer, const VkSetDescriptorBufferOffsetsInfoEXT* pSetDescriptorBufferOffsetsInfo, + const ErrorObject& error_obj) const override; + bool PreCallValidateCmdBindDescriptorBufferEmbeddedSamplers2EXT( + VkCommandBuffer commandBuffer, + const VkBindDescriptorBufferEmbeddedSamplersInfoEXT* pBindDescriptorBufferEmbeddedSamplersInfo, + const ErrorObject& error_obj) const override; + bool PreCallValidateGetDescriptorSetLayoutSizeEXT(VkDevice device, VkDescriptorSetLayout layout, + VkDeviceSize* pLayoutSizeInBytes, + const ErrorObject& error_obj) const override; + bool PreCallValidateGetDescriptorSetLayoutBindingOffsetEXT(VkDevice device, VkDescriptorSetLayout layout, uint32_t binding, + VkDeviceSize* pOffset, const ErrorObject& error_obj) const override; + bool PreCallValidateGetDescriptorEXT(VkDevice device, const VkDescriptorGetInfoEXT* pDescriptorInfo, size_t dataSize, + void* pDescriptor, const ErrorObject& error_obj) const override; + bool PreCallValidateCmdBindDescriptorBuffersEXT(VkCommandBuffer commandBuffer, uint32_t bufferCount, + const VkDescriptorBufferBindingInfoEXT* pBindingInfos, + const ErrorObject& error_obj) const override; + bool PreCallValidateCmdSetDescriptorBufferOffsetsEXT(VkCommandBuffer commandBuffer, VkPipelineBindPoint pipelineBindPoint, + VkPipelineLayout layout, uint32_t firstSet, uint32_t setCount, + const uint32_t* pBufferIndices, const VkDeviceSize* pOffsets, + const ErrorObject& error_obj) const override; + bool PreCallValidateCmdBindDescriptorBufferEmbeddedSamplersEXT(VkCommandBuffer commandBuffer, + VkPipelineBindPoint pipelineBindPoint, VkPipelineLayout layout, + uint32_t set, const ErrorObject& error_obj) const override; + bool PreCallValidateGetBufferOpaqueCaptureDescriptorDataEXT(VkDevice device, const VkBufferCaptureDescriptorDataInfoEXT* pInfo, + void* pData, const ErrorObject& error_obj) const override; + bool PreCallValidateGetImageOpaqueCaptureDescriptorDataEXT(VkDevice device, const VkImageCaptureDescriptorDataInfoEXT* pInfo, + void* pData, const ErrorObject& error_obj) const override; + bool PreCallValidateGetImageViewOpaqueCaptureDescriptorDataEXT(VkDevice device, + const VkImageViewCaptureDescriptorDataInfoEXT* pInfo, + void* pData, const ErrorObject& error_obj) const override; + bool PreCallValidateGetSamplerOpaqueCaptureDescriptorDataEXT(VkDevice device, + const VkSamplerCaptureDescriptorDataInfoEXT* pInfo, void* pData, + const ErrorObject& error_obj) const override; + bool PreCallValidateGetAccelerationStructureOpaqueCaptureDescriptorDataEXT( + VkDevice device, const VkAccelerationStructureCaptureDescriptorDataInfoEXT* pInfo, void* pData, + const ErrorObject& error_obj) const override; }; } // namespace legacy // NOLINTEND diff --git a/layers/vulkan/generated/pnext_chain_extraction.cpp b/layers/vulkan/generated/pnext_chain_extraction.cpp index 19fe3ef0dc8..1200b527767 100644 --- a/layers/vulkan/generated/pnext_chain_extraction.cpp +++ b/layers/vulkan/generated/pnext_chain_extraction.cpp @@ -2074,6 +2074,11 @@ void PnextChainFree(void *chain) { header->pNext = nullptr; delete reinterpret_cast(header); break; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COOPERATIVE_MATRIX_CONVERSION_FEATURES_QCOM: + PnextChainFree(header->pNext); + header->pNext = nullptr; + delete reinterpret_cast(header); + break; case VK_STRUCTURE_TYPE_IMPORT_MEMORY_HOST_POINTER_INFO_EXT: PnextChainFree(header->pNext); header->pNext = nullptr; diff --git a/layers/vulkan/generated/spirv_validation_helper.cpp b/layers/vulkan/generated/spirv_validation_helper.cpp index a971dabaf0f..6eb3db76118 100644 --- a/layers/vulkan/generated/spirv_validation_helper.cpp +++ b/layers/vulkan/generated/spirv_validation_helper.cpp @@ -251,6 +251,7 @@ const std::unordered_multimap& GetSpirvCapabilites( {spv::CapabilityTileImageDepthReadAccessEXT, {0, &DeviceFeatures::shaderTileImageDepthReadAccess, nullptr, ""}}, {spv::CapabilityTileImageStencilReadAccessEXT, {0, &DeviceFeatures::shaderTileImageStencilReadAccess, nullptr, ""}}, {spv::CapabilityCooperativeMatrixKHR, {0, &DeviceFeatures::cooperativeMatrix, nullptr, ""}}, + {spv::CapabilityCooperativeMatrixConversionQCOM, {0, &DeviceFeatures::cooperativeMatrixConversion, nullptr, ""}}, #ifdef VK_ENABLE_BETA_EXTENSIONS {spv::CapabilityShaderEnqueueAMDX, {0, &DeviceFeatures::shaderEnqueue, nullptr, ""}}, #endif @@ -1213,6 +1214,7 @@ static inline const char* SpvCapabilityRequirements(uint32_t capability) { {spv::CapabilityTileImageDepthReadAccessEXT, "VkPhysicalDeviceShaderTileImageFeaturesEXT::shaderTileImageDepthReadAccess"}, {spv::CapabilityTileImageStencilReadAccessEXT, "VkPhysicalDeviceShaderTileImageFeaturesEXT::shaderTileImageStencilReadAccess"}, {spv::CapabilityCooperativeMatrixKHR, "VkPhysicalDeviceCooperativeMatrixFeaturesKHR::cooperativeMatrix"}, + {spv::CapabilityCooperativeMatrixConversionQCOM, "VkPhysicalDeviceCooperativeMatrixConversionFeaturesQCOM::cooperativeMatrixConversion"}, #ifdef VK_ENABLE_BETA_EXTENSIONS {spv::CapabilityShaderEnqueueAMDX, "VkPhysicalDeviceShaderEnqueueFeaturesAMDX::shaderEnqueue"}, #endif // VK_ENABLE_BETA_EXTENSIONS diff --git a/layers/vulkan/generated/stateless_validation_helper.cpp b/layers/vulkan/generated/stateless_validation_helper.cpp index 52b946faa23..c8b816735cc 100644 --- a/layers/vulkan/generated/stateless_validation_helper.cpp +++ b/layers/vulkan/generated/stateless_validation_helper.cpp @@ -1512,6 +1512,18 @@ bool Context::ValidatePnextFeatureStructContents(const Location& loc, const VkBa } } break; + // Validation code for VkPhysicalDeviceCooperativeMatrixConversionFeaturesQCOM structure members + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COOPERATIVE_MATRIX_CONVERSION_FEATURES_QCOM: { // Covers + // VUID-VkPhysicalDeviceCooperativeMatrixConversionFeaturesQCOM-sType-sType + if (is_const_param) { + [[maybe_unused]] const Location pNext_loc = + loc.pNext(Struct::VkPhysicalDeviceCooperativeMatrixConversionFeaturesQCOM); + VkPhysicalDeviceCooperativeMatrixConversionFeaturesQCOM* structure = + (VkPhysicalDeviceCooperativeMatrixConversionFeaturesQCOM*)header; + skip |= ValidateBool32(pNext_loc.dot(Field::cooperativeMatrixConversion), structure->cooperativeMatrixConversion); + } + } break; + // Validation code for VkPhysicalDeviceMeshShaderFeaturesNV structure members case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MESH_SHADER_FEATURES_NV: { // Covers // VUID-VkPhysicalDeviceMeshShaderFeaturesNV-sType-sType @@ -8539,7 +8551,7 @@ bool Instance::PreCallValidateCreateDevice(VkPhysicalDevice physicalDevice, cons "VUID-vkCreateDevice-pCreateInfo-parameter", "VUID-VkDeviceCreateInfo-sType-sType"); if (pCreateInfo != nullptr) { [[maybe_unused]] const Location pCreateInfo_loc = loc.dot(Field::pCreateInfo); - constexpr std::array allowed_structs_VkDeviceCreateInfo = { + constexpr std::array allowed_structs_VkDeviceCreateInfo = { VK_STRUCTURE_TYPE_DEVICE_DEVICE_MEMORY_REPORT_CREATE_INFO_EXT, VK_STRUCTURE_TYPE_DEVICE_DIAGNOSTICS_CONFIG_CREATE_INFO_NV, VK_STRUCTURE_TYPE_DEVICE_GROUP_DEVICE_CREATE_INFO, @@ -8571,6 +8583,7 @@ bool Instance::PreCallValidateCreateDevice(VkPhysicalDevice physicalDevice, cons VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COMPUTE_SHADER_DERIVATIVES_FEATURES_KHR, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_CONDITIONAL_RENDERING_FEATURES_EXT, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COOPERATIVE_MATRIX_2_FEATURES_NV, + VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COOPERATIVE_MATRIX_CONVERSION_FEATURES_QCOM, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COOPERATIVE_MATRIX_FEATURES_KHR, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COOPERATIVE_MATRIX_FEATURES_NV, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COOPERATIVE_VECTOR_FEATURES_NV, diff --git a/layers/vulkan/generated/test_icd_helper.h b/layers/vulkan/generated/test_icd_helper.h index aea70956d7a..854844006b4 100644 --- a/layers/vulkan/generated/test_icd_helper.h +++ b/layers/vulkan/generated/test_icd_helper.h @@ -316,6 +316,7 @@ static const std::unordered_map device_extension_map = { {VK_NV_REPRESENTATIVE_FRAGMENT_TEST_EXTENSION_NAME, VK_NV_REPRESENTATIVE_FRAGMENT_TEST_SPEC_VERSION}, {VK_EXT_FILTER_CUBIC_EXTENSION_NAME, VK_EXT_FILTER_CUBIC_SPEC_VERSION}, {VK_QCOM_RENDER_PASS_SHADER_RESOLVE_EXTENSION_NAME, VK_QCOM_RENDER_PASS_SHADER_RESOLVE_SPEC_VERSION}, + {VK_QCOM_COOPERATIVE_MATRIX_CONVERSION_EXTENSION_NAME, VK_QCOM_COOPERATIVE_MATRIX_CONVERSION_SPEC_VERSION}, {VK_EXT_GLOBAL_PRIORITY_EXTENSION_NAME, VK_EXT_GLOBAL_PRIORITY_SPEC_VERSION}, {VK_EXT_EXTERNAL_MEMORY_HOST_EXTENSION_NAME, VK_EXT_EXTERNAL_MEMORY_HOST_SPEC_VERSION}, {VK_AMD_BUFFER_MARKER_EXTENSION_NAME, VK_AMD_BUFFER_MARKER_SPEC_VERSION}, diff --git a/layers/vulkan/generated/vk_extension_helper.cpp b/layers/vulkan/generated/vk_extension_helper.cpp index 122ed940c60..93a7d81a169 100644 --- a/layers/vulkan/generated/vk_extension_helper.cpp +++ b/layers/vulkan/generated/vk_extension_helper.cpp @@ -247,6 +247,7 @@ vvl::Extension GetExtension(std::string extension) { {"VK_NV_representative_fragment_test", vvl::Extension::_VK_NV_representative_fragment_test}, {"VK_EXT_filter_cubic", vvl::Extension::_VK_EXT_filter_cubic}, {"VK_QCOM_render_pass_shader_resolve", vvl::Extension::_VK_QCOM_render_pass_shader_resolve}, + {"VK_QCOM_cooperative_matrix_conversion", vvl::Extension::_VK_QCOM_cooperative_matrix_conversion}, {"VK_EXT_global_priority", vvl::Extension::_VK_EXT_global_priority}, {"VK_EXT_external_memory_host", vvl::Extension::_VK_EXT_external_memory_host}, {"VK_AMD_buffer_marker", vvl::Extension::_VK_AMD_buffer_marker}, @@ -1428,6 +1429,9 @@ static const DeviceExtensionsInfoMap& GetDeviceInfoMap() { VK_KHR_GET_PHYSICAL_DEVICE_PROPERTIES_2_EXTENSION_NAME}}})}, {vvl::Extension::_VK_EXT_filter_cubic, Info(&DeviceExtensions::vk_ext_filter_cubic, {})}, {vvl::Extension::_VK_QCOM_render_pass_shader_resolve, Info(&DeviceExtensions::vk_qcom_render_pass_shader_resolve, {})}, + {vvl::Extension::_VK_QCOM_cooperative_matrix_conversion, + Info(&DeviceExtensions::vk_qcom_cooperative_matrix_conversion, + {{{&DeviceExtensions::vk_khr_cooperative_matrix, VK_KHR_COOPERATIVE_MATRIX_EXTENSION_NAME}}})}, {vvl::Extension::_VK_EXT_global_priority, Info(&DeviceExtensions::vk_ext_global_priority, {})}, {vvl::Extension::_VK_EXT_external_memory_host, Info(&DeviceExtensions::vk_ext_external_memory_host, diff --git a/layers/vulkan/generated/vk_extension_helper.h b/layers/vulkan/generated/vk_extension_helper.h index ded8bb30800..f649bf68038 100644 --- a/layers/vulkan/generated/vk_extension_helper.h +++ b/layers/vulkan/generated/vk_extension_helper.h @@ -347,6 +347,7 @@ struct DeviceExtensions : public InstanceExtensions { ExtEnabled vk_nv_representative_fragment_test{kNotSupported}; ExtEnabled vk_ext_filter_cubic{kNotSupported}; ExtEnabled vk_qcom_render_pass_shader_resolve{kNotSupported}; + ExtEnabled vk_qcom_cooperative_matrix_conversion{kNotSupported}; ExtEnabled vk_ext_global_priority{kNotSupported}; ExtEnabled vk_ext_external_memory_host{kNotSupported}; ExtEnabled vk_amd_buffer_marker{kNotSupported}; @@ -827,6 +828,7 @@ constexpr bool IsDeviceExtension(vvl::Extension extension) { case vvl::Extension::_VK_NV_representative_fragment_test: case vvl::Extension::_VK_EXT_filter_cubic: case vvl::Extension::_VK_QCOM_render_pass_shader_resolve: + case vvl::Extension::_VK_QCOM_cooperative_matrix_conversion: case vvl::Extension::_VK_EXT_global_priority: case vvl::Extension::_VK_EXT_external_memory_host: case vvl::Extension::_VK_AMD_buffer_marker: diff --git a/layers/vulkan/generated/vk_validation_error_messages.h b/layers/vulkan/generated/vk_validation_error_messages.h index bd7a1293c9a..b9629d57d92 100644 --- a/layers/vulkan/generated/vk_validation_error_messages.h +++ b/layers/vulkan/generated/vk_validation_error_messages.h @@ -1,6 +1,6 @@ // *** THIS FILE IS GENERATED - DO NOT EDIT *** // See generate_spec_error_message.py for modifications -// Based on Vulkan specification version: 1.4.341 +// Based on Vulkan specification version: 1.4.342 /*************************************************************************** * @@ -34,7 +34,7 @@ struct vuid_info { }; const vvl::unordered_map &GetVuidMap() { - static const std::array, 23482> vuid_array = {{ + static const std::array, 23481> vuid_array = {{ { {"VUID-BaryCoordKHR-BaryCoordKHR-04154", 36}, { {"The BaryCoordKHR decoration must be used only within the Fragment Execution Model", 81}, { "chapters/interfaces.html", 24} } }, { {"VUID-BaryCoordKHR-BaryCoordKHR-04155", 36}, { {"The variable decorated with BaryCoordKHR must be declared using the Input Storage Class", 87}, { "chapters/interfaces.html", 24} } }, { {"VUID-BaryCoordKHR-BaryCoordKHR-04156", 36}, { {"The variable decorated with BaryCoordKHR must be declared as a three-component vector of 32-bit floating-point values", 117}, { "chapters/interfaces.html", 24} } }, @@ -349,6 +349,7 @@ const vvl::unordered_map &GetVuidMap() { { {"VUID-RuntimeSpirv-Image-11380", 29}, { {"If the Image operand of OpImageTexelPointer or OpUntypedImageTexelPointerEXT is derived from a variable decorated with ResourceHeapEXT, the Image Format and Sampled Type of the OpTypeImage pointed to must correspond to a descriptor with a VkFormat that matches as described by Compatibility Between SPIR-V Image Formats and Vulkan Formats and Image Format and Type Matching", 373}, { "appendices/spirvenv.html", 24} } }, { {"VUID-RuntimeSpirv-Image-11382", 29}, { {"If the Image operand of OpImageTexelPointer or OpUntypedImageTexelPointerEXT is derived from a variable decorated with ResourceHeapEXT, the operands of that OpTypeImage must correspond to a descriptor with operands that match as described by Heap Image Operand Correspondence and Heap Image View Type Dimensionality", 315}, { "appendices/spirvenv.html", 24} } }, { {"VUID-RuntimeSpirv-InputAttachmentArrayNonUniformIndexing-10138", 62}, { {"If the InputAttachmentArrayNonUniformIndexing capability is not declared, and an instruction accesses memory through an input attachment, the input attachment through which that memory is accessed must be dynamically uniform within the invocation group or subgroup", 264}, { "appendices/spirvenv.html", 24} } }, + { {"VUID-RuntimeSpirv-KSize-12353", 29}, { {"For OpExtractSubArrayQCOM, the length of the Result Type operand must match the VkCooperativeMatrixPropertiesKHR::KSize of one of the matrices in any of the supported VkCooperativeMatrixPropertiesKHR", 199}, { "appendices/spirvenv.html", 24} } }, { {"VUID-RuntimeSpirv-LocalSizeId-06434", 35}, { {"If Execution Mode LocalSizeId is used, maintenance4 must be enabled", 67}, { "appendices/spirvenv.html", 24} } }, { {"VUID-RuntimeSpirv-Location-06272", 32}, { {"The sum of Location and the number of locations the variable it decorates consumes must be less than or equal to the value for the matching Execution Model defined in Shader Input and Output Locations", 200}, { "appendices/spirvenv.html", 24} } }, { {"VUID-RuntimeSpirv-Location-06428", 32}, { {"The maximum number of storage buffers, storage images, and output Location decorated color attachments written to in the Fragment Execution Model must be less than or equal to maxFragmentCombinedOutputResources", 210}, { "appendices/spirvenv.html", 24} } }, @@ -367,6 +368,7 @@ const vvl::unordered_map &GetVuidMap() { { {"VUID-RuntimeSpirv-MeshEXT-12333", 31}, { {"For mesh shaders using the MeshEXT Execution Model the index into the array of any variable decorated with the PerPrimitiveEXT decoration must be less than the \"Primitive Count\" operand of OpSetMeshOutputsEXT", 210}, { "appendices/spirvenv.html", 24} } }, { {"VUID-RuntimeSpirv-MeshNV-07113", 30}, { {"For mesh shaders using the MeshNV Execution Model the OutputVertices OpExecutionMode must be less than or equal to VkPhysicalDeviceMeshShaderPropertiesNV::maxMeshOutputVertices", 176}, { "appendices/spirvenv.html", 24} } }, { {"VUID-RuntimeSpirv-MeshNV-07114", 30}, { {"For mesh shaders using the MeshNV Execution Model the OutputPrimitivesNV OpExecutionMode must be less than or equal to VkPhysicalDeviceMeshShaderPropertiesNV::maxMeshOutputPrimitives", 182}, { "appendices/spirvenv.html", 24} } }, + { {"VUID-RuntimeSpirv-NSize-12352", 29}, { {"For OpExtractSubArrayQCOM, the length of the Source Array operand must match the VkCooperativeMatrixPropertiesKHR::NSize of one of the matrices in any of the supported VkCooperativeMatrixPropertiesKHR", 200}, { "appendices/spirvenv.html", 24} } }, { {"VUID-RuntimeSpirv-NodePayloadAMDX-09192", 39}, { {"Variables in the NodePayloadAMDX storage class must only be declared in the GLCompute or MeshEXT execution model", 112}, { "appendices/spirvenv.html", 24} } }, { {"VUID-RuntimeSpirv-NonWritable-06340", 35}, { {"If the fragmentStoresAndAtomics feature is not enabled, then all storage image, storage texel buffer, and storage buffer variables in the fragment stage must be decorated with the NonWritable decoration", 202}, { "appendices/spirvenv.html", 24} } }, { {"VUID-RuntimeSpirv-NonWritable-06341", 35}, { {"If the vertexPipelineStoresAndAtomics feature is not enabled, then all storage image, storage texel buffer, and storage buffer variables in the vertex, tessellation, and geometry stages must be decorated with the NonWritable decoration", 235}, { "appendices/spirvenv.html", 24} } }, @@ -417,6 +419,7 @@ const vvl::unordered_map &GetVuidMap() { { {"VUID-RuntimeSpirv-OpEntryPoint-07754", 36}, { {"Any user-defined variables between the OpEntryPoint of two shader stages must have the same type and width for each Component", 125}, { "appendices/spirvenv.html", 24} } }, { {"VUID-RuntimeSpirv-OpEntryPoint-08727", 36}, { {"Each OpEntryPoint must not have more than one variable decorated with InputAttachmentIndex per image aspect of the attachment image bound to it, either explicitly or implicitly as described by input attachment interface", 219}, { "appendices/spirvenv.html", 24} } }, { {"VUID-RuntimeSpirv-OpEntryPoint-08743", 36}, { {"Any user-defined variables shared between the OpEntryPoint of two shader stages, and declared with Input as its Storage Class for the subsequent shader stage, must have all Location slots and Component words declared in the preceding shader stage's OpEntryPoint with Output as the Storage Class", 294}, { "appendices/spirvenv.html", 24} } }, + { {"VUID-RuntimeSpirv-OpExtractSubArrayQCOM-12354", 45}, { {"For OpExtractSubArrayQCOM, the Start Index operand must be a multiple of the length of the Result Type operand", 110}, { "appendices/spirvenv.html", 24} } }, { {"VUID-RuntimeSpirv-OpHitObjectTraceRayEXT-11878", 46}, { {"For OpHitObjectTraceRayEXT, OpHitObjectTraceRayMotionEXT, OpHitObjectTraceMotionReorderExecuteEXT and OpHitObjectTraceReorderExecuteEXT instructions, all components of the RayOrigin and RayDirection operands must be finite floating-point values", 244}, { "appendices/spirvenv.html", 24} } }, { {"VUID-RuntimeSpirv-OpHitObjectTraceRayEXT-11879", 46}, { {"For OpHitObjectTraceRayEXT, OpHitObjectTraceRayMotionEXT, OpHitObjectTraceMotionReorderExecuteEXT and OpHitObjectTraceReorderExecuteEXT instructions, the RayTmin and RayTmax operands must be non-negative floating-point values", 225}, { "appendices/spirvenv.html", 24} } }, { {"VUID-RuntimeSpirv-OpHitObjectTraceRayEXT-11880", 46}, { {"For OpHitObjectTraceRayEXT, OpHitObjectTraceRayMotionEXT, OpHitObjectTraceMotionReorderExecuteEXT and OpHitObjectTraceReorderExecuteEXT instructions, the RayTmin operand must be less than or equal to the RayTmax operand", 219}, { "appendices/spirvenv.html", 24} } }, @@ -800,12 +803,12 @@ const vvl::unordered_map &GetVuidMap() { { {"VUID-StandaloneSpirv-Offset-04689", 33}, { {"The size of any output block containing any member decorated with Offset that is a 64-bit type must be a multiple of 8", 118}, { "appendices/spirvenv.html", 24} } }, { {"VUID-StandaloneSpirv-Offset-04690", 33}, { {"The first member of an output block specifying a Offset decoration must specify a Offset value that is aligned to an 8 byte boundary if that block contains any member decorated with Offset and is a 64-bit type", 209}, { "appendices/spirvenv.html", 24} } }, { {"VUID-StandaloneSpirv-Offset-04691", 33}, { {"Output variables or block members decorated with Offset that have a 32-bit type, or a composite type contains a 32-bit type, must specify an Offset value aligned to a 4 byte boundary", 182}, { "appendices/spirvenv.html", 24} } }, - { {"VUID-StandaloneSpirv-Offset-04692", 33}, { {"Output variables, blocks or block members decorated with Offset must only contain base types that have components that are either 32-bit or 64-bit in size", 154}, { "appendices/spirvenv.html", 24} } }, + { {"VUID-StandaloneSpirv-Offset-04692", 33}, { {"Output variables, blocks, or block members decorated with Offset must only contain base types that have components that are either 32-bit or 64-bit in size", 155}, { "appendices/spirvenv.html", 24} } }, { {"VUID-StandaloneSpirv-Offset-04716", 33}, { {"Only variables or block members in the output interface decorated with Offset can be captured for transform feedback, and those variables or block members must also be decorated with XfbBuffer and XfbStride, or inherit XfbBuffer and XfbStride decorations from a block containing them", 283}, { "appendices/spirvenv.html", 24} } }, { {"VUID-StandaloneSpirv-Offset-04865", 33}, { {"Any image instruction which uses an Offset, ConstOffset, or ConstOffsets image operand, must only consume a \"Sampled Image\" operand whose type has its \"Sampled\" operand set to 1", 181}, { "appendices/spirvenv.html", 24} } }, { {"VUID-StandaloneSpirv-OpArrayLength-11805", 40}, { {"OpArrayLength and OpUntypedArrayLengthKHR must not be used with an OpTypeRuntimeArray that is the last member of a Block-decorated OpTypeStruct in the Uniform storage Storage Class", 180}, { "appendices/spirvenv.html", 24} } }, { {"VUID-StandaloneSpirv-OpControlBarrier-04682", 43}, { {"If OpControlBarrier is used in ray generation, intersection, any-hit, closest hit, miss, fragment, vertex, tessellation evaluation, or geometry shaders, the execution Scope must be Subgroup", 189}, { "appendices/spirvenv.html", 24} } }, - { {"VUID-StandaloneSpirv-OpEntryPoint-06674", 39}, { {"Each OpEntryPoint must not statically use more than one variable in the PushConstant Storage Class", 98}, { "appendices/spirvenv.html", 24} } }, + { {"VUID-StandaloneSpirv-OpEntryPoint-06674", 39}, { {"Each OpEntryPoint must statically use at most one variable in the PushConstant Storage Class unless the PushConstantBanksNV capability is declared", 146}, { "appendices/spirvenv.html", 24} } }, { {"VUID-StandaloneSpirv-OpEntryPoint-08721", 39}, { {"Each OpEntryPoint must not have more than one Input variable assigned the same Component word inside a Location slot, either explicitly or implicitly", 149}, { "appendices/spirvenv.html", 24} } }, { {"VUID-StandaloneSpirv-OpEntryPoint-08722", 39}, { {"Each OpEntryPoint must not have more than one Output variable assigned the same Component word inside a Location slot, either explicitly or implicitly", 150}, { "appendices/spirvenv.html", 24} } }, { {"VUID-StandaloneSpirv-OpEntryPoint-09658", 39}, { {"For a given OpEntryPoint, any BuiltIn decoration must not be used more than once by the Input interface", 103}, { "appendices/spirvenv.html", 24} } }, @@ -836,7 +839,7 @@ const vvl::unordered_map &GetVuidMap() { { {"VUID-StandaloneSpirv-OpUntypedVariableKHR-11347", 47}, { {"Any OpUntypedVariableKHR in the UniformConstant storage class without a Data Type must be decorated with SamplerHeapEXT or ResourceHeapEXT", 138}, { "appendices/spirvenv.html", 24} } }, { {"VUID-StandaloneSpirv-OpVariable-04651", 37}, { {"Any variable with an Initializer operand must have Output, Private, Function, or Workgroup as its Storage Class operand", 119}, { "appendices/spirvenv.html", 24} } }, { {"VUID-StandaloneSpirv-OpVariable-04734", 37}, { {"Any variable with an Initializer operand and Workgroup as its Storage Class operand must use OpConstantNull as the initializer", 126}, { "appendices/spirvenv.html", 24} } }, - { {"VUID-StandaloneSpirv-OpVariable-06673", 37}, { {"There must not be more than one variable in the PushConstant Storage Class listed in the Interface for each OpEntryPoint", 120}, { "appendices/spirvenv.html", 24} } }, + { {"VUID-StandaloneSpirv-OpVariable-06673", 37}, { {"There must be at most one variable in the PushConstant Storage Class listed in the Interface for each OpEntryPoint unless the PushConstantBanksNV capability is declared", 168}, { "appendices/spirvenv.html", 24} } }, { {"VUID-StandaloneSpirv-OriginLowerLeft-04653", 42}, { {"The OriginLowerLeft Execution Mode must not be used; fragment entry points must declare OriginUpperLeft", 103}, { "appendices/spirvenv.html", 24} } }, { {"VUID-StandaloneSpirv-Output-10586", 33}, { {"Variables in the Output storage class in the Vertex, TessellationControl, TessellationEvaluation, or Geometry execution model must not have overlapping Component and Location decorations as defined by Location and Component Assignment", 234}, { "appendices/spirvenv.html", 24} } }, { {"VUID-StandaloneSpirv-Output-10587", 33}, { {"Variables in the Output storage class in the Fragment execution model must not have both identical Index decorations and overlapping Component and Location decorations as defined by Location and Component Assignment", 215}, { "appendices/spirvenv.html", 24} } }, @@ -1633,6 +1636,8 @@ const vvl::unordered_map &GetVuidMap() { { {"VUID-VkBufferCreateInfo-flags-08099", 35}, { {"If flags includes VK_BUFFER_CREATE_DESCRIPTOR_BUFFER_CAPTURE_REPLAY_BIT_EXT, the descriptorBufferCaptureReplay feature must be enabled", 134}, { "chapters/resources.html", 23} } }, { {"VUID-VkBufferCreateInfo-flags-08325", 35}, { {"If flags includes VK_BUFFER_CREATE_VIDEO_PROFILE_INDEPENDENT_BIT_KHR, then videoMaintenance1 must be enabled", 108}, { "chapters/resources.html", 23} } }, { {"VUID-VkBufferCreateInfo-flags-09641", 35}, { {"If flags includes VK_BUFFER_CREATE_PROTECTED_BIT, then the effective usage must not contain bits other than VK_BUFFER_USAGE_TRANSFER_SRC_BIT VK_BUFFER_USAGE_TRANSFER_DST_BIT VK_BUFFER_USAGE_UNIFORM_TEXEL_BUFFER_BIT VK_BUFFER_USAGE_STORAGE_TEXEL_BUFFER_BIT VK_BUFFER_USAGE_UNIFORM_BUFFER_BIT VK_BUFFER_USAGE_STORAGE_BUFFER_BIT VK_BUFFER_USAGE_SHADER_DEVICE_ADDRESS_BIT VK_BUFFER_USAGE_2_VIDEO_DECODE_SRC_BIT_KHR VK_BUFFER_USAGE_2_VIDEO_ENCODE_DST_BIT_KHR VK_BUFFER_USAGE_2_DESCRIPTOR_HEAP_BIT_EXT", 495}, { "chapters/resources.html", 23} } }, + { {"VUID-VkBufferCreateInfo-flags-11277", 35}, { {"If the protectedDescriptorHeaps property is not supported and the effective usage includes the VK_BUFFER_USAGE_2_DESCRIPTOR_HEAP_BIT_EXT flag, flags must not include the VK_BUFFER_CREATE_PROTECTED_BIT flag", 205}, { "chapters/resources.html", 23} } }, + { {"VUID-VkBufferCreateInfo-flags-11279", 35}, { {"If the sparseDescriptorHeaps property is not supported and the effective usage includes the VK_BUFFER_USAGE_2_DESCRIPTOR_HEAP_BIT_EXT flag, flags must not include any of the VK_BUFFER_CREATE_SPARSE_BINDING_BIT, VK_BUFFER_CREATE_SPARSE_RESIDENCY_BIT, or VK_BUFFER_CREATE_SPARSE_ALIASED_BIT flags", 294}, { "chapters/resources.html", 23} } }, { {"VUID-VkBufferCreateInfo-flags-parameter", 39}, { {"flags must be a valid combination of VkBufferCreateFlagBits values", 66}, { "chapters/resources.html", 23} } }, { {"VUID-VkBufferCreateInfo-opaqueCaptureAddress-03337", 50}, { {"If VkBufferOpaqueCaptureAddressCreateInfo::opaqueCaptureAddress is not zero, flags must include VK_BUFFER_CREATE_DEVICE_ADDRESS_CAPTURE_REPLAY_BIT", 146}, { "chapters/resources.html", 23} } }, { {"VUID-VkBufferCreateInfo-pNext-00920", 35}, { {"If the pNext chain includes a VkExternalMemoryBufferCreateInfo structure, its handleTypes member must only contain bits that are also in VkExternalBufferProperties::externalMemoryProperties.compatibleHandleTypes, as returned by vkGetPhysicalDeviceExternalBufferProperties with pExternalBufferInfo->handleType equal to any one of the handle types specified in VkExternalMemoryBufferCreateInfo::handleTypes", 404}, { "chapters/resources.html", 23} } }, @@ -1849,8 +1854,8 @@ const vvl::unordered_map &GetVuidMap() { { {"VUID-VkBufferViewCreateInfo-None-12278", 38}, { {"If Vulkan 1.3 is not supported and the ycbcr2plane444Formats feature is not enabled, format must not be VK_FORMAT_G8_B8R8_2PLANE_444_UNORM, VK_FORMAT_G10X6_B10X6R10X6_2PLANE_444_UNORM_3PACK16, VK_FORMAT_G12X4_B12X4R12X4_2PLANE_444_UNORM_3PACK16, or VK_FORMAT_G16_B16R16_2PLANE_444_UNORM", 286}, { "chapters/resources.html", 23} } }, { {"VUID-VkBufferViewCreateInfo-buffer-00932", 40}, { {"buffer must have been created with at least one of the VK_BUFFER_USAGE_UNIFORM_TEXEL_BUFFER_BIT or VK_BUFFER_USAGE_STORAGE_TEXEL_BUFFER_BIT usage flags set", 155}, { "chapters/resources.html", 23} } }, { {"VUID-VkBufferViewCreateInfo-buffer-00935", 40}, { {"If buffer is non-sparse then it must be bound completely and contiguously to a single VkDeviceMemory object", 107}, { "chapters/resources.html", 23} } }, - { {"VUID-VkBufferViewCreateInfo-buffer-02750", 40}, { {"If the texelBufferAlignment feature is enabled and if buffer was created with the VK_BUFFER_USAGE_STORAGE_TEXEL_BUFFER_BIT usage flag set, offset must be a multiple of the lesser of VkPhysicalDeviceTexelBufferAlignmentProperties::storageTexelBufferOffsetAlignmentBytes or, if VkPhysicalDeviceTexelBufferAlignmentProperties::storageTexelBufferOffsetSingleTexelAlignment is VK_TRUE, the size of a texel of the requested format. If the size of a texel is a multiple of three bytes, then the size of a single component of format is used instead", 540}, { "chapters/resources.html", 23} } }, - { {"VUID-VkBufferViewCreateInfo-buffer-02751", 40}, { {"If the texelBufferAlignment feature is enabled and if buffer was created with the VK_BUFFER_USAGE_UNIFORM_TEXEL_BUFFER_BIT usage flag set, offset must be a multiple of the lesser of VkPhysicalDeviceTexelBufferAlignmentProperties::uniformTexelBufferOffsetAlignmentBytes or, if VkPhysicalDeviceTexelBufferAlignmentProperties::uniformTexelBufferOffsetSingleTexelAlignment is VK_TRUE, the size of a texel of the requested format. If the size of a texel is a multiple of three bytes, then the size of a single component of format is used instead", 540}, { "chapters/resources.html", 23} } }, + { {"VUID-VkBufferViewCreateInfo-buffer-02750", 40}, { {"If buffer was created with the VK_BUFFER_USAGE_STORAGE_TEXEL_BUFFER_BIT usage flag set, offset must be a multiple of the effective alignment requirement of format for VK_DESCRIPTOR_TYPE_STORAGE_TEXEL_BUFFER as defined by minTexelBufferOffsetAlignment", 250}, { "chapters/resources.html", 23} } }, + { {"VUID-VkBufferViewCreateInfo-buffer-02751", 40}, { {"If buffer was created with the VK_BUFFER_USAGE_UNIFORM_TEXEL_BUFFER_BIT usage flag set, offset must be a multiple of the effective alignment requirement of format for VK_DESCRIPTOR_TYPE_UNIFORM_TEXEL_BUFFER as defined by minTexelBufferOffsetAlignment", 250}, { "chapters/resources.html", 23} } }, { {"VUID-VkBufferViewCreateInfo-buffer-parameter", 44}, { {"buffer must be a valid VkBuffer handle", 38}, { "chapters/resources.html", 23} } }, { {"VUID-VkBufferViewCreateInfo-flags-zerobitmask", 45}, { {"flags must be 0", 15}, { "chapters/resources.html", 23} } }, { {"VUID-VkBufferViewCreateInfo-format-08778", 40}, { {"If the buffer view usage contains VK_BUFFER_USAGE_UNIFORM_TEXEL_BUFFER_BIT, then format features of format must contain VK_FORMAT_FEATURE_UNIFORM_TEXEL_BUFFER_BIT", 162}, { "chapters/resources.html", 23} } }, @@ -1858,7 +1863,6 @@ const vvl::unordered_map &GetVuidMap() { { {"VUID-VkBufferViewCreateInfo-format-parameter", 44}, { {"format must be a valid VkFormat value", 37}, { "chapters/resources.html", 23} } }, { {"VUID-VkBufferViewCreateInfo-offset-00925", 40}, { {"offset must be less than the size of buffer", 43}, { "chapters/resources.html", 23} } }, { {"VUID-VkBufferViewCreateInfo-offset-00931", 40}, { {"If range is not equal to VK_WHOLE_SIZE, the sum of offset and range must be less than or equal to the size of buffer", 116}, { "chapters/resources.html", 23} } }, - { {"VUID-VkBufferViewCreateInfo-offset-02749", 40}, { {"If the texelBufferAlignment feature is not enabled, offset must be a multiple of VkPhysicalDeviceLimits::minTexelBufferOffsetAlignment", 134}, { "chapters/resources.html", 23} } }, { {"VUID-VkBufferViewCreateInfo-pNext-06782", 39}, { {"If the pNext chain includes a VkExportMetalObjectCreateInfoEXT structure, its exportObjectType member must be VK_EXPORT_METAL_OBJECT_TYPE_METAL_TEXTURE_BIT_EXT", 159}, { "chapters/resources.html", 23} } }, { {"VUID-VkBufferViewCreateInfo-pNext-08780", 39}, { {"If the pNext chain includes a VkBufferUsageFlags2CreateInfo, its usage must not contain any other bit than VK_BUFFER_USAGE_2_UNIFORM_TEXEL_BUFFER_BIT or VK_BUFFER_USAGE_2_STORAGE_TEXEL_BUFFER_BIT", 195}, { "chapters/resources.html", 23} } }, { {"VUID-VkBufferViewCreateInfo-pNext-08781", 39}, { {"If the pNext chain includes a VkBufferUsageFlags2CreateInfo, its usage must be a subset of the VkBufferCreateInfo::usage specified or VkBufferUsageFlags2CreateInfo::usage from VkBufferCreateInfo::pNext when creating buffer", 222}, { "chapters/resources.html", 23} } }, @@ -3077,10 +3081,8 @@ const vvl::unordered_map &GetVuidMap() { { {"VUID-VkDescriptorGetInfoEXT-type-12223", 38}, { {"If type is VK_DESCRIPTOR_TYPE_STORAGE_TEXEL_BUFFER, pStorageTexelBuffer is not NULL and pStorageTexelBuffer->address is not zero, pStorageTexelBuffer->address must be a device address allocated to the application from a buffer created with the VK_BUFFER_USAGE_STORAGE_TEXEL_BUFFER_BIT usage flag set", 299}, { "chapters/descriptorsets.html", 28} } }, { {"VUID-VkDescriptorGetInfoEXT-type-12265", 38}, { {"If type is VK_DESCRIPTOR_TYPE_UNIFORM_BUFFER and pUniformBuffer is not NULL, pUniformBuffer->address must be aligned to VkPhysicalDeviceLimits::minUniformBufferOffsetAlignment", 175}, { "chapters/descriptorsets.html", 28} } }, { {"VUID-VkDescriptorGetInfoEXT-type-12266", 38}, { {"If type is VK_DESCRIPTOR_TYPE_STORAGE_BUFFER and pStorageBuffer is not NULL, pStorageBuffer->address must be aligned to VkPhysicalDeviceLimits::minStorageBufferOffsetAlignment", 175}, { "chapters/descriptorsets.html", 28} } }, - { {"VUID-VkDescriptorGetInfoEXT-type-12267", 38}, { {"If type is VK_DESCRIPTOR_TYPE_UNIFORM_TEXEL_BUFFER, the texelBufferAlignment feature is not enabled, and pUniformTexelBuffer is not NULL, pUniformTexelBuffer->address must be aligned to VkPhysicalDeviceLimits::minTexelBufferOffsetAlignment", 239}, { "chapters/descriptorsets.html", 28} } }, - { {"VUID-VkDescriptorGetInfoEXT-type-12268", 38}, { {"If type is VK_DESCRIPTOR_TYPE_STORAGE_TEXEL_BUFFER, the texelBufferAlignment feature is not enabled, and pStorageTexelBuffer is not NULL, pStorageTexelBuffer->address must be aligned to VkPhysicalDeviceLimits::minTexelBufferOffsetAlignment", 239}, { "chapters/descriptorsets.html", 28} } }, - { {"VUID-VkDescriptorGetInfoEXT-type-12269", 38}, { {"If type is VK_DESCRIPTOR_TYPE_UNIFORM_TEXEL_BUFFER, the texelBufferAlignment feature is enabled, and pUniformTexelBuffer is not NULL, pUniformTexelBuffer->address must be a multiple of the lesser of VkPhysicalDeviceTexelBufferAlignmentProperties::uniformTexelBufferOffsetAlignmentBytes or, if VkPhysicalDeviceTexelBufferAlignmentProperties::uniformTexelBufferOffsetSingleTexelAlignment is VK_TRUE, the size of a texel of the requested pUniformTexelBuffer->format. If the size of a texel is a multiple of three bytes, then the size of a single component of format is used instead", 578}, { "chapters/descriptorsets.html", 28} } }, - { {"VUID-VkDescriptorGetInfoEXT-type-12270", 38}, { {"If type is VK_DESCRIPTOR_TYPE_STORAGE_TEXEL_BUFFER, the texelBufferAlignment feature is enabled, and pStorageTexelBuffer is not NULL, pStorageTexelBuffer->address must be a multiple of the lesser of VkPhysicalDeviceTexelBufferAlignmentProperties::storageTexelBufferOffsetAlignmentBytes or, if VkPhysicalDeviceTexelBufferAlignmentProperties::storageTexelBufferOffsetSingleTexelAlignment is VK_TRUE, the size of a texel of the requested pStorageTexelBuffer->format. If the size of a texel is a multiple of three bytes, then the size of a single component of format is used instead", 578}, { "chapters/descriptorsets.html", 28} } }, + { {"VUID-VkDescriptorGetInfoEXT-type-12269", 38}, { {"If type is VK_DESCRIPTOR_TYPE_UNIFORM_TEXEL_BUFFER, and pUniformTexelBuffer is not NULL, pUniformTexelBuffer->address must be a multiple of the effective alignment requirement as determined by minTexelBufferOffsetAlignment", 222}, { "chapters/descriptorsets.html", 28} } }, + { {"VUID-VkDescriptorGetInfoEXT-type-12270", 38}, { {"If type is VK_DESCRIPTOR_TYPE_STORAGE_TEXEL_BUFFER, the and pStorageTexelBuffer is not NULL, pStorageTexelBuffer->address must be a multiple of the effective alignment requirement as determined by minTexelBufferOffsetAlignment", 226}, { "chapters/descriptorsets.html", 28} } }, { {"VUID-VkDescriptorGetInfoEXT-type-parameter", 42}, { {"type must be a valid VkDescriptorType value", 43}, { "chapters/descriptorsets.html", 28} } }, { {"VUID-VkDescriptorGetTensorInfoARM-nullDescriptor-09899", 54}, { {"If the nullDescriptor feature is not enabled, tensorView must not be VK_NULL_HANDLE", 83}, { "chapters/descriptorsets.html", 28} } }, { {"VUID-VkDescriptorGetTensorInfoARM-sType-sType", 45}, { {"sType must be VK_STRUCTURE_TYPE_DESCRIPTOR_GET_TENSOR_INFO_ARM", 62}, { "chapters/descriptorsets.html", 28} } }, @@ -3320,7 +3322,7 @@ const vvl::unordered_map &GetVuidMap() { { {"VUID-VkDeviceCreateInfo-ppEnabledExtensionNames-10858", 53}, { {"If ppEnabledExtensionNames contains \"VK_KHR_push_descriptor\" and the pNext chain includes a VkPhysicalDeviceVulkan14Features structure, then VkPhysicalDeviceVulkan14Features::pushDescriptor must be VK_TRUE", 207}, { "chapters/devsandqueues.html", 27} } }, { {"VUID-VkDeviceCreateInfo-ppEnabledExtensionNames-parameter", 57}, { {"If enabledExtensionCount is not 0, ppEnabledExtensionNames must be a valid pointer to an array of enabledExtensionCount null-terminated UTF-8 strings", 149}, { "chapters/devsandqueues.html", 27} } }, { {"VUID-VkDeviceCreateInfo-ppEnabledLayerNames-parameter", 53}, { {"If enabledLayerCount is not 0, ppEnabledLayerNames must be a valid pointer to an array of enabledLayerCount null-terminated UTF-8 strings", 137}, { "chapters/devsandqueues.html", 27} } }, - { {"VUID-VkDeviceCreateInfo-queueFamilyIndex-02802", 46}, { {"The queueFamilyIndex member of each element of pQueueCreateInfos must be unique within pQueueCreateInfos , except that two members can share the same queueFamilyIndex if one describes protected-capable queues and one describes queues that are not protected-capable", 264}, { "chapters/devsandqueues.html", 27} } }, + { {"VUID-VkDeviceCreateInfo-queueFamilyIndex-02802", 46}, { {"The combination of the values in the queueFamilyIndex and flags members of each element of pQueueCreateInfos must be unique within pQueueCreateInfos", 148}, { "chapters/devsandqueues.html", 27} } }, { {"VUID-VkDeviceCreateInfo-queueFamilyIndex-11831", 46}, { {"If any element of pQueueCreateInfos specifies a queueFamilyIndex that supports VK_QUEUE_DATA_GRAPH_BIT_ARM and that queueFamilyIndex enumerates an engine through vkGetPhysicalDeviceQueueFamilyDataGraphPropertiesARM with type VK_PHYSICAL_DEVICE_DATA_GRAPH_PROCESSING_ENGINE_TYPE_NEURAL_QCOM or VK_PHYSICAL_DEVICE_DATA_GRAPH_PROCESSING_ENGINE_TYPE_COMPUTE_QCOM, a VkPhysicalDeviceDataGraphModelFeaturesQCOM structure must be included in pNext with dataGraphModel set to VK_TRUE", 475}, { "chapters/devsandqueues.html", 27} } }, { {"VUID-VkDeviceCreateInfo-robustBufferAccess-10247", 48}, { {"If the robustBufferAccess feature is enabled, and robustBufferAccessUpdateAfterBind is VK_FALSE, then descriptorBindingUniformBufferUpdateAfterBind, descriptorBindingStorageBufferUpdateAfterBind, descriptorBindingUniformTexelBufferUpdateAfterBind, and descriptorBindingStorageTexelBufferUpdateAfterBind must not be enabled", 322}, { "chapters/devsandqueues.html", 27} } }, { {"VUID-VkDeviceCreateInfo-sType-sType", 35}, { {"sType must be VK_STRUCTURE_TYPE_DEVICE_CREATE_INFO", 50}, { "chapters/devsandqueues.html", 27} } }, @@ -3765,8 +3767,8 @@ const vvl::unordered_map &GetVuidMap() { { {"VUID-VkFramebufferCreateInfo-flags-04538", 40}, { {"If flags does not include VK_FRAMEBUFFER_CREATE_IMAGELESS_BIT, and renderPass was not specified with non-zero view masks, each element of pAttachments that is used as a fragment shading rate attachment by renderPass must have a layerCount that is either 1, or greater than layers", 279}, { "chapters/renderpass.html", 24} } }, { {"VUID-VkFramebufferCreateInfo-flags-04539", 40}, { {"If the maintenance7 feature is not enabled or the robustFragmentShadingRateAttachmentAccess limit is VK_FALSE or the imageView member of a VkRenderingFragmentShadingRateAttachmentInfoKHR structure was created with VkImageSubresourceRange::baseMipLevel greater than 0, flags does not include VK_FRAMEBUFFER_CREATE_IMAGELESS_BIT, an element of pAttachments that is used as a fragment shading rate attachment must have a width at least as large as ceil(width / texelWidth), where texelWidth is the largest value of shadingRateAttachmentTexelSize.width in a VkFragmentShadingRateAttachmentInfoKHR which references that attachment", 625}, { "chapters/renderpass.html", 24} } }, { {"VUID-VkFramebufferCreateInfo-flags-04540", 40}, { {"If the maintenance7 feature is not enabled or the robustFragmentShadingRateAttachmentAccess limit is VK_FALSE or the imageView member of a VkRenderingFragmentShadingRateAttachmentInfoKHR structure was created with VkImageSubresourceRange::baseMipLevel greater than 0, flags does not include VK_FRAMEBUFFER_CREATE_IMAGELESS_BIT, an element of pAttachments that is used as a fragment shading rate attachment must have a height at least as large as ceil(height / texelHeight), where texelHeight is the largest value of shadingRateAttachmentTexelSize.height in a VkFragmentShadingRateAttachmentInfoKHR which references that attachment", 630}, { "chapters/renderpass.html", 24} } }, - { {"VUID-VkFramebufferCreateInfo-flags-04541", 40}, { {"If flags includes VK_FRAMEBUFFER_CREATE_IMAGELESS_BIT, the width member of any element of the pAttachmentImageInfos member of a VkFramebufferAttachmentsCreateInfo structure in the pNext chain that is used as an input, color, resolve or depth/stencil attachment in renderPass must be greater than or equal to width", 313}, { "chapters/renderpass.html", 24} } }, - { {"VUID-VkFramebufferCreateInfo-flags-04542", 40}, { {"If flags includes VK_FRAMEBUFFER_CREATE_IMAGELESS_BIT, the height member of any element of the pAttachmentImageInfos member of a VkFramebufferAttachmentsCreateInfo structure in the pNext chain that is used as an input, color, resolve or depth/stencil attachment in renderPass must be greater than or equal to height", 315}, { "chapters/renderpass.html", 24} } }, + { {"VUID-VkFramebufferCreateInfo-flags-04541", 40}, { {"If flags includes VK_FRAMEBUFFER_CREATE_IMAGELESS_BIT, the width member of any element of the pAttachmentImageInfos member of a VkFramebufferAttachmentsCreateInfo structure in the pNext chain that is used as an input, color, resolve, or depth/stencil attachment in renderPass must be greater than or equal to width", 314}, { "chapters/renderpass.html", 24} } }, + { {"VUID-VkFramebufferCreateInfo-flags-04542", 40}, { {"If flags includes VK_FRAMEBUFFER_CREATE_IMAGELESS_BIT, the height member of any element of the pAttachmentImageInfos member of a VkFramebufferAttachmentsCreateInfo structure in the pNext chain that is used as an input, color, resolve, or depth/stencil attachment in renderPass must be greater than or equal to height", 316}, { "chapters/renderpass.html", 24} } }, { {"VUID-VkFramebufferCreateInfo-flags-04543", 40}, { {"If the maintenance7 feature is not enabled or the robustFragmentShadingRateAttachmentAccess limit is VK_FALSE or the imageView member of a VkRenderingFragmentShadingRateAttachmentInfoKHR structure was created with VkImageSubresourceRange::baseMipLevel greater than 0, and flags includes VK_FRAMEBUFFER_CREATE_IMAGELESS_BIT, the width member of any element of the pAttachmentImageInfos member of a VkFramebufferAttachmentsCreateInfo structure in the pNext chain that is used as a fragment shading rate attachment must be greater than or equal to ceil(width / texelWidth), where texelWidth is the largest value of shadingRateAttachmentTexelSize.width in a VkFragmentShadingRateAttachmentInfoKHR which references that attachment", 725}, { "chapters/renderpass.html", 24} } }, { {"VUID-VkFramebufferCreateInfo-flags-04544", 40}, { {"If the maintenance7 feature is not enabled or the robustFragmentShadingRateAttachmentAccess limit is VK_FALSE or the imageView member of a VkRenderingFragmentShadingRateAttachmentInfoKHR structure was created with VkImageSubresourceRange::baseMipLevel greater than 0, and flags includes VK_FRAMEBUFFER_CREATE_IMAGELESS_BIT, the height member of any element of the pAttachmentImageInfos member of a VkFramebufferAttachmentsCreateInfo structure in the pNext chain that is used as a fragment shading rate attachment must be greater than or equal to ceil(height / texelHeight), where texelHeight is the largest value of shadingRateAttachmentTexelSize.height in a VkFragmentShadingRateAttachmentInfoKHR which references that attachment", 730}, { "chapters/renderpass.html", 24} } }, { {"VUID-VkFramebufferCreateInfo-flags-04545", 40}, { {"If flags includes VK_FRAMEBUFFER_CREATE_IMAGELESS_BIT, the layerCount member of any element of the pAttachmentImageInfos member of a VkFramebufferAttachmentsCreateInfo structure in the pNext chain that is used as a fragment shading rate attachment must be either 1, or greater than or equal to layers", 300}, { "chapters/renderpass.html", 24} } }, @@ -3804,8 +3806,8 @@ const vvl::unordered_map &GetVuidMap() { { {"VUID-VkFramebufferCreateInfo-renderPass-parameter", 49}, { {"renderPass must be a valid VkRenderPass handle", 46}, { "chapters/renderpass.html", 24} } }, { {"VUID-VkFramebufferCreateInfo-sType-sType", 40}, { {"sType must be VK_STRUCTURE_TYPE_FRAMEBUFFER_CREATE_INFO", 55}, { "chapters/renderpass.html", 24} } }, { {"VUID-VkFramebufferCreateInfo-sType-unique", 41}, { {"The sType value of each structure in the pNext chain must be unique", 67}, { "chapters/renderpass.html", 24} } }, - { {"VUID-VkFramebufferCreateInfo-samples-06881", 42}, { {"If multisampled-render-to-single-sampled is enabled for any subpass, all color, depth/stencil and input attachments used in that subpass which have VkAttachmentDescription::samples or VkAttachmentDescription2::samples equal to VK_SAMPLE_COUNT_1_BIT must have been created with VK_IMAGE_CREATE_MULTISAMPLED_RENDER_TO_SINGLE_SAMPLED_BIT_EXT in their VkImageCreateInfo::flags", 372}, { "chapters/renderpass.html", 24} } }, - { {"VUID-VkFramebufferCreateInfo-samples-07009", 42}, { {"If multisampled-render-to-single-sampled is enabled for any subpass, all color, depth/stencil and input attachments used in that subpass which have VkAttachmentDescription::samples or VkAttachmentDescription2::samples equal to VK_SAMPLE_COUNT_1_BIT must have a format that supports the sample count specified in VkMultisampledRenderToSingleSampledInfoEXT::rasterizationSamples", 376}, { "chapters/renderpass.html", 24} } }, + { {"VUID-VkFramebufferCreateInfo-samples-06881", 42}, { {"If multisampled-render-to-single-sampled is enabled for any subpass, all color, depth/stencil, and input attachments used in that subpass which have VkAttachmentDescription::samples or VkAttachmentDescription2::samples equal to VK_SAMPLE_COUNT_1_BIT must have been created with VK_IMAGE_CREATE_MULTISAMPLED_RENDER_TO_SINGLE_SAMPLED_BIT_EXT in their VkImageCreateInfo::flags", 373}, { "chapters/renderpass.html", 24} } }, + { {"VUID-VkFramebufferCreateInfo-samples-07009", 42}, { {"If multisampled-render-to-single-sampled is enabled for any subpass, all color, depth/stencil, and input attachments used in that subpass which have VkAttachmentDescription::samples or VkAttachmentDescription2::samples equal to VK_SAMPLE_COUNT_1_BIT must have a format that supports the sample count specified in VkMultisampledRenderToSingleSampledInfoEXT::rasterizationSamples", 377}, { "chapters/renderpass.html", 24} } }, { {"VUID-VkFramebufferCreateInfo-width-00885", 40}, { {"width must be greater than 0", 28}, { "chapters/renderpass.html", 24} } }, { {"VUID-VkFramebufferCreateInfo-width-00886", 40}, { {"width must be less than or equal to maxFramebufferWidth", 55}, { "chapters/renderpass.html", 24} } }, { {"VUID-VkFramebufferMixedSamplesCombinationNV-pNext-pNext", 55}, { {"pNext must be NULL", 18}, { "chapters/fragops.html", 21} } }, @@ -5927,6 +5929,7 @@ const vvl::unordered_map &GetVuidMap() { { {"VUID-VkPhysicalDeviceConservativeRasterizationPropertiesEXT-sType-sType", 71}, { {"sType must be VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_CONSERVATIVE_RASTERIZATION_PROPERTIES_EXT", 89}, { "chapters/limits.html", 20} } }, { {"VUID-VkPhysicalDeviceCooperativeMatrix2FeaturesNV-sType-sType", 61}, { {"sType must be VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COOPERATIVE_MATRIX_2_FEATURES_NV", 80}, { "chapters/features.html", 22} } }, { {"VUID-VkPhysicalDeviceCooperativeMatrix2PropertiesNV-sType-sType", 63}, { {"sType must be VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COOPERATIVE_MATRIX_2_PROPERTIES_NV", 82}, { "chapters/limits.html", 20} } }, + { {"VUID-VkPhysicalDeviceCooperativeMatrixConversionFeaturesQCOM-sType-sType", 72}, { {"sType must be VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COOPERATIVE_MATRIX_CONVERSION_FEATURES_QCOM", 91}, { "chapters/features.html", 22} } }, { {"VUID-VkPhysicalDeviceCooperativeMatrixFeaturesKHR-sType-sType", 61}, { {"sType must be VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COOPERATIVE_MATRIX_FEATURES_KHR", 79}, { "chapters/features.html", 22} } }, { {"VUID-VkPhysicalDeviceCooperativeMatrixFeaturesNV-sType-sType", 60}, { {"sType must be VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COOPERATIVE_MATRIX_FEATURES_NV", 78}, { "chapters/features.html", 22} } }, { {"VUID-VkPhysicalDeviceCooperativeMatrixPropertiesKHR-sType-sType", 63}, { {"sType must be VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COOPERATIVE_MATRIX_PROPERTIES_KHR", 81}, { "chapters/limits.html", 20} } }, @@ -7547,17 +7550,11 @@ const vvl::unordered_map &GetVuidMap() { { {"VUID-VkResourceDescriptorInfoEXT-sType-sType", 44}, { {"sType must be VK_STRUCTURE_TYPE_RESOURCE_DESCRIPTOR_INFO_EXT", 60}, { "chapters/descriptorheaps.html", 29} } }, { {"VUID-VkResourceDescriptorInfoEXT-sType-unique", 45}, { {"The sType value of each structure in the pNext chain must be unique", 67}, { "chapters/descriptorheaps.html", 29} } }, { {"VUID-VkResourceDescriptorInfoEXT-type-11210", 43}, { {"type must be one of VK_DESCRIPTOR_TYPE_UNIFORM_BUFFER, VK_DESCRIPTOR_TYPE_STORAGE_BUFFER, VK_DESCRIPTOR_TYPE_SAMPLED_IMAGE, VK_DESCRIPTOR_TYPE_STORAGE_IMAGE, VK_DESCRIPTOR_TYPE_UNIFORM_TEXEL_BUFFER, VK_DESCRIPTOR_TYPE_STORAGE_TEXEL_BUFFER, VK_DESCRIPTOR_TYPE_SAMPLE_WEIGHT_IMAGE_QCOM, VK_DESCRIPTOR_TYPE_BLOCK_MATCH_IMAGE_QCOM, VK_DESCRIPTOR_TYPE_ACCELERATION_STRUCTURE_KHR, VK_DESCRIPTOR_TYPE_ACCELERATION_STRUCTURE_NV, VK_DESCRIPTOR_TYPE_PARTITIONED_ACCELERATION_STRUCTURE_NV, VK_DESCRIPTOR_TYPE_TENSOR_ARM, or VK_DESCRIPTOR_TYPE_INPUT_ATTACHMENT", 548}, { "chapters/descriptorheaps.html", 29} } }, - { {"VUID-VkResourceDescriptorInfoEXT-type-11214", 43}, { {"If type is VK_DESCRIPTOR_TYPE_UNIFORM_TEXEL_BUFFER, the texelBufferAlignment feature is enabled, and uniformTexelBufferOffsetSingleTexelAlignment is VK_FALSE, data->pTexelBuffer->addressRange.address and data->pTexelBuffer->addressRange.size must be multiples of uniformTexelBufferOffsetAlignmentBytes", 301}, { "chapters/descriptorheaps.html", 29} } }, - { {"VUID-VkResourceDescriptorInfoEXT-type-11215", 43}, { {"If type is VK_DESCRIPTOR_TYPE_STORAGE_TEXEL_BUFFER, the texelBufferAlignment feature is enabled, and storageTexelBufferOffsetSingleTexelAlignment is VK_FALSE, data->pTexelBuffer->addressRange.address and data->pTexelBuffer->addressRange.size must be multiples of storageTexelBufferOffsetAlignmentBytes", 301}, { "chapters/descriptorheaps.html", 29} } }, - { {"VUID-VkResourceDescriptorInfoEXT-type-11216", 43}, { {"If type is VK_DESCRIPTOR_TYPE_UNIFORM_TEXEL_BUFFER, the texelBufferAlignment feature is enabled, and uniformTexelBufferOffsetSingleTexelAlignment is VK_TRUE, data->pTexelBuffer->addressRange.address and data->pTexelBuffer->addressRange.size must be multiples of either uniformTexelBufferOffsetAlignmentBytes or the highest integer power-of-two factor of the size of data->pTexelBuffer->format in bytes; whichever is lower", 421}, { "chapters/descriptorheaps.html", 29} } }, - { {"VUID-VkResourceDescriptorInfoEXT-type-11217", 43}, { {"If type is VK_DESCRIPTOR_TYPE_STORAGE_TEXEL_BUFFER, the texelBufferAlignment feature is enabled, and storageTexelBufferOffsetSingleTexelAlignment is VK_TRUE, data->pTexelBuffer->addressRange.address and data->pTexelBuffer->addressRange.size must be multiples of either storageTexelBufferOffsetAlignmentBytes or the highest integer power-of-two factor of the size of data->pTexelBuffer->format in bytes; whichever is lower", 421}, { "chapters/descriptorheaps.html", 29} } }, { {"VUID-VkResourceDescriptorInfoEXT-type-11422", 43}, { {"If type is VK_DESCRIPTOR_TYPE_SAMPLE_WEIGHT_IMAGE_QCOM, VK_DESCRIPTOR_TYPE_BLOCK_MATCH_IMAGE_QCOM, or VK_DESCRIPTOR_TYPE_INPUT_ATTACHMENT, data.pImage->pView->image must not have been created with an imageType of VK_IMAGE_TYPE_3D", 229}, { "chapters/descriptorheaps.html", 29} } }, { {"VUID-VkResourceDescriptorInfoEXT-type-11424", 43}, { {"If type is VK_DESCRIPTOR_TYPE_STORAGE_IMAGE, data.pImage->pView->viewType is VK_IMAGE_VIEW_TYPE_2D, and the image2DViewOf3D feature is not enabled, data.pImage->pView->image must not have been created with an imageType of VK_IMAGE_TYPE_3D", 238}, { "chapters/descriptorheaps.html", 29} } }, { {"VUID-VkResourceDescriptorInfoEXT-type-11425", 43}, { {"If type is VK_DESCRIPTOR_TYPE_SAMPLED_IMAGE, data.pImage->pView->viewType is VK_IMAGE_VIEW_TYPE_2D, and the sampler2DViewOf3D feature is not enabled, data.pImage->pView->image must not have been created with an imageType of VK_IMAGE_TYPE_3D", 240}, { "chapters/descriptorheaps.html", 29} } }, { {"VUID-VkResourceDescriptorInfoEXT-type-11433", 43}, { {"If type is VK_DESCRIPTOR_TYPE_STORAGE_BUFFER or VK_DESCRIPTOR_TYPE_UNIFORM_BUFFER, data.pAddressRange->size must not be 0", 121}, { "chapters/descriptorheaps.html", 29} } }, - { {"VUID-VkResourceDescriptorInfoEXT-type-11452", 43}, { {"If type is VK_DESCRIPTOR_TYPE_UNIFORM_BUFFER, data->pAddressRange->address and data->pAddressRange->size must be multiples of minUniformBufferOffsetAlignment", 157}, { "chapters/descriptorheaps.html", 29} } }, - { {"VUID-VkResourceDescriptorInfoEXT-type-11453", 43}, { {"If type is VK_DESCRIPTOR_TYPE_STORAGE_BUFFER, data->pAddressRange->address and data->pAddressRange->size must be multiples of minStorageBufferOffsetAlignment", 157}, { "chapters/descriptorheaps.html", 29} } }, - { {"VUID-VkResourceDescriptorInfoEXT-type-11454", 43}, { {"If type is one of VK_DESCRIPTOR_TYPE_ACCELERATION_STRUCTURE_KHR VK_DESCRIPTOR_TYPE_ACCELERATION_STRUCTURE_NV VK_DESCRIPTOR_TYPE_PARTITIONED_ACCELERATION_STRUCTURE_NV data->pAddressRange->address and data->pAddressRange->size must be multiples of 256", 249}, { "chapters/descriptorheaps.html", 29} } }, + { {"VUID-VkResourceDescriptorInfoEXT-type-11454", 43}, { {"If type is one of VK_DESCRIPTOR_TYPE_ACCELERATION_STRUCTURE_KHR VK_DESCRIPTOR_TYPE_ACCELERATION_STRUCTURE_NV VK_DESCRIPTOR_TYPE_PARTITIONED_ACCELERATION_STRUCTURE_NV data->pAddressRange->address must be a multiple of 256", 220}, { "chapters/descriptorheaps.html", 29} } }, { {"VUID-VkResourceDescriptorInfoEXT-type-11458", 43}, { {"If type is VK_DESCRIPTOR_TYPE_SAMPLED_IMAGE and data.pImage is not NULL, data.pImage->pView->image must have been created with the VK_IMAGE_USAGE_SAMPLED_BIT usage flag set", 172}, { "chapters/descriptorheaps.html", 29} } }, { {"VUID-VkResourceDescriptorInfoEXT-type-11459", 43}, { {"If type is VK_DESCRIPTOR_TYPE_STORAGE_IMAGE and data.pImage is not NULL, data.pImage->pView->image must have been created with the VK_IMAGE_USAGE_STORAGE_BIT usage flag set", 172}, { "chapters/descriptorheaps.html", 29} } }, { {"VUID-VkResourceDescriptorInfoEXT-type-11460", 43}, { {"If type is VK_DESCRIPTOR_TYPE_INPUT_ATTACHMENT and data.pImage is not NULL, data.pImage->pView->image must have been created with the VK_IMAGE_USAGE_INPUT_ATTACHMENT_BIT usage flag set", 184}, { "chapters/descriptorheaps.html", 29} } }, @@ -7570,6 +7567,9 @@ const vvl::unordered_map &GetVuidMap() { { {"VUID-VkResourceDescriptorInfoEXT-type-11469", 43}, { {"If type is VK_DESCRIPTOR_TYPE_SAMPLE_WEIGHT_IMAGE_QCOM, VK_DESCRIPTOR_TYPE_BLOCK_MATCH_IMAGE_QCOM, or VK_DESCRIPTOR_TYPE_INPUT_ATTACHMENT, data->pImage must not be NULL", 168}, { "chapters/descriptorheaps.html", 29} } }, { {"VUID-VkResourceDescriptorInfoEXT-type-11483", 43}, { {"If type is VK_DESCRIPTOR_TYPE_PARTITIONED_ACCELERATION_STRUCTURE_NV or VK_DESCRIPTOR_TYPE_ACCELERATION_STRUCTURE_KHR, and data.pAddressRange is not NULL, data.pAddressRange->address must be an acceleration structure address retrieved from a VkAccelerationStructureKHR object via vkGetAccelerationStructureDeviceAddressKHR", 321}, { "chapters/descriptorheaps.html", 29} } }, { {"VUID-VkResourceDescriptorInfoEXT-type-11484", 43}, { {"If type is VK_DESCRIPTOR_TYPE_PARTITIONED_ACCELERATION_STRUCTURE_NV or VK_DESCRIPTOR_TYPE_ACCELERATION_STRUCTURE_KHR, data.pAddressRange is not NULL, and data.pAddressRange->size is not 0, data.pAddressRange must be a device address range allocated to the application from the buffer used to create the acceleration structure that data.pAddressRange->address was retrieved from, and within the buffer range bound to that acceleration structure", 443}, { "chapters/descriptorheaps.html", 29} } }, + { {"VUID-VkResourceDescriptorInfoEXT-type-12349", 43}, { {"If type is VK_DESCRIPTOR_TYPE_UNIFORM_TEXEL_BUFFER or VK_DESCRIPTOR_TYPE_STORAGE_TEXEL_BUFFER, data->pTexelBuffer->addressRange.address must be a multiple of the effective alignment requirement of data->pTexelBuffer->format as determined by minTexelBufferOffsetAlignment", 270}, { "chapters/descriptorheaps.html", 29} } }, + { {"VUID-VkResourceDescriptorInfoEXT-type-12350", 43}, { {"If type is VK_DESCRIPTOR_TYPE_UNIFORM_BUFFER, data->pAddressRange->address must be a multiple of minUniformBufferOffsetAlignment", 128}, { "chapters/descriptorheaps.html", 29} } }, + { {"VUID-VkResourceDescriptorInfoEXT-type-12351", 43}, { {"If type is VK_DESCRIPTOR_TYPE_STORAGE_BUFFER, data->pAddressRange->address must be a multiple of minStorageBufferOffsetAlignment", 128}, { "chapters/descriptorheaps.html", 29} } }, { {"VUID-VkResourceDescriptorInfoEXT-type-parameter", 47}, { {"type must be a valid VkDescriptorType value", 43}, { "chapters/descriptorheaps.html", 29} } }, { {"VUID-VkSampleLocationsInfoEXT-pSampleLocations-parameter", 56}, { {"If sampleLocationsCount is not 0, pSampleLocations must be a valid pointer to an array of sampleLocationsCount VkSampleLocationEXT structures", 141}, { "chapters/primsrast.html", 23} } }, { {"VUID-VkSampleLocationsInfoEXT-sType-sType", 41}, { {"sType must be VK_STRUCTURE_TYPE_SAMPLE_LOCATIONS_INFO_EXT", 57}, { "chapters/primsrast.html", 23} } }, @@ -7673,7 +7673,7 @@ const vvl::unordered_map &GetVuidMap() { { {"VUID-VkSamplerYcbcrConversionCreateInfo-yChromaOffset-parameter", 63}, { {"yChromaOffset must be a valid VkChromaLocation value", 52}, { "chapters/samplers.html", 22} } }, { {"VUID-VkSamplerYcbcrConversionCreateInfo-ycbcrModel-01655", 56}, { {"If ycbcrModel is not VK_SAMPLER_YCBCR_MODEL_CONVERSION_RGB_IDENTITY, then components.r, components.g, and components.b must correspond to components of the format; that is, components.r, components.g, and components.b must not be VK_COMPONENT_SWIZZLE_ZERO or VK_COMPONENT_SWIZZLE_ONE, and must not correspond to a component containing zero or one as a consequence of component substitution", 389}, { "chapters/samplers.html", 22} } }, { {"VUID-VkSamplerYcbcrConversionCreateInfo-ycbcrModel-parameter", 60}, { {"ycbcrModel must be a valid VkSamplerYcbcrModelConversion value", 62}, { "chapters/samplers.html", 22} } }, - { {"VUID-VkSamplerYcbcrConversionCreateInfo-ycbcrRange-02748", 56}, { {"If ycbcrRange is VK_SAMPLER_YCBCR_RANGE_ITU_NARROW then the R, G and B components obtained by applying the component swizzle to format must each have a bit-depth greater than or equal to 8", 188}, { "chapters/samplers.html", 22} } }, + { {"VUID-VkSamplerYcbcrConversionCreateInfo-ycbcrRange-02748", 56}, { {"If ycbcrRange is VK_SAMPLER_YCBCR_RANGE_ITU_NARROW, then the R, G, and B components obtained by applying the component swizzle to format must each have a bit-depth greater than or equal to 8", 190}, { "chapters/samplers.html", 22} } }, { {"VUID-VkSamplerYcbcrConversionCreateInfo-ycbcrRange-parameter", 60}, { {"ycbcrRange must be a valid VkSamplerYcbcrRange value", 52}, { "chapters/samplers.html", 22} } }, { {"VUID-VkSamplerYcbcrConversionImageFormatProperties-sType-sType", 62}, { {"sType must be VK_STRUCTURE_TYPE_SAMPLER_YCBCR_CONVERSION_IMAGE_FORMAT_PROPERTIES", 80}, { "chapters/capabilities.html", 26} } }, { {"VUID-VkSamplerYcbcrConversionInfo-conversion-parameter", 54}, { {"conversion must be a valid VkSamplerYcbcrConversion handle", 58}, { "chapters/samplers.html", 22} } }, @@ -8460,7 +8460,6 @@ const vvl::unordered_map &GetVuidMap() { { {"VUID-VkTensorViewCreateInfoARM-tensor-parameter", 47}, { {"tensor must be a valid VkTensorARM handle", 41}, { "chapters/resources.html", 23} } }, { {"VUID-VkTensorViewCreateInfoARM-usage-09747", 42}, { {"The usage flags of tensor must have at least one of the following bits set: VK_TENSOR_USAGE_SHADER_BIT_ARM VK_TENSOR_USAGE_DATA_GRAPH_BIT_ARM", 141}, { "chapters/resources.html", 23} } }, { {"VUID-VkTensorViewCreateInfoARM-usage-09748", 42}, { {"The tensor view's format features must contain the format feature flags required by the usage flags of tensor for format as indicated in the Format Feature Dependent Usage Flags section", 185}, { "chapters/resources.html", 23} } }, - { {"VUID-VkTexelBufferDescriptorInfoEXT-None-11218", 46}, { {"If texelBufferAlignment is not enabled, addressRange.address and addressRange.size must be aligned to minTexelBufferOffsetAlignment", 131}, { "chapters/descriptorheaps.html", 29} } }, { {"VUID-VkTexelBufferDescriptorInfoEXT-format-parameter", 52}, { {"format must be a valid VkFormat value", 37}, { "chapters/descriptorheaps.html", 29} } }, { {"VUID-VkTexelBufferDescriptorInfoEXT-pNext-pNext", 47}, { {"pNext must be NULL", 18}, { "chapters/descriptorheaps.html", 29} } }, { {"VUID-VkTexelBufferDescriptorInfoEXT-sType-sType", 47}, { {"sType must be VK_STRUCTURE_TYPE_TEXEL_BUFFER_DESCRIPTOR_INFO_EXT", 64}, { "chapters/descriptorheaps.html", 29} } }, @@ -10057,7 +10056,7 @@ const vvl::unordered_map &GetVuidMap() { { {"VUID-vkCmdBuildAccelerationStructuresIndirectKHR-pInfos-03708", 61}, { {"For each element of pInfos, if its mode member is VK_BUILD_ACCELERATION_STRUCTURE_MODE_UPDATE_KHR the buffer used to create its srcAccelerationStructure member must be bound to device memory", 190}, { "chapters/accelstructures.html", 29} } }, { {"VUID-vkCmdBuildAccelerationStructuresIndirectKHR-pInfos-03709", 61}, { {"For each element of pInfos, the buffer used to create each acceleration structure referenced by the geometry.instances.data member of any element of pGeometries or ppGeometries with a geometryType of VK_GEOMETRY_TYPE_INSTANCES_KHR must be bound to device memory", 261}, { "chapters/accelstructures.html", 29} } }, { {"VUID-vkCmdBuildAccelerationStructuresIndirectKHR-pInfos-03710", 61}, { {"For each element of pInfos, its scratchData.deviceAddress member must be a multiple of VkPhysicalDeviceAccelerationStructurePropertiesKHR::minAccelerationStructureScratchOffsetAlignment", 185}, { "chapters/accelstructures.html", 29} } }, - { {"VUID-vkCmdBuildAccelerationStructuresIndirectKHR-pInfos-03711", 61}, { {"For each element of pInfos[i].pGeometries or pInfos[i].ppGeometries with a geometryType of VK_GEOMETRY_TYPE_TRIANGLES_KHR, geometry.triangles.vertexData.deviceAddress must be aligned to the size in bytes of the smallest component of the format in vertexFormat", 259}, { "chapters/accelstructures.html", 29} } }, + { {"VUID-vkCmdBuildAccelerationStructuresIndirectKHR-pInfos-03711", 61}, { {"For each element of pInfos[i].pGeometries or pInfos[i].ppGeometries with a geometryType of VK_GEOMETRY_TYPE_TRIANGLES_KHR, geometry.triangles.vertexData.deviceAddress must be aligned to: the size of the format specified in vertexFormat, in bytes, if that format is a packed format the component size of the format specified in vertexFormat, in bytes, if that format is not a packed format", 388}, { "chapters/accelstructures.html", 29} } }, { {"VUID-vkCmdBuildAccelerationStructuresIndirectKHR-pInfos-03712", 61}, { {"For each element of pInfos[i].pGeometries or pInfos[i].ppGeometries with a geometryType of VK_GEOMETRY_TYPE_TRIANGLES_KHR, and with geometry.triangles.indexType not equal to VK_INDEX_TYPE_NONE_KHR, geometry.triangles.indexData.deviceAddress must be aligned to the size in bytes of the type in indexType", 302}, { "chapters/accelstructures.html", 29} } }, { {"VUID-vkCmdBuildAccelerationStructuresIndirectKHR-pInfos-03714", 61}, { {"For each element of pInfos[i].pGeometries or pInfos[i].ppGeometries with a geometryType of VK_GEOMETRY_TYPE_AABBS_KHR, geometry.aabbs.data.deviceAddress must be aligned to 8 bytes", 179}, { "chapters/accelstructures.html", 29} } }, { {"VUID-vkCmdBuildAccelerationStructuresIndirectKHR-pInfos-03715", 61}, { {"For each element of pInfos[i].pGeometries or pInfos[i].ppGeometries with a geometryType of VK_GEOMETRY_TYPE_INSTANCES_KHR, if geometry.arrayOfPointers is VK_FALSE, geometry.instances.data.deviceAddress must be aligned to 16 bytes", 229}, { "chapters/accelstructures.html", 29} } }, @@ -10141,7 +10140,7 @@ const vvl::unordered_map &GetVuidMap() { { {"VUID-vkCmdBuildAccelerationStructuresKHR-pInfos-03708", 53}, { {"For each element of pInfos, if its mode member is VK_BUILD_ACCELERATION_STRUCTURE_MODE_UPDATE_KHR the buffer used to create its srcAccelerationStructure member must be bound to device memory", 190}, { "chapters/accelstructures.html", 29} } }, { {"VUID-vkCmdBuildAccelerationStructuresKHR-pInfos-03709", 53}, { {"For each element of pInfos, the buffer used to create each acceleration structure referenced by the geometry.instances.data member of any element of pGeometries or ppGeometries with a geometryType of VK_GEOMETRY_TYPE_INSTANCES_KHR must be bound to device memory", 261}, { "chapters/accelstructures.html", 29} } }, { {"VUID-vkCmdBuildAccelerationStructuresKHR-pInfos-03710", 53}, { {"For each element of pInfos, its scratchData.deviceAddress member must be a multiple of VkPhysicalDeviceAccelerationStructurePropertiesKHR::minAccelerationStructureScratchOffsetAlignment", 185}, { "chapters/accelstructures.html", 29} } }, - { {"VUID-vkCmdBuildAccelerationStructuresKHR-pInfos-03711", 53}, { {"For each element of pInfos[i].pGeometries or pInfos[i].ppGeometries with a geometryType of VK_GEOMETRY_TYPE_TRIANGLES_KHR, geometry.triangles.vertexData.deviceAddress must be aligned to the size in bytes of the smallest component of the format in vertexFormat", 259}, { "chapters/accelstructures.html", 29} } }, + { {"VUID-vkCmdBuildAccelerationStructuresKHR-pInfos-03711", 53}, { {"For each element of pInfos[i].pGeometries or pInfos[i].ppGeometries with a geometryType of VK_GEOMETRY_TYPE_TRIANGLES_KHR, geometry.triangles.vertexData.deviceAddress must be aligned to: the size of the format specified in vertexFormat, in bytes, if that format is a packed format the component size of the format specified in vertexFormat, in bytes, if that format is not a packed format", 388}, { "chapters/accelstructures.html", 29} } }, { {"VUID-vkCmdBuildAccelerationStructuresKHR-pInfos-03712", 53}, { {"For each element of pInfos[i].pGeometries or pInfos[i].ppGeometries with a geometryType of VK_GEOMETRY_TYPE_TRIANGLES_KHR, and with geometry.triangles.indexType not equal to VK_INDEX_TYPE_NONE_KHR, geometry.triangles.indexData.deviceAddress must be aligned to the size in bytes of the type in indexType", 302}, { "chapters/accelstructures.html", 29} } }, { {"VUID-vkCmdBuildAccelerationStructuresKHR-pInfos-03714", 53}, { {"For each element of pInfos[i].pGeometries or pInfos[i].ppGeometries with a geometryType of VK_GEOMETRY_TYPE_AABBS_KHR, geometry.aabbs.data.deviceAddress must be aligned to 8 bytes", 179}, { "chapters/accelstructures.html", 29} } }, { {"VUID-vkCmdBuildAccelerationStructuresKHR-pInfos-03715", 53}, { {"For each element of pInfos[i].pGeometries or pInfos[i].ppGeometries with a geometryType of VK_GEOMETRY_TYPE_INSTANCES_KHR, if geometry.arrayOfPointers is VK_FALSE, geometry.instances.data.deviceAddress must be aligned to 16 bytes", 229}, { "chapters/accelstructures.html", 29} } }, @@ -10267,7 +10266,7 @@ const vvl::unordered_map &GetVuidMap() { { {"VUID-vkCmdBuildPartitionedAccelerationStructuresNV-pBuildInfo-10546", 67}, { {"The number of inputs specified in pBuildInfo->srcInfos must be greater than or equal to pBuildInfo->srcInfosCount", 113}, { "chapters/accelstructures.html", 29} } }, { {"VUID-vkCmdBuildPartitionedAccelerationStructuresNV-pBuildInfo-10547", 67}, { {"The memory region containing the acceleration structure at address pBuildInfo->srcAccelerationStructureData must not overlap with scratch memory region at address pBuildInfo->scratchData", 186}, { "chapters/accelstructures.html", 29} } }, { {"VUID-vkCmdBuildPartitionedAccelerationStructuresNV-pBuildInfo-10548", 67}, { {"The memory region containing the acceleration structure at address pBuildInfo->dstAccelerationStructureData must not overlap with scratch memory region at address pBuildInfo->scratchData", 186}, { "chapters/accelstructures.html", 29} } }, - { {"VUID-vkCmdBuildPartitionedAccelerationStructuresNV-pBuildInfo-10549", 67}, { {"The memory regions containing the acceleration structures at addresses pBuildInfo->srcAccelerationStructureData and pBuildInfo->dstAccelerationStructureData must not overlap with each other", 189}, { "chapters/accelstructures.html", 29} } }, + { {"VUID-vkCmdBuildPartitionedAccelerationStructuresNV-pBuildInfo-10549", 67}, { {"If the source and destination acceleration structures are not the same, the memory regions containing the acceleration structures at addresses pBuildInfo->srcAccelerationStructureData and pBuildInfo->dstAccelerationStructureData must not overlap with each other", 261}, { "chapters/accelstructures.html", 29} } }, { {"VUID-vkCmdBuildPartitionedAccelerationStructuresNV-pBuildInfo-10550", 67}, { {"pBuildInfo->scratchData must be a device address allocated to the application from a buffer created with the VK_BUFFER_USAGE_STORAGE_BUFFER_BIT usage flag set", 158}, { "chapters/accelstructures.html", 29} } }, { {"VUID-vkCmdBuildPartitionedAccelerationStructuresNV-pBuildInfo-10551", 67}, { {"pBuildInfo->srcInfos and pBuildInfo->srcInfosCount must be device addresses allocated to the application from buffers created with the VK_BUFFER_USAGE_ACCELERATION_STRUCTURE_BUILD_INPUT_READ_ONLY_BIT_KHR usage flag set", 218}, { "chapters/accelstructures.html", 29} } }, { {"VUID-vkCmdBuildPartitionedAccelerationStructuresNV-pBuildInfo-10552", 67}, { {"pBuildInfo->srcAccelerationStructureData and pBuildInfo->dstAccelerationStructureData must be a device addresses allocated to the application from buffers created with the VK_BUFFER_USAGE_ACCELERATION_STRUCTURE_STORAGE_BIT_KHR usage flag set", 241}, { "chapters/accelstructures.html", 29} } }, @@ -21643,7 +21642,7 @@ const vvl::unordered_map &GetVuidMap() { { {"VUID-vkCreateSampler-device-09668", 33}, { {"device must support at least one queue family with one of the VK_QUEUE_COMPUTE_BIT or VK_QUEUE_GRAPHICS_BIT capabilities", 120}, { "chapters/samplers.html", 22} } }, { {"VUID-vkCreateSampler-device-parameter", 37}, { {"device must be a valid VkDevice handle", 38}, { "chapters/samplers.html", 22} } }, { {"VUID-vkCreateSampler-maxSamplerAllocationCount-04110", 52}, { {"There must be less than VkPhysicalDeviceLimits::maxSamplerAllocationCount VkSampler objects currently created on the device", 123}, { "chapters/samplers.html", 22} } }, - { {"VUID-vkCreateSampler-maxSamplerAllocationCount-11412", 52}, { {"If there are any pipelines ifdef:VK_EXT_shader_object[or shaders] with embedded samplers currently created on the device, there must be less than (maxSamplerAllocationCount - (minSamplerHeapReservedRangeWithEmbedded / samplerDescriptorSize)) VkSampler objects currently created on the device", 291}, { "chapters/samplers.html", 22} } }, + { {"VUID-vkCreateSampler-maxSamplerAllocationCount-11412", 52}, { {"If there are any pipelines or shaders with embedded samplers currently created on the device, there must be less than (maxSamplerAllocationCount - (minSamplerHeapReservedRangeWithEmbedded / samplerDescriptorSize)) VkSampler objects currently created on the device", 263}, { "chapters/samplers.html", 22} } }, { {"VUID-vkCreateSampler-pAllocator-parameter", 41}, { {"If pAllocator is not NULL, pAllocator must be a valid pointer to a valid VkAllocationCallbacks structure", 104}, { "chapters/samplers.html", 22} } }, { {"VUID-vkCreateSampler-pCreateInfo-parameter", 42}, { {"pCreateInfo must be a valid pointer to a valid VkSamplerCreateInfo structure", 76}, { "chapters/samplers.html", 22} } }, { {"VUID-vkCreateSampler-pSampler-parameter", 39}, { {"pSampler must be a valid pointer to a VkSampler handle", 54}, { "chapters/samplers.html", 22} } }, diff --git a/scripts/generators/sync_validation_generator.py b/scripts/generators/sync_validation_generator.py index 82cf7e0e118..89c45fb9d6e 100644 --- a/scripts/generators/sync_validation_generator.py +++ b/scripts/generators/sync_validation_generator.py @@ -70,9 +70,19 @@ def __init__(self): self.stageAccessCombo = [] # fake stages and accesses for acquire present support - self.pipelineStagePresentEngine = Flag('VK_PIPELINE_STAGE_2_PRESENT_ENGINE_BIT_SYNCVAL', [], 0, False, False, None, None, []) - self.accessAcquireRead = Flag('VK_ACCESS_2_PRESENT_ACQUIRE_READ_BIT_SYNCVAL', [], 0, False, False, None, None, []) - self.accessPresented = Flag('VK_ACCESS_2_PRESENT_PRESENTED_BIT_SYNCVAL', [], 0, False, False, None, None, []) + def make_flag(name): + return Flag(name = name, + aliases = [], + protect = None, + value = 0, + valueStr = "", + bitpos = None, + multiBit = False, + zero = False, + extensions = []) + self.pipelineStagePresentEngine = make_flag('VK_PIPELINE_STAGE_2_PRESENT_ENGINE_BIT_SYNCVAL') + self.accessAcquireRead = make_flag('VK_ACCESS_2_PRESENT_ACQUIRE_READ_BIT_SYNCVAL') + self.accessPresented = make_flag('VK_ACCESS_2_PRESENT_PRESENTED_BIT_SYNCVAL') def generate(self): self.write(f'''// *** THIS FILE IS GENERATED - DO NOT EDIT *** diff --git a/scripts/known_good.json b/scripts/known_good.json index 13a1e088e02..c6b992a4189 100644 --- a/scripts/known_good.json +++ b/scripts/known_good.json @@ -7,7 +7,7 @@ "sub_dir": "Vulkan-Headers", "build_dir": "Vulkan-Headers/build", "install_dir": "Vulkan-Headers/build/install", - "commit": "v1.4.341" + "commit": "v1.4.342" }, { "name": "Vulkan-Utility-Libraries", @@ -15,7 +15,7 @@ "sub_dir": "Vulkan-Utility-Libraries", "build_dir": "Vulkan-Utility-Libraries/build", "install_dir": "Vulkan-Utility-Libraries/build/install", - "commit": "v1.4.341", + "commit": "v1.4.342", "deps": [ { "var_name": "VULKAN_HEADERS_INSTALL_DIR", @@ -99,7 +99,7 @@ "sub_dir": "Vulkan-Loader", "build_dir": "Vulkan-Loader/build", "install_dir": "Vulkan-Loader/build/install", - "commit": "v1.4.341", + "commit": "v1.4.342", "build_step": "skip", "optional": [ "tests" diff --git a/tests/layers/VkLayer_device_profile_api.json.in b/tests/layers/VkLayer_device_profile_api.json.in index 85e9f0bac31..735cec19f62 100644 --- a/tests/layers/VkLayer_device_profile_api.json.in +++ b/tests/layers/VkLayer_device_profile_api.json.in @@ -4,7 +4,7 @@ "name": "VK_LAYER_LUNARG_device_profile_api", "type": "GLOBAL", "library_path": "@JSON_LIBRARY_PATH@", - "api_version": "1.4.341", + "api_version": "1.4.342", "implementation_version": "2", "description": "LunarG Device Profile Api Layer", "device_extensions": [