layers: Split up ValidatePnextStructContents
diff --git a/layers/stateless/sl_utils.cpp b/layers/stateless/sl_utils.cpp index b6b3ee9..3c6f6f9 100644 --- a/layers/stateless/sl_utils.cpp +++ b/layers/stateless/sl_utils.cpp
@@ -274,6 +274,15 @@ } // Send Location without pNext field so the pNext() connector can be used skip |= ValidatePnextStructContents(loc, current, pnext_vuid, caller_physical_device, is_const_param); + if (loc.function == Func::vkGetPhysicalDeviceProperties2 || + loc.function == Func::vkGetPhysicalDeviceProperties2KHR) { + skip |= ValidatePnextPropertyStructContents(loc, current, pnext_vuid, caller_physical_device, + is_const_param); + } else if (loc.function == Func::vkGetPhysicalDeviceFeatures2 || + loc.function == Func::vkGetPhysicalDeviceFeatures2KHR || loc.function == Func::vkCreateDevice) { + skip |= ValidatePnextFeatureStructContents(loc, current, pnext_vuid, caller_physical_device, + is_const_param); + } } } current = reinterpret_cast<const VkBaseOutStructure *>(current->pNext);
diff --git a/layers/stateless/stateless_validation.h b/layers/stateless/stateless_validation.h index 7e295be..df3846e 100644 --- a/layers/stateless/stateless_validation.h +++ b/layers/stateless/stateless_validation.h
@@ -364,6 +364,12 @@ bool CheckPromotedApiAgainstVulkanVersion(VkPhysicalDevice pdev, const Location &loc, const uint32_t promoted_version) const; bool SupportedByPdev(const VkPhysicalDevice physical_device, vvl::Extension extension) const; + bool ValidatePnextFeatureStructContents(const Location &loc, const VkBaseOutStructure *header, const char *pnext_vuid, + VkPhysicalDevice caller_physical_device = VK_NULL_HANDLE, + bool is_const_param = true) const; + bool ValidatePnextPropertyStructContents(const Location &loc, const VkBaseOutStructure *header, const char *pnext_vuid, + VkPhysicalDevice caller_physical_device = VK_NULL_HANDLE, + bool is_const_param = true) const; bool ValidatePnextStructContents(const Location &loc, const VkBaseOutStructure *header, const char *pnext_vuid, VkPhysicalDevice caller_physical_device = VK_NULL_HANDLE, bool is_const_param = true) const;
diff --git a/layers/vulkan/generated/stateless_validation_helper.cpp b/layers/vulkan/generated/stateless_validation_helper.cpp index 6f3b4cc..a2452a1 100644 --- a/layers/vulkan/generated/stateless_validation_helper.cpp +++ b/layers/vulkan/generated/stateless_validation_helper.cpp
@@ -28,6 +28,4634 @@ #include "generated/enum_flag_bits.h" #include "generated/layer_chassis_dispatch.h" +bool StatelessValidation::ValidatePnextFeatureStructContents(const Location& loc, const VkBaseOutStructure* header, + const char* pnext_vuid, VkPhysicalDevice caller_physical_device, + bool is_const_param) const { + bool skip = false; + const bool is_physdev_api = caller_physical_device != VK_NULL_HANDLE; + switch (header->sType) { + // Validation code for VkPhysicalDevice16BitStorageFeatures structure members + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_16BIT_STORAGE_FEATURES: { // Covers + // VUID-VkPhysicalDevice16BitStorageFeatures-sType-sType + + if ((is_physdev_api && !SupportedByPdev(physical_device, vvl::Extension::_VK_KHR_16bit_storage)) || + (!is_physdev_api && !IsExtEnabled(device_extensions.vk_khr_16bit_storage))) { + skip |= LogError(pnext_vuid, instance, loc.dot(Field::pNext), + "includes a pointer to a VkStructureType " + "(VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_16BIT_STORAGE_FEATURES), but its parent extension " + "VK_KHR_16bit_storage has not been enabled."); + } + if (is_const_param) { + [[maybe_unused]] const Location pNext_loc = loc.pNext(Struct::VkPhysicalDevice16BitStorageFeatures); + if (!IsExtEnabled(device_extensions.vk_khr_16bit_storage)) { + skip |= LogError(pnext_vuid, instance, pNext_loc, + "includes a pointer to a VkPhysicalDevice16BitStorageFeatures, but when creating VkDevice, " + "the parent extension " + "(VK_KHR_16bit_storage) was not included in ppEnabledExtensionNames."); + } + VkPhysicalDevice16BitStorageFeatures* structure = (VkPhysicalDevice16BitStorageFeatures*)header; + skip |= ValidateBool32(pNext_loc.dot(Field::storageBuffer16BitAccess), structure->storageBuffer16BitAccess); + + skip |= ValidateBool32(pNext_loc.dot(Field::uniformAndStorageBuffer16BitAccess), + structure->uniformAndStorageBuffer16BitAccess); + + skip |= ValidateBool32(pNext_loc.dot(Field::storagePushConstant16), structure->storagePushConstant16); + + skip |= ValidateBool32(pNext_loc.dot(Field::storageInputOutput16), structure->storageInputOutput16); + } + } break; + + // Validation code for VkPhysicalDeviceMultiviewFeatures structure members + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MULTIVIEW_FEATURES: { // Covers VUID-VkPhysicalDeviceMultiviewFeatures-sType-sType + + if ((is_physdev_api && !SupportedByPdev(physical_device, vvl::Extension::_VK_KHR_multiview)) || + (!is_physdev_api && !IsExtEnabled(device_extensions.vk_khr_multiview))) { + skip |= LogError(pnext_vuid, instance, loc.dot(Field::pNext), + "includes a pointer to a VkStructureType (VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MULTIVIEW_FEATURES), " + "but its parent extension " + "VK_KHR_multiview has not been enabled."); + } + if (is_const_param) { + [[maybe_unused]] const Location pNext_loc = loc.pNext(Struct::VkPhysicalDeviceMultiviewFeatures); + if (!IsExtEnabled(device_extensions.vk_khr_multiview)) { + skip |= LogError(pnext_vuid, instance, pNext_loc, + "includes a pointer to a VkPhysicalDeviceMultiviewFeatures, but when creating VkDevice, the " + "parent extension " + "(VK_KHR_multiview) was not included in ppEnabledExtensionNames."); + } + VkPhysicalDeviceMultiviewFeatures* structure = (VkPhysicalDeviceMultiviewFeatures*)header; + skip |= ValidateBool32(pNext_loc.dot(Field::multiview), structure->multiview); + + skip |= ValidateBool32(pNext_loc.dot(Field::multiviewGeometryShader), structure->multiviewGeometryShader); + + skip |= ValidateBool32(pNext_loc.dot(Field::multiviewTessellationShader), structure->multiviewTessellationShader); + } + } break; + + // Validation code for VkPhysicalDeviceVariablePointersFeatures structure members + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VARIABLE_POINTERS_FEATURES: { // Covers + // VUID-VkPhysicalDeviceVariablePointersFeatures-sType-sType + + if ((is_physdev_api && !SupportedByPdev(physical_device, vvl::Extension::_VK_KHR_variable_pointers)) || + (!is_physdev_api && !IsExtEnabled(device_extensions.vk_khr_variable_pointers))) { + skip |= LogError(pnext_vuid, instance, loc.dot(Field::pNext), + "includes a pointer to a VkStructureType " + "(VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VARIABLE_POINTERS_FEATURES), but its parent extension " + "VK_KHR_variable_pointers has not been enabled."); + } + if (is_const_param) { + [[maybe_unused]] const Location pNext_loc = loc.pNext(Struct::VkPhysicalDeviceVariablePointersFeatures); + if (!IsExtEnabled(device_extensions.vk_khr_variable_pointers)) { + skip |= LogError(pnext_vuid, instance, pNext_loc, + "includes a pointer to a VkPhysicalDeviceVariablePointersFeatures, but when creating " + "VkDevice, the parent extension " + "(VK_KHR_variable_pointers) was not included in ppEnabledExtensionNames."); + } + VkPhysicalDeviceVariablePointersFeatures* structure = (VkPhysicalDeviceVariablePointersFeatures*)header; + skip |= + ValidateBool32(pNext_loc.dot(Field::variablePointersStorageBuffer), structure->variablePointersStorageBuffer); + + skip |= ValidateBool32(pNext_loc.dot(Field::variablePointers), structure->variablePointers); + } + } break; + + // Validation code for VkPhysicalDeviceProtectedMemoryFeatures structure members + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PROTECTED_MEMORY_FEATURES: { // Covers + // VUID-VkPhysicalDeviceProtectedMemoryFeatures-sType-sType + + if (is_physdev_api) { + VkPhysicalDeviceProperties device_properties = {}; + DispatchGetPhysicalDeviceProperties(caller_physical_device, &device_properties); + if (device_properties.apiVersion < VK_API_VERSION_1_1) { + skip |= LogError( + pnext_vuid, instance, loc.dot(Field::pNext), + "includes a pointer to a VkStructureType (VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PROTECTED_MEMORY_FEATURES) " + "which was added in VK_API_VERSION_1_1 but the " + "current effective API version is %s.", + StringAPIVersion(api_version).c_str()); + } + } + if (is_const_param) { + [[maybe_unused]] const Location pNext_loc = loc.pNext(Struct::VkPhysicalDeviceProtectedMemoryFeatures); + VkPhysicalDeviceProtectedMemoryFeatures* structure = (VkPhysicalDeviceProtectedMemoryFeatures*)header; + skip |= ValidateBool32(pNext_loc.dot(Field::protectedMemory), structure->protectedMemory); + } + } break; + + // Validation code for VkPhysicalDeviceSamplerYcbcrConversionFeatures structure members + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SAMPLER_YCBCR_CONVERSION_FEATURES: { // Covers + // VUID-VkPhysicalDeviceSamplerYcbcrConversionFeatures-sType-sType + + if ((is_physdev_api && !SupportedByPdev(physical_device, vvl::Extension::_VK_KHR_sampler_ycbcr_conversion)) || + (!is_physdev_api && !IsExtEnabled(device_extensions.vk_khr_sampler_ycbcr_conversion))) { + skip |= LogError(pnext_vuid, instance, loc.dot(Field::pNext), + "includes a pointer to a VkStructureType " + "(VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SAMPLER_YCBCR_CONVERSION_FEATURES), but its parent extension " + "VK_KHR_sampler_ycbcr_conversion has not been enabled."); + } + if (is_const_param) { + [[maybe_unused]] const Location pNext_loc = loc.pNext(Struct::VkPhysicalDeviceSamplerYcbcrConversionFeatures); + if (!IsExtEnabled(device_extensions.vk_khr_sampler_ycbcr_conversion)) { + skip |= LogError(pnext_vuid, instance, pNext_loc, + "includes a pointer to a VkPhysicalDeviceSamplerYcbcrConversionFeatures, but when creating " + "VkDevice, the parent extension " + "(VK_KHR_sampler_ycbcr_conversion) was not included in ppEnabledExtensionNames."); + } + VkPhysicalDeviceSamplerYcbcrConversionFeatures* structure = (VkPhysicalDeviceSamplerYcbcrConversionFeatures*)header; + skip |= ValidateBool32(pNext_loc.dot(Field::samplerYcbcrConversion), structure->samplerYcbcrConversion); + } + } break; + + // Validation code for VkPhysicalDeviceShaderDrawParametersFeatures structure members + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_DRAW_PARAMETERS_FEATURES: { // Covers + // VUID-VkPhysicalDeviceShaderDrawParametersFeatures-sType-sType + + if (is_physdev_api) { + VkPhysicalDeviceProperties device_properties = {}; + DispatchGetPhysicalDeviceProperties(caller_physical_device, &device_properties); + if (device_properties.apiVersion < VK_API_VERSION_1_1) { + skip |= LogError(pnext_vuid, instance, loc.dot(Field::pNext), + "includes a pointer to a VkStructureType " + "(VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_DRAW_PARAMETERS_FEATURES) which was added in " + "VK_API_VERSION_1_1 but the " + "current effective API version is %s.", + StringAPIVersion(api_version).c_str()); + } + } + if (is_const_param) { + [[maybe_unused]] const Location pNext_loc = loc.pNext(Struct::VkPhysicalDeviceShaderDrawParametersFeatures); + VkPhysicalDeviceShaderDrawParametersFeatures* structure = (VkPhysicalDeviceShaderDrawParametersFeatures*)header; + skip |= ValidateBool32(pNext_loc.dot(Field::shaderDrawParameters), structure->shaderDrawParameters); + } + } break; + + // Validation code for VkPhysicalDeviceVulkan11Features structure members + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_1_1_FEATURES: { // Covers VUID-VkPhysicalDeviceVulkan11Features-sType-sType + + if (is_physdev_api) { + VkPhysicalDeviceProperties device_properties = {}; + DispatchGetPhysicalDeviceProperties(caller_physical_device, &device_properties); + if (device_properties.apiVersion < VK_API_VERSION_1_2) { + skip |= + LogError(pnext_vuid, instance, loc.dot(Field::pNext), + "includes a pointer to a VkStructureType (VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_1_1_FEATURES) " + "which was added in VK_API_VERSION_1_2 but the " + "current effective API version is %s.", + StringAPIVersion(api_version).c_str()); + } + } + if (is_const_param) { + [[maybe_unused]] const Location pNext_loc = loc.pNext(Struct::VkPhysicalDeviceVulkan11Features); + VkPhysicalDeviceVulkan11Features* structure = (VkPhysicalDeviceVulkan11Features*)header; + skip |= ValidateBool32(pNext_loc.dot(Field::storageBuffer16BitAccess), structure->storageBuffer16BitAccess); + + skip |= ValidateBool32(pNext_loc.dot(Field::uniformAndStorageBuffer16BitAccess), + structure->uniformAndStorageBuffer16BitAccess); + + skip |= ValidateBool32(pNext_loc.dot(Field::storagePushConstant16), structure->storagePushConstant16); + + skip |= ValidateBool32(pNext_loc.dot(Field::storageInputOutput16), structure->storageInputOutput16); + + skip |= ValidateBool32(pNext_loc.dot(Field::multiview), structure->multiview); + + skip |= ValidateBool32(pNext_loc.dot(Field::multiviewGeometryShader), structure->multiviewGeometryShader); + + skip |= ValidateBool32(pNext_loc.dot(Field::multiviewTessellationShader), structure->multiviewTessellationShader); + + skip |= + ValidateBool32(pNext_loc.dot(Field::variablePointersStorageBuffer), structure->variablePointersStorageBuffer); + + skip |= ValidateBool32(pNext_loc.dot(Field::variablePointers), structure->variablePointers); + + skip |= ValidateBool32(pNext_loc.dot(Field::protectedMemory), structure->protectedMemory); + + skip |= ValidateBool32(pNext_loc.dot(Field::samplerYcbcrConversion), structure->samplerYcbcrConversion); + + skip |= ValidateBool32(pNext_loc.dot(Field::shaderDrawParameters), structure->shaderDrawParameters); + } + } break; + + // Validation code for VkPhysicalDeviceVulkan12Features structure members + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_1_2_FEATURES: { // Covers VUID-VkPhysicalDeviceVulkan12Features-sType-sType + + if (is_physdev_api) { + VkPhysicalDeviceProperties device_properties = {}; + DispatchGetPhysicalDeviceProperties(caller_physical_device, &device_properties); + if (device_properties.apiVersion < VK_API_VERSION_1_2) { + skip |= + LogError(pnext_vuid, instance, loc.dot(Field::pNext), + "includes a pointer to a VkStructureType (VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_1_2_FEATURES) " + "which was added in VK_API_VERSION_1_2 but the " + "current effective API version is %s.", + StringAPIVersion(api_version).c_str()); + } + } + if (is_const_param) { + [[maybe_unused]] const Location pNext_loc = loc.pNext(Struct::VkPhysicalDeviceVulkan12Features); + VkPhysicalDeviceVulkan12Features* structure = (VkPhysicalDeviceVulkan12Features*)header; + skip |= ValidateBool32(pNext_loc.dot(Field::samplerMirrorClampToEdge), structure->samplerMirrorClampToEdge); + + skip |= ValidateBool32(pNext_loc.dot(Field::drawIndirectCount), structure->drawIndirectCount); + + skip |= ValidateBool32(pNext_loc.dot(Field::storageBuffer8BitAccess), structure->storageBuffer8BitAccess); + + skip |= ValidateBool32(pNext_loc.dot(Field::uniformAndStorageBuffer8BitAccess), + structure->uniformAndStorageBuffer8BitAccess); + + skip |= ValidateBool32(pNext_loc.dot(Field::storagePushConstant8), structure->storagePushConstant8); + + skip |= ValidateBool32(pNext_loc.dot(Field::shaderBufferInt64Atomics), structure->shaderBufferInt64Atomics); + + skip |= ValidateBool32(pNext_loc.dot(Field::shaderSharedInt64Atomics), structure->shaderSharedInt64Atomics); + + skip |= ValidateBool32(pNext_loc.dot(Field::shaderFloat16), structure->shaderFloat16); + + skip |= ValidateBool32(pNext_loc.dot(Field::shaderInt8), structure->shaderInt8); + + skip |= ValidateBool32(pNext_loc.dot(Field::descriptorIndexing), structure->descriptorIndexing); + + skip |= ValidateBool32(pNext_loc.dot(Field::shaderInputAttachmentArrayDynamicIndexing), + structure->shaderInputAttachmentArrayDynamicIndexing); + + skip |= ValidateBool32(pNext_loc.dot(Field::shaderUniformTexelBufferArrayDynamicIndexing), + structure->shaderUniformTexelBufferArrayDynamicIndexing); + + skip |= ValidateBool32(pNext_loc.dot(Field::shaderStorageTexelBufferArrayDynamicIndexing), + structure->shaderStorageTexelBufferArrayDynamicIndexing); + + skip |= ValidateBool32(pNext_loc.dot(Field::shaderUniformBufferArrayNonUniformIndexing), + structure->shaderUniformBufferArrayNonUniformIndexing); + + skip |= ValidateBool32(pNext_loc.dot(Field::shaderSampledImageArrayNonUniformIndexing), + structure->shaderSampledImageArrayNonUniformIndexing); + + skip |= ValidateBool32(pNext_loc.dot(Field::shaderStorageBufferArrayNonUniformIndexing), + structure->shaderStorageBufferArrayNonUniformIndexing); + + skip |= ValidateBool32(pNext_loc.dot(Field::shaderStorageImageArrayNonUniformIndexing), + structure->shaderStorageImageArrayNonUniformIndexing); + + skip |= ValidateBool32(pNext_loc.dot(Field::shaderInputAttachmentArrayNonUniformIndexing), + structure->shaderInputAttachmentArrayNonUniformIndexing); + + skip |= ValidateBool32(pNext_loc.dot(Field::shaderUniformTexelBufferArrayNonUniformIndexing), + structure->shaderUniformTexelBufferArrayNonUniformIndexing); + + skip |= ValidateBool32(pNext_loc.dot(Field::shaderStorageTexelBufferArrayNonUniformIndexing), + structure->shaderStorageTexelBufferArrayNonUniformIndexing); + + skip |= ValidateBool32(pNext_loc.dot(Field::descriptorBindingUniformBufferUpdateAfterBind), + structure->descriptorBindingUniformBufferUpdateAfterBind); + + skip |= ValidateBool32(pNext_loc.dot(Field::descriptorBindingSampledImageUpdateAfterBind), + structure->descriptorBindingSampledImageUpdateAfterBind); + + skip |= ValidateBool32(pNext_loc.dot(Field::descriptorBindingStorageImageUpdateAfterBind), + structure->descriptorBindingStorageImageUpdateAfterBind); + + skip |= ValidateBool32(pNext_loc.dot(Field::descriptorBindingStorageBufferUpdateAfterBind), + structure->descriptorBindingStorageBufferUpdateAfterBind); + + skip |= ValidateBool32(pNext_loc.dot(Field::descriptorBindingUniformTexelBufferUpdateAfterBind), + structure->descriptorBindingUniformTexelBufferUpdateAfterBind); + + skip |= ValidateBool32(pNext_loc.dot(Field::descriptorBindingStorageTexelBufferUpdateAfterBind), + structure->descriptorBindingStorageTexelBufferUpdateAfterBind); + + skip |= ValidateBool32(pNext_loc.dot(Field::descriptorBindingUpdateUnusedWhilePending), + structure->descriptorBindingUpdateUnusedWhilePending); + + skip |= ValidateBool32(pNext_loc.dot(Field::descriptorBindingPartiallyBound), + structure->descriptorBindingPartiallyBound); + + skip |= ValidateBool32(pNext_loc.dot(Field::descriptorBindingVariableDescriptorCount), + structure->descriptorBindingVariableDescriptorCount); + + skip |= ValidateBool32(pNext_loc.dot(Field::runtimeDescriptorArray), structure->runtimeDescriptorArray); + + skip |= ValidateBool32(pNext_loc.dot(Field::samplerFilterMinmax), structure->samplerFilterMinmax); + + skip |= ValidateBool32(pNext_loc.dot(Field::scalarBlockLayout), structure->scalarBlockLayout); + + skip |= ValidateBool32(pNext_loc.dot(Field::imagelessFramebuffer), structure->imagelessFramebuffer); + + skip |= ValidateBool32(pNext_loc.dot(Field::uniformBufferStandardLayout), structure->uniformBufferStandardLayout); + + skip |= ValidateBool32(pNext_loc.dot(Field::shaderSubgroupExtendedTypes), structure->shaderSubgroupExtendedTypes); + + skip |= ValidateBool32(pNext_loc.dot(Field::separateDepthStencilLayouts), structure->separateDepthStencilLayouts); + + skip |= ValidateBool32(pNext_loc.dot(Field::hostQueryReset), structure->hostQueryReset); + + skip |= ValidateBool32(pNext_loc.dot(Field::timelineSemaphore), structure->timelineSemaphore); + + skip |= ValidateBool32(pNext_loc.dot(Field::bufferDeviceAddress), structure->bufferDeviceAddress); + + skip |= ValidateBool32(pNext_loc.dot(Field::bufferDeviceAddressCaptureReplay), + structure->bufferDeviceAddressCaptureReplay); + + skip |= + ValidateBool32(pNext_loc.dot(Field::bufferDeviceAddressMultiDevice), structure->bufferDeviceAddressMultiDevice); + + skip |= ValidateBool32(pNext_loc.dot(Field::vulkanMemoryModel), structure->vulkanMemoryModel); + + skip |= ValidateBool32(pNext_loc.dot(Field::vulkanMemoryModelDeviceScope), structure->vulkanMemoryModelDeviceScope); + + skip |= ValidateBool32(pNext_loc.dot(Field::vulkanMemoryModelAvailabilityVisibilityChains), + structure->vulkanMemoryModelAvailabilityVisibilityChains); + + skip |= ValidateBool32(pNext_loc.dot(Field::shaderOutputViewportIndex), structure->shaderOutputViewportIndex); + + skip |= ValidateBool32(pNext_loc.dot(Field::shaderOutputLayer), structure->shaderOutputLayer); + + skip |= ValidateBool32(pNext_loc.dot(Field::subgroupBroadcastDynamicId), structure->subgroupBroadcastDynamicId); + } + } break; + + // Validation code for VkPhysicalDevice8BitStorageFeatures structure members + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_8BIT_STORAGE_FEATURES: { // Covers + // VUID-VkPhysicalDevice8BitStorageFeatures-sType-sType + + if ((is_physdev_api && !SupportedByPdev(physical_device, vvl::Extension::_VK_KHR_8bit_storage)) || + (!is_physdev_api && !IsExtEnabled(device_extensions.vk_khr_8bit_storage))) { + skip |= LogError(pnext_vuid, instance, loc.dot(Field::pNext), + "includes a pointer to a VkStructureType " + "(VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_8BIT_STORAGE_FEATURES), but its parent extension " + "VK_KHR_8bit_storage has not been enabled."); + } + if (is_const_param) { + [[maybe_unused]] const Location pNext_loc = loc.pNext(Struct::VkPhysicalDevice8BitStorageFeatures); + if (!IsExtEnabled(device_extensions.vk_khr_8bit_storage)) { + skip |= LogError(pnext_vuid, instance, pNext_loc, + "includes a pointer to a VkPhysicalDevice8BitStorageFeatures, but when creating VkDevice, the " + "parent extension " + "(VK_KHR_8bit_storage) was not included in ppEnabledExtensionNames."); + } + VkPhysicalDevice8BitStorageFeatures* structure = (VkPhysicalDevice8BitStorageFeatures*)header; + skip |= ValidateBool32(pNext_loc.dot(Field::storageBuffer8BitAccess), structure->storageBuffer8BitAccess); + + skip |= ValidateBool32(pNext_loc.dot(Field::uniformAndStorageBuffer8BitAccess), + structure->uniformAndStorageBuffer8BitAccess); + + skip |= ValidateBool32(pNext_loc.dot(Field::storagePushConstant8), structure->storagePushConstant8); + } + } break; + + // Validation code for VkPhysicalDeviceShaderAtomicInt64Features structure members + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_ATOMIC_INT64_FEATURES: { // Covers + // VUID-VkPhysicalDeviceShaderAtomicInt64Features-sType-sType + + if ((is_physdev_api && !SupportedByPdev(physical_device, vvl::Extension::_VK_KHR_shader_atomic_int64)) || + (!is_physdev_api && !IsExtEnabled(device_extensions.vk_khr_shader_atomic_int64))) { + skip |= LogError(pnext_vuid, instance, loc.dot(Field::pNext), + "includes a pointer to a VkStructureType " + "(VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_ATOMIC_INT64_FEATURES), but its parent extension " + "VK_KHR_shader_atomic_int64 has not been enabled."); + } + if (is_const_param) { + [[maybe_unused]] const Location pNext_loc = loc.pNext(Struct::VkPhysicalDeviceShaderAtomicInt64Features); + if (!IsExtEnabled(device_extensions.vk_khr_shader_atomic_int64)) { + skip |= LogError(pnext_vuid, instance, pNext_loc, + "includes a pointer to a VkPhysicalDeviceShaderAtomicInt64Features, but when creating " + "VkDevice, the parent extension " + "(VK_KHR_shader_atomic_int64) was not included in ppEnabledExtensionNames."); + } + VkPhysicalDeviceShaderAtomicInt64Features* structure = (VkPhysicalDeviceShaderAtomicInt64Features*)header; + skip |= ValidateBool32(pNext_loc.dot(Field::shaderBufferInt64Atomics), structure->shaderBufferInt64Atomics); + + skip |= ValidateBool32(pNext_loc.dot(Field::shaderSharedInt64Atomics), structure->shaderSharedInt64Atomics); + } + } break; + + // Validation code for VkPhysicalDeviceShaderFloat16Int8Features structure members + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_FLOAT16_INT8_FEATURES: { // Covers + // VUID-VkPhysicalDeviceShaderFloat16Int8Features-sType-sType + + if ((is_physdev_api && !SupportedByPdev(physical_device, vvl::Extension::_VK_KHR_shader_float16_int8)) || + (!is_physdev_api && !IsExtEnabled(device_extensions.vk_khr_shader_float16_int8))) { + skip |= LogError(pnext_vuid, instance, loc.dot(Field::pNext), + "includes a pointer to a VkStructureType " + "(VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_FLOAT16_INT8_FEATURES), but its parent extension " + "VK_KHR_shader_float16_int8 has not been enabled."); + } + if (is_const_param) { + [[maybe_unused]] const Location pNext_loc = loc.pNext(Struct::VkPhysicalDeviceShaderFloat16Int8Features); + if (!IsExtEnabled(device_extensions.vk_khr_shader_float16_int8)) { + skip |= LogError(pnext_vuid, instance, pNext_loc, + "includes a pointer to a VkPhysicalDeviceShaderFloat16Int8Features, but when creating " + "VkDevice, the parent extension " + "(VK_KHR_shader_float16_int8) was not included in ppEnabledExtensionNames."); + } + VkPhysicalDeviceShaderFloat16Int8Features* structure = (VkPhysicalDeviceShaderFloat16Int8Features*)header; + skip |= ValidateBool32(pNext_loc.dot(Field::shaderFloat16), structure->shaderFloat16); + + skip |= ValidateBool32(pNext_loc.dot(Field::shaderInt8), structure->shaderInt8); + } + } break; + + // Validation code for VkPhysicalDeviceDescriptorIndexingFeatures structure members + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DESCRIPTOR_INDEXING_FEATURES: { // Covers + // VUID-VkPhysicalDeviceDescriptorIndexingFeatures-sType-sType + + if ((is_physdev_api && !SupportedByPdev(physical_device, vvl::Extension::_VK_EXT_descriptor_indexing)) || + (!is_physdev_api && !IsExtEnabled(device_extensions.vk_ext_descriptor_indexing))) { + skip |= LogError(pnext_vuid, instance, loc.dot(Field::pNext), + "includes a pointer to a VkStructureType " + "(VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DESCRIPTOR_INDEXING_FEATURES), but its parent extension " + "VK_EXT_descriptor_indexing has not been enabled."); + } + if (is_const_param) { + [[maybe_unused]] const Location pNext_loc = loc.pNext(Struct::VkPhysicalDeviceDescriptorIndexingFeatures); + if (!IsExtEnabled(device_extensions.vk_ext_descriptor_indexing)) { + skip |= LogError(pnext_vuid, instance, pNext_loc, + "includes a pointer to a VkPhysicalDeviceDescriptorIndexingFeatures, but when creating " + "VkDevice, the parent extension " + "(VK_EXT_descriptor_indexing) was not included in ppEnabledExtensionNames."); + } + VkPhysicalDeviceDescriptorIndexingFeatures* structure = (VkPhysicalDeviceDescriptorIndexingFeatures*)header; + skip |= ValidateBool32(pNext_loc.dot(Field::shaderInputAttachmentArrayDynamicIndexing), + structure->shaderInputAttachmentArrayDynamicIndexing); + + skip |= ValidateBool32(pNext_loc.dot(Field::shaderUniformTexelBufferArrayDynamicIndexing), + structure->shaderUniformTexelBufferArrayDynamicIndexing); + + skip |= ValidateBool32(pNext_loc.dot(Field::shaderStorageTexelBufferArrayDynamicIndexing), + structure->shaderStorageTexelBufferArrayDynamicIndexing); + + skip |= ValidateBool32(pNext_loc.dot(Field::shaderUniformBufferArrayNonUniformIndexing), + structure->shaderUniformBufferArrayNonUniformIndexing); + + skip |= ValidateBool32(pNext_loc.dot(Field::shaderSampledImageArrayNonUniformIndexing), + structure->shaderSampledImageArrayNonUniformIndexing); + + skip |= ValidateBool32(pNext_loc.dot(Field::shaderStorageBufferArrayNonUniformIndexing), + structure->shaderStorageBufferArrayNonUniformIndexing); + + skip |= ValidateBool32(pNext_loc.dot(Field::shaderStorageImageArrayNonUniformIndexing), + structure->shaderStorageImageArrayNonUniformIndexing); + + skip |= ValidateBool32(pNext_loc.dot(Field::shaderInputAttachmentArrayNonUniformIndexing), + structure->shaderInputAttachmentArrayNonUniformIndexing); + + skip |= ValidateBool32(pNext_loc.dot(Field::shaderUniformTexelBufferArrayNonUniformIndexing), + structure->shaderUniformTexelBufferArrayNonUniformIndexing); + + skip |= ValidateBool32(pNext_loc.dot(Field::shaderStorageTexelBufferArrayNonUniformIndexing), + structure->shaderStorageTexelBufferArrayNonUniformIndexing); + + skip |= ValidateBool32(pNext_loc.dot(Field::descriptorBindingUniformBufferUpdateAfterBind), + structure->descriptorBindingUniformBufferUpdateAfterBind); + + skip |= ValidateBool32(pNext_loc.dot(Field::descriptorBindingSampledImageUpdateAfterBind), + structure->descriptorBindingSampledImageUpdateAfterBind); + + skip |= ValidateBool32(pNext_loc.dot(Field::descriptorBindingStorageImageUpdateAfterBind), + structure->descriptorBindingStorageImageUpdateAfterBind); + + skip |= ValidateBool32(pNext_loc.dot(Field::descriptorBindingStorageBufferUpdateAfterBind), + structure->descriptorBindingStorageBufferUpdateAfterBind); + + skip |= ValidateBool32(pNext_loc.dot(Field::descriptorBindingUniformTexelBufferUpdateAfterBind), + structure->descriptorBindingUniformTexelBufferUpdateAfterBind); + + skip |= ValidateBool32(pNext_loc.dot(Field::descriptorBindingStorageTexelBufferUpdateAfterBind), + structure->descriptorBindingStorageTexelBufferUpdateAfterBind); + + skip |= ValidateBool32(pNext_loc.dot(Field::descriptorBindingUpdateUnusedWhilePending), + structure->descriptorBindingUpdateUnusedWhilePending); + + skip |= ValidateBool32(pNext_loc.dot(Field::descriptorBindingPartiallyBound), + structure->descriptorBindingPartiallyBound); + + skip |= ValidateBool32(pNext_loc.dot(Field::descriptorBindingVariableDescriptorCount), + structure->descriptorBindingVariableDescriptorCount); + + skip |= ValidateBool32(pNext_loc.dot(Field::runtimeDescriptorArray), structure->runtimeDescriptorArray); + } + } break; + + // Validation code for VkPhysicalDeviceScalarBlockLayoutFeatures structure members + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SCALAR_BLOCK_LAYOUT_FEATURES: { // Covers + // VUID-VkPhysicalDeviceScalarBlockLayoutFeatures-sType-sType + + if ((is_physdev_api && !SupportedByPdev(physical_device, vvl::Extension::_VK_EXT_scalar_block_layout)) || + (!is_physdev_api && !IsExtEnabled(device_extensions.vk_ext_scalar_block_layout))) { + skip |= LogError(pnext_vuid, instance, loc.dot(Field::pNext), + "includes a pointer to a VkStructureType " + "(VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SCALAR_BLOCK_LAYOUT_FEATURES), but its parent extension " + "VK_EXT_scalar_block_layout has not been enabled."); + } + if (is_const_param) { + [[maybe_unused]] const Location pNext_loc = loc.pNext(Struct::VkPhysicalDeviceScalarBlockLayoutFeatures); + if (!IsExtEnabled(device_extensions.vk_ext_scalar_block_layout)) { + skip |= LogError(pnext_vuid, instance, pNext_loc, + "includes a pointer to a VkPhysicalDeviceScalarBlockLayoutFeatures, but when creating " + "VkDevice, the parent extension " + "(VK_EXT_scalar_block_layout) was not included in ppEnabledExtensionNames."); + } + VkPhysicalDeviceScalarBlockLayoutFeatures* structure = (VkPhysicalDeviceScalarBlockLayoutFeatures*)header; + skip |= ValidateBool32(pNext_loc.dot(Field::scalarBlockLayout), structure->scalarBlockLayout); + } + } break; + + // Validation code for VkPhysicalDeviceVulkanMemoryModelFeatures structure members + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_MEMORY_MODEL_FEATURES: { // Covers + // VUID-VkPhysicalDeviceVulkanMemoryModelFeatures-sType-sType + + if ((is_physdev_api && !SupportedByPdev(physical_device, vvl::Extension::_VK_KHR_vulkan_memory_model)) || + (!is_physdev_api && !IsExtEnabled(device_extensions.vk_khr_vulkan_memory_model))) { + skip |= LogError(pnext_vuid, instance, loc.dot(Field::pNext), + "includes a pointer to a VkStructureType " + "(VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_MEMORY_MODEL_FEATURES), but its parent extension " + "VK_KHR_vulkan_memory_model has not been enabled."); + } + if (is_const_param) { + [[maybe_unused]] const Location pNext_loc = loc.pNext(Struct::VkPhysicalDeviceVulkanMemoryModelFeatures); + if (!IsExtEnabled(device_extensions.vk_khr_vulkan_memory_model)) { + skip |= LogError(pnext_vuid, instance, pNext_loc, + "includes a pointer to a VkPhysicalDeviceVulkanMemoryModelFeatures, but when creating " + "VkDevice, the parent extension " + "(VK_KHR_vulkan_memory_model) was not included in ppEnabledExtensionNames."); + } + VkPhysicalDeviceVulkanMemoryModelFeatures* structure = (VkPhysicalDeviceVulkanMemoryModelFeatures*)header; + skip |= ValidateBool32(pNext_loc.dot(Field::vulkanMemoryModel), structure->vulkanMemoryModel); + + skip |= ValidateBool32(pNext_loc.dot(Field::vulkanMemoryModelDeviceScope), structure->vulkanMemoryModelDeviceScope); + + skip |= ValidateBool32(pNext_loc.dot(Field::vulkanMemoryModelAvailabilityVisibilityChains), + structure->vulkanMemoryModelAvailabilityVisibilityChains); + } + } break; + + // Validation code for VkPhysicalDeviceImagelessFramebufferFeatures structure members + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGELESS_FRAMEBUFFER_FEATURES: { // Covers + // VUID-VkPhysicalDeviceImagelessFramebufferFeatures-sType-sType + + if ((is_physdev_api && !SupportedByPdev(physical_device, vvl::Extension::_VK_KHR_imageless_framebuffer)) || + (!is_physdev_api && !IsExtEnabled(device_extensions.vk_khr_imageless_framebuffer))) { + skip |= LogError(pnext_vuid, instance, loc.dot(Field::pNext), + "includes a pointer to a VkStructureType " + "(VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGELESS_FRAMEBUFFER_FEATURES), but its parent extension " + "VK_KHR_imageless_framebuffer has not been enabled."); + } + if (is_const_param) { + [[maybe_unused]] const Location pNext_loc = loc.pNext(Struct::VkPhysicalDeviceImagelessFramebufferFeatures); + if (!IsExtEnabled(device_extensions.vk_khr_imageless_framebuffer)) { + skip |= LogError(pnext_vuid, instance, pNext_loc, + "includes a pointer to a VkPhysicalDeviceImagelessFramebufferFeatures, but when creating " + "VkDevice, the parent extension " + "(VK_KHR_imageless_framebuffer) was not included in ppEnabledExtensionNames."); + } + VkPhysicalDeviceImagelessFramebufferFeatures* structure = (VkPhysicalDeviceImagelessFramebufferFeatures*)header; + skip |= ValidateBool32(pNext_loc.dot(Field::imagelessFramebuffer), structure->imagelessFramebuffer); + } + } break; + + // Validation code for VkPhysicalDeviceUniformBufferStandardLayoutFeatures structure members + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_UNIFORM_BUFFER_STANDARD_LAYOUT_FEATURES: { // Covers + // VUID-VkPhysicalDeviceUniformBufferStandardLayoutFeatures-sType-sType + + if ((is_physdev_api && !SupportedByPdev(physical_device, vvl::Extension::_VK_KHR_uniform_buffer_standard_layout)) || + (!is_physdev_api && !IsExtEnabled(device_extensions.vk_khr_uniform_buffer_standard_layout))) { + skip |= LogError( + pnext_vuid, instance, loc.dot(Field::pNext), + "includes a pointer to a VkStructureType " + "(VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_UNIFORM_BUFFER_STANDARD_LAYOUT_FEATURES), but its parent extension " + "VK_KHR_uniform_buffer_standard_layout has not been enabled."); + } + if (is_const_param) { + [[maybe_unused]] const Location pNext_loc = loc.pNext(Struct::VkPhysicalDeviceUniformBufferStandardLayoutFeatures); + if (!IsExtEnabled(device_extensions.vk_khr_uniform_buffer_standard_layout)) { + skip |= LogError(pnext_vuid, instance, pNext_loc, + "includes a pointer to a VkPhysicalDeviceUniformBufferStandardLayoutFeatures, but when " + "creating VkDevice, the parent extension " + "(VK_KHR_uniform_buffer_standard_layout) was not included in ppEnabledExtensionNames."); + } + VkPhysicalDeviceUniformBufferStandardLayoutFeatures* structure = + (VkPhysicalDeviceUniformBufferStandardLayoutFeatures*)header; + skip |= ValidateBool32(pNext_loc.dot(Field::uniformBufferStandardLayout), structure->uniformBufferStandardLayout); + } + } break; + + // Validation code for VkPhysicalDeviceShaderSubgroupExtendedTypesFeatures structure members + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_SUBGROUP_EXTENDED_TYPES_FEATURES: { // Covers + // VUID-VkPhysicalDeviceShaderSubgroupExtendedTypesFeatures-sType-sType + + if ((is_physdev_api && !SupportedByPdev(physical_device, vvl::Extension::_VK_KHR_shader_subgroup_extended_types)) || + (!is_physdev_api && !IsExtEnabled(device_extensions.vk_khr_shader_subgroup_extended_types))) { + skip |= LogError( + pnext_vuid, instance, loc.dot(Field::pNext), + "includes a pointer to a VkStructureType " + "(VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_SUBGROUP_EXTENDED_TYPES_FEATURES), but its parent extension " + "VK_KHR_shader_subgroup_extended_types has not been enabled."); + } + } break; + + // Validation code for VkPhysicalDeviceSeparateDepthStencilLayoutsFeatures structure members + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SEPARATE_DEPTH_STENCIL_LAYOUTS_FEATURES: { // Covers + // VUID-VkPhysicalDeviceSeparateDepthStencilLayoutsFeatures-sType-sType + + if ((is_physdev_api && !SupportedByPdev(physical_device, vvl::Extension::_VK_KHR_separate_depth_stencil_layouts)) || + (!is_physdev_api && !IsExtEnabled(device_extensions.vk_khr_separate_depth_stencil_layouts))) { + skip |= LogError( + pnext_vuid, instance, loc.dot(Field::pNext), + "includes a pointer to a VkStructureType " + "(VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SEPARATE_DEPTH_STENCIL_LAYOUTS_FEATURES), but its parent extension " + "VK_KHR_separate_depth_stencil_layouts has not been enabled."); + } + if (is_const_param) { + [[maybe_unused]] const Location pNext_loc = loc.pNext(Struct::VkPhysicalDeviceSeparateDepthStencilLayoutsFeatures); + if (!IsExtEnabled(device_extensions.vk_khr_separate_depth_stencil_layouts)) { + skip |= LogError(pnext_vuid, instance, pNext_loc, + "includes a pointer to a VkPhysicalDeviceSeparateDepthStencilLayoutsFeatures, but when " + "creating VkDevice, the parent extension " + "(VK_KHR_separate_depth_stencil_layouts) was not included in ppEnabledExtensionNames."); + } + VkPhysicalDeviceSeparateDepthStencilLayoutsFeatures* structure = + (VkPhysicalDeviceSeparateDepthStencilLayoutsFeatures*)header; + skip |= ValidateBool32(pNext_loc.dot(Field::separateDepthStencilLayouts), structure->separateDepthStencilLayouts); + } + } break; + + // Validation code for VkPhysicalDeviceHostQueryResetFeatures structure members + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_HOST_QUERY_RESET_FEATURES: { // Covers + // VUID-VkPhysicalDeviceHostQueryResetFeatures-sType-sType + + if ((is_physdev_api && !SupportedByPdev(physical_device, vvl::Extension::_VK_EXT_host_query_reset)) || + (!is_physdev_api && !IsExtEnabled(device_extensions.vk_ext_host_query_reset))) { + skip |= LogError(pnext_vuid, instance, loc.dot(Field::pNext), + "includes a pointer to a VkStructureType " + "(VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_HOST_QUERY_RESET_FEATURES), but its parent extension " + "VK_EXT_host_query_reset has not been enabled."); + } + if (is_const_param) { + [[maybe_unused]] const Location pNext_loc = loc.pNext(Struct::VkPhysicalDeviceHostQueryResetFeatures); + if (!IsExtEnabled(device_extensions.vk_ext_host_query_reset)) { + skip |= LogError(pnext_vuid, instance, pNext_loc, + "includes a pointer to a VkPhysicalDeviceHostQueryResetFeatures, but when creating VkDevice, " + "the parent extension " + "(VK_EXT_host_query_reset) was not included in ppEnabledExtensionNames."); + } + VkPhysicalDeviceHostQueryResetFeatures* structure = (VkPhysicalDeviceHostQueryResetFeatures*)header; + skip |= ValidateBool32(pNext_loc.dot(Field::hostQueryReset), structure->hostQueryReset); + } + } break; + + // Validation code for VkPhysicalDeviceTimelineSemaphoreFeatures structure members + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TIMELINE_SEMAPHORE_FEATURES: { // Covers + // VUID-VkPhysicalDeviceTimelineSemaphoreFeatures-sType-sType + + if ((is_physdev_api && !SupportedByPdev(physical_device, vvl::Extension::_VK_KHR_timeline_semaphore)) || + (!is_physdev_api && !IsExtEnabled(device_extensions.vk_khr_timeline_semaphore))) { + skip |= LogError(pnext_vuid, instance, loc.dot(Field::pNext), + "includes a pointer to a VkStructureType " + "(VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TIMELINE_SEMAPHORE_FEATURES), but its parent extension " + "VK_KHR_timeline_semaphore has not been enabled."); + } + if (is_const_param) { + [[maybe_unused]] const Location pNext_loc = loc.pNext(Struct::VkPhysicalDeviceTimelineSemaphoreFeatures); + if (!IsExtEnabled(device_extensions.vk_khr_timeline_semaphore)) { + skip |= LogError(pnext_vuid, instance, pNext_loc, + "includes a pointer to a VkPhysicalDeviceTimelineSemaphoreFeatures, but when creating " + "VkDevice, the parent extension " + "(VK_KHR_timeline_semaphore) was not included in ppEnabledExtensionNames."); + } + VkPhysicalDeviceTimelineSemaphoreFeatures* structure = (VkPhysicalDeviceTimelineSemaphoreFeatures*)header; + skip |= ValidateBool32(pNext_loc.dot(Field::timelineSemaphore), structure->timelineSemaphore); + } + } break; + + // Validation code for VkPhysicalDeviceBufferDeviceAddressFeatures structure members + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_BUFFER_DEVICE_ADDRESS_FEATURES: { // Covers + // VUID-VkPhysicalDeviceBufferDeviceAddressFeatures-sType-sType + + if ((is_physdev_api && !SupportedByPdev(physical_device, vvl::Extension::_VK_KHR_buffer_device_address)) || + (!is_physdev_api && !IsExtEnabled(device_extensions.vk_khr_buffer_device_address))) { + skip |= LogError(pnext_vuid, instance, loc.dot(Field::pNext), + "includes a pointer to a VkStructureType " + "(VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_BUFFER_DEVICE_ADDRESS_FEATURES), but its parent extension " + "VK_KHR_buffer_device_address has not been enabled."); + } + if (is_const_param) { + [[maybe_unused]] const Location pNext_loc = loc.pNext(Struct::VkPhysicalDeviceBufferDeviceAddressFeatures); + if (!IsExtEnabled(device_extensions.vk_khr_buffer_device_address)) { + skip |= LogError(pnext_vuid, instance, pNext_loc, + "includes a pointer to a VkPhysicalDeviceBufferDeviceAddressFeatures, but when creating " + "VkDevice, the parent extension " + "(VK_KHR_buffer_device_address) was not included in ppEnabledExtensionNames."); + } + VkPhysicalDeviceBufferDeviceAddressFeatures* structure = (VkPhysicalDeviceBufferDeviceAddressFeatures*)header; + skip |= ValidateBool32(pNext_loc.dot(Field::bufferDeviceAddress), structure->bufferDeviceAddress); + + skip |= ValidateBool32(pNext_loc.dot(Field::bufferDeviceAddressCaptureReplay), + structure->bufferDeviceAddressCaptureReplay); + + skip |= + ValidateBool32(pNext_loc.dot(Field::bufferDeviceAddressMultiDevice), structure->bufferDeviceAddressMultiDevice); + } + } break; + + // Validation code for VkPhysicalDeviceVulkan13Features structure members + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_1_3_FEATURES: { // Covers VUID-VkPhysicalDeviceVulkan13Features-sType-sType + + if (is_physdev_api) { + VkPhysicalDeviceProperties device_properties = {}; + DispatchGetPhysicalDeviceProperties(caller_physical_device, &device_properties); + if (device_properties.apiVersion < VK_API_VERSION_1_3) { + skip |= + LogError(pnext_vuid, instance, loc.dot(Field::pNext), + "includes a pointer to a VkStructureType (VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_1_3_FEATURES) " + "which was added in VK_API_VERSION_1_3 but the " + "current effective API version is %s.", + StringAPIVersion(api_version).c_str()); + } + } + if (is_const_param) { + [[maybe_unused]] const Location pNext_loc = loc.pNext(Struct::VkPhysicalDeviceVulkan13Features); + VkPhysicalDeviceVulkan13Features* structure = (VkPhysicalDeviceVulkan13Features*)header; + skip |= ValidateBool32(pNext_loc.dot(Field::robustImageAccess), structure->robustImageAccess); + + skip |= ValidateBool32(pNext_loc.dot(Field::inlineUniformBlock), structure->inlineUniformBlock); + + skip |= ValidateBool32(pNext_loc.dot(Field::descriptorBindingInlineUniformBlockUpdateAfterBind), + structure->descriptorBindingInlineUniformBlockUpdateAfterBind); + + skip |= ValidateBool32(pNext_loc.dot(Field::pipelineCreationCacheControl), structure->pipelineCreationCacheControl); + + skip |= ValidateBool32(pNext_loc.dot(Field::privateData), structure->privateData); + + skip |= + ValidateBool32(pNext_loc.dot(Field::shaderDemoteToHelperInvocation), structure->shaderDemoteToHelperInvocation); + + skip |= ValidateBool32(pNext_loc.dot(Field::shaderTerminateInvocation), structure->shaderTerminateInvocation); + + skip |= ValidateBool32(pNext_loc.dot(Field::subgroupSizeControl), structure->subgroupSizeControl); + + skip |= ValidateBool32(pNext_loc.dot(Field::computeFullSubgroups), structure->computeFullSubgroups); + + skip |= ValidateBool32(pNext_loc.dot(Field::synchronization2), structure->synchronization2); + + skip |= ValidateBool32(pNext_loc.dot(Field::textureCompressionASTC_HDR), structure->textureCompressionASTC_HDR); + + skip |= ValidateBool32(pNext_loc.dot(Field::shaderZeroInitializeWorkgroupMemory), + structure->shaderZeroInitializeWorkgroupMemory); + + skip |= ValidateBool32(pNext_loc.dot(Field::dynamicRendering), structure->dynamicRendering); + + skip |= ValidateBool32(pNext_loc.dot(Field::shaderIntegerDotProduct), structure->shaderIntegerDotProduct); + + skip |= ValidateBool32(pNext_loc.dot(Field::maintenance4), structure->maintenance4); + } + } break; + + // Validation code for VkPhysicalDeviceShaderTerminateInvocationFeatures structure members + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_TERMINATE_INVOCATION_FEATURES: { // Covers + // VUID-VkPhysicalDeviceShaderTerminateInvocationFeatures-sType-sType + + if ((is_physdev_api && !SupportedByPdev(physical_device, vvl::Extension::_VK_KHR_shader_terminate_invocation)) || + (!is_physdev_api && !IsExtEnabled(device_extensions.vk_khr_shader_terminate_invocation))) { + skip |= + LogError(pnext_vuid, instance, loc.dot(Field::pNext), + "includes a pointer to a VkStructureType " + "(VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_TERMINATE_INVOCATION_FEATURES), but its parent extension " + "VK_KHR_shader_terminate_invocation has not been enabled."); + } + if (is_const_param) { + [[maybe_unused]] const Location pNext_loc = loc.pNext(Struct::VkPhysicalDeviceShaderTerminateInvocationFeatures); + if (!IsExtEnabled(device_extensions.vk_khr_shader_terminate_invocation)) { + skip |= LogError(pnext_vuid, instance, pNext_loc, + "includes a pointer to a VkPhysicalDeviceShaderTerminateInvocationFeatures, but when creating " + "VkDevice, the parent extension " + "(VK_KHR_shader_terminate_invocation) was not included in ppEnabledExtensionNames."); + } + VkPhysicalDeviceShaderTerminateInvocationFeatures* structure = + (VkPhysicalDeviceShaderTerminateInvocationFeatures*)header; + skip |= ValidateBool32(pNext_loc.dot(Field::shaderTerminateInvocation), structure->shaderTerminateInvocation); + } + } break; + + // Validation code for VkPhysicalDeviceShaderDemoteToHelperInvocationFeatures structure members + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_DEMOTE_TO_HELPER_INVOCATION_FEATURES: { // Covers + // VUID-VkPhysicalDeviceShaderDemoteToHelperInvocationFeatures-sType-sType + + if ((is_physdev_api && !SupportedByPdev(physical_device, vvl::Extension::_VK_EXT_shader_demote_to_helper_invocation)) || + (!is_physdev_api && !IsExtEnabled(device_extensions.vk_ext_shader_demote_to_helper_invocation))) { + skip |= LogError( + pnext_vuid, instance, loc.dot(Field::pNext), + "includes a pointer to a VkStructureType " + "(VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_DEMOTE_TO_HELPER_INVOCATION_FEATURES), but its parent extension " + "VK_EXT_shader_demote_to_helper_invocation has not been enabled."); + } + if (is_const_param) { + [[maybe_unused]] const Location pNext_loc = + loc.pNext(Struct::VkPhysicalDeviceShaderDemoteToHelperInvocationFeatures); + if (!IsExtEnabled(device_extensions.vk_ext_shader_demote_to_helper_invocation)) { + skip |= LogError(pnext_vuid, instance, pNext_loc, + "includes a pointer to a VkPhysicalDeviceShaderDemoteToHelperInvocationFeatures, but when " + "creating VkDevice, the parent extension " + "(VK_EXT_shader_demote_to_helper_invocation) was not included in ppEnabledExtensionNames."); + } + VkPhysicalDeviceShaderDemoteToHelperInvocationFeatures* structure = + (VkPhysicalDeviceShaderDemoteToHelperInvocationFeatures*)header; + skip |= + ValidateBool32(pNext_loc.dot(Field::shaderDemoteToHelperInvocation), structure->shaderDemoteToHelperInvocation); + } + } break; + + // Validation code for VkPhysicalDevicePrivateDataFeatures structure members + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PRIVATE_DATA_FEATURES: { // Covers + // VUID-VkPhysicalDevicePrivateDataFeatures-sType-sType + + if ((is_physdev_api && !SupportedByPdev(physical_device, vvl::Extension::_VK_EXT_private_data)) || + (!is_physdev_api && !IsExtEnabled(device_extensions.vk_ext_private_data))) { + skip |= LogError(pnext_vuid, instance, loc.dot(Field::pNext), + "includes a pointer to a VkStructureType " + "(VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PRIVATE_DATA_FEATURES), but its parent extension " + "VK_EXT_private_data has not been enabled."); + } + if (is_const_param) { + [[maybe_unused]] const Location pNext_loc = loc.pNext(Struct::VkPhysicalDevicePrivateDataFeatures); + if (!IsExtEnabled(device_extensions.vk_ext_private_data)) { + skip |= LogError(pnext_vuid, instance, pNext_loc, + "includes a pointer to a VkPhysicalDevicePrivateDataFeatures, but when creating VkDevice, the " + "parent extension " + "(VK_EXT_private_data) was not included in ppEnabledExtensionNames."); + } + VkPhysicalDevicePrivateDataFeatures* structure = (VkPhysicalDevicePrivateDataFeatures*)header; + skip |= ValidateBool32(pNext_loc.dot(Field::privateData), structure->privateData); + } + } break; + + // Validation code for VkPhysicalDevicePipelineCreationCacheControlFeatures structure members + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PIPELINE_CREATION_CACHE_CONTROL_FEATURES: { // Covers + // VUID-VkPhysicalDevicePipelineCreationCacheControlFeatures-sType-sType + + if ((is_physdev_api && !SupportedByPdev(physical_device, vvl::Extension::_VK_EXT_pipeline_creation_cache_control)) || + (!is_physdev_api && !IsExtEnabled(device_extensions.vk_ext_pipeline_creation_cache_control))) { + skip |= LogError( + pnext_vuid, instance, loc.dot(Field::pNext), + "includes a pointer to a VkStructureType " + "(VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PIPELINE_CREATION_CACHE_CONTROL_FEATURES), but its parent extension " + "VK_EXT_pipeline_creation_cache_control has not been enabled."); + } + if (is_const_param) { + [[maybe_unused]] const Location pNext_loc = loc.pNext(Struct::VkPhysicalDevicePipelineCreationCacheControlFeatures); + if (!IsExtEnabled(device_extensions.vk_ext_pipeline_creation_cache_control)) { + skip |= LogError(pnext_vuid, instance, pNext_loc, + "includes a pointer to a VkPhysicalDevicePipelineCreationCacheControlFeatures, but when " + "creating VkDevice, the parent extension " + "(VK_EXT_pipeline_creation_cache_control) was not included in ppEnabledExtensionNames."); + } + VkPhysicalDevicePipelineCreationCacheControlFeatures* structure = + (VkPhysicalDevicePipelineCreationCacheControlFeatures*)header; + skip |= ValidateBool32(pNext_loc.dot(Field::pipelineCreationCacheControl), structure->pipelineCreationCacheControl); + } + } break; + + // Validation code for VkPhysicalDeviceSynchronization2Features structure members + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SYNCHRONIZATION_2_FEATURES: { // Covers + // VUID-VkPhysicalDeviceSynchronization2Features-sType-sType + + if ((is_physdev_api && !SupportedByPdev(physical_device, vvl::Extension::_VK_KHR_synchronization2)) || + (!is_physdev_api && !IsExtEnabled(device_extensions.vk_khr_synchronization2))) { + skip |= LogError(pnext_vuid, instance, loc.dot(Field::pNext), + "includes a pointer to a VkStructureType " + "(VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SYNCHRONIZATION_2_FEATURES), but its parent extension " + "VK_KHR_synchronization2 has not been enabled."); + } + if (is_const_param) { + [[maybe_unused]] const Location pNext_loc = loc.pNext(Struct::VkPhysicalDeviceSynchronization2Features); + if (!IsExtEnabled(device_extensions.vk_khr_synchronization2)) { + skip |= LogError(pnext_vuid, instance, pNext_loc, + "includes a pointer to a VkPhysicalDeviceSynchronization2Features, but when creating " + "VkDevice, the parent extension " + "(VK_KHR_synchronization2) was not included in ppEnabledExtensionNames."); + } + VkPhysicalDeviceSynchronization2Features* structure = (VkPhysicalDeviceSynchronization2Features*)header; + skip |= ValidateBool32(pNext_loc.dot(Field::synchronization2), structure->synchronization2); + } + } break; + + // Validation code for VkPhysicalDeviceZeroInitializeWorkgroupMemoryFeatures structure members + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ZERO_INITIALIZE_WORKGROUP_MEMORY_FEATURES: { // Covers + // VUID-VkPhysicalDeviceZeroInitializeWorkgroupMemoryFeatures-sType-sType + + if ((is_physdev_api && !SupportedByPdev(physical_device, vvl::Extension::_VK_KHR_zero_initialize_workgroup_memory)) || + (!is_physdev_api && !IsExtEnabled(device_extensions.vk_khr_zero_initialize_workgroup_memory))) { + skip |= LogError( + pnext_vuid, instance, loc.dot(Field::pNext), + "includes a pointer to a VkStructureType " + "(VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ZERO_INITIALIZE_WORKGROUP_MEMORY_FEATURES), but its parent extension " + "VK_KHR_zero_initialize_workgroup_memory has not been enabled."); + } + if (is_const_param) { + [[maybe_unused]] const Location pNext_loc = + loc.pNext(Struct::VkPhysicalDeviceZeroInitializeWorkgroupMemoryFeatures); + if (!IsExtEnabled(device_extensions.vk_khr_zero_initialize_workgroup_memory)) { + skip |= LogError(pnext_vuid, instance, pNext_loc, + "includes a pointer to a VkPhysicalDeviceZeroInitializeWorkgroupMemoryFeatures, but when " + "creating VkDevice, the parent extension " + "(VK_KHR_zero_initialize_workgroup_memory) was not included in ppEnabledExtensionNames."); + } + VkPhysicalDeviceZeroInitializeWorkgroupMemoryFeatures* structure = + (VkPhysicalDeviceZeroInitializeWorkgroupMemoryFeatures*)header; + skip |= ValidateBool32(pNext_loc.dot(Field::shaderZeroInitializeWorkgroupMemory), + structure->shaderZeroInitializeWorkgroupMemory); + } + } break; + + // Validation code for VkPhysicalDeviceImageRobustnessFeatures structure members + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_ROBUSTNESS_FEATURES: { // Covers + // VUID-VkPhysicalDeviceImageRobustnessFeatures-sType-sType + + if ((is_physdev_api && !SupportedByPdev(physical_device, vvl::Extension::_VK_EXT_image_robustness)) || + (!is_physdev_api && !IsExtEnabled(device_extensions.vk_ext_image_robustness))) { + skip |= LogError(pnext_vuid, instance, loc.dot(Field::pNext), + "includes a pointer to a VkStructureType " + "(VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_ROBUSTNESS_FEATURES), but its parent extension " + "VK_EXT_image_robustness has not been enabled."); + } + if (is_const_param) { + [[maybe_unused]] const Location pNext_loc = loc.pNext(Struct::VkPhysicalDeviceImageRobustnessFeatures); + if (!IsExtEnabled(device_extensions.vk_ext_image_robustness)) { + skip |= LogError(pnext_vuid, instance, pNext_loc, + "includes a pointer to a VkPhysicalDeviceImageRobustnessFeatures, but when creating VkDevice, " + "the parent extension " + "(VK_EXT_image_robustness) was not included in ppEnabledExtensionNames."); + } + VkPhysicalDeviceImageRobustnessFeatures* structure = (VkPhysicalDeviceImageRobustnessFeatures*)header; + skip |= ValidateBool32(pNext_loc.dot(Field::robustImageAccess), structure->robustImageAccess); + } + } break; + + // Validation code for VkPhysicalDeviceSubgroupSizeControlFeatures structure members + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SUBGROUP_SIZE_CONTROL_FEATURES: { // Covers + // VUID-VkPhysicalDeviceSubgroupSizeControlFeatures-sType-sType + + if ((is_physdev_api && !SupportedByPdev(physical_device, vvl::Extension::_VK_EXT_subgroup_size_control)) || + (!is_physdev_api && !IsExtEnabled(device_extensions.vk_ext_subgroup_size_control))) { + skip |= LogError(pnext_vuid, instance, loc.dot(Field::pNext), + "includes a pointer to a VkStructureType " + "(VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SUBGROUP_SIZE_CONTROL_FEATURES), but its parent extension " + "VK_EXT_subgroup_size_control has not been enabled."); + } + if (is_const_param) { + [[maybe_unused]] const Location pNext_loc = loc.pNext(Struct::VkPhysicalDeviceSubgroupSizeControlFeatures); + if (!IsExtEnabled(device_extensions.vk_ext_subgroup_size_control)) { + skip |= LogError(pnext_vuid, instance, pNext_loc, + "includes a pointer to a VkPhysicalDeviceSubgroupSizeControlFeatures, but when creating " + "VkDevice, the parent extension " + "(VK_EXT_subgroup_size_control) was not included in ppEnabledExtensionNames."); + } + VkPhysicalDeviceSubgroupSizeControlFeatures* structure = (VkPhysicalDeviceSubgroupSizeControlFeatures*)header; + skip |= ValidateBool32(pNext_loc.dot(Field::subgroupSizeControl), structure->subgroupSizeControl); + + skip |= ValidateBool32(pNext_loc.dot(Field::computeFullSubgroups), structure->computeFullSubgroups); + } + } break; + + // Validation code for VkPhysicalDeviceInlineUniformBlockFeatures structure members + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_INLINE_UNIFORM_BLOCK_FEATURES: { // Covers + // VUID-VkPhysicalDeviceInlineUniformBlockFeatures-sType-sType + + if ((is_physdev_api && !SupportedByPdev(physical_device, vvl::Extension::_VK_EXT_inline_uniform_block)) || + (!is_physdev_api && !IsExtEnabled(device_extensions.vk_ext_inline_uniform_block))) { + skip |= LogError(pnext_vuid, instance, loc.dot(Field::pNext), + "includes a pointer to a VkStructureType " + "(VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_INLINE_UNIFORM_BLOCK_FEATURES), but its parent extension " + "VK_EXT_inline_uniform_block has not been enabled."); + } + if (is_const_param) { + [[maybe_unused]] const Location pNext_loc = loc.pNext(Struct::VkPhysicalDeviceInlineUniformBlockFeatures); + if (!IsExtEnabled(device_extensions.vk_ext_inline_uniform_block)) { + skip |= LogError(pnext_vuid, instance, pNext_loc, + "includes a pointer to a VkPhysicalDeviceInlineUniformBlockFeatures, but when creating " + "VkDevice, the parent extension " + "(VK_EXT_inline_uniform_block) was not included in ppEnabledExtensionNames."); + } + VkPhysicalDeviceInlineUniformBlockFeatures* structure = (VkPhysicalDeviceInlineUniformBlockFeatures*)header; + skip |= ValidateBool32(pNext_loc.dot(Field::inlineUniformBlock), structure->inlineUniformBlock); + + skip |= ValidateBool32(pNext_loc.dot(Field::descriptorBindingInlineUniformBlockUpdateAfterBind), + structure->descriptorBindingInlineUniformBlockUpdateAfterBind); + } + } break; + + // Validation code for VkPhysicalDeviceTextureCompressionASTCHDRFeatures structure members + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TEXTURE_COMPRESSION_ASTC_HDR_FEATURES: { // Covers + // VUID-VkPhysicalDeviceTextureCompressionASTCHDRFeatures-sType-sType + + if ((is_physdev_api && !SupportedByPdev(physical_device, vvl::Extension::_VK_EXT_texture_compression_astc_hdr)) || + (!is_physdev_api && !IsExtEnabled(device_extensions.vk_ext_texture_compression_astc_hdr))) { + skip |= + LogError(pnext_vuid, instance, loc.dot(Field::pNext), + "includes a pointer to a VkStructureType " + "(VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TEXTURE_COMPRESSION_ASTC_HDR_FEATURES), but its parent extension " + "VK_EXT_texture_compression_astc_hdr has not been enabled."); + } + if (is_const_param) { + [[maybe_unused]] const Location pNext_loc = loc.pNext(Struct::VkPhysicalDeviceTextureCompressionASTCHDRFeatures); + if (!IsExtEnabled(device_extensions.vk_ext_texture_compression_astc_hdr)) { + skip |= LogError(pnext_vuid, instance, pNext_loc, + "includes a pointer to a VkPhysicalDeviceTextureCompressionASTCHDRFeatures, but when creating " + "VkDevice, the parent extension " + "(VK_EXT_texture_compression_astc_hdr) was not included in ppEnabledExtensionNames."); + } + VkPhysicalDeviceTextureCompressionASTCHDRFeatures* structure = + (VkPhysicalDeviceTextureCompressionASTCHDRFeatures*)header; + skip |= ValidateBool32(pNext_loc.dot(Field::textureCompressionASTC_HDR), structure->textureCompressionASTC_HDR); + } + } break; + + // Validation code for VkPhysicalDeviceDynamicRenderingFeatures structure members + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DYNAMIC_RENDERING_FEATURES: { // Covers + // VUID-VkPhysicalDeviceDynamicRenderingFeatures-sType-sType + + if ((is_physdev_api && !SupportedByPdev(physical_device, vvl::Extension::_VK_KHR_dynamic_rendering)) || + (!is_physdev_api && !IsExtEnabled(device_extensions.vk_khr_dynamic_rendering))) { + skip |= LogError(pnext_vuid, instance, loc.dot(Field::pNext), + "includes a pointer to a VkStructureType " + "(VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DYNAMIC_RENDERING_FEATURES), but its parent extension " + "VK_KHR_dynamic_rendering has not been enabled."); + } + if (is_const_param) { + [[maybe_unused]] const Location pNext_loc = loc.pNext(Struct::VkPhysicalDeviceDynamicRenderingFeatures); + if (!IsExtEnabled(device_extensions.vk_khr_dynamic_rendering)) { + skip |= LogError(pnext_vuid, instance, pNext_loc, + "includes a pointer to a VkPhysicalDeviceDynamicRenderingFeatures, but when creating " + "VkDevice, the parent extension " + "(VK_KHR_dynamic_rendering) was not included in ppEnabledExtensionNames."); + } + VkPhysicalDeviceDynamicRenderingFeatures* structure = (VkPhysicalDeviceDynamicRenderingFeatures*)header; + skip |= ValidateBool32(pNext_loc.dot(Field::dynamicRendering), structure->dynamicRendering); + } + } break; + + // Validation code for VkPhysicalDeviceShaderIntegerDotProductFeatures structure members + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_INTEGER_DOT_PRODUCT_FEATURES: { // Covers + // VUID-VkPhysicalDeviceShaderIntegerDotProductFeatures-sType-sType + + if ((is_physdev_api && !SupportedByPdev(physical_device, vvl::Extension::_VK_KHR_shader_integer_dot_product)) || + (!is_physdev_api && !IsExtEnabled(device_extensions.vk_khr_shader_integer_dot_product))) { + skip |= + LogError(pnext_vuid, instance, loc.dot(Field::pNext), + "includes a pointer to a VkStructureType " + "(VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_INTEGER_DOT_PRODUCT_FEATURES), but its parent extension " + "VK_KHR_shader_integer_dot_product has not been enabled."); + } + if (is_const_param) { + [[maybe_unused]] const Location pNext_loc = loc.pNext(Struct::VkPhysicalDeviceShaderIntegerDotProductFeatures); + if (!IsExtEnabled(device_extensions.vk_khr_shader_integer_dot_product)) { + skip |= LogError(pnext_vuid, instance, pNext_loc, + "includes a pointer to a VkPhysicalDeviceShaderIntegerDotProductFeatures, but when creating " + "VkDevice, the parent extension " + "(VK_KHR_shader_integer_dot_product) was not included in ppEnabledExtensionNames."); + } + VkPhysicalDeviceShaderIntegerDotProductFeatures* structure = + (VkPhysicalDeviceShaderIntegerDotProductFeatures*)header; + skip |= ValidateBool32(pNext_loc.dot(Field::shaderIntegerDotProduct), structure->shaderIntegerDotProduct); + } + } break; + + // Validation code for VkPhysicalDeviceMaintenance4Features structure members + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MAINTENANCE_4_FEATURES: { // Covers + // VUID-VkPhysicalDeviceMaintenance4Features-sType-sType + + if ((is_physdev_api && !SupportedByPdev(physical_device, vvl::Extension::_VK_KHR_maintenance4)) || + (!is_physdev_api && !IsExtEnabled(device_extensions.vk_khr_maintenance4))) { + skip |= LogError(pnext_vuid, instance, loc.dot(Field::pNext), + "includes a pointer to a VkStructureType " + "(VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MAINTENANCE_4_FEATURES), but its parent extension " + "VK_KHR_maintenance4 has not been enabled."); + } + if (is_const_param) { + [[maybe_unused]] const Location pNext_loc = loc.pNext(Struct::VkPhysicalDeviceMaintenance4Features); + if (!IsExtEnabled(device_extensions.vk_khr_maintenance4)) { + skip |= LogError(pnext_vuid, instance, pNext_loc, + "includes a pointer to a VkPhysicalDeviceMaintenance4Features, but when creating VkDevice, " + "the parent extension " + "(VK_KHR_maintenance4) was not included in ppEnabledExtensionNames."); + } + VkPhysicalDeviceMaintenance4Features* structure = (VkPhysicalDeviceMaintenance4Features*)header; + skip |= ValidateBool32(pNext_loc.dot(Field::maintenance4), structure->maintenance4); + } + } break; + + // Validation code for VkPhysicalDevicePerformanceQueryFeaturesKHR structure members + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PERFORMANCE_QUERY_FEATURES_KHR: { // Covers + // VUID-VkPhysicalDevicePerformanceQueryFeaturesKHR-sType-sType + if (is_const_param) { + [[maybe_unused]] const Location pNext_loc = loc.pNext(Struct::VkPhysicalDevicePerformanceQueryFeaturesKHR); + if (!IsExtEnabled(device_extensions.vk_khr_performance_query)) { + skip |= LogError(pnext_vuid, instance, pNext_loc, + "includes a pointer to a VkPhysicalDevicePerformanceQueryFeaturesKHR, but when creating " + "VkDevice, the parent extension " + "(VK_KHR_performance_query) was not included in ppEnabledExtensionNames."); + } + VkPhysicalDevicePerformanceQueryFeaturesKHR* structure = (VkPhysicalDevicePerformanceQueryFeaturesKHR*)header; + skip |= ValidateBool32(pNext_loc.dot(Field::performanceCounterQueryPools), structure->performanceCounterQueryPools); + + skip |= ValidateBool32(pNext_loc.dot(Field::performanceCounterMultipleQueryPools), + structure->performanceCounterMultipleQueryPools); + } + } break; +#ifdef VK_ENABLE_BETA_EXTENSIONS + + // Validation code for VkPhysicalDevicePortabilitySubsetFeaturesKHR structure members + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PORTABILITY_SUBSET_FEATURES_KHR: { // Covers + // VUID-VkPhysicalDevicePortabilitySubsetFeaturesKHR-sType-sType + if (is_const_param) { + [[maybe_unused]] const Location pNext_loc = loc.pNext(Struct::VkPhysicalDevicePortabilitySubsetFeaturesKHR); + if (!IsExtEnabled(device_extensions.vk_khr_portability_subset)) { + skip |= LogError(pnext_vuid, instance, pNext_loc, + "includes a pointer to a VkPhysicalDevicePortabilitySubsetFeaturesKHR, but when creating " + "VkDevice, the parent extension " + "(VK_KHR_portability_subset) was not included in ppEnabledExtensionNames."); + } + VkPhysicalDevicePortabilitySubsetFeaturesKHR* structure = (VkPhysicalDevicePortabilitySubsetFeaturesKHR*)header; + skip |= + ValidateBool32(pNext_loc.dot(Field::constantAlphaColorBlendFactors), structure->constantAlphaColorBlendFactors); + + skip |= ValidateBool32(pNext_loc.dot(Field::events), structure->events); + + skip |= ValidateBool32(pNext_loc.dot(Field::imageViewFormatReinterpretation), + structure->imageViewFormatReinterpretation); + + skip |= ValidateBool32(pNext_loc.dot(Field::imageViewFormatSwizzle), structure->imageViewFormatSwizzle); + + skip |= ValidateBool32(pNext_loc.dot(Field::imageView2DOn3DImage), structure->imageView2DOn3DImage); + + skip |= ValidateBool32(pNext_loc.dot(Field::multisampleArrayImage), structure->multisampleArrayImage); + + skip |= ValidateBool32(pNext_loc.dot(Field::mutableComparisonSamplers), structure->mutableComparisonSamplers); + + skip |= ValidateBool32(pNext_loc.dot(Field::pointPolygons), structure->pointPolygons); + + skip |= ValidateBool32(pNext_loc.dot(Field::samplerMipLodBias), structure->samplerMipLodBias); + + skip |= ValidateBool32(pNext_loc.dot(Field::separateStencilMaskRef), structure->separateStencilMaskRef); + + skip |= ValidateBool32(pNext_loc.dot(Field::shaderSampleRateInterpolationFunctions), + structure->shaderSampleRateInterpolationFunctions); + + skip |= ValidateBool32(pNext_loc.dot(Field::tessellationIsolines), structure->tessellationIsolines); + + skip |= ValidateBool32(pNext_loc.dot(Field::tessellationPointMode), structure->tessellationPointMode); + + skip |= ValidateBool32(pNext_loc.dot(Field::triangleFans), structure->triangleFans); + + skip |= ValidateBool32(pNext_loc.dot(Field::vertexAttributeAccessBeyondStride), + structure->vertexAttributeAccessBeyondStride); + } + } break; +#endif // VK_ENABLE_BETA_EXTENSIONS + + // Validation code for VkPhysicalDeviceShaderClockFeaturesKHR structure members + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_CLOCK_FEATURES_KHR: { // Covers + // VUID-VkPhysicalDeviceShaderClockFeaturesKHR-sType-sType + if (is_const_param) { + [[maybe_unused]] const Location pNext_loc = loc.pNext(Struct::VkPhysicalDeviceShaderClockFeaturesKHR); + if (!IsExtEnabled(device_extensions.vk_khr_shader_clock)) { + skip |= LogError(pnext_vuid, instance, pNext_loc, + "includes a pointer to a VkPhysicalDeviceShaderClockFeaturesKHR, but when creating VkDevice, " + "the parent extension " + "(VK_KHR_shader_clock) was not included in ppEnabledExtensionNames."); + } + VkPhysicalDeviceShaderClockFeaturesKHR* structure = (VkPhysicalDeviceShaderClockFeaturesKHR*)header; + skip |= ValidateBool32(pNext_loc.dot(Field::shaderSubgroupClock), structure->shaderSubgroupClock); + + skip |= ValidateBool32(pNext_loc.dot(Field::shaderDeviceClock), structure->shaderDeviceClock); + } + } break; + + // Validation code for VkPhysicalDeviceGlobalPriorityQueryFeaturesKHR structure members + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_GLOBAL_PRIORITY_QUERY_FEATURES_KHR: { // Covers + // VUID-VkPhysicalDeviceGlobalPriorityQueryFeaturesKHR-sType-sType + if (is_const_param) { + [[maybe_unused]] const Location pNext_loc = loc.pNext(Struct::VkPhysicalDeviceGlobalPriorityQueryFeaturesKHR); + if (!IsExtEnabled(device_extensions.vk_khr_global_priority) && + !IsExtEnabled(device_extensions.vk_ext_global_priority_query)) { + skip |= LogError( + pnext_vuid, instance, pNext_loc, + "includes a pointer to a VkPhysicalDeviceGlobalPriorityQueryFeaturesKHR, but when creating VkDevice, the " + "parent extension " + "(VK_KHR_global_priority or VK_EXT_global_priority_query) was not included in ppEnabledExtensionNames."); + } + VkPhysicalDeviceGlobalPriorityQueryFeaturesKHR* structure = (VkPhysicalDeviceGlobalPriorityQueryFeaturesKHR*)header; + skip |= ValidateBool32(pNext_loc.dot(Field::globalPriorityQuery), structure->globalPriorityQuery); + } + } break; + + // Validation code for VkPhysicalDeviceFragmentShadingRateFeaturesKHR structure members + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_SHADING_RATE_FEATURES_KHR: { // Covers + // VUID-VkPhysicalDeviceFragmentShadingRateFeaturesKHR-sType-sType + if (is_const_param) { + [[maybe_unused]] const Location pNext_loc = loc.pNext(Struct::VkPhysicalDeviceFragmentShadingRateFeaturesKHR); + if (!IsExtEnabled(device_extensions.vk_khr_fragment_shading_rate)) { + skip |= LogError(pnext_vuid, instance, pNext_loc, + "includes a pointer to a VkPhysicalDeviceFragmentShadingRateFeaturesKHR, but when creating " + "VkDevice, the parent extension " + "(VK_KHR_fragment_shading_rate) was not included in ppEnabledExtensionNames."); + } + VkPhysicalDeviceFragmentShadingRateFeaturesKHR* structure = (VkPhysicalDeviceFragmentShadingRateFeaturesKHR*)header; + skip |= ValidateBool32(pNext_loc.dot(Field::pipelineFragmentShadingRate), structure->pipelineFragmentShadingRate); + + skip |= ValidateBool32(pNext_loc.dot(Field::primitiveFragmentShadingRate), structure->primitiveFragmentShadingRate); + + skip |= + ValidateBool32(pNext_loc.dot(Field::attachmentFragmentShadingRate), structure->attachmentFragmentShadingRate); + } + } break; + + // Validation code for VkPhysicalDeviceDynamicRenderingLocalReadFeaturesKHR structure members + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DYNAMIC_RENDERING_LOCAL_READ_FEATURES_KHR: { // Covers + // VUID-VkPhysicalDeviceDynamicRenderingLocalReadFeaturesKHR-sType-sType + if (is_const_param) { + [[maybe_unused]] const Location pNext_loc = loc.pNext(Struct::VkPhysicalDeviceDynamicRenderingLocalReadFeaturesKHR); + if (!IsExtEnabled(device_extensions.vk_khr_dynamic_rendering_local_read)) { + skip |= LogError(pnext_vuid, instance, pNext_loc, + "includes a pointer to a VkPhysicalDeviceDynamicRenderingLocalReadFeaturesKHR, but when " + "creating VkDevice, the parent extension " + "(VK_KHR_dynamic_rendering_local_read) was not included in ppEnabledExtensionNames."); + } + VkPhysicalDeviceDynamicRenderingLocalReadFeaturesKHR* structure = + (VkPhysicalDeviceDynamicRenderingLocalReadFeaturesKHR*)header; + skip |= ValidateBool32(pNext_loc.dot(Field::dynamicRenderingLocalRead), structure->dynamicRenderingLocalRead); + } + } break; + + // Validation code for VkPhysicalDeviceShaderQuadControlFeaturesKHR structure members + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_QUAD_CONTROL_FEATURES_KHR: { // Covers + // VUID-VkPhysicalDeviceShaderQuadControlFeaturesKHR-sType-sType + if (is_const_param) { + [[maybe_unused]] const Location pNext_loc = loc.pNext(Struct::VkPhysicalDeviceShaderQuadControlFeaturesKHR); + if (!IsExtEnabled(device_extensions.vk_khr_shader_quad_control)) { + skip |= LogError(pnext_vuid, instance, pNext_loc, + "includes a pointer to a VkPhysicalDeviceShaderQuadControlFeaturesKHR, but when creating " + "VkDevice, the parent extension " + "(VK_KHR_shader_quad_control) was not included in ppEnabledExtensionNames."); + } + VkPhysicalDeviceShaderQuadControlFeaturesKHR* structure = (VkPhysicalDeviceShaderQuadControlFeaturesKHR*)header; + skip |= ValidateBool32(pNext_loc.dot(Field::shaderQuadControl), structure->shaderQuadControl); + } + } break; + + // Validation code for VkPhysicalDevicePresentWaitFeaturesKHR structure members + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PRESENT_WAIT_FEATURES_KHR: { // Covers + // VUID-VkPhysicalDevicePresentWaitFeaturesKHR-sType-sType + if (is_const_param) { + [[maybe_unused]] const Location pNext_loc = loc.pNext(Struct::VkPhysicalDevicePresentWaitFeaturesKHR); + if (!IsExtEnabled(device_extensions.vk_khr_present_wait)) { + skip |= LogError(pnext_vuid, instance, pNext_loc, + "includes a pointer to a VkPhysicalDevicePresentWaitFeaturesKHR, but when creating VkDevice, " + "the parent extension " + "(VK_KHR_present_wait) was not included in ppEnabledExtensionNames."); + } + VkPhysicalDevicePresentWaitFeaturesKHR* structure = (VkPhysicalDevicePresentWaitFeaturesKHR*)header; + skip |= ValidateBool32(pNext_loc.dot(Field::presentWait), structure->presentWait); + } + } break; + + // Validation code for VkPhysicalDevicePipelineExecutablePropertiesFeaturesKHR structure members + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PIPELINE_EXECUTABLE_PROPERTIES_FEATURES_KHR: { // Covers + // VUID-VkPhysicalDevicePipelineExecutablePropertiesFeaturesKHR-sType-sType + if (is_const_param) { + [[maybe_unused]] const Location pNext_loc = + loc.pNext(Struct::VkPhysicalDevicePipelineExecutablePropertiesFeaturesKHR); + if (!IsExtEnabled(device_extensions.vk_khr_pipeline_executable_properties)) { + skip |= LogError(pnext_vuid, instance, pNext_loc, + "includes a pointer to a VkPhysicalDevicePipelineExecutablePropertiesFeaturesKHR, but when " + "creating VkDevice, the parent extension " + "(VK_KHR_pipeline_executable_properties) was not included in ppEnabledExtensionNames."); + } + VkPhysicalDevicePipelineExecutablePropertiesFeaturesKHR* structure = + (VkPhysicalDevicePipelineExecutablePropertiesFeaturesKHR*)header; + skip |= ValidateBool32(pNext_loc.dot(Field::pipelineExecutableInfo), structure->pipelineExecutableInfo); + } + } break; + + // Validation code for VkPhysicalDevicePresentIdFeaturesKHR structure members + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PRESENT_ID_FEATURES_KHR: { // Covers + // VUID-VkPhysicalDevicePresentIdFeaturesKHR-sType-sType + if (is_const_param) { + [[maybe_unused]] const Location pNext_loc = loc.pNext(Struct::VkPhysicalDevicePresentIdFeaturesKHR); + if (!IsExtEnabled(device_extensions.vk_khr_present_id)) { + skip |= LogError(pnext_vuid, instance, pNext_loc, + "includes a pointer to a VkPhysicalDevicePresentIdFeaturesKHR, but when creating VkDevice, " + "the parent extension " + "(VK_KHR_present_id) was not included in ppEnabledExtensionNames."); + } + VkPhysicalDevicePresentIdFeaturesKHR* structure = (VkPhysicalDevicePresentIdFeaturesKHR*)header; + skip |= ValidateBool32(pNext_loc.dot(Field::presentId), structure->presentId); + } + } break; + + // Validation code for VkPhysicalDeviceFragmentShaderBarycentricFeaturesKHR structure members + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_SHADER_BARYCENTRIC_FEATURES_KHR: { // Covers + // VUID-VkPhysicalDeviceFragmentShaderBarycentricFeaturesKHR-sType-sType + if (is_const_param) { + [[maybe_unused]] const Location pNext_loc = loc.pNext(Struct::VkPhysicalDeviceFragmentShaderBarycentricFeaturesKHR); + if (!IsExtEnabled(device_extensions.vk_khr_fragment_shader_barycentric) && + !IsExtEnabled(device_extensions.vk_nv_fragment_shader_barycentric)) { + skip |= LogError(pnext_vuid, instance, pNext_loc, + "includes a pointer to a VkPhysicalDeviceFragmentShaderBarycentricFeaturesKHR, but when " + "creating VkDevice, the parent extension " + "(VK_KHR_fragment_shader_barycentric or VK_NV_fragment_shader_barycentric) was not included " + "in ppEnabledExtensionNames."); + } + VkPhysicalDeviceFragmentShaderBarycentricFeaturesKHR* structure = + (VkPhysicalDeviceFragmentShaderBarycentricFeaturesKHR*)header; + skip |= ValidateBool32(pNext_loc.dot(Field::fragmentShaderBarycentric), structure->fragmentShaderBarycentric); + } + } break; + + // Validation code for VkPhysicalDeviceShaderSubgroupUniformControlFlowFeaturesKHR structure members + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_SUBGROUP_UNIFORM_CONTROL_FLOW_FEATURES_KHR: { // Covers + // VUID-VkPhysicalDeviceShaderSubgroupUniformControlFlowFeaturesKHR-sType-sType + if (is_const_param) { + [[maybe_unused]] const Location pNext_loc = + loc.pNext(Struct::VkPhysicalDeviceShaderSubgroupUniformControlFlowFeaturesKHR); + if (!IsExtEnabled(device_extensions.vk_khr_shader_subgroup_uniform_control_flow)) { + skip |= LogError(pnext_vuid, instance, pNext_loc, + "includes a pointer to a VkPhysicalDeviceShaderSubgroupUniformControlFlowFeaturesKHR, but " + "when creating VkDevice, the parent extension " + "(VK_KHR_shader_subgroup_uniform_control_flow) was not included in ppEnabledExtensionNames."); + } + VkPhysicalDeviceShaderSubgroupUniformControlFlowFeaturesKHR* structure = + (VkPhysicalDeviceShaderSubgroupUniformControlFlowFeaturesKHR*)header; + skip |= ValidateBool32(pNext_loc.dot(Field::shaderSubgroupUniformControlFlow), + structure->shaderSubgroupUniformControlFlow); + } + } break; + + // Validation code for VkPhysicalDeviceWorkgroupMemoryExplicitLayoutFeaturesKHR structure members + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_WORKGROUP_MEMORY_EXPLICIT_LAYOUT_FEATURES_KHR: { // Covers + // VUID-VkPhysicalDeviceWorkgroupMemoryExplicitLayoutFeaturesKHR-sType-sType + if (is_const_param) { + [[maybe_unused]] const Location pNext_loc = + loc.pNext(Struct::VkPhysicalDeviceWorkgroupMemoryExplicitLayoutFeaturesKHR); + if (!IsExtEnabled(device_extensions.vk_khr_workgroup_memory_explicit_layout)) { + skip |= LogError(pnext_vuid, instance, pNext_loc, + "includes a pointer to a VkPhysicalDeviceWorkgroupMemoryExplicitLayoutFeaturesKHR, but when " + "creating VkDevice, the parent extension " + "(VK_KHR_workgroup_memory_explicit_layout) was not included in ppEnabledExtensionNames."); + } + VkPhysicalDeviceWorkgroupMemoryExplicitLayoutFeaturesKHR* structure = + (VkPhysicalDeviceWorkgroupMemoryExplicitLayoutFeaturesKHR*)header; + skip |= + ValidateBool32(pNext_loc.dot(Field::workgroupMemoryExplicitLayout), structure->workgroupMemoryExplicitLayout); + + skip |= ValidateBool32(pNext_loc.dot(Field::workgroupMemoryExplicitLayoutScalarBlockLayout), + structure->workgroupMemoryExplicitLayoutScalarBlockLayout); + + skip |= ValidateBool32(pNext_loc.dot(Field::workgroupMemoryExplicitLayout8BitAccess), + structure->workgroupMemoryExplicitLayout8BitAccess); + + skip |= ValidateBool32(pNext_loc.dot(Field::workgroupMemoryExplicitLayout16BitAccess), + structure->workgroupMemoryExplicitLayout16BitAccess); + } + } break; + + // Validation code for VkPhysicalDeviceRayTracingMaintenance1FeaturesKHR structure members + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RAY_TRACING_MAINTENANCE_1_FEATURES_KHR: { // Covers + // VUID-VkPhysicalDeviceRayTracingMaintenance1FeaturesKHR-sType-sType + if (is_const_param) { + [[maybe_unused]] const Location pNext_loc = loc.pNext(Struct::VkPhysicalDeviceRayTracingMaintenance1FeaturesKHR); + if (!IsExtEnabled(device_extensions.vk_khr_ray_tracing_maintenance1)) { + skip |= LogError(pnext_vuid, instance, pNext_loc, + "includes a pointer to a VkPhysicalDeviceRayTracingMaintenance1FeaturesKHR, but when creating " + "VkDevice, the parent extension " + "(VK_KHR_ray_tracing_maintenance1) was not included in ppEnabledExtensionNames."); + } + VkPhysicalDeviceRayTracingMaintenance1FeaturesKHR* structure = + (VkPhysicalDeviceRayTracingMaintenance1FeaturesKHR*)header; + skip |= ValidateBool32(pNext_loc.dot(Field::rayTracingMaintenance1), structure->rayTracingMaintenance1); + + skip |= ValidateBool32(pNext_loc.dot(Field::rayTracingPipelineTraceRaysIndirect2), + structure->rayTracingPipelineTraceRaysIndirect2); + } + } break; + + // Validation code for VkPhysicalDeviceShaderSubgroupRotateFeaturesKHR structure members + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_SUBGROUP_ROTATE_FEATURES_KHR: { // Covers + // VUID-VkPhysicalDeviceShaderSubgroupRotateFeaturesKHR-sType-sType + if (is_const_param) { + [[maybe_unused]] const Location pNext_loc = loc.pNext(Struct::VkPhysicalDeviceShaderSubgroupRotateFeaturesKHR); + if (!IsExtEnabled(device_extensions.vk_khr_shader_subgroup_rotate)) { + skip |= LogError(pnext_vuid, instance, pNext_loc, + "includes a pointer to a VkPhysicalDeviceShaderSubgroupRotateFeaturesKHR, but when creating " + "VkDevice, the parent extension " + "(VK_KHR_shader_subgroup_rotate) was not included in ppEnabledExtensionNames."); + } + VkPhysicalDeviceShaderSubgroupRotateFeaturesKHR* structure = + (VkPhysicalDeviceShaderSubgroupRotateFeaturesKHR*)header; + skip |= ValidateBool32(pNext_loc.dot(Field::shaderSubgroupRotate), structure->shaderSubgroupRotate); + + skip |= + ValidateBool32(pNext_loc.dot(Field::shaderSubgroupRotateClustered), structure->shaderSubgroupRotateClustered); + } + } break; + + // Validation code for VkPhysicalDeviceShaderMaximalReconvergenceFeaturesKHR structure members + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_MAXIMAL_RECONVERGENCE_FEATURES_KHR: { // Covers + // VUID-VkPhysicalDeviceShaderMaximalReconvergenceFeaturesKHR-sType-sType + if (is_const_param) { + [[maybe_unused]] const Location pNext_loc = + loc.pNext(Struct::VkPhysicalDeviceShaderMaximalReconvergenceFeaturesKHR); + if (!IsExtEnabled(device_extensions.vk_khr_shader_maximal_reconvergence)) { + skip |= LogError(pnext_vuid, instance, pNext_loc, + "includes a pointer to a VkPhysicalDeviceShaderMaximalReconvergenceFeaturesKHR, but when " + "creating VkDevice, the parent extension " + "(VK_KHR_shader_maximal_reconvergence) was not included in ppEnabledExtensionNames."); + } + VkPhysicalDeviceShaderMaximalReconvergenceFeaturesKHR* structure = + (VkPhysicalDeviceShaderMaximalReconvergenceFeaturesKHR*)header; + skip |= ValidateBool32(pNext_loc.dot(Field::shaderMaximalReconvergence), structure->shaderMaximalReconvergence); + } + } break; + + // Validation code for VkPhysicalDeviceMaintenance5FeaturesKHR structure members + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MAINTENANCE_5_FEATURES_KHR: { // Covers + // VUID-VkPhysicalDeviceMaintenance5FeaturesKHR-sType-sType + if (is_const_param) { + [[maybe_unused]] const Location pNext_loc = loc.pNext(Struct::VkPhysicalDeviceMaintenance5FeaturesKHR); + if (!IsExtEnabled(device_extensions.vk_khr_maintenance5)) { + skip |= LogError(pnext_vuid, instance, pNext_loc, + "includes a pointer to a VkPhysicalDeviceMaintenance5FeaturesKHR, but when creating VkDevice, " + "the parent extension " + "(VK_KHR_maintenance5) was not included in ppEnabledExtensionNames."); + } + VkPhysicalDeviceMaintenance5FeaturesKHR* structure = (VkPhysicalDeviceMaintenance5FeaturesKHR*)header; + skip |= ValidateBool32(pNext_loc.dot(Field::maintenance5), structure->maintenance5); + } + } break; + + // Validation code for VkPhysicalDeviceRayTracingPositionFetchFeaturesKHR structure members + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RAY_TRACING_POSITION_FETCH_FEATURES_KHR: { // Covers + // VUID-VkPhysicalDeviceRayTracingPositionFetchFeaturesKHR-sType-sType + if (is_const_param) { + [[maybe_unused]] const Location pNext_loc = loc.pNext(Struct::VkPhysicalDeviceRayTracingPositionFetchFeaturesKHR); + if (!IsExtEnabled(device_extensions.vk_khr_ray_tracing_position_fetch)) { + skip |= LogError(pnext_vuid, instance, pNext_loc, + "includes a pointer to a VkPhysicalDeviceRayTracingPositionFetchFeaturesKHR, but when " + "creating VkDevice, the parent extension " + "(VK_KHR_ray_tracing_position_fetch) was not included in ppEnabledExtensionNames."); + } + VkPhysicalDeviceRayTracingPositionFetchFeaturesKHR* structure = + (VkPhysicalDeviceRayTracingPositionFetchFeaturesKHR*)header; + skip |= ValidateBool32(pNext_loc.dot(Field::rayTracingPositionFetch), structure->rayTracingPositionFetch); + } + } break; + + // Validation code for VkPhysicalDeviceCooperativeMatrixFeaturesKHR structure members + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COOPERATIVE_MATRIX_FEATURES_KHR: { // Covers + // VUID-VkPhysicalDeviceCooperativeMatrixFeaturesKHR-sType-sType + if (is_const_param) { + [[maybe_unused]] const Location pNext_loc = loc.pNext(Struct::VkPhysicalDeviceCooperativeMatrixFeaturesKHR); + if (!IsExtEnabled(device_extensions.vk_khr_cooperative_matrix)) { + skip |= LogError(pnext_vuid, instance, pNext_loc, + "includes a pointer to a VkPhysicalDeviceCooperativeMatrixFeaturesKHR, but when creating " + "VkDevice, the parent extension " + "(VK_KHR_cooperative_matrix) was not included in ppEnabledExtensionNames."); + } + VkPhysicalDeviceCooperativeMatrixFeaturesKHR* structure = (VkPhysicalDeviceCooperativeMatrixFeaturesKHR*)header; + skip |= ValidateBool32(pNext_loc.dot(Field::cooperativeMatrix), structure->cooperativeMatrix); + + skip |= ValidateBool32(pNext_loc.dot(Field::cooperativeMatrixRobustBufferAccess), + structure->cooperativeMatrixRobustBufferAccess); + } + } break; + + // Validation code for VkPhysicalDeviceVideoMaintenance1FeaturesKHR structure members + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VIDEO_MAINTENANCE_1_FEATURES_KHR: { // Covers + // VUID-VkPhysicalDeviceVideoMaintenance1FeaturesKHR-sType-sType + if (is_const_param) { + [[maybe_unused]] const Location pNext_loc = loc.pNext(Struct::VkPhysicalDeviceVideoMaintenance1FeaturesKHR); + VkPhysicalDeviceVideoMaintenance1FeaturesKHR* structure = (VkPhysicalDeviceVideoMaintenance1FeaturesKHR*)header; + skip |= ValidateBool32(pNext_loc.dot(Field::videoMaintenance1), structure->videoMaintenance1); + } + } break; + + // Validation code for VkPhysicalDeviceVertexAttributeDivisorFeaturesKHR structure members + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VERTEX_ATTRIBUTE_DIVISOR_FEATURES_KHR: { // Covers + // VUID-VkPhysicalDeviceVertexAttributeDivisorFeaturesKHR-sType-sType + if (is_const_param) { + [[maybe_unused]] const Location pNext_loc = loc.pNext(Struct::VkPhysicalDeviceVertexAttributeDivisorFeaturesKHR); + if (!IsExtEnabled(device_extensions.vk_khr_vertex_attribute_divisor) && + !IsExtEnabled(device_extensions.vk_ext_vertex_attribute_divisor)) { + skip |= LogError(pnext_vuid, instance, pNext_loc, + "includes a pointer to a VkPhysicalDeviceVertexAttributeDivisorFeaturesKHR, but when creating " + "VkDevice, the parent extension " + "(VK_KHR_vertex_attribute_divisor or VK_EXT_vertex_attribute_divisor) was not included in " + "ppEnabledExtensionNames."); + } + VkPhysicalDeviceVertexAttributeDivisorFeaturesKHR* structure = + (VkPhysicalDeviceVertexAttributeDivisorFeaturesKHR*)header; + skip |= ValidateBool32(pNext_loc.dot(Field::vertexAttributeInstanceRateDivisor), + structure->vertexAttributeInstanceRateDivisor); + + skip |= ValidateBool32(pNext_loc.dot(Field::vertexAttributeInstanceRateZeroDivisor), + structure->vertexAttributeInstanceRateZeroDivisor); + } + } break; + + // Validation code for VkPhysicalDeviceShaderFloatControls2FeaturesKHR structure members + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_FLOAT_CONTROLS_2_FEATURES_KHR: { // Covers + // VUID-VkPhysicalDeviceShaderFloatControls2FeaturesKHR-sType-sType + if (is_const_param) { + [[maybe_unused]] const Location pNext_loc = loc.pNext(Struct::VkPhysicalDeviceShaderFloatControls2FeaturesKHR); + if (!IsExtEnabled(device_extensions.vk_khr_shader_float_controls2)) { + skip |= LogError(pnext_vuid, instance, pNext_loc, + "includes a pointer to a VkPhysicalDeviceShaderFloatControls2FeaturesKHR, but when creating " + "VkDevice, the parent extension " + "(VK_KHR_shader_float_controls2) was not included in ppEnabledExtensionNames."); + } + VkPhysicalDeviceShaderFloatControls2FeaturesKHR* structure = + (VkPhysicalDeviceShaderFloatControls2FeaturesKHR*)header; + skip |= ValidateBool32(pNext_loc.dot(Field::shaderFloatControls2), structure->shaderFloatControls2); + } + } break; + + // Validation code for VkPhysicalDeviceIndexTypeUint8FeaturesKHR structure members + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_INDEX_TYPE_UINT8_FEATURES_KHR: { // Covers + // VUID-VkPhysicalDeviceIndexTypeUint8FeaturesKHR-sType-sType + if (is_const_param) { + [[maybe_unused]] const Location pNext_loc = loc.pNext(Struct::VkPhysicalDeviceIndexTypeUint8FeaturesKHR); + if (!IsExtEnabled(device_extensions.vk_khr_index_type_uint8) && + !IsExtEnabled(device_extensions.vk_ext_index_type_uint8)) { + skip |= LogError( + pnext_vuid, instance, pNext_loc, + "includes a pointer to a VkPhysicalDeviceIndexTypeUint8FeaturesKHR, but when creating VkDevice, the parent " + "extension " + "(VK_KHR_index_type_uint8 or VK_EXT_index_type_uint8) was not included in ppEnabledExtensionNames."); + } + VkPhysicalDeviceIndexTypeUint8FeaturesKHR* structure = (VkPhysicalDeviceIndexTypeUint8FeaturesKHR*)header; + skip |= ValidateBool32(pNext_loc.dot(Field::indexTypeUint8), structure->indexTypeUint8); + } + } break; + + // Validation code for VkPhysicalDeviceLineRasterizationFeaturesKHR structure members + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_LINE_RASTERIZATION_FEATURES_KHR: { // Covers + // VUID-VkPhysicalDeviceLineRasterizationFeaturesKHR-sType-sType + if (is_const_param) { + [[maybe_unused]] const Location pNext_loc = loc.pNext(Struct::VkPhysicalDeviceLineRasterizationFeaturesKHR); + if (!IsExtEnabled(device_extensions.vk_khr_line_rasterization) && + !IsExtEnabled(device_extensions.vk_ext_line_rasterization)) { + skip |= LogError( + pnext_vuid, instance, pNext_loc, + "includes a pointer to a VkPhysicalDeviceLineRasterizationFeaturesKHR, but when creating VkDevice, the " + "parent extension " + "(VK_KHR_line_rasterization or VK_EXT_line_rasterization) was not included in ppEnabledExtensionNames."); + } + VkPhysicalDeviceLineRasterizationFeaturesKHR* structure = (VkPhysicalDeviceLineRasterizationFeaturesKHR*)header; + skip |= ValidateBool32(pNext_loc.dot(Field::rectangularLines), structure->rectangularLines); + + skip |= ValidateBool32(pNext_loc.dot(Field::bresenhamLines), structure->bresenhamLines); + + skip |= ValidateBool32(pNext_loc.dot(Field::smoothLines), structure->smoothLines); + + skip |= ValidateBool32(pNext_loc.dot(Field::stippledRectangularLines), structure->stippledRectangularLines); + + skip |= ValidateBool32(pNext_loc.dot(Field::stippledBresenhamLines), structure->stippledBresenhamLines); + + skip |= ValidateBool32(pNext_loc.dot(Field::stippledSmoothLines), structure->stippledSmoothLines); + } + } break; + + // Validation code for VkPhysicalDeviceShaderExpectAssumeFeaturesKHR structure members + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_EXPECT_ASSUME_FEATURES_KHR: { // Covers + // VUID-VkPhysicalDeviceShaderExpectAssumeFeaturesKHR-sType-sType + if (is_const_param) { + [[maybe_unused]] const Location pNext_loc = loc.pNext(Struct::VkPhysicalDeviceShaderExpectAssumeFeaturesKHR); + if (!IsExtEnabled(device_extensions.vk_khr_shader_expect_assume)) { + skip |= LogError(pnext_vuid, instance, pNext_loc, + "includes a pointer to a VkPhysicalDeviceShaderExpectAssumeFeaturesKHR, but when creating " + "VkDevice, the parent extension " + "(VK_KHR_shader_expect_assume) was not included in ppEnabledExtensionNames."); + } + VkPhysicalDeviceShaderExpectAssumeFeaturesKHR* structure = (VkPhysicalDeviceShaderExpectAssumeFeaturesKHR*)header; + skip |= ValidateBool32(pNext_loc.dot(Field::shaderExpectAssume), structure->shaderExpectAssume); + } + } break; + + // Validation code for VkPhysicalDeviceMaintenance6FeaturesKHR structure members + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MAINTENANCE_6_FEATURES_KHR: { // Covers + // VUID-VkPhysicalDeviceMaintenance6FeaturesKHR-sType-sType + if (is_const_param) { + [[maybe_unused]] const Location pNext_loc = loc.pNext(Struct::VkPhysicalDeviceMaintenance6FeaturesKHR); + if (!IsExtEnabled(device_extensions.vk_khr_maintenance6)) { + skip |= LogError(pnext_vuid, instance, pNext_loc, + "includes a pointer to a VkPhysicalDeviceMaintenance6FeaturesKHR, but when creating VkDevice, " + "the parent extension " + "(VK_KHR_maintenance6) was not included in ppEnabledExtensionNames."); + } + VkPhysicalDeviceMaintenance6FeaturesKHR* structure = (VkPhysicalDeviceMaintenance6FeaturesKHR*)header; + skip |= ValidateBool32(pNext_loc.dot(Field::maintenance6), structure->maintenance6); + } + } break; + + // Validation code for VkPhysicalDeviceTransformFeedbackFeaturesEXT structure members + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TRANSFORM_FEEDBACK_FEATURES_EXT: { // Covers + // VUID-VkPhysicalDeviceTransformFeedbackFeaturesEXT-sType-sType + if (is_const_param) { + [[maybe_unused]] const Location pNext_loc = loc.pNext(Struct::VkPhysicalDeviceTransformFeedbackFeaturesEXT); + if (!IsExtEnabled(device_extensions.vk_ext_transform_feedback)) { + skip |= LogError(pnext_vuid, instance, pNext_loc, + "includes a pointer to a VkPhysicalDeviceTransformFeedbackFeaturesEXT, but when creating " + "VkDevice, the parent extension " + "(VK_EXT_transform_feedback) was not included in ppEnabledExtensionNames."); + } + VkPhysicalDeviceTransformFeedbackFeaturesEXT* structure = (VkPhysicalDeviceTransformFeedbackFeaturesEXT*)header; + skip |= ValidateBool32(pNext_loc.dot(Field::transformFeedback), structure->transformFeedback); + + skip |= ValidateBool32(pNext_loc.dot(Field::geometryStreams), structure->geometryStreams); + } + } break; + + // Validation code for VkPhysicalDeviceCornerSampledImageFeaturesNV structure members + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_CORNER_SAMPLED_IMAGE_FEATURES_NV: { // Covers + // VUID-VkPhysicalDeviceCornerSampledImageFeaturesNV-sType-sType + if (is_const_param) { + [[maybe_unused]] const Location pNext_loc = loc.pNext(Struct::VkPhysicalDeviceCornerSampledImageFeaturesNV); + if (!IsExtEnabled(device_extensions.vk_nv_corner_sampled_image)) { + skip |= LogError(pnext_vuid, instance, pNext_loc, + "includes a pointer to a VkPhysicalDeviceCornerSampledImageFeaturesNV, but when creating " + "VkDevice, the parent extension " + "(VK_NV_corner_sampled_image) was not included in ppEnabledExtensionNames."); + } + VkPhysicalDeviceCornerSampledImageFeaturesNV* structure = (VkPhysicalDeviceCornerSampledImageFeaturesNV*)header; + skip |= ValidateBool32(pNext_loc.dot(Field::cornerSampledImage), structure->cornerSampledImage); + } + } break; + + // Validation code for VkPhysicalDeviceASTCDecodeFeaturesEXT structure members + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ASTC_DECODE_FEATURES_EXT: { // Covers + // VUID-VkPhysicalDeviceASTCDecodeFeaturesEXT-sType-sType + if (is_const_param) { + [[maybe_unused]] const Location pNext_loc = loc.pNext(Struct::VkPhysicalDeviceASTCDecodeFeaturesEXT); + if (!IsExtEnabled(device_extensions.vk_ext_astc_decode_mode)) { + skip |= LogError(pnext_vuid, instance, pNext_loc, + "includes a pointer to a VkPhysicalDeviceASTCDecodeFeaturesEXT, but when creating VkDevice, " + "the parent extension " + "(VK_EXT_astc_decode_mode) was not included in ppEnabledExtensionNames."); + } + VkPhysicalDeviceASTCDecodeFeaturesEXT* structure = (VkPhysicalDeviceASTCDecodeFeaturesEXT*)header; + skip |= ValidateBool32(pNext_loc.dot(Field::decodeModeSharedExponent), structure->decodeModeSharedExponent); + } + } break; + + // Validation code for VkPhysicalDevicePipelineRobustnessFeaturesEXT structure members + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PIPELINE_ROBUSTNESS_FEATURES_EXT: { // Covers + // VUID-VkPhysicalDevicePipelineRobustnessFeaturesEXT-sType-sType + if (is_const_param) { + [[maybe_unused]] const Location pNext_loc = loc.pNext(Struct::VkPhysicalDevicePipelineRobustnessFeaturesEXT); + if (!IsExtEnabled(device_extensions.vk_ext_pipeline_robustness)) { + skip |= LogError(pnext_vuid, instance, pNext_loc, + "includes a pointer to a VkPhysicalDevicePipelineRobustnessFeaturesEXT, but when creating " + "VkDevice, the parent extension " + "(VK_EXT_pipeline_robustness) was not included in ppEnabledExtensionNames."); + } + VkPhysicalDevicePipelineRobustnessFeaturesEXT* structure = (VkPhysicalDevicePipelineRobustnessFeaturesEXT*)header; + skip |= ValidateBool32(pNext_loc.dot(Field::pipelineRobustness), structure->pipelineRobustness); + } + } break; + + // Validation code for VkPhysicalDeviceConditionalRenderingFeaturesEXT structure members + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_CONDITIONAL_RENDERING_FEATURES_EXT: { // Covers + // VUID-VkPhysicalDeviceConditionalRenderingFeaturesEXT-sType-sType + if (is_const_param) { + [[maybe_unused]] const Location pNext_loc = loc.pNext(Struct::VkPhysicalDeviceConditionalRenderingFeaturesEXT); + if (!IsExtEnabled(device_extensions.vk_ext_conditional_rendering)) { + skip |= LogError(pnext_vuid, instance, pNext_loc, + "includes a pointer to a VkPhysicalDeviceConditionalRenderingFeaturesEXT, but when creating " + "VkDevice, the parent extension " + "(VK_EXT_conditional_rendering) was not included in ppEnabledExtensionNames."); + } + VkPhysicalDeviceConditionalRenderingFeaturesEXT* structure = + (VkPhysicalDeviceConditionalRenderingFeaturesEXT*)header; + skip |= ValidateBool32(pNext_loc.dot(Field::conditionalRendering), structure->conditionalRendering); + + skip |= + ValidateBool32(pNext_loc.dot(Field::inheritedConditionalRendering), structure->inheritedConditionalRendering); + } + } break; + + // Validation code for VkPhysicalDeviceDepthClipEnableFeaturesEXT structure members + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DEPTH_CLIP_ENABLE_FEATURES_EXT: { // Covers + // VUID-VkPhysicalDeviceDepthClipEnableFeaturesEXT-sType-sType + if (is_const_param) { + [[maybe_unused]] const Location pNext_loc = loc.pNext(Struct::VkPhysicalDeviceDepthClipEnableFeaturesEXT); + if (!IsExtEnabled(device_extensions.vk_ext_depth_clip_enable)) { + skip |= LogError(pnext_vuid, instance, pNext_loc, + "includes a pointer to a VkPhysicalDeviceDepthClipEnableFeaturesEXT, but when creating " + "VkDevice, the parent extension " + "(VK_EXT_depth_clip_enable) was not included in ppEnabledExtensionNames."); + } + VkPhysicalDeviceDepthClipEnableFeaturesEXT* structure = (VkPhysicalDeviceDepthClipEnableFeaturesEXT*)header; + skip |= ValidateBool32(pNext_loc.dot(Field::depthClipEnable), structure->depthClipEnable); + } + } break; + + // Validation code for VkPhysicalDeviceRelaxedLineRasterizationFeaturesIMG structure members + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RELAXED_LINE_RASTERIZATION_FEATURES_IMG: { // Covers + // VUID-VkPhysicalDeviceRelaxedLineRasterizationFeaturesIMG-sType-sType + if (is_const_param) { + [[maybe_unused]] const Location pNext_loc = loc.pNext(Struct::VkPhysicalDeviceRelaxedLineRasterizationFeaturesIMG); + if (!IsExtEnabled(device_extensions.vk_img_relaxed_line_rasterization)) { + skip |= LogError(pnext_vuid, instance, pNext_loc, + "includes a pointer to a VkPhysicalDeviceRelaxedLineRasterizationFeaturesIMG, but when " + "creating VkDevice, the parent extension " + "(VK_IMG_relaxed_line_rasterization) was not included in ppEnabledExtensionNames."); + } + VkPhysicalDeviceRelaxedLineRasterizationFeaturesIMG* structure = + (VkPhysicalDeviceRelaxedLineRasterizationFeaturesIMG*)header; + skip |= ValidateBool32(pNext_loc.dot(Field::relaxedLineRasterization), structure->relaxedLineRasterization); + } + } break; +#ifdef VK_ENABLE_BETA_EXTENSIONS + + // Validation code for VkPhysicalDeviceShaderEnqueueFeaturesAMDX structure members + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_ENQUEUE_FEATURES_AMDX: { // Covers + // VUID-VkPhysicalDeviceShaderEnqueueFeaturesAMDX-sType-sType + if (is_const_param) { + [[maybe_unused]] const Location pNext_loc = loc.pNext(Struct::VkPhysicalDeviceShaderEnqueueFeaturesAMDX); + if (!IsExtEnabled(device_extensions.vk_amdx_shader_enqueue)) { + skip |= LogError(pnext_vuid, instance, pNext_loc, + "includes a pointer to a VkPhysicalDeviceShaderEnqueueFeaturesAMDX, but when creating " + "VkDevice, the parent extension " + "(VK_AMDX_shader_enqueue) was not included in ppEnabledExtensionNames."); + } + VkPhysicalDeviceShaderEnqueueFeaturesAMDX* structure = (VkPhysicalDeviceShaderEnqueueFeaturesAMDX*)header; + skip |= ValidateBool32(pNext_loc.dot(Field::shaderEnqueue), structure->shaderEnqueue); + } + } break; +#endif // VK_ENABLE_BETA_EXTENSIONS + + // Validation code for VkPhysicalDeviceBlendOperationAdvancedFeaturesEXT structure members + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_BLEND_OPERATION_ADVANCED_FEATURES_EXT: { // Covers + // VUID-VkPhysicalDeviceBlendOperationAdvancedFeaturesEXT-sType-sType + if (is_const_param) { + [[maybe_unused]] const Location pNext_loc = loc.pNext(Struct::VkPhysicalDeviceBlendOperationAdvancedFeaturesEXT); + if (!IsExtEnabled(device_extensions.vk_ext_blend_operation_advanced)) { + skip |= LogError(pnext_vuid, instance, pNext_loc, + "includes a pointer to a VkPhysicalDeviceBlendOperationAdvancedFeaturesEXT, but when creating " + "VkDevice, the parent extension " + "(VK_EXT_blend_operation_advanced) was not included in ppEnabledExtensionNames."); + } + VkPhysicalDeviceBlendOperationAdvancedFeaturesEXT* structure = + (VkPhysicalDeviceBlendOperationAdvancedFeaturesEXT*)header; + skip |= ValidateBool32(pNext_loc.dot(Field::advancedBlendCoherentOperations), + structure->advancedBlendCoherentOperations); + } + } break; + + // Validation code for VkPhysicalDeviceShaderSMBuiltinsFeaturesNV structure members + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_SM_BUILTINS_FEATURES_NV: { // Covers + // VUID-VkPhysicalDeviceShaderSMBuiltinsFeaturesNV-sType-sType + if (is_const_param) { + [[maybe_unused]] const Location pNext_loc = loc.pNext(Struct::VkPhysicalDeviceShaderSMBuiltinsFeaturesNV); + if (!IsExtEnabled(device_extensions.vk_nv_shader_sm_builtins)) { + skip |= LogError(pnext_vuid, instance, pNext_loc, + "includes a pointer to a VkPhysicalDeviceShaderSMBuiltinsFeaturesNV, but when creating " + "VkDevice, the parent extension " + "(VK_NV_shader_sm_builtins) was not included in ppEnabledExtensionNames."); + } + VkPhysicalDeviceShaderSMBuiltinsFeaturesNV* structure = (VkPhysicalDeviceShaderSMBuiltinsFeaturesNV*)header; + skip |= ValidateBool32(pNext_loc.dot(Field::shaderSMBuiltins), structure->shaderSMBuiltins); + } + } break; + + // Validation code for VkPhysicalDeviceShadingRateImageFeaturesNV structure members + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADING_RATE_IMAGE_FEATURES_NV: { // Covers + // VUID-VkPhysicalDeviceShadingRateImageFeaturesNV-sType-sType + if (is_const_param) { + [[maybe_unused]] const Location pNext_loc = loc.pNext(Struct::VkPhysicalDeviceShadingRateImageFeaturesNV); + if (!IsExtEnabled(device_extensions.vk_nv_shading_rate_image)) { + skip |= LogError(pnext_vuid, instance, pNext_loc, + "includes a pointer to a VkPhysicalDeviceShadingRateImageFeaturesNV, but when creating " + "VkDevice, the parent extension " + "(VK_NV_shading_rate_image) was not included in ppEnabledExtensionNames."); + } + VkPhysicalDeviceShadingRateImageFeaturesNV* structure = (VkPhysicalDeviceShadingRateImageFeaturesNV*)header; + skip |= ValidateBool32(pNext_loc.dot(Field::shadingRateImage), structure->shadingRateImage); + + skip |= ValidateBool32(pNext_loc.dot(Field::shadingRateCoarseSampleOrder), structure->shadingRateCoarseSampleOrder); + } + } break; + + // Validation code for VkPhysicalDeviceRepresentativeFragmentTestFeaturesNV structure members + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_REPRESENTATIVE_FRAGMENT_TEST_FEATURES_NV: { // Covers + // VUID-VkPhysicalDeviceRepresentativeFragmentTestFeaturesNV-sType-sType + if (is_const_param) { + [[maybe_unused]] const Location pNext_loc = loc.pNext(Struct::VkPhysicalDeviceRepresentativeFragmentTestFeaturesNV); + if (!IsExtEnabled(device_extensions.vk_nv_representative_fragment_test)) { + skip |= LogError(pnext_vuid, instance, pNext_loc, + "includes a pointer to a VkPhysicalDeviceRepresentativeFragmentTestFeaturesNV, but when " + "creating VkDevice, the parent extension " + "(VK_NV_representative_fragment_test) was not included in ppEnabledExtensionNames."); + } + VkPhysicalDeviceRepresentativeFragmentTestFeaturesNV* structure = + (VkPhysicalDeviceRepresentativeFragmentTestFeaturesNV*)header; + skip |= ValidateBool32(pNext_loc.dot(Field::representativeFragmentTest), structure->representativeFragmentTest); + } + } break; + + // Validation code for VkPhysicalDeviceComputeShaderDerivativesFeaturesNV structure members + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COMPUTE_SHADER_DERIVATIVES_FEATURES_NV: { // Covers + // VUID-VkPhysicalDeviceComputeShaderDerivativesFeaturesNV-sType-sType + if (is_const_param) { + [[maybe_unused]] const Location pNext_loc = loc.pNext(Struct::VkPhysicalDeviceComputeShaderDerivativesFeaturesNV); + if (!IsExtEnabled(device_extensions.vk_nv_compute_shader_derivatives)) { + skip |= LogError(pnext_vuid, instance, pNext_loc, + "includes a pointer to a VkPhysicalDeviceComputeShaderDerivativesFeaturesNV, but when " + "creating VkDevice, the parent extension " + "(VK_NV_compute_shader_derivatives) was not included in ppEnabledExtensionNames."); + } + VkPhysicalDeviceComputeShaderDerivativesFeaturesNV* structure = + (VkPhysicalDeviceComputeShaderDerivativesFeaturesNV*)header; + skip |= ValidateBool32(pNext_loc.dot(Field::computeDerivativeGroupQuads), structure->computeDerivativeGroupQuads); + + skip |= ValidateBool32(pNext_loc.dot(Field::computeDerivativeGroupLinear), structure->computeDerivativeGroupLinear); + } + } break; + + // Validation code for VkPhysicalDeviceMeshShaderFeaturesNV structure members + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MESH_SHADER_FEATURES_NV: { // Covers + // VUID-VkPhysicalDeviceMeshShaderFeaturesNV-sType-sType + if (is_const_param) { + [[maybe_unused]] const Location pNext_loc = loc.pNext(Struct::VkPhysicalDeviceMeshShaderFeaturesNV); + if (!IsExtEnabled(device_extensions.vk_nv_mesh_shader)) { + skip |= LogError(pnext_vuid, instance, pNext_loc, + "includes a pointer to a VkPhysicalDeviceMeshShaderFeaturesNV, but when creating VkDevice, " + "the parent extension " + "(VK_NV_mesh_shader) was not included in ppEnabledExtensionNames."); + } + VkPhysicalDeviceMeshShaderFeaturesNV* structure = (VkPhysicalDeviceMeshShaderFeaturesNV*)header; + skip |= ValidateBool32(pNext_loc.dot(Field::taskShader), structure->taskShader); + + skip |= ValidateBool32(pNext_loc.dot(Field::meshShader), structure->meshShader); + } + } break; + + // Validation code for VkPhysicalDeviceShaderImageFootprintFeaturesNV structure members + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_IMAGE_FOOTPRINT_FEATURES_NV: { // Covers + // VUID-VkPhysicalDeviceShaderImageFootprintFeaturesNV-sType-sType + if (is_const_param) { + [[maybe_unused]] const Location pNext_loc = loc.pNext(Struct::VkPhysicalDeviceShaderImageFootprintFeaturesNV); + if (!IsExtEnabled(device_extensions.vk_nv_shader_image_footprint)) { + skip |= LogError(pnext_vuid, instance, pNext_loc, + "includes a pointer to a VkPhysicalDeviceShaderImageFootprintFeaturesNV, but when creating " + "VkDevice, the parent extension " + "(VK_NV_shader_image_footprint) was not included in ppEnabledExtensionNames."); + } + VkPhysicalDeviceShaderImageFootprintFeaturesNV* structure = (VkPhysicalDeviceShaderImageFootprintFeaturesNV*)header; + skip |= ValidateBool32(pNext_loc.dot(Field::imageFootprint), structure->imageFootprint); + } + } break; + + // Validation code for VkPhysicalDeviceExclusiveScissorFeaturesNV structure members + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXCLUSIVE_SCISSOR_FEATURES_NV: { // Covers + // VUID-VkPhysicalDeviceExclusiveScissorFeaturesNV-sType-sType + if (is_const_param) { + [[maybe_unused]] const Location pNext_loc = loc.pNext(Struct::VkPhysicalDeviceExclusiveScissorFeaturesNV); + if (!IsExtEnabled(device_extensions.vk_nv_scissor_exclusive)) { + skip |= LogError(pnext_vuid, instance, pNext_loc, + "includes a pointer to a VkPhysicalDeviceExclusiveScissorFeaturesNV, but when creating " + "VkDevice, the parent extension " + "(VK_NV_scissor_exclusive) was not included in ppEnabledExtensionNames."); + } + VkPhysicalDeviceExclusiveScissorFeaturesNV* structure = (VkPhysicalDeviceExclusiveScissorFeaturesNV*)header; + skip |= ValidateBool32(pNext_loc.dot(Field::exclusiveScissor), structure->exclusiveScissor); + } + } break; + + // Validation code for VkPhysicalDeviceShaderIntegerFunctions2FeaturesINTEL structure members + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_INTEGER_FUNCTIONS_2_FEATURES_INTEL: { // Covers + // VUID-VkPhysicalDeviceShaderIntegerFunctions2FeaturesINTEL-sType-sType + if (is_const_param) { + [[maybe_unused]] const Location pNext_loc = loc.pNext(Struct::VkPhysicalDeviceShaderIntegerFunctions2FeaturesINTEL); + if (!IsExtEnabled(device_extensions.vk_intel_shader_integer_functions2)) { + skip |= LogError(pnext_vuid, instance, pNext_loc, + "includes a pointer to a VkPhysicalDeviceShaderIntegerFunctions2FeaturesINTEL, but when " + "creating VkDevice, the parent extension " + "(VK_INTEL_shader_integer_functions2) was not included in ppEnabledExtensionNames."); + } + VkPhysicalDeviceShaderIntegerFunctions2FeaturesINTEL* structure = + (VkPhysicalDeviceShaderIntegerFunctions2FeaturesINTEL*)header; + skip |= ValidateBool32(pNext_loc.dot(Field::shaderIntegerFunctions2), structure->shaderIntegerFunctions2); + } + } break; + + // Validation code for VkPhysicalDeviceFragmentDensityMapFeaturesEXT structure members + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_DENSITY_MAP_FEATURES_EXT: { // Covers + // VUID-VkPhysicalDeviceFragmentDensityMapFeaturesEXT-sType-sType + if (is_const_param) { + [[maybe_unused]] const Location pNext_loc = loc.pNext(Struct::VkPhysicalDeviceFragmentDensityMapFeaturesEXT); + if (!IsExtEnabled(device_extensions.vk_ext_fragment_density_map)) { + skip |= LogError(pnext_vuid, instance, pNext_loc, + "includes a pointer to a VkPhysicalDeviceFragmentDensityMapFeaturesEXT, but when creating " + "VkDevice, the parent extension " + "(VK_EXT_fragment_density_map) was not included in ppEnabledExtensionNames."); + } + VkPhysicalDeviceFragmentDensityMapFeaturesEXT* structure = (VkPhysicalDeviceFragmentDensityMapFeaturesEXT*)header; + skip |= ValidateBool32(pNext_loc.dot(Field::fragmentDensityMap), structure->fragmentDensityMap); + + skip |= ValidateBool32(pNext_loc.dot(Field::fragmentDensityMapDynamic), structure->fragmentDensityMapDynamic); + + skip |= ValidateBool32(pNext_loc.dot(Field::fragmentDensityMapNonSubsampledImages), + structure->fragmentDensityMapNonSubsampledImages); + } + } break; + + // Validation code for VkPhysicalDeviceCoherentMemoryFeaturesAMD structure members + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COHERENT_MEMORY_FEATURES_AMD: { // Covers + // VUID-VkPhysicalDeviceCoherentMemoryFeaturesAMD-sType-sType + if (is_const_param) { + [[maybe_unused]] const Location pNext_loc = loc.pNext(Struct::VkPhysicalDeviceCoherentMemoryFeaturesAMD); + if (!IsExtEnabled(device_extensions.vk_amd_device_coherent_memory)) { + skip |= LogError(pnext_vuid, instance, pNext_loc, + "includes a pointer to a VkPhysicalDeviceCoherentMemoryFeaturesAMD, but when creating " + "VkDevice, the parent extension " + "(VK_AMD_device_coherent_memory) was not included in ppEnabledExtensionNames."); + } + VkPhysicalDeviceCoherentMemoryFeaturesAMD* structure = (VkPhysicalDeviceCoherentMemoryFeaturesAMD*)header; + skip |= ValidateBool32(pNext_loc.dot(Field::deviceCoherentMemory), structure->deviceCoherentMemory); + } + } break; + + // Validation code for VkPhysicalDeviceShaderImageAtomicInt64FeaturesEXT structure members + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_IMAGE_ATOMIC_INT64_FEATURES_EXT: { // Covers + // VUID-VkPhysicalDeviceShaderImageAtomicInt64FeaturesEXT-sType-sType + if (is_const_param) { + [[maybe_unused]] const Location pNext_loc = loc.pNext(Struct::VkPhysicalDeviceShaderImageAtomicInt64FeaturesEXT); + if (!IsExtEnabled(device_extensions.vk_ext_shader_image_atomic_int64)) { + skip |= LogError(pnext_vuid, instance, pNext_loc, + "includes a pointer to a VkPhysicalDeviceShaderImageAtomicInt64FeaturesEXT, but when creating " + "VkDevice, the parent extension " + "(VK_EXT_shader_image_atomic_int64) was not included in ppEnabledExtensionNames."); + } + VkPhysicalDeviceShaderImageAtomicInt64FeaturesEXT* structure = + (VkPhysicalDeviceShaderImageAtomicInt64FeaturesEXT*)header; + skip |= ValidateBool32(pNext_loc.dot(Field::shaderImageInt64Atomics), structure->shaderImageInt64Atomics); + + skip |= ValidateBool32(pNext_loc.dot(Field::sparseImageInt64Atomics), structure->sparseImageInt64Atomics); + } + } break; + + // Validation code for VkPhysicalDeviceMemoryPriorityFeaturesEXT structure members + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MEMORY_PRIORITY_FEATURES_EXT: { // Covers + // VUID-VkPhysicalDeviceMemoryPriorityFeaturesEXT-sType-sType + if (is_const_param) { + [[maybe_unused]] const Location pNext_loc = loc.pNext(Struct::VkPhysicalDeviceMemoryPriorityFeaturesEXT); + if (!IsExtEnabled(device_extensions.vk_ext_memory_priority)) { + skip |= LogError(pnext_vuid, instance, pNext_loc, + "includes a pointer to a VkPhysicalDeviceMemoryPriorityFeaturesEXT, but when creating " + "VkDevice, the parent extension " + "(VK_EXT_memory_priority) was not included in ppEnabledExtensionNames."); + } + VkPhysicalDeviceMemoryPriorityFeaturesEXT* structure = (VkPhysicalDeviceMemoryPriorityFeaturesEXT*)header; + skip |= ValidateBool32(pNext_loc.dot(Field::memoryPriority), structure->memoryPriority); + } + } break; + + // Validation code for VkPhysicalDeviceDedicatedAllocationImageAliasingFeaturesNV structure members + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DEDICATED_ALLOCATION_IMAGE_ALIASING_FEATURES_NV: { // Covers + // VUID-VkPhysicalDeviceDedicatedAllocationImageAliasingFeaturesNV-sType-sType + if (is_const_param) { + [[maybe_unused]] const Location pNext_loc = + loc.pNext(Struct::VkPhysicalDeviceDedicatedAllocationImageAliasingFeaturesNV); + if (!IsExtEnabled(device_extensions.vk_nv_dedicated_allocation_image_aliasing)) { + skip |= LogError(pnext_vuid, instance, pNext_loc, + "includes a pointer to a VkPhysicalDeviceDedicatedAllocationImageAliasingFeaturesNV, but when " + "creating VkDevice, the parent extension " + "(VK_NV_dedicated_allocation_image_aliasing) was not included in ppEnabledExtensionNames."); + } + VkPhysicalDeviceDedicatedAllocationImageAliasingFeaturesNV* structure = + (VkPhysicalDeviceDedicatedAllocationImageAliasingFeaturesNV*)header; + skip |= ValidateBool32(pNext_loc.dot(Field::dedicatedAllocationImageAliasing), + structure->dedicatedAllocationImageAliasing); + } + } break; + + // Validation code for VkPhysicalDeviceBufferDeviceAddressFeaturesEXT structure members + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_BUFFER_DEVICE_ADDRESS_FEATURES_EXT: { // Covers + // VUID-VkPhysicalDeviceBufferDeviceAddressFeaturesEXT-sType-sType + if (is_const_param) { + [[maybe_unused]] const Location pNext_loc = loc.pNext(Struct::VkPhysicalDeviceBufferDeviceAddressFeaturesEXT); + if (!IsExtEnabled(device_extensions.vk_ext_buffer_device_address)) { + skip |= LogError(pnext_vuid, instance, pNext_loc, + "includes a pointer to a VkPhysicalDeviceBufferDeviceAddressFeaturesEXT, but when creating " + "VkDevice, the parent extension " + "(VK_EXT_buffer_device_address) was not included in ppEnabledExtensionNames."); + } + VkPhysicalDeviceBufferDeviceAddressFeaturesEXT* structure = (VkPhysicalDeviceBufferDeviceAddressFeaturesEXT*)header; + skip |= ValidateBool32(pNext_loc.dot(Field::bufferDeviceAddress), structure->bufferDeviceAddress); + + skip |= ValidateBool32(pNext_loc.dot(Field::bufferDeviceAddressCaptureReplay), + structure->bufferDeviceAddressCaptureReplay); + + skip |= + ValidateBool32(pNext_loc.dot(Field::bufferDeviceAddressMultiDevice), structure->bufferDeviceAddressMultiDevice); + } + } break; + + // Validation code for VkPhysicalDeviceCooperativeMatrixFeaturesNV structure members + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COOPERATIVE_MATRIX_FEATURES_NV: { // Covers + // VUID-VkPhysicalDeviceCooperativeMatrixFeaturesNV-sType-sType + if (is_const_param) { + [[maybe_unused]] const Location pNext_loc = loc.pNext(Struct::VkPhysicalDeviceCooperativeMatrixFeaturesNV); + if (!IsExtEnabled(device_extensions.vk_nv_cooperative_matrix)) { + skip |= LogError(pnext_vuid, instance, pNext_loc, + "includes a pointer to a VkPhysicalDeviceCooperativeMatrixFeaturesNV, but when creating " + "VkDevice, the parent extension " + "(VK_NV_cooperative_matrix) was not included in ppEnabledExtensionNames."); + } + VkPhysicalDeviceCooperativeMatrixFeaturesNV* structure = (VkPhysicalDeviceCooperativeMatrixFeaturesNV*)header; + skip |= ValidateBool32(pNext_loc.dot(Field::cooperativeMatrix), structure->cooperativeMatrix); + + skip |= ValidateBool32(pNext_loc.dot(Field::cooperativeMatrixRobustBufferAccess), + structure->cooperativeMatrixRobustBufferAccess); + } + } break; + + // Validation code for VkPhysicalDeviceCoverageReductionModeFeaturesNV structure members + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COVERAGE_REDUCTION_MODE_FEATURES_NV: { // Covers + // VUID-VkPhysicalDeviceCoverageReductionModeFeaturesNV-sType-sType + if (is_const_param) { + [[maybe_unused]] const Location pNext_loc = loc.pNext(Struct::VkPhysicalDeviceCoverageReductionModeFeaturesNV); + if (!IsExtEnabled(device_extensions.vk_nv_coverage_reduction_mode)) { + skip |= LogError(pnext_vuid, instance, pNext_loc, + "includes a pointer to a VkPhysicalDeviceCoverageReductionModeFeaturesNV, but when creating " + "VkDevice, the parent extension " + "(VK_NV_coverage_reduction_mode) was not included in ppEnabledExtensionNames."); + } + VkPhysicalDeviceCoverageReductionModeFeaturesNV* structure = + (VkPhysicalDeviceCoverageReductionModeFeaturesNV*)header; + skip |= ValidateBool32(pNext_loc.dot(Field::coverageReductionMode), structure->coverageReductionMode); + } + } break; + + // Validation code for VkPhysicalDeviceFragmentShaderInterlockFeaturesEXT structure members + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_SHADER_INTERLOCK_FEATURES_EXT: { // Covers + // VUID-VkPhysicalDeviceFragmentShaderInterlockFeaturesEXT-sType-sType + if (is_const_param) { + [[maybe_unused]] const Location pNext_loc = loc.pNext(Struct::VkPhysicalDeviceFragmentShaderInterlockFeaturesEXT); + if (!IsExtEnabled(device_extensions.vk_ext_fragment_shader_interlock)) { + skip |= LogError(pnext_vuid, instance, pNext_loc, + "includes a pointer to a VkPhysicalDeviceFragmentShaderInterlockFeaturesEXT, but when " + "creating VkDevice, the parent extension " + "(VK_EXT_fragment_shader_interlock) was not included in ppEnabledExtensionNames."); + } + VkPhysicalDeviceFragmentShaderInterlockFeaturesEXT* structure = + (VkPhysicalDeviceFragmentShaderInterlockFeaturesEXT*)header; + skip |= + ValidateBool32(pNext_loc.dot(Field::fragmentShaderSampleInterlock), structure->fragmentShaderSampleInterlock); + + skip |= ValidateBool32(pNext_loc.dot(Field::fragmentShaderPixelInterlock), structure->fragmentShaderPixelInterlock); + + skip |= ValidateBool32(pNext_loc.dot(Field::fragmentShaderShadingRateInterlock), + structure->fragmentShaderShadingRateInterlock); + } + } break; + + // Validation code for VkPhysicalDeviceYcbcrImageArraysFeaturesEXT structure members + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_YCBCR_IMAGE_ARRAYS_FEATURES_EXT: { // Covers + // VUID-VkPhysicalDeviceYcbcrImageArraysFeaturesEXT-sType-sType + if (is_const_param) { + [[maybe_unused]] const Location pNext_loc = loc.pNext(Struct::VkPhysicalDeviceYcbcrImageArraysFeaturesEXT); + if (!IsExtEnabled(device_extensions.vk_ext_ycbcr_image_arrays)) { + skip |= LogError(pnext_vuid, instance, pNext_loc, + "includes a pointer to a VkPhysicalDeviceYcbcrImageArraysFeaturesEXT, but when creating " + "VkDevice, the parent extension " + "(VK_EXT_ycbcr_image_arrays) was not included in ppEnabledExtensionNames."); + } + VkPhysicalDeviceYcbcrImageArraysFeaturesEXT* structure = (VkPhysicalDeviceYcbcrImageArraysFeaturesEXT*)header; + skip |= ValidateBool32(pNext_loc.dot(Field::ycbcrImageArrays), structure->ycbcrImageArrays); + } + } break; + + // Validation code for VkPhysicalDeviceProvokingVertexFeaturesEXT structure members + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PROVOKING_VERTEX_FEATURES_EXT: { // Covers + // VUID-VkPhysicalDeviceProvokingVertexFeaturesEXT-sType-sType + if (is_const_param) { + [[maybe_unused]] const Location pNext_loc = loc.pNext(Struct::VkPhysicalDeviceProvokingVertexFeaturesEXT); + if (!IsExtEnabled(device_extensions.vk_ext_provoking_vertex)) { + skip |= LogError(pnext_vuid, instance, pNext_loc, + "includes a pointer to a VkPhysicalDeviceProvokingVertexFeaturesEXT, but when creating " + "VkDevice, the parent extension " + "(VK_EXT_provoking_vertex) was not included in ppEnabledExtensionNames."); + } + VkPhysicalDeviceProvokingVertexFeaturesEXT* structure = (VkPhysicalDeviceProvokingVertexFeaturesEXT*)header; + skip |= ValidateBool32(pNext_loc.dot(Field::provokingVertexLast), structure->provokingVertexLast); + + skip |= ValidateBool32(pNext_loc.dot(Field::transformFeedbackPreservesProvokingVertex), + structure->transformFeedbackPreservesProvokingVertex); + } + } break; + + // Validation code for VkPhysicalDeviceShaderAtomicFloatFeaturesEXT structure members + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_ATOMIC_FLOAT_FEATURES_EXT: { // Covers + // VUID-VkPhysicalDeviceShaderAtomicFloatFeaturesEXT-sType-sType + if (is_const_param) { + [[maybe_unused]] const Location pNext_loc = loc.pNext(Struct::VkPhysicalDeviceShaderAtomicFloatFeaturesEXT); + if (!IsExtEnabled(device_extensions.vk_ext_shader_atomic_float)) { + skip |= LogError(pnext_vuid, instance, pNext_loc, + "includes a pointer to a VkPhysicalDeviceShaderAtomicFloatFeaturesEXT, but when creating " + "VkDevice, the parent extension " + "(VK_EXT_shader_atomic_float) was not included in ppEnabledExtensionNames."); + } + VkPhysicalDeviceShaderAtomicFloatFeaturesEXT* structure = (VkPhysicalDeviceShaderAtomicFloatFeaturesEXT*)header; + skip |= ValidateBool32(pNext_loc.dot(Field::shaderBufferFloat32Atomics), structure->shaderBufferFloat32Atomics); + + skip |= ValidateBool32(pNext_loc.dot(Field::shaderBufferFloat32AtomicAdd), structure->shaderBufferFloat32AtomicAdd); + + skip |= ValidateBool32(pNext_loc.dot(Field::shaderBufferFloat64Atomics), structure->shaderBufferFloat64Atomics); + + skip |= ValidateBool32(pNext_loc.dot(Field::shaderBufferFloat64AtomicAdd), structure->shaderBufferFloat64AtomicAdd); + + skip |= ValidateBool32(pNext_loc.dot(Field::shaderSharedFloat32Atomics), structure->shaderSharedFloat32Atomics); + + skip |= ValidateBool32(pNext_loc.dot(Field::shaderSharedFloat32AtomicAdd), structure->shaderSharedFloat32AtomicAdd); + + skip |= ValidateBool32(pNext_loc.dot(Field::shaderSharedFloat64Atomics), structure->shaderSharedFloat64Atomics); + + skip |= ValidateBool32(pNext_loc.dot(Field::shaderSharedFloat64AtomicAdd), structure->shaderSharedFloat64AtomicAdd); + + skip |= ValidateBool32(pNext_loc.dot(Field::shaderImageFloat32Atomics), structure->shaderImageFloat32Atomics); + + skip |= ValidateBool32(pNext_loc.dot(Field::shaderImageFloat32AtomicAdd), structure->shaderImageFloat32AtomicAdd); + + skip |= ValidateBool32(pNext_loc.dot(Field::sparseImageFloat32Atomics), structure->sparseImageFloat32Atomics); + + skip |= ValidateBool32(pNext_loc.dot(Field::sparseImageFloat32AtomicAdd), structure->sparseImageFloat32AtomicAdd); + } + } break; + + // Validation code for VkPhysicalDeviceExtendedDynamicStateFeaturesEXT structure members + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTENDED_DYNAMIC_STATE_FEATURES_EXT: { // Covers + // VUID-VkPhysicalDeviceExtendedDynamicStateFeaturesEXT-sType-sType + if (is_const_param) { + [[maybe_unused]] const Location pNext_loc = loc.pNext(Struct::VkPhysicalDeviceExtendedDynamicStateFeaturesEXT); + if (!IsExtEnabled(device_extensions.vk_ext_extended_dynamic_state)) { + skip |= LogError(pnext_vuid, instance, pNext_loc, + "includes a pointer to a VkPhysicalDeviceExtendedDynamicStateFeaturesEXT, but when creating " + "VkDevice, the parent extension " + "(VK_EXT_extended_dynamic_state) was not included in ppEnabledExtensionNames."); + } + VkPhysicalDeviceExtendedDynamicStateFeaturesEXT* structure = + (VkPhysicalDeviceExtendedDynamicStateFeaturesEXT*)header; + skip |= ValidateBool32(pNext_loc.dot(Field::extendedDynamicState), structure->extendedDynamicState); + } + } break; + + // Validation code for VkPhysicalDeviceHostImageCopyFeaturesEXT structure members + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_HOST_IMAGE_COPY_FEATURES_EXT: { // Covers + // VUID-VkPhysicalDeviceHostImageCopyFeaturesEXT-sType-sType + if (is_const_param) { + [[maybe_unused]] const Location pNext_loc = loc.pNext(Struct::VkPhysicalDeviceHostImageCopyFeaturesEXT); + if (!IsExtEnabled(device_extensions.vk_ext_host_image_copy)) { + skip |= LogError(pnext_vuid, instance, pNext_loc, + "includes a pointer to a VkPhysicalDeviceHostImageCopyFeaturesEXT, but when creating " + "VkDevice, the parent extension " + "(VK_EXT_host_image_copy) was not included in ppEnabledExtensionNames."); + } + VkPhysicalDeviceHostImageCopyFeaturesEXT* structure = (VkPhysicalDeviceHostImageCopyFeaturesEXT*)header; + skip |= ValidateBool32(pNext_loc.dot(Field::hostImageCopy), structure->hostImageCopy); + } + } break; + + // Validation code for VkPhysicalDeviceMapMemoryPlacedFeaturesEXT structure members + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MAP_MEMORY_PLACED_FEATURES_EXT: { // Covers + // VUID-VkPhysicalDeviceMapMemoryPlacedFeaturesEXT-sType-sType + if (is_const_param) { + [[maybe_unused]] const Location pNext_loc = loc.pNext(Struct::VkPhysicalDeviceMapMemoryPlacedFeaturesEXT); + if (!IsExtEnabled(device_extensions.vk_ext_map_memory_placed)) { + skip |= LogError(pnext_vuid, instance, pNext_loc, + "includes a pointer to a VkPhysicalDeviceMapMemoryPlacedFeaturesEXT, but when creating " + "VkDevice, the parent extension " + "(VK_EXT_map_memory_placed) was not included in ppEnabledExtensionNames."); + } + VkPhysicalDeviceMapMemoryPlacedFeaturesEXT* structure = (VkPhysicalDeviceMapMemoryPlacedFeaturesEXT*)header; + skip |= ValidateBool32(pNext_loc.dot(Field::memoryMapPlaced), structure->memoryMapPlaced); + + skip |= ValidateBool32(pNext_loc.dot(Field::memoryMapRangePlaced), structure->memoryMapRangePlaced); + + skip |= ValidateBool32(pNext_loc.dot(Field::memoryUnmapReserve), structure->memoryUnmapReserve); + } + } break; + + // Validation code for VkPhysicalDeviceShaderAtomicFloat2FeaturesEXT structure members + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_ATOMIC_FLOAT_2_FEATURES_EXT: { // Covers + // VUID-VkPhysicalDeviceShaderAtomicFloat2FeaturesEXT-sType-sType + if (is_const_param) { + [[maybe_unused]] const Location pNext_loc = loc.pNext(Struct::VkPhysicalDeviceShaderAtomicFloat2FeaturesEXT); + if (!IsExtEnabled(device_extensions.vk_ext_shader_atomic_float2)) { + skip |= LogError(pnext_vuid, instance, pNext_loc, + "includes a pointer to a VkPhysicalDeviceShaderAtomicFloat2FeaturesEXT, but when creating " + "VkDevice, the parent extension " + "(VK_EXT_shader_atomic_float2) was not included in ppEnabledExtensionNames."); + } + VkPhysicalDeviceShaderAtomicFloat2FeaturesEXT* structure = (VkPhysicalDeviceShaderAtomicFloat2FeaturesEXT*)header; + skip |= ValidateBool32(pNext_loc.dot(Field::shaderBufferFloat16Atomics), structure->shaderBufferFloat16Atomics); + + skip |= ValidateBool32(pNext_loc.dot(Field::shaderBufferFloat16AtomicAdd), structure->shaderBufferFloat16AtomicAdd); + + skip |= ValidateBool32(pNext_loc.dot(Field::shaderBufferFloat16AtomicMinMax), + structure->shaderBufferFloat16AtomicMinMax); + + skip |= ValidateBool32(pNext_loc.dot(Field::shaderBufferFloat32AtomicMinMax), + structure->shaderBufferFloat32AtomicMinMax); + + skip |= ValidateBool32(pNext_loc.dot(Field::shaderBufferFloat64AtomicMinMax), + structure->shaderBufferFloat64AtomicMinMax); + + skip |= ValidateBool32(pNext_loc.dot(Field::shaderSharedFloat16Atomics), structure->shaderSharedFloat16Atomics); + + skip |= ValidateBool32(pNext_loc.dot(Field::shaderSharedFloat16AtomicAdd), structure->shaderSharedFloat16AtomicAdd); + + skip |= ValidateBool32(pNext_loc.dot(Field::shaderSharedFloat16AtomicMinMax), + structure->shaderSharedFloat16AtomicMinMax); + + skip |= ValidateBool32(pNext_loc.dot(Field::shaderSharedFloat32AtomicMinMax), + structure->shaderSharedFloat32AtomicMinMax); + + skip |= ValidateBool32(pNext_loc.dot(Field::shaderSharedFloat64AtomicMinMax), + structure->shaderSharedFloat64AtomicMinMax); + + skip |= + ValidateBool32(pNext_loc.dot(Field::shaderImageFloat32AtomicMinMax), structure->shaderImageFloat32AtomicMinMax); + + skip |= + ValidateBool32(pNext_loc.dot(Field::sparseImageFloat32AtomicMinMax), structure->sparseImageFloat32AtomicMinMax); + } + } break; + + // Validation code for VkPhysicalDeviceSwapchainMaintenance1FeaturesEXT structure members + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SWAPCHAIN_MAINTENANCE_1_FEATURES_EXT: { // Covers + // VUID-VkPhysicalDeviceSwapchainMaintenance1FeaturesEXT-sType-sType + if (is_const_param) { + [[maybe_unused]] const Location pNext_loc = loc.pNext(Struct::VkPhysicalDeviceSwapchainMaintenance1FeaturesEXT); + if (!IsExtEnabled(device_extensions.vk_ext_swapchain_maintenance1)) { + skip |= LogError(pnext_vuid, instance, pNext_loc, + "includes a pointer to a VkPhysicalDeviceSwapchainMaintenance1FeaturesEXT, but when creating " + "VkDevice, the parent extension " + "(VK_EXT_swapchain_maintenance1) was not included in ppEnabledExtensionNames."); + } + VkPhysicalDeviceSwapchainMaintenance1FeaturesEXT* structure = + (VkPhysicalDeviceSwapchainMaintenance1FeaturesEXT*)header; + skip |= ValidateBool32(pNext_loc.dot(Field::swapchainMaintenance1), structure->swapchainMaintenance1); + } + } break; + + // Validation code for VkPhysicalDeviceDeviceGeneratedCommandsFeaturesNV structure members + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DEVICE_GENERATED_COMMANDS_FEATURES_NV: { // Covers + // VUID-VkPhysicalDeviceDeviceGeneratedCommandsFeaturesNV-sType-sType + if (is_const_param) { + [[maybe_unused]] const Location pNext_loc = loc.pNext(Struct::VkPhysicalDeviceDeviceGeneratedCommandsFeaturesNV); + if (!IsExtEnabled(device_extensions.vk_nv_device_generated_commands)) { + skip |= LogError(pnext_vuid, instance, pNext_loc, + "includes a pointer to a VkPhysicalDeviceDeviceGeneratedCommandsFeaturesNV, but when creating " + "VkDevice, the parent extension " + "(VK_NV_device_generated_commands) was not included in ppEnabledExtensionNames."); + } + VkPhysicalDeviceDeviceGeneratedCommandsFeaturesNV* structure = + (VkPhysicalDeviceDeviceGeneratedCommandsFeaturesNV*)header; + skip |= ValidateBool32(pNext_loc.dot(Field::deviceGeneratedCommands), structure->deviceGeneratedCommands); + } + } break; + + // Validation code for VkPhysicalDeviceInheritedViewportScissorFeaturesNV structure members + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_INHERITED_VIEWPORT_SCISSOR_FEATURES_NV: { // Covers + // VUID-VkPhysicalDeviceInheritedViewportScissorFeaturesNV-sType-sType + if (is_const_param) { + [[maybe_unused]] const Location pNext_loc = loc.pNext(Struct::VkPhysicalDeviceInheritedViewportScissorFeaturesNV); + if (!IsExtEnabled(device_extensions.vk_nv_inherited_viewport_scissor)) { + skip |= LogError(pnext_vuid, instance, pNext_loc, + "includes a pointer to a VkPhysicalDeviceInheritedViewportScissorFeaturesNV, but when " + "creating VkDevice, the parent extension " + "(VK_NV_inherited_viewport_scissor) was not included in ppEnabledExtensionNames."); + } + VkPhysicalDeviceInheritedViewportScissorFeaturesNV* structure = + (VkPhysicalDeviceInheritedViewportScissorFeaturesNV*)header; + skip |= ValidateBool32(pNext_loc.dot(Field::inheritedViewportScissor2D), structure->inheritedViewportScissor2D); + } + } break; + + // Validation code for VkPhysicalDeviceTexelBufferAlignmentFeaturesEXT structure members + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TEXEL_BUFFER_ALIGNMENT_FEATURES_EXT: { // Covers + // VUID-VkPhysicalDeviceTexelBufferAlignmentFeaturesEXT-sType-sType + if (is_const_param) { + [[maybe_unused]] const Location pNext_loc = loc.pNext(Struct::VkPhysicalDeviceTexelBufferAlignmentFeaturesEXT); + if (!IsExtEnabled(device_extensions.vk_ext_texel_buffer_alignment)) { + skip |= LogError(pnext_vuid, instance, pNext_loc, + "includes a pointer to a VkPhysicalDeviceTexelBufferAlignmentFeaturesEXT, but when creating " + "VkDevice, the parent extension " + "(VK_EXT_texel_buffer_alignment) was not included in ppEnabledExtensionNames."); + } + VkPhysicalDeviceTexelBufferAlignmentFeaturesEXT* structure = + (VkPhysicalDeviceTexelBufferAlignmentFeaturesEXT*)header; + skip |= ValidateBool32(pNext_loc.dot(Field::texelBufferAlignment), structure->texelBufferAlignment); + } + } break; + + // Validation code for VkPhysicalDeviceDepthBiasControlFeaturesEXT structure members + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DEPTH_BIAS_CONTROL_FEATURES_EXT: { // Covers + // VUID-VkPhysicalDeviceDepthBiasControlFeaturesEXT-sType-sType + if (is_const_param) { + [[maybe_unused]] const Location pNext_loc = loc.pNext(Struct::VkPhysicalDeviceDepthBiasControlFeaturesEXT); + if (!IsExtEnabled(device_extensions.vk_ext_depth_bias_control)) { + skip |= LogError(pnext_vuid, instance, pNext_loc, + "includes a pointer to a VkPhysicalDeviceDepthBiasControlFeaturesEXT, but when creating " + "VkDevice, the parent extension " + "(VK_EXT_depth_bias_control) was not included in ppEnabledExtensionNames."); + } + VkPhysicalDeviceDepthBiasControlFeaturesEXT* structure = (VkPhysicalDeviceDepthBiasControlFeaturesEXT*)header; + skip |= ValidateBool32(pNext_loc.dot(Field::depthBiasControl), structure->depthBiasControl); + + skip |= ValidateBool32(pNext_loc.dot(Field::leastRepresentableValueForceUnormRepresentation), + structure->leastRepresentableValueForceUnormRepresentation); + + skip |= ValidateBool32(pNext_loc.dot(Field::floatRepresentation), structure->floatRepresentation); + + skip |= ValidateBool32(pNext_loc.dot(Field::depthBiasExact), structure->depthBiasExact); + } + } break; + + // Validation code for VkPhysicalDeviceDeviceMemoryReportFeaturesEXT structure members + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DEVICE_MEMORY_REPORT_FEATURES_EXT: { // Covers + // VUID-VkPhysicalDeviceDeviceMemoryReportFeaturesEXT-sType-sType + if (is_const_param) { + [[maybe_unused]] const Location pNext_loc = loc.pNext(Struct::VkPhysicalDeviceDeviceMemoryReportFeaturesEXT); + if (!IsExtEnabled(device_extensions.vk_ext_device_memory_report)) { + skip |= LogError(pnext_vuid, instance, pNext_loc, + "includes a pointer to a VkPhysicalDeviceDeviceMemoryReportFeaturesEXT, but when creating " + "VkDevice, the parent extension " + "(VK_EXT_device_memory_report) was not included in ppEnabledExtensionNames."); + } + VkPhysicalDeviceDeviceMemoryReportFeaturesEXT* structure = (VkPhysicalDeviceDeviceMemoryReportFeaturesEXT*)header; + skip |= ValidateBool32(pNext_loc.dot(Field::deviceMemoryReport), structure->deviceMemoryReport); + } + } break; + + // Validation code for VkPhysicalDeviceRobustness2FeaturesEXT structure members + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ROBUSTNESS_2_FEATURES_EXT: { // Covers + // VUID-VkPhysicalDeviceRobustness2FeaturesEXT-sType-sType + if (is_const_param) { + [[maybe_unused]] const Location pNext_loc = loc.pNext(Struct::VkPhysicalDeviceRobustness2FeaturesEXT); + if (!IsExtEnabled(device_extensions.vk_ext_robustness2)) { + skip |= LogError(pnext_vuid, instance, pNext_loc, + "includes a pointer to a VkPhysicalDeviceRobustness2FeaturesEXT, but when creating VkDevice, " + "the parent extension " + "(VK_EXT_robustness2) was not included in ppEnabledExtensionNames."); + } + VkPhysicalDeviceRobustness2FeaturesEXT* structure = (VkPhysicalDeviceRobustness2FeaturesEXT*)header; + skip |= ValidateBool32(pNext_loc.dot(Field::robustBufferAccess2), structure->robustBufferAccess2); + + skip |= ValidateBool32(pNext_loc.dot(Field::robustImageAccess2), structure->robustImageAccess2); + + skip |= ValidateBool32(pNext_loc.dot(Field::nullDescriptor), structure->nullDescriptor); + } + } break; + + // Validation code for VkPhysicalDeviceCustomBorderColorFeaturesEXT structure members + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_CUSTOM_BORDER_COLOR_FEATURES_EXT: { // Covers + // VUID-VkPhysicalDeviceCustomBorderColorFeaturesEXT-sType-sType + if (is_const_param) { + [[maybe_unused]] const Location pNext_loc = loc.pNext(Struct::VkPhysicalDeviceCustomBorderColorFeaturesEXT); + if (!IsExtEnabled(device_extensions.vk_ext_custom_border_color)) { + skip |= LogError(pnext_vuid, instance, pNext_loc, + "includes a pointer to a VkPhysicalDeviceCustomBorderColorFeaturesEXT, but when creating " + "VkDevice, the parent extension " + "(VK_EXT_custom_border_color) was not included in ppEnabledExtensionNames."); + } + VkPhysicalDeviceCustomBorderColorFeaturesEXT* structure = (VkPhysicalDeviceCustomBorderColorFeaturesEXT*)header; + skip |= ValidateBool32(pNext_loc.dot(Field::customBorderColors), structure->customBorderColors); + + skip |= + ValidateBool32(pNext_loc.dot(Field::customBorderColorWithoutFormat), structure->customBorderColorWithoutFormat); + } + } break; + + // Validation code for VkPhysicalDevicePresentBarrierFeaturesNV structure members + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PRESENT_BARRIER_FEATURES_NV: { // Covers + // VUID-VkPhysicalDevicePresentBarrierFeaturesNV-sType-sType + if (is_const_param) { + [[maybe_unused]] const Location pNext_loc = loc.pNext(Struct::VkPhysicalDevicePresentBarrierFeaturesNV); + if (!IsExtEnabled(device_extensions.vk_nv_present_barrier)) { + skip |= LogError(pnext_vuid, instance, pNext_loc, + "includes a pointer to a VkPhysicalDevicePresentBarrierFeaturesNV, but when creating " + "VkDevice, the parent extension " + "(VK_NV_present_barrier) was not included in ppEnabledExtensionNames."); + } + VkPhysicalDevicePresentBarrierFeaturesNV* structure = (VkPhysicalDevicePresentBarrierFeaturesNV*)header; + skip |= ValidateBool32(pNext_loc.dot(Field::presentBarrier), structure->presentBarrier); + } + } break; + + // Validation code for VkPhysicalDeviceDiagnosticsConfigFeaturesNV structure members + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DIAGNOSTICS_CONFIG_FEATURES_NV: { // Covers + // VUID-VkPhysicalDeviceDiagnosticsConfigFeaturesNV-sType-sType + if (is_const_param) { + [[maybe_unused]] const Location pNext_loc = loc.pNext(Struct::VkPhysicalDeviceDiagnosticsConfigFeaturesNV); + if (!IsExtEnabled(device_extensions.vk_nv_device_diagnostics_config)) { + skip |= LogError(pnext_vuid, instance, pNext_loc, + "includes a pointer to a VkPhysicalDeviceDiagnosticsConfigFeaturesNV, but when creating " + "VkDevice, the parent extension " + "(VK_NV_device_diagnostics_config) was not included in ppEnabledExtensionNames."); + } + VkPhysicalDeviceDiagnosticsConfigFeaturesNV* structure = (VkPhysicalDeviceDiagnosticsConfigFeaturesNV*)header; + skip |= ValidateBool32(pNext_loc.dot(Field::diagnosticsConfig), structure->diagnosticsConfig); + } + } break; + + // Validation code for VkPhysicalDeviceCudaKernelLaunchFeaturesNV structure members + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_CUDA_KERNEL_LAUNCH_FEATURES_NV: { // Covers + // VUID-VkPhysicalDeviceCudaKernelLaunchFeaturesNV-sType-sType + if (is_const_param) { + [[maybe_unused]] const Location pNext_loc = loc.pNext(Struct::VkPhysicalDeviceCudaKernelLaunchFeaturesNV); + if (!IsExtEnabled(device_extensions.vk_nv_cuda_kernel_launch)) { + skip |= LogError(pnext_vuid, instance, pNext_loc, + "includes a pointer to a VkPhysicalDeviceCudaKernelLaunchFeaturesNV, but when creating " + "VkDevice, the parent extension " + "(VK_NV_cuda_kernel_launch) was not included in ppEnabledExtensionNames."); + } + VkPhysicalDeviceCudaKernelLaunchFeaturesNV* structure = (VkPhysicalDeviceCudaKernelLaunchFeaturesNV*)header; + skip |= ValidateBool32(pNext_loc.dot(Field::cudaKernelLaunchFeatures), structure->cudaKernelLaunchFeatures); + } + } break; + + // Validation code for VkPhysicalDeviceDescriptorBufferFeaturesEXT structure members + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DESCRIPTOR_BUFFER_FEATURES_EXT: { // Covers + // VUID-VkPhysicalDeviceDescriptorBufferFeaturesEXT-sType-sType + if (is_const_param) { + [[maybe_unused]] const Location pNext_loc = loc.pNext(Struct::VkPhysicalDeviceDescriptorBufferFeaturesEXT); + if (!IsExtEnabled(device_extensions.vk_ext_descriptor_buffer)) { + skip |= LogError(pnext_vuid, instance, pNext_loc, + "includes a pointer to a VkPhysicalDeviceDescriptorBufferFeaturesEXT, but when creating " + "VkDevice, the parent extension " + "(VK_EXT_descriptor_buffer) was not included in ppEnabledExtensionNames."); + } + VkPhysicalDeviceDescriptorBufferFeaturesEXT* structure = (VkPhysicalDeviceDescriptorBufferFeaturesEXT*)header; + skip |= ValidateBool32(pNext_loc.dot(Field::descriptorBuffer), structure->descriptorBuffer); + + skip |= + ValidateBool32(pNext_loc.dot(Field::descriptorBufferCaptureReplay), structure->descriptorBufferCaptureReplay); + + skip |= ValidateBool32(pNext_loc.dot(Field::descriptorBufferImageLayoutIgnored), + structure->descriptorBufferImageLayoutIgnored); + + skip |= ValidateBool32(pNext_loc.dot(Field::descriptorBufferPushDescriptors), + structure->descriptorBufferPushDescriptors); + } + } break; + + // Validation code for VkPhysicalDeviceGraphicsPipelineLibraryFeaturesEXT structure members + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_GRAPHICS_PIPELINE_LIBRARY_FEATURES_EXT: { // Covers + // VUID-VkPhysicalDeviceGraphicsPipelineLibraryFeaturesEXT-sType-sType + if (is_const_param) { + [[maybe_unused]] const Location pNext_loc = loc.pNext(Struct::VkPhysicalDeviceGraphicsPipelineLibraryFeaturesEXT); + if (!IsExtEnabled(device_extensions.vk_ext_graphics_pipeline_library)) { + skip |= LogError(pnext_vuid, instance, pNext_loc, + "includes a pointer to a VkPhysicalDeviceGraphicsPipelineLibraryFeaturesEXT, but when " + "creating VkDevice, the parent extension " + "(VK_EXT_graphics_pipeline_library) was not included in ppEnabledExtensionNames."); + } + VkPhysicalDeviceGraphicsPipelineLibraryFeaturesEXT* structure = + (VkPhysicalDeviceGraphicsPipelineLibraryFeaturesEXT*)header; + skip |= ValidateBool32(pNext_loc.dot(Field::graphicsPipelineLibrary), structure->graphicsPipelineLibrary); + } + } break; + + // Validation code for VkPhysicalDeviceShaderEarlyAndLateFragmentTestsFeaturesAMD structure members + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_EARLY_AND_LATE_FRAGMENT_TESTS_FEATURES_AMD: { // Covers + // VUID-VkPhysicalDeviceShaderEarlyAndLateFragmentTestsFeaturesAMD-sType-sType + if (is_const_param) { + [[maybe_unused]] const Location pNext_loc = + loc.pNext(Struct::VkPhysicalDeviceShaderEarlyAndLateFragmentTestsFeaturesAMD); + if (!IsExtEnabled(device_extensions.vk_amd_shader_early_and_late_fragment_tests)) { + skip |= LogError(pnext_vuid, instance, pNext_loc, + "includes a pointer to a VkPhysicalDeviceShaderEarlyAndLateFragmentTestsFeaturesAMD, but when " + "creating VkDevice, the parent extension " + "(VK_AMD_shader_early_and_late_fragment_tests) was not included in ppEnabledExtensionNames."); + } + VkPhysicalDeviceShaderEarlyAndLateFragmentTestsFeaturesAMD* structure = + (VkPhysicalDeviceShaderEarlyAndLateFragmentTestsFeaturesAMD*)header; + skip |= ValidateBool32(pNext_loc.dot(Field::shaderEarlyAndLateFragmentTests), + structure->shaderEarlyAndLateFragmentTests); + } + } break; + + // Validation code for VkPhysicalDeviceFragmentShadingRateEnumsFeaturesNV structure members + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_SHADING_RATE_ENUMS_FEATURES_NV: { // Covers + // VUID-VkPhysicalDeviceFragmentShadingRateEnumsFeaturesNV-sType-sType + if (is_const_param) { + [[maybe_unused]] const Location pNext_loc = loc.pNext(Struct::VkPhysicalDeviceFragmentShadingRateEnumsFeaturesNV); + if (!IsExtEnabled(device_extensions.vk_nv_fragment_shading_rate_enums)) { + skip |= LogError(pnext_vuid, instance, pNext_loc, + "includes a pointer to a VkPhysicalDeviceFragmentShadingRateEnumsFeaturesNV, but when " + "creating VkDevice, the parent extension " + "(VK_NV_fragment_shading_rate_enums) was not included in ppEnabledExtensionNames."); + } + VkPhysicalDeviceFragmentShadingRateEnumsFeaturesNV* structure = + (VkPhysicalDeviceFragmentShadingRateEnumsFeaturesNV*)header; + skip |= ValidateBool32(pNext_loc.dot(Field::fragmentShadingRateEnums), structure->fragmentShadingRateEnums); + + skip |= ValidateBool32(pNext_loc.dot(Field::supersampleFragmentShadingRates), + structure->supersampleFragmentShadingRates); + + skip |= ValidateBool32(pNext_loc.dot(Field::noInvocationFragmentShadingRates), + structure->noInvocationFragmentShadingRates); + } + } break; + + // Validation code for VkPhysicalDeviceRayTracingMotionBlurFeaturesNV structure members + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RAY_TRACING_MOTION_BLUR_FEATURES_NV: { // Covers + // VUID-VkPhysicalDeviceRayTracingMotionBlurFeaturesNV-sType-sType + if (is_const_param) { + [[maybe_unused]] const Location pNext_loc = loc.pNext(Struct::VkPhysicalDeviceRayTracingMotionBlurFeaturesNV); + if (!IsExtEnabled(device_extensions.vk_nv_ray_tracing_motion_blur)) { + skip |= LogError(pnext_vuid, instance, pNext_loc, + "includes a pointer to a VkPhysicalDeviceRayTracingMotionBlurFeaturesNV, but when creating " + "VkDevice, the parent extension " + "(VK_NV_ray_tracing_motion_blur) was not included in ppEnabledExtensionNames."); + } + VkPhysicalDeviceRayTracingMotionBlurFeaturesNV* structure = (VkPhysicalDeviceRayTracingMotionBlurFeaturesNV*)header; + skip |= ValidateBool32(pNext_loc.dot(Field::rayTracingMotionBlur), structure->rayTracingMotionBlur); + + skip |= ValidateBool32(pNext_loc.dot(Field::rayTracingMotionBlurPipelineTraceRaysIndirect), + structure->rayTracingMotionBlurPipelineTraceRaysIndirect); + } + } break; + + // Validation code for VkPhysicalDeviceYcbcr2Plane444FormatsFeaturesEXT structure members + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_YCBCR_2_PLANE_444_FORMATS_FEATURES_EXT: { // Covers + // VUID-VkPhysicalDeviceYcbcr2Plane444FormatsFeaturesEXT-sType-sType + if (is_const_param) { + [[maybe_unused]] const Location pNext_loc = loc.pNext(Struct::VkPhysicalDeviceYcbcr2Plane444FormatsFeaturesEXT); + if (!IsExtEnabled(device_extensions.vk_ext_ycbcr_2plane_444_formats)) { + skip |= LogError(pnext_vuid, instance, pNext_loc, + "includes a pointer to a VkPhysicalDeviceYcbcr2Plane444FormatsFeaturesEXT, but when creating " + "VkDevice, the parent extension " + "(VK_EXT_ycbcr_2plane_444_formats) was not included in ppEnabledExtensionNames."); + } + VkPhysicalDeviceYcbcr2Plane444FormatsFeaturesEXT* structure = + (VkPhysicalDeviceYcbcr2Plane444FormatsFeaturesEXT*)header; + skip |= ValidateBool32(pNext_loc.dot(Field::ycbcr2plane444Formats), structure->ycbcr2plane444Formats); + } + } break; + + // Validation code for VkPhysicalDeviceFragmentDensityMap2FeaturesEXT structure members + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_DENSITY_MAP_2_FEATURES_EXT: { // Covers + // VUID-VkPhysicalDeviceFragmentDensityMap2FeaturesEXT-sType-sType + if (is_const_param) { + [[maybe_unused]] const Location pNext_loc = loc.pNext(Struct::VkPhysicalDeviceFragmentDensityMap2FeaturesEXT); + if (!IsExtEnabled(device_extensions.vk_ext_fragment_density_map2)) { + skip |= LogError(pnext_vuid, instance, pNext_loc, + "includes a pointer to a VkPhysicalDeviceFragmentDensityMap2FeaturesEXT, but when creating " + "VkDevice, the parent extension " + "(VK_EXT_fragment_density_map2) was not included in ppEnabledExtensionNames."); + } + VkPhysicalDeviceFragmentDensityMap2FeaturesEXT* structure = (VkPhysicalDeviceFragmentDensityMap2FeaturesEXT*)header; + skip |= ValidateBool32(pNext_loc.dot(Field::fragmentDensityMapDeferred), structure->fragmentDensityMapDeferred); + } + } break; + + // Validation code for VkPhysicalDeviceImageCompressionControlFeaturesEXT structure members + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_COMPRESSION_CONTROL_FEATURES_EXT: { // Covers + // VUID-VkPhysicalDeviceImageCompressionControlFeaturesEXT-sType-sType + if (is_const_param) { + [[maybe_unused]] const Location pNext_loc = loc.pNext(Struct::VkPhysicalDeviceImageCompressionControlFeaturesEXT); + if (!IsExtEnabled(device_extensions.vk_ext_image_compression_control)) { + skip |= LogError(pnext_vuid, instance, pNext_loc, + "includes a pointer to a VkPhysicalDeviceImageCompressionControlFeaturesEXT, but when " + "creating VkDevice, the parent extension " + "(VK_EXT_image_compression_control) was not included in ppEnabledExtensionNames."); + } + VkPhysicalDeviceImageCompressionControlFeaturesEXT* structure = + (VkPhysicalDeviceImageCompressionControlFeaturesEXT*)header; + skip |= ValidateBool32(pNext_loc.dot(Field::imageCompressionControl), structure->imageCompressionControl); + } + } break; + + // Validation code for VkPhysicalDeviceAttachmentFeedbackLoopLayoutFeaturesEXT structure members + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ATTACHMENT_FEEDBACK_LOOP_LAYOUT_FEATURES_EXT: { // Covers + // VUID-VkPhysicalDeviceAttachmentFeedbackLoopLayoutFeaturesEXT-sType-sType + if (is_const_param) { + [[maybe_unused]] const Location pNext_loc = + loc.pNext(Struct::VkPhysicalDeviceAttachmentFeedbackLoopLayoutFeaturesEXT); + if (!IsExtEnabled(device_extensions.vk_ext_attachment_feedback_loop_layout)) { + skip |= LogError(pnext_vuid, instance, pNext_loc, + "includes a pointer to a VkPhysicalDeviceAttachmentFeedbackLoopLayoutFeaturesEXT, but when " + "creating VkDevice, the parent extension " + "(VK_EXT_attachment_feedback_loop_layout) was not included in ppEnabledExtensionNames."); + } + VkPhysicalDeviceAttachmentFeedbackLoopLayoutFeaturesEXT* structure = + (VkPhysicalDeviceAttachmentFeedbackLoopLayoutFeaturesEXT*)header; + skip |= ValidateBool32(pNext_loc.dot(Field::attachmentFeedbackLoopLayout), structure->attachmentFeedbackLoopLayout); + } + } break; + + // Validation code for VkPhysicalDevice4444FormatsFeaturesEXT structure members + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_4444_FORMATS_FEATURES_EXT: { // Covers + // VUID-VkPhysicalDevice4444FormatsFeaturesEXT-sType-sType + if (is_const_param) { + [[maybe_unused]] const Location pNext_loc = loc.pNext(Struct::VkPhysicalDevice4444FormatsFeaturesEXT); + if (!IsExtEnabled(device_extensions.vk_ext_4444_formats)) { + skip |= LogError(pnext_vuid, instance, pNext_loc, + "includes a pointer to a VkPhysicalDevice4444FormatsFeaturesEXT, but when creating VkDevice, " + "the parent extension " + "(VK_EXT_4444_formats) was not included in ppEnabledExtensionNames."); + } + VkPhysicalDevice4444FormatsFeaturesEXT* structure = (VkPhysicalDevice4444FormatsFeaturesEXT*)header; + skip |= ValidateBool32(pNext_loc.dot(Field::formatA4R4G4B4), structure->formatA4R4G4B4); + + skip |= ValidateBool32(pNext_loc.dot(Field::formatA4B4G4R4), structure->formatA4B4G4R4); + } + } break; + + // Validation code for VkPhysicalDeviceFaultFeaturesEXT structure members + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FAULT_FEATURES_EXT: { // Covers VUID-VkPhysicalDeviceFaultFeaturesEXT-sType-sType + if (is_const_param) { + [[maybe_unused]] const Location pNext_loc = loc.pNext(Struct::VkPhysicalDeviceFaultFeaturesEXT); + if (!IsExtEnabled(device_extensions.vk_ext_device_fault)) { + skip |= LogError(pnext_vuid, instance, pNext_loc, + "includes a pointer to a VkPhysicalDeviceFaultFeaturesEXT, but when creating VkDevice, the " + "parent extension " + "(VK_EXT_device_fault) was not included in ppEnabledExtensionNames."); + } + VkPhysicalDeviceFaultFeaturesEXT* structure = (VkPhysicalDeviceFaultFeaturesEXT*)header; + skip |= ValidateBool32(pNext_loc.dot(Field::deviceFault), structure->deviceFault); + + skip |= ValidateBool32(pNext_loc.dot(Field::deviceFaultVendorBinary), structure->deviceFaultVendorBinary); + } + } break; + + // Validation code for VkPhysicalDeviceRasterizationOrderAttachmentAccessFeaturesEXT structure members + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RASTERIZATION_ORDER_ATTACHMENT_ACCESS_FEATURES_EXT: { // Covers + // VUID-VkPhysicalDeviceRasterizationOrderAttachmentAccessFeaturesEXT-sType-sType + if (is_const_param) { + [[maybe_unused]] const Location pNext_loc = + loc.pNext(Struct::VkPhysicalDeviceRasterizationOrderAttachmentAccessFeaturesEXT); + if (!IsExtEnabled(device_extensions.vk_arm_rasterization_order_attachment_access) && + !IsExtEnabled(device_extensions.vk_ext_rasterization_order_attachment_access)) { + skip |= LogError(pnext_vuid, instance, pNext_loc, + "includes a pointer to a VkPhysicalDeviceRasterizationOrderAttachmentAccessFeaturesEXT, but " + "when creating VkDevice, the parent extension " + "(VK_ARM_rasterization_order_attachment_access or " + "VK_EXT_rasterization_order_attachment_access) was not included in ppEnabledExtensionNames."); + } + VkPhysicalDeviceRasterizationOrderAttachmentAccessFeaturesEXT* structure = + (VkPhysicalDeviceRasterizationOrderAttachmentAccessFeaturesEXT*)header; + skip |= ValidateBool32(pNext_loc.dot(Field::rasterizationOrderColorAttachmentAccess), + structure->rasterizationOrderColorAttachmentAccess); + + skip |= ValidateBool32(pNext_loc.dot(Field::rasterizationOrderDepthAttachmentAccess), + structure->rasterizationOrderDepthAttachmentAccess); + + skip |= ValidateBool32(pNext_loc.dot(Field::rasterizationOrderStencilAttachmentAccess), + structure->rasterizationOrderStencilAttachmentAccess); + } + } break; + + // Validation code for VkPhysicalDeviceRGBA10X6FormatsFeaturesEXT structure members + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RGBA10X6_FORMATS_FEATURES_EXT: { // Covers + // VUID-VkPhysicalDeviceRGBA10X6FormatsFeaturesEXT-sType-sType + if (is_const_param) { + [[maybe_unused]] const Location pNext_loc = loc.pNext(Struct::VkPhysicalDeviceRGBA10X6FormatsFeaturesEXT); + if (!IsExtEnabled(device_extensions.vk_ext_rgba10x6_formats)) { + skip |= LogError(pnext_vuid, instance, pNext_loc, + "includes a pointer to a VkPhysicalDeviceRGBA10X6FormatsFeaturesEXT, but when creating " + "VkDevice, the parent extension " + "(VK_EXT_rgba10x6_formats) was not included in ppEnabledExtensionNames."); + } + VkPhysicalDeviceRGBA10X6FormatsFeaturesEXT* structure = (VkPhysicalDeviceRGBA10X6FormatsFeaturesEXT*)header; + skip |= ValidateBool32(pNext_loc.dot(Field::formatRgba10x6WithoutYCbCrSampler), + structure->formatRgba10x6WithoutYCbCrSampler); + } + } break; + + // Validation code for VkPhysicalDeviceMutableDescriptorTypeFeaturesEXT structure members + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MUTABLE_DESCRIPTOR_TYPE_FEATURES_EXT: { // Covers + // VUID-VkPhysicalDeviceMutableDescriptorTypeFeaturesEXT-sType-sType + if (is_const_param) { + [[maybe_unused]] const Location pNext_loc = loc.pNext(Struct::VkPhysicalDeviceMutableDescriptorTypeFeaturesEXT); + if (!IsExtEnabled(device_extensions.vk_valve_mutable_descriptor_type) && + !IsExtEnabled(device_extensions.vk_ext_mutable_descriptor_type)) { + skip |= LogError(pnext_vuid, instance, pNext_loc, + "includes a pointer to a VkPhysicalDeviceMutableDescriptorTypeFeaturesEXT, but when creating " + "VkDevice, the parent extension " + "(VK_VALVE_mutable_descriptor_type or VK_EXT_mutable_descriptor_type) was not included in " + "ppEnabledExtensionNames."); + } + VkPhysicalDeviceMutableDescriptorTypeFeaturesEXT* structure = + (VkPhysicalDeviceMutableDescriptorTypeFeaturesEXT*)header; + skip |= ValidateBool32(pNext_loc.dot(Field::mutableDescriptorType), structure->mutableDescriptorType); + } + } break; + + // Validation code for VkPhysicalDeviceVertexInputDynamicStateFeaturesEXT structure members + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VERTEX_INPUT_DYNAMIC_STATE_FEATURES_EXT: { // Covers + // VUID-VkPhysicalDeviceVertexInputDynamicStateFeaturesEXT-sType-sType + if (is_const_param) { + [[maybe_unused]] const Location pNext_loc = loc.pNext(Struct::VkPhysicalDeviceVertexInputDynamicStateFeaturesEXT); + if (!IsExtEnabled(device_extensions.vk_ext_vertex_input_dynamic_state)) { + skip |= LogError(pnext_vuid, instance, pNext_loc, + "includes a pointer to a VkPhysicalDeviceVertexInputDynamicStateFeaturesEXT, but when " + "creating VkDevice, the parent extension " + "(VK_EXT_vertex_input_dynamic_state) was not included in ppEnabledExtensionNames."); + } + VkPhysicalDeviceVertexInputDynamicStateFeaturesEXT* structure = + (VkPhysicalDeviceVertexInputDynamicStateFeaturesEXT*)header; + skip |= ValidateBool32(pNext_loc.dot(Field::vertexInputDynamicState), structure->vertexInputDynamicState); + } + } break; + + // Validation code for VkPhysicalDeviceAddressBindingReportFeaturesEXT structure members + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ADDRESS_BINDING_REPORT_FEATURES_EXT: { // Covers + // VUID-VkPhysicalDeviceAddressBindingReportFeaturesEXT-sType-sType + if (is_const_param) { + [[maybe_unused]] const Location pNext_loc = loc.pNext(Struct::VkPhysicalDeviceAddressBindingReportFeaturesEXT); + if (!IsExtEnabled(device_extensions.vk_ext_device_address_binding_report)) { + skip |= LogError(pnext_vuid, instance, pNext_loc, + "includes a pointer to a VkPhysicalDeviceAddressBindingReportFeaturesEXT, but when creating " + "VkDevice, the parent extension " + "(VK_EXT_device_address_binding_report) was not included in ppEnabledExtensionNames."); + } + VkPhysicalDeviceAddressBindingReportFeaturesEXT* structure = + (VkPhysicalDeviceAddressBindingReportFeaturesEXT*)header; + skip |= ValidateBool32(pNext_loc.dot(Field::reportAddressBinding), structure->reportAddressBinding); + } + } break; + + // Validation code for VkPhysicalDeviceDepthClipControlFeaturesEXT structure members + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DEPTH_CLIP_CONTROL_FEATURES_EXT: { // Covers + // VUID-VkPhysicalDeviceDepthClipControlFeaturesEXT-sType-sType + if (is_const_param) { + [[maybe_unused]] const Location pNext_loc = loc.pNext(Struct::VkPhysicalDeviceDepthClipControlFeaturesEXT); + if (!IsExtEnabled(device_extensions.vk_ext_depth_clip_control)) { + skip |= LogError(pnext_vuid, instance, pNext_loc, + "includes a pointer to a VkPhysicalDeviceDepthClipControlFeaturesEXT, but when creating " + "VkDevice, the parent extension " + "(VK_EXT_depth_clip_control) was not included in ppEnabledExtensionNames."); + } + VkPhysicalDeviceDepthClipControlFeaturesEXT* structure = (VkPhysicalDeviceDepthClipControlFeaturesEXT*)header; + skip |= ValidateBool32(pNext_loc.dot(Field::depthClipControl), structure->depthClipControl); + } + } break; + + // Validation code for VkPhysicalDevicePrimitiveTopologyListRestartFeaturesEXT structure members + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PRIMITIVE_TOPOLOGY_LIST_RESTART_FEATURES_EXT: { // Covers + // VUID-VkPhysicalDevicePrimitiveTopologyListRestartFeaturesEXT-sType-sType + if (is_const_param) { + [[maybe_unused]] const Location pNext_loc = + loc.pNext(Struct::VkPhysicalDevicePrimitiveTopologyListRestartFeaturesEXT); + if (!IsExtEnabled(device_extensions.vk_ext_primitive_topology_list_restart)) { + skip |= LogError(pnext_vuid, instance, pNext_loc, + "includes a pointer to a VkPhysicalDevicePrimitiveTopologyListRestartFeaturesEXT, but when " + "creating VkDevice, the parent extension " + "(VK_EXT_primitive_topology_list_restart) was not included in ppEnabledExtensionNames."); + } + VkPhysicalDevicePrimitiveTopologyListRestartFeaturesEXT* structure = + (VkPhysicalDevicePrimitiveTopologyListRestartFeaturesEXT*)header; + skip |= ValidateBool32(pNext_loc.dot(Field::primitiveTopologyListRestart), structure->primitiveTopologyListRestart); + + skip |= ValidateBool32(pNext_loc.dot(Field::primitiveTopologyPatchListRestart), + structure->primitiveTopologyPatchListRestart); + } + } break; + + // Validation code for VkPhysicalDeviceSubpassShadingFeaturesHUAWEI structure members + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SUBPASS_SHADING_FEATURES_HUAWEI: { // Covers + // VUID-VkPhysicalDeviceSubpassShadingFeaturesHUAWEI-sType-sType + if (is_const_param) { + [[maybe_unused]] const Location pNext_loc = loc.pNext(Struct::VkPhysicalDeviceSubpassShadingFeaturesHUAWEI); + if (!IsExtEnabled(device_extensions.vk_huawei_subpass_shading)) { + skip |= LogError(pnext_vuid, instance, pNext_loc, + "includes a pointer to a VkPhysicalDeviceSubpassShadingFeaturesHUAWEI, but when creating " + "VkDevice, the parent extension " + "(VK_HUAWEI_subpass_shading) was not included in ppEnabledExtensionNames."); + } + VkPhysicalDeviceSubpassShadingFeaturesHUAWEI* structure = (VkPhysicalDeviceSubpassShadingFeaturesHUAWEI*)header; + skip |= ValidateBool32(pNext_loc.dot(Field::subpassShading), structure->subpassShading); + } + } break; + + // Validation code for VkPhysicalDeviceInvocationMaskFeaturesHUAWEI structure members + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_INVOCATION_MASK_FEATURES_HUAWEI: { // Covers + // VUID-VkPhysicalDeviceInvocationMaskFeaturesHUAWEI-sType-sType + if (is_const_param) { + [[maybe_unused]] const Location pNext_loc = loc.pNext(Struct::VkPhysicalDeviceInvocationMaskFeaturesHUAWEI); + if (!IsExtEnabled(device_extensions.vk_huawei_invocation_mask)) { + skip |= LogError(pnext_vuid, instance, pNext_loc, + "includes a pointer to a VkPhysicalDeviceInvocationMaskFeaturesHUAWEI, but when creating " + "VkDevice, the parent extension " + "(VK_HUAWEI_invocation_mask) was not included in ppEnabledExtensionNames."); + } + VkPhysicalDeviceInvocationMaskFeaturesHUAWEI* structure = (VkPhysicalDeviceInvocationMaskFeaturesHUAWEI*)header; + skip |= ValidateBool32(pNext_loc.dot(Field::invocationMask), structure->invocationMask); + } + } break; + + // Validation code for VkPhysicalDeviceExternalMemoryRDMAFeaturesNV structure members + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTERNAL_MEMORY_RDMA_FEATURES_NV: { // Covers + // VUID-VkPhysicalDeviceExternalMemoryRDMAFeaturesNV-sType-sType + if (is_const_param) { + [[maybe_unused]] const Location pNext_loc = loc.pNext(Struct::VkPhysicalDeviceExternalMemoryRDMAFeaturesNV); + if (!IsExtEnabled(device_extensions.vk_nv_external_memory_rdma)) { + skip |= LogError(pnext_vuid, instance, pNext_loc, + "includes a pointer to a VkPhysicalDeviceExternalMemoryRDMAFeaturesNV, but when creating " + "VkDevice, the parent extension " + "(VK_NV_external_memory_rdma) was not included in ppEnabledExtensionNames."); + } + VkPhysicalDeviceExternalMemoryRDMAFeaturesNV* structure = (VkPhysicalDeviceExternalMemoryRDMAFeaturesNV*)header; + skip |= ValidateBool32(pNext_loc.dot(Field::externalMemoryRDMA), structure->externalMemoryRDMA); + } + } break; + + // Validation code for VkPhysicalDevicePipelinePropertiesFeaturesEXT structure members + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PIPELINE_PROPERTIES_FEATURES_EXT: { // Covers + // VUID-VkPhysicalDevicePipelinePropertiesFeaturesEXT-sType-sType + if (is_const_param) { + [[maybe_unused]] const Location pNext_loc = loc.pNext(Struct::VkPhysicalDevicePipelinePropertiesFeaturesEXT); + if (!IsExtEnabled(device_extensions.vk_ext_pipeline_properties)) { + skip |= LogError(pnext_vuid, instance, pNext_loc, + "includes a pointer to a VkPhysicalDevicePipelinePropertiesFeaturesEXT, but when creating " + "VkDevice, the parent extension " + "(VK_EXT_pipeline_properties) was not included in ppEnabledExtensionNames."); + } + VkPhysicalDevicePipelinePropertiesFeaturesEXT* structure = (VkPhysicalDevicePipelinePropertiesFeaturesEXT*)header; + skip |= ValidateBool32(pNext_loc.dot(Field::pipelinePropertiesIdentifier), structure->pipelinePropertiesIdentifier); + } + } break; + + // Validation code for VkPhysicalDeviceFrameBoundaryFeaturesEXT structure members + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAME_BOUNDARY_FEATURES_EXT: { // Covers + // VUID-VkPhysicalDeviceFrameBoundaryFeaturesEXT-sType-sType + if (is_const_param) { + [[maybe_unused]] const Location pNext_loc = loc.pNext(Struct::VkPhysicalDeviceFrameBoundaryFeaturesEXT); + if (!IsExtEnabled(device_extensions.vk_ext_frame_boundary)) { + skip |= LogError(pnext_vuid, instance, pNext_loc, + "includes a pointer to a VkPhysicalDeviceFrameBoundaryFeaturesEXT, but when creating " + "VkDevice, the parent extension " + "(VK_EXT_frame_boundary) was not included in ppEnabledExtensionNames."); + } + VkPhysicalDeviceFrameBoundaryFeaturesEXT* structure = (VkPhysicalDeviceFrameBoundaryFeaturesEXT*)header; + skip |= ValidateBool32(pNext_loc.dot(Field::frameBoundary), structure->frameBoundary); + } + } break; + + // Validation code for VkPhysicalDeviceMultisampledRenderToSingleSampledFeaturesEXT structure members + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MULTISAMPLED_RENDER_TO_SINGLE_SAMPLED_FEATURES_EXT: { // Covers + // VUID-VkPhysicalDeviceMultisampledRenderToSingleSampledFeaturesEXT-sType-sType + if (is_const_param) { + [[maybe_unused]] const Location pNext_loc = + loc.pNext(Struct::VkPhysicalDeviceMultisampledRenderToSingleSampledFeaturesEXT); + if (!IsExtEnabled(device_extensions.vk_ext_multisampled_render_to_single_sampled)) { + skip |= LogError(pnext_vuid, instance, pNext_loc, + "includes a pointer to a VkPhysicalDeviceMultisampledRenderToSingleSampledFeaturesEXT, but " + "when creating VkDevice, the parent extension " + "(VK_EXT_multisampled_render_to_single_sampled) was not included in ppEnabledExtensionNames."); + } + VkPhysicalDeviceMultisampledRenderToSingleSampledFeaturesEXT* structure = + (VkPhysicalDeviceMultisampledRenderToSingleSampledFeaturesEXT*)header; + skip |= ValidateBool32(pNext_loc.dot(Field::multisampledRenderToSingleSampled), + structure->multisampledRenderToSingleSampled); + } + } break; + + // Validation code for VkPhysicalDeviceExtendedDynamicState2FeaturesEXT structure members + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTENDED_DYNAMIC_STATE_2_FEATURES_EXT: { // Covers + // VUID-VkPhysicalDeviceExtendedDynamicState2FeaturesEXT-sType-sType + if (is_const_param) { + [[maybe_unused]] const Location pNext_loc = loc.pNext(Struct::VkPhysicalDeviceExtendedDynamicState2FeaturesEXT); + if (!IsExtEnabled(device_extensions.vk_ext_extended_dynamic_state2)) { + skip |= LogError(pnext_vuid, instance, pNext_loc, + "includes a pointer to a VkPhysicalDeviceExtendedDynamicState2FeaturesEXT, but when creating " + "VkDevice, the parent extension " + "(VK_EXT_extended_dynamic_state2) was not included in ppEnabledExtensionNames."); + } + VkPhysicalDeviceExtendedDynamicState2FeaturesEXT* structure = + (VkPhysicalDeviceExtendedDynamicState2FeaturesEXT*)header; + skip |= ValidateBool32(pNext_loc.dot(Field::extendedDynamicState2), structure->extendedDynamicState2); + + skip |= ValidateBool32(pNext_loc.dot(Field::extendedDynamicState2LogicOp), structure->extendedDynamicState2LogicOp); + + skip |= ValidateBool32(pNext_loc.dot(Field::extendedDynamicState2PatchControlPoints), + structure->extendedDynamicState2PatchControlPoints); + } + } break; + + // Validation code for VkPhysicalDeviceColorWriteEnableFeaturesEXT structure members + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COLOR_WRITE_ENABLE_FEATURES_EXT: { // Covers + // VUID-VkPhysicalDeviceColorWriteEnableFeaturesEXT-sType-sType + if (is_const_param) { + [[maybe_unused]] const Location pNext_loc = loc.pNext(Struct::VkPhysicalDeviceColorWriteEnableFeaturesEXT); + if (!IsExtEnabled(device_extensions.vk_ext_color_write_enable)) { + skip |= LogError(pnext_vuid, instance, pNext_loc, + "includes a pointer to a VkPhysicalDeviceColorWriteEnableFeaturesEXT, but when creating " + "VkDevice, the parent extension " + "(VK_EXT_color_write_enable) was not included in ppEnabledExtensionNames."); + } + VkPhysicalDeviceColorWriteEnableFeaturesEXT* structure = (VkPhysicalDeviceColorWriteEnableFeaturesEXT*)header; + skip |= ValidateBool32(pNext_loc.dot(Field::colorWriteEnable), structure->colorWriteEnable); + } + } break; + + // Validation code for VkPhysicalDevicePrimitivesGeneratedQueryFeaturesEXT structure members + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PRIMITIVES_GENERATED_QUERY_FEATURES_EXT: { // Covers + // VUID-VkPhysicalDevicePrimitivesGeneratedQueryFeaturesEXT-sType-sType + if (is_const_param) { + [[maybe_unused]] const Location pNext_loc = loc.pNext(Struct::VkPhysicalDevicePrimitivesGeneratedQueryFeaturesEXT); + if (!IsExtEnabled(device_extensions.vk_ext_primitives_generated_query)) { + skip |= LogError(pnext_vuid, instance, pNext_loc, + "includes a pointer to a VkPhysicalDevicePrimitivesGeneratedQueryFeaturesEXT, but when " + "creating VkDevice, the parent extension " + "(VK_EXT_primitives_generated_query) was not included in ppEnabledExtensionNames."); + } + VkPhysicalDevicePrimitivesGeneratedQueryFeaturesEXT* structure = + (VkPhysicalDevicePrimitivesGeneratedQueryFeaturesEXT*)header; + skip |= ValidateBool32(pNext_loc.dot(Field::primitivesGeneratedQuery), structure->primitivesGeneratedQuery); + + skip |= ValidateBool32(pNext_loc.dot(Field::primitivesGeneratedQueryWithRasterizerDiscard), + structure->primitivesGeneratedQueryWithRasterizerDiscard); + + skip |= ValidateBool32(pNext_loc.dot(Field::primitivesGeneratedQueryWithNonZeroStreams), + structure->primitivesGeneratedQueryWithNonZeroStreams); + } + } break; + + // Validation code for VkPhysicalDeviceImageViewMinLodFeaturesEXT structure members + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_VIEW_MIN_LOD_FEATURES_EXT: { // Covers + // VUID-VkPhysicalDeviceImageViewMinLodFeaturesEXT-sType-sType + if (is_const_param) { + [[maybe_unused]] const Location pNext_loc = loc.pNext(Struct::VkPhysicalDeviceImageViewMinLodFeaturesEXT); + if (!IsExtEnabled(device_extensions.vk_ext_image_view_min_lod)) { + skip |= LogError(pnext_vuid, instance, pNext_loc, + "includes a pointer to a VkPhysicalDeviceImageViewMinLodFeaturesEXT, but when creating " + "VkDevice, the parent extension " + "(VK_EXT_image_view_min_lod) was not included in ppEnabledExtensionNames."); + } + VkPhysicalDeviceImageViewMinLodFeaturesEXT* structure = (VkPhysicalDeviceImageViewMinLodFeaturesEXT*)header; + skip |= ValidateBool32(pNext_loc.dot(Field::minLod), structure->minLod); + } + } break; + + // Validation code for VkPhysicalDeviceMultiDrawFeaturesEXT structure members + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MULTI_DRAW_FEATURES_EXT: { // Covers + // VUID-VkPhysicalDeviceMultiDrawFeaturesEXT-sType-sType + if (is_const_param) { + [[maybe_unused]] const Location pNext_loc = loc.pNext(Struct::VkPhysicalDeviceMultiDrawFeaturesEXT); + if (!IsExtEnabled(device_extensions.vk_ext_multi_draw)) { + skip |= LogError(pnext_vuid, instance, pNext_loc, + "includes a pointer to a VkPhysicalDeviceMultiDrawFeaturesEXT, but when creating VkDevice, " + "the parent extension " + "(VK_EXT_multi_draw) was not included in ppEnabledExtensionNames."); + } + VkPhysicalDeviceMultiDrawFeaturesEXT* structure = (VkPhysicalDeviceMultiDrawFeaturesEXT*)header; + skip |= ValidateBool32(pNext_loc.dot(Field::multiDraw), structure->multiDraw); + } + } break; + + // Validation code for VkPhysicalDeviceImage2DViewOf3DFeaturesEXT structure members + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_2D_VIEW_OF_3D_FEATURES_EXT: { // Covers + // VUID-VkPhysicalDeviceImage2DViewOf3DFeaturesEXT-sType-sType + if (is_const_param) { + [[maybe_unused]] const Location pNext_loc = loc.pNext(Struct::VkPhysicalDeviceImage2DViewOf3DFeaturesEXT); + if (!IsExtEnabled(device_extensions.vk_ext_image_2d_view_of_3d)) { + skip |= LogError(pnext_vuid, instance, pNext_loc, + "includes a pointer to a VkPhysicalDeviceImage2DViewOf3DFeaturesEXT, but when creating " + "VkDevice, the parent extension " + "(VK_EXT_image_2d_view_of_3d) was not included in ppEnabledExtensionNames."); + } + VkPhysicalDeviceImage2DViewOf3DFeaturesEXT* structure = (VkPhysicalDeviceImage2DViewOf3DFeaturesEXT*)header; + skip |= ValidateBool32(pNext_loc.dot(Field::image2DViewOf3D), structure->image2DViewOf3D); + + skip |= ValidateBool32(pNext_loc.dot(Field::sampler2DViewOf3D), structure->sampler2DViewOf3D); + } + } break; + + // Validation code for VkPhysicalDeviceShaderTileImageFeaturesEXT structure members + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_TILE_IMAGE_FEATURES_EXT: { // Covers + // VUID-VkPhysicalDeviceShaderTileImageFeaturesEXT-sType-sType + if (is_const_param) { + [[maybe_unused]] const Location pNext_loc = loc.pNext(Struct::VkPhysicalDeviceShaderTileImageFeaturesEXT); + if (!IsExtEnabled(device_extensions.vk_ext_shader_tile_image)) { + skip |= LogError(pnext_vuid, instance, pNext_loc, + "includes a pointer to a VkPhysicalDeviceShaderTileImageFeaturesEXT, but when creating " + "VkDevice, the parent extension " + "(VK_EXT_shader_tile_image) was not included in ppEnabledExtensionNames."); + } + VkPhysicalDeviceShaderTileImageFeaturesEXT* structure = (VkPhysicalDeviceShaderTileImageFeaturesEXT*)header; + skip |= + ValidateBool32(pNext_loc.dot(Field::shaderTileImageColorReadAccess), structure->shaderTileImageColorReadAccess); + + skip |= + ValidateBool32(pNext_loc.dot(Field::shaderTileImageDepthReadAccess), structure->shaderTileImageDepthReadAccess); + + skip |= ValidateBool32(pNext_loc.dot(Field::shaderTileImageStencilReadAccess), + structure->shaderTileImageStencilReadAccess); + } + } break; + + // Validation code for VkPhysicalDeviceOpacityMicromapFeaturesEXT structure members + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_OPACITY_MICROMAP_FEATURES_EXT: { // Covers + // VUID-VkPhysicalDeviceOpacityMicromapFeaturesEXT-sType-sType + if (is_const_param) { + [[maybe_unused]] const Location pNext_loc = loc.pNext(Struct::VkPhysicalDeviceOpacityMicromapFeaturesEXT); + if (!IsExtEnabled(device_extensions.vk_ext_opacity_micromap)) { + skip |= LogError(pnext_vuid, instance, pNext_loc, + "includes a pointer to a VkPhysicalDeviceOpacityMicromapFeaturesEXT, but when creating " + "VkDevice, the parent extension " + "(VK_EXT_opacity_micromap) was not included in ppEnabledExtensionNames."); + } + VkPhysicalDeviceOpacityMicromapFeaturesEXT* structure = (VkPhysicalDeviceOpacityMicromapFeaturesEXT*)header; + skip |= ValidateBool32(pNext_loc.dot(Field::micromap), structure->micromap); + + skip |= ValidateBool32(pNext_loc.dot(Field::micromapCaptureReplay), structure->micromapCaptureReplay); + + skip |= ValidateBool32(pNext_loc.dot(Field::micromapHostCommands), structure->micromapHostCommands); + } + } break; +#ifdef VK_ENABLE_BETA_EXTENSIONS + + // Validation code for VkPhysicalDeviceDisplacementMicromapFeaturesNV structure members + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DISPLACEMENT_MICROMAP_FEATURES_NV: { // Covers + // VUID-VkPhysicalDeviceDisplacementMicromapFeaturesNV-sType-sType + if (is_const_param) { + [[maybe_unused]] const Location pNext_loc = loc.pNext(Struct::VkPhysicalDeviceDisplacementMicromapFeaturesNV); + if (!IsExtEnabled(device_extensions.vk_nv_displacement_micromap)) { + skip |= LogError(pnext_vuid, instance, pNext_loc, + "includes a pointer to a VkPhysicalDeviceDisplacementMicromapFeaturesNV, but when creating " + "VkDevice, the parent extension " + "(VK_NV_displacement_micromap) was not included in ppEnabledExtensionNames."); + } + VkPhysicalDeviceDisplacementMicromapFeaturesNV* structure = (VkPhysicalDeviceDisplacementMicromapFeaturesNV*)header; + skip |= ValidateBool32(pNext_loc.dot(Field::displacementMicromap), structure->displacementMicromap); + } + } break; +#endif // VK_ENABLE_BETA_EXTENSIONS + + // Validation code for VkPhysicalDeviceClusterCullingShaderFeaturesHUAWEI structure members + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_CLUSTER_CULLING_SHADER_FEATURES_HUAWEI: { // Covers + // VUID-VkPhysicalDeviceClusterCullingShaderFeaturesHUAWEI-sType-sType + if (is_const_param) { + [[maybe_unused]] const Location pNext_loc = loc.pNext(Struct::VkPhysicalDeviceClusterCullingShaderFeaturesHUAWEI); + if (!IsExtEnabled(device_extensions.vk_huawei_cluster_culling_shader)) { + skip |= LogError(pnext_vuid, instance, pNext_loc, + "includes a pointer to a VkPhysicalDeviceClusterCullingShaderFeaturesHUAWEI, but when " + "creating VkDevice, the parent extension " + "(VK_HUAWEI_cluster_culling_shader) was not included in ppEnabledExtensionNames."); + } + VkPhysicalDeviceClusterCullingShaderFeaturesHUAWEI* structure = + (VkPhysicalDeviceClusterCullingShaderFeaturesHUAWEI*)header; + skip |= ValidateBool32(pNext_loc.dot(Field::clustercullingShader), structure->clustercullingShader); + + skip |= + ValidateBool32(pNext_loc.dot(Field::multiviewClusterCullingShader), structure->multiviewClusterCullingShader); + } + } break; + + // Validation code for VkPhysicalDeviceBorderColorSwizzleFeaturesEXT structure members + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_BORDER_COLOR_SWIZZLE_FEATURES_EXT: { // Covers + // VUID-VkPhysicalDeviceBorderColorSwizzleFeaturesEXT-sType-sType + if (is_const_param) { + [[maybe_unused]] const Location pNext_loc = loc.pNext(Struct::VkPhysicalDeviceBorderColorSwizzleFeaturesEXT); + if (!IsExtEnabled(device_extensions.vk_ext_border_color_swizzle)) { + skip |= LogError(pnext_vuid, instance, pNext_loc, + "includes a pointer to a VkPhysicalDeviceBorderColorSwizzleFeaturesEXT, but when creating " + "VkDevice, the parent extension " + "(VK_EXT_border_color_swizzle) was not included in ppEnabledExtensionNames."); + } + VkPhysicalDeviceBorderColorSwizzleFeaturesEXT* structure = (VkPhysicalDeviceBorderColorSwizzleFeaturesEXT*)header; + skip |= ValidateBool32(pNext_loc.dot(Field::borderColorSwizzle), structure->borderColorSwizzle); + + skip |= ValidateBool32(pNext_loc.dot(Field::borderColorSwizzleFromImage), structure->borderColorSwizzleFromImage); + } + } break; + + // Validation code for VkPhysicalDevicePageableDeviceLocalMemoryFeaturesEXT structure members + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PAGEABLE_DEVICE_LOCAL_MEMORY_FEATURES_EXT: { // Covers + // VUID-VkPhysicalDevicePageableDeviceLocalMemoryFeaturesEXT-sType-sType + if (is_const_param) { + [[maybe_unused]] const Location pNext_loc = loc.pNext(Struct::VkPhysicalDevicePageableDeviceLocalMemoryFeaturesEXT); + if (!IsExtEnabled(device_extensions.vk_ext_pageable_device_local_memory)) { + skip |= LogError(pnext_vuid, instance, pNext_loc, + "includes a pointer to a VkPhysicalDevicePageableDeviceLocalMemoryFeaturesEXT, but when " + "creating VkDevice, the parent extension " + "(VK_EXT_pageable_device_local_memory) was not included in ppEnabledExtensionNames."); + } + VkPhysicalDevicePageableDeviceLocalMemoryFeaturesEXT* structure = + (VkPhysicalDevicePageableDeviceLocalMemoryFeaturesEXT*)header; + skip |= ValidateBool32(pNext_loc.dot(Field::pageableDeviceLocalMemory), structure->pageableDeviceLocalMemory); + } + } break; + + // Validation code for VkPhysicalDeviceSchedulingControlsFeaturesARM structure members + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SCHEDULING_CONTROLS_FEATURES_ARM: { // Covers + // VUID-VkPhysicalDeviceSchedulingControlsFeaturesARM-sType-sType + if (is_const_param) { + [[maybe_unused]] const Location pNext_loc = loc.pNext(Struct::VkPhysicalDeviceSchedulingControlsFeaturesARM); + if (!IsExtEnabled(device_extensions.vk_arm_scheduling_controls)) { + skip |= LogError(pnext_vuid, instance, pNext_loc, + "includes a pointer to a VkPhysicalDeviceSchedulingControlsFeaturesARM, but when creating " + "VkDevice, the parent extension " + "(VK_ARM_scheduling_controls) was not included in ppEnabledExtensionNames."); + } + VkPhysicalDeviceSchedulingControlsFeaturesARM* structure = (VkPhysicalDeviceSchedulingControlsFeaturesARM*)header; + skip |= ValidateBool32(pNext_loc.dot(Field::schedulingControls), structure->schedulingControls); + } + } break; + + // Validation code for VkPhysicalDeviceImageSlicedViewOf3DFeaturesEXT structure members + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_SLICED_VIEW_OF_3D_FEATURES_EXT: { // Covers + // VUID-VkPhysicalDeviceImageSlicedViewOf3DFeaturesEXT-sType-sType + if (is_const_param) { + [[maybe_unused]] const Location pNext_loc = loc.pNext(Struct::VkPhysicalDeviceImageSlicedViewOf3DFeaturesEXT); + if (!IsExtEnabled(device_extensions.vk_ext_image_sliced_view_of_3d)) { + skip |= LogError(pnext_vuid, instance, pNext_loc, + "includes a pointer to a VkPhysicalDeviceImageSlicedViewOf3DFeaturesEXT, but when creating " + "VkDevice, the parent extension " + "(VK_EXT_image_sliced_view_of_3d) was not included in ppEnabledExtensionNames."); + } + VkPhysicalDeviceImageSlicedViewOf3DFeaturesEXT* structure = (VkPhysicalDeviceImageSlicedViewOf3DFeaturesEXT*)header; + skip |= ValidateBool32(pNext_loc.dot(Field::imageSlicedViewOf3D), structure->imageSlicedViewOf3D); + } + } break; + + // Validation code for VkPhysicalDeviceDescriptorSetHostMappingFeaturesVALVE structure members + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DESCRIPTOR_SET_HOST_MAPPING_FEATURES_VALVE: { // Covers + // VUID-VkPhysicalDeviceDescriptorSetHostMappingFeaturesVALVE-sType-sType + if (is_const_param) { + [[maybe_unused]] const Location pNext_loc = + loc.pNext(Struct::VkPhysicalDeviceDescriptorSetHostMappingFeaturesVALVE); + if (!IsExtEnabled(device_extensions.vk_valve_descriptor_set_host_mapping)) { + skip |= LogError(pnext_vuid, instance, pNext_loc, + "includes a pointer to a VkPhysicalDeviceDescriptorSetHostMappingFeaturesVALVE, but when " + "creating VkDevice, the parent extension " + "(VK_VALVE_descriptor_set_host_mapping) was not included in ppEnabledExtensionNames."); + } + VkPhysicalDeviceDescriptorSetHostMappingFeaturesVALVE* structure = + (VkPhysicalDeviceDescriptorSetHostMappingFeaturesVALVE*)header; + skip |= ValidateBool32(pNext_loc.dot(Field::descriptorSetHostMapping), structure->descriptorSetHostMapping); + } + } break; + + // Validation code for VkPhysicalDeviceDepthClampZeroOneFeaturesEXT structure members + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DEPTH_CLAMP_ZERO_ONE_FEATURES_EXT: { // Covers + // VUID-VkPhysicalDeviceDepthClampZeroOneFeaturesEXT-sType-sType + if (is_const_param) { + [[maybe_unused]] const Location pNext_loc = loc.pNext(Struct::VkPhysicalDeviceDepthClampZeroOneFeaturesEXT); + if (!IsExtEnabled(device_extensions.vk_ext_depth_clamp_zero_one)) { + skip |= LogError(pnext_vuid, instance, pNext_loc, + "includes a pointer to a VkPhysicalDeviceDepthClampZeroOneFeaturesEXT, but when creating " + "VkDevice, the parent extension " + "(VK_EXT_depth_clamp_zero_one) was not included in ppEnabledExtensionNames."); + } + VkPhysicalDeviceDepthClampZeroOneFeaturesEXT* structure = (VkPhysicalDeviceDepthClampZeroOneFeaturesEXT*)header; + skip |= ValidateBool32(pNext_loc.dot(Field::depthClampZeroOne), structure->depthClampZeroOne); + } + } break; + + // Validation code for VkPhysicalDeviceNonSeamlessCubeMapFeaturesEXT structure members + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_NON_SEAMLESS_CUBE_MAP_FEATURES_EXT: { // Covers + // VUID-VkPhysicalDeviceNonSeamlessCubeMapFeaturesEXT-sType-sType + if (is_const_param) { + [[maybe_unused]] const Location pNext_loc = loc.pNext(Struct::VkPhysicalDeviceNonSeamlessCubeMapFeaturesEXT); + if (!IsExtEnabled(device_extensions.vk_ext_non_seamless_cube_map)) { + skip |= LogError(pnext_vuid, instance, pNext_loc, + "includes a pointer to a VkPhysicalDeviceNonSeamlessCubeMapFeaturesEXT, but when creating " + "VkDevice, the parent extension " + "(VK_EXT_non_seamless_cube_map) was not included in ppEnabledExtensionNames."); + } + VkPhysicalDeviceNonSeamlessCubeMapFeaturesEXT* structure = (VkPhysicalDeviceNonSeamlessCubeMapFeaturesEXT*)header; + skip |= ValidateBool32(pNext_loc.dot(Field::nonSeamlessCubeMap), structure->nonSeamlessCubeMap); + } + } break; + + // Validation code for VkPhysicalDeviceRenderPassStripedFeaturesARM structure members + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RENDER_PASS_STRIPED_FEATURES_ARM: { // Covers + // VUID-VkPhysicalDeviceRenderPassStripedFeaturesARM-sType-sType + if (is_const_param) { + [[maybe_unused]] const Location pNext_loc = loc.pNext(Struct::VkPhysicalDeviceRenderPassStripedFeaturesARM); + if (!IsExtEnabled(device_extensions.vk_arm_render_pass_striped)) { + skip |= LogError(pnext_vuid, instance, pNext_loc, + "includes a pointer to a VkPhysicalDeviceRenderPassStripedFeaturesARM, but when creating " + "VkDevice, the parent extension " + "(VK_ARM_render_pass_striped) was not included in ppEnabledExtensionNames."); + } + VkPhysicalDeviceRenderPassStripedFeaturesARM* structure = (VkPhysicalDeviceRenderPassStripedFeaturesARM*)header; + skip |= ValidateBool32(pNext_loc.dot(Field::renderPassStriped), structure->renderPassStriped); + } + } break; + + // Validation code for VkPhysicalDeviceFragmentDensityMapOffsetFeaturesQCOM structure members + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_DENSITY_MAP_OFFSET_FEATURES_QCOM: { // Covers + // VUID-VkPhysicalDeviceFragmentDensityMapOffsetFeaturesQCOM-sType-sType + if (is_const_param) { + [[maybe_unused]] const Location pNext_loc = loc.pNext(Struct::VkPhysicalDeviceFragmentDensityMapOffsetFeaturesQCOM); + if (!IsExtEnabled(device_extensions.vk_qcom_fragment_density_map_offset)) { + skip |= LogError(pnext_vuid, instance, pNext_loc, + "includes a pointer to a VkPhysicalDeviceFragmentDensityMapOffsetFeaturesQCOM, but when " + "creating VkDevice, the parent extension " + "(VK_QCOM_fragment_density_map_offset) was not included in ppEnabledExtensionNames."); + } + VkPhysicalDeviceFragmentDensityMapOffsetFeaturesQCOM* structure = + (VkPhysicalDeviceFragmentDensityMapOffsetFeaturesQCOM*)header; + skip |= ValidateBool32(pNext_loc.dot(Field::fragmentDensityMapOffset), structure->fragmentDensityMapOffset); + } + } break; + + // Validation code for VkPhysicalDeviceCopyMemoryIndirectFeaturesNV structure members + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COPY_MEMORY_INDIRECT_FEATURES_NV: { // Covers + // VUID-VkPhysicalDeviceCopyMemoryIndirectFeaturesNV-sType-sType + if (is_const_param) { + [[maybe_unused]] const Location pNext_loc = loc.pNext(Struct::VkPhysicalDeviceCopyMemoryIndirectFeaturesNV); + if (!IsExtEnabled(device_extensions.vk_nv_copy_memory_indirect)) { + skip |= LogError(pnext_vuid, instance, pNext_loc, + "includes a pointer to a VkPhysicalDeviceCopyMemoryIndirectFeaturesNV, but when creating " + "VkDevice, the parent extension " + "(VK_NV_copy_memory_indirect) was not included in ppEnabledExtensionNames."); + } + VkPhysicalDeviceCopyMemoryIndirectFeaturesNV* structure = (VkPhysicalDeviceCopyMemoryIndirectFeaturesNV*)header; + skip |= ValidateBool32(pNext_loc.dot(Field::indirectCopy), structure->indirectCopy); + } + } break; + + // Validation code for VkPhysicalDeviceMemoryDecompressionFeaturesNV structure members + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MEMORY_DECOMPRESSION_FEATURES_NV: { // Covers + // VUID-VkPhysicalDeviceMemoryDecompressionFeaturesNV-sType-sType + if (is_const_param) { + [[maybe_unused]] const Location pNext_loc = loc.pNext(Struct::VkPhysicalDeviceMemoryDecompressionFeaturesNV); + if (!IsExtEnabled(device_extensions.vk_nv_memory_decompression)) { + skip |= LogError(pnext_vuid, instance, pNext_loc, + "includes a pointer to a VkPhysicalDeviceMemoryDecompressionFeaturesNV, but when creating " + "VkDevice, the parent extension " + "(VK_NV_memory_decompression) was not included in ppEnabledExtensionNames."); + } + VkPhysicalDeviceMemoryDecompressionFeaturesNV* structure = (VkPhysicalDeviceMemoryDecompressionFeaturesNV*)header; + skip |= ValidateBool32(pNext_loc.dot(Field::memoryDecompression), structure->memoryDecompression); + } + } break; + + // Validation code for VkPhysicalDeviceDeviceGeneratedCommandsComputeFeaturesNV structure members + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DEVICE_GENERATED_COMMANDS_COMPUTE_FEATURES_NV: { // Covers + // VUID-VkPhysicalDeviceDeviceGeneratedCommandsComputeFeaturesNV-sType-sType + if (is_const_param) { + [[maybe_unused]] const Location pNext_loc = + loc.pNext(Struct::VkPhysicalDeviceDeviceGeneratedCommandsComputeFeaturesNV); + if (!IsExtEnabled(device_extensions.vk_nv_device_generated_commands_compute)) { + skip |= LogError(pnext_vuid, instance, pNext_loc, + "includes a pointer to a VkPhysicalDeviceDeviceGeneratedCommandsComputeFeaturesNV, but when " + "creating VkDevice, the parent extension " + "(VK_NV_device_generated_commands_compute) was not included in ppEnabledExtensionNames."); + } + VkPhysicalDeviceDeviceGeneratedCommandsComputeFeaturesNV* structure = + (VkPhysicalDeviceDeviceGeneratedCommandsComputeFeaturesNV*)header; + skip |= ValidateBool32(pNext_loc.dot(Field::deviceGeneratedCompute), structure->deviceGeneratedCompute); + + skip |= ValidateBool32(pNext_loc.dot(Field::deviceGeneratedComputePipelines), + structure->deviceGeneratedComputePipelines); + + skip |= ValidateBool32(pNext_loc.dot(Field::deviceGeneratedComputeCaptureReplay), + structure->deviceGeneratedComputeCaptureReplay); + } + } break; + + // Validation code for VkPhysicalDeviceLinearColorAttachmentFeaturesNV structure members + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_LINEAR_COLOR_ATTACHMENT_FEATURES_NV: { // Covers + // VUID-VkPhysicalDeviceLinearColorAttachmentFeaturesNV-sType-sType + if (is_const_param) { + [[maybe_unused]] const Location pNext_loc = loc.pNext(Struct::VkPhysicalDeviceLinearColorAttachmentFeaturesNV); + if (!IsExtEnabled(device_extensions.vk_nv_linear_color_attachment)) { + skip |= LogError(pnext_vuid, instance, pNext_loc, + "includes a pointer to a VkPhysicalDeviceLinearColorAttachmentFeaturesNV, but when creating " + "VkDevice, the parent extension " + "(VK_NV_linear_color_attachment) was not included in ppEnabledExtensionNames."); + } + VkPhysicalDeviceLinearColorAttachmentFeaturesNV* structure = + (VkPhysicalDeviceLinearColorAttachmentFeaturesNV*)header; + skip |= ValidateBool32(pNext_loc.dot(Field::linearColorAttachment), structure->linearColorAttachment); + } + } break; + + // Validation code for VkPhysicalDeviceImageCompressionControlSwapchainFeaturesEXT structure members + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_COMPRESSION_CONTROL_SWAPCHAIN_FEATURES_EXT: { // Covers + // VUID-VkPhysicalDeviceImageCompressionControlSwapchainFeaturesEXT-sType-sType + if (is_const_param) { + [[maybe_unused]] const Location pNext_loc = + loc.pNext(Struct::VkPhysicalDeviceImageCompressionControlSwapchainFeaturesEXT); + if (!IsExtEnabled(device_extensions.vk_ext_image_compression_control_swapchain)) { + skip |= LogError(pnext_vuid, instance, pNext_loc, + "includes a pointer to a VkPhysicalDeviceImageCompressionControlSwapchainFeaturesEXT, but " + "when creating VkDevice, the parent extension " + "(VK_EXT_image_compression_control_swapchain) was not included in ppEnabledExtensionNames."); + } + VkPhysicalDeviceImageCompressionControlSwapchainFeaturesEXT* structure = + (VkPhysicalDeviceImageCompressionControlSwapchainFeaturesEXT*)header; + skip |= ValidateBool32(pNext_loc.dot(Field::imageCompressionControlSwapchain), + structure->imageCompressionControlSwapchain); + } + } break; + + // Validation code for VkPhysicalDeviceImageProcessingFeaturesQCOM structure members + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_PROCESSING_FEATURES_QCOM: { // Covers + // VUID-VkPhysicalDeviceImageProcessingFeaturesQCOM-sType-sType + if (is_const_param) { + [[maybe_unused]] const Location pNext_loc = loc.pNext(Struct::VkPhysicalDeviceImageProcessingFeaturesQCOM); + if (!IsExtEnabled(device_extensions.vk_qcom_image_processing)) { + skip |= LogError(pnext_vuid, instance, pNext_loc, + "includes a pointer to a VkPhysicalDeviceImageProcessingFeaturesQCOM, but when creating " + "VkDevice, the parent extension " + "(VK_QCOM_image_processing) was not included in ppEnabledExtensionNames."); + } + VkPhysicalDeviceImageProcessingFeaturesQCOM* structure = (VkPhysicalDeviceImageProcessingFeaturesQCOM*)header; + skip |= ValidateBool32(pNext_loc.dot(Field::textureSampleWeighted), structure->textureSampleWeighted); + + skip |= ValidateBool32(pNext_loc.dot(Field::textureBoxFilter), structure->textureBoxFilter); + + skip |= ValidateBool32(pNext_loc.dot(Field::textureBlockMatch), structure->textureBlockMatch); + } + } break; + + // Validation code for VkPhysicalDeviceNestedCommandBufferFeaturesEXT structure members + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_NESTED_COMMAND_BUFFER_FEATURES_EXT: { // Covers + // VUID-VkPhysicalDeviceNestedCommandBufferFeaturesEXT-sType-sType + if (is_const_param) { + [[maybe_unused]] const Location pNext_loc = loc.pNext(Struct::VkPhysicalDeviceNestedCommandBufferFeaturesEXT); + if (!IsExtEnabled(device_extensions.vk_ext_nested_command_buffer)) { + skip |= LogError(pnext_vuid, instance, pNext_loc, + "includes a pointer to a VkPhysicalDeviceNestedCommandBufferFeaturesEXT, but when creating " + "VkDevice, the parent extension " + "(VK_EXT_nested_command_buffer) was not included in ppEnabledExtensionNames."); + } + VkPhysicalDeviceNestedCommandBufferFeaturesEXT* structure = (VkPhysicalDeviceNestedCommandBufferFeaturesEXT*)header; + skip |= ValidateBool32(pNext_loc.dot(Field::nestedCommandBuffer), structure->nestedCommandBuffer); + + skip |= ValidateBool32(pNext_loc.dot(Field::nestedCommandBufferRendering), structure->nestedCommandBufferRendering); + + skip |= ValidateBool32(pNext_loc.dot(Field::nestedCommandBufferSimultaneousUse), + structure->nestedCommandBufferSimultaneousUse); + } + } break; + + // Validation code for VkPhysicalDeviceExtendedDynamicState3FeaturesEXT structure members + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTENDED_DYNAMIC_STATE_3_FEATURES_EXT: { // Covers + // VUID-VkPhysicalDeviceExtendedDynamicState3FeaturesEXT-sType-sType + if (is_const_param) { + [[maybe_unused]] const Location pNext_loc = loc.pNext(Struct::VkPhysicalDeviceExtendedDynamicState3FeaturesEXT); + if (!IsExtEnabled(device_extensions.vk_ext_extended_dynamic_state3)) { + skip |= LogError(pnext_vuid, instance, pNext_loc, + "includes a pointer to a VkPhysicalDeviceExtendedDynamicState3FeaturesEXT, but when creating " + "VkDevice, the parent extension " + "(VK_EXT_extended_dynamic_state3) was not included in ppEnabledExtensionNames."); + } + VkPhysicalDeviceExtendedDynamicState3FeaturesEXT* structure = + (VkPhysicalDeviceExtendedDynamicState3FeaturesEXT*)header; + skip |= ValidateBool32(pNext_loc.dot(Field::extendedDynamicState3TessellationDomainOrigin), + structure->extendedDynamicState3TessellationDomainOrigin); + + skip |= ValidateBool32(pNext_loc.dot(Field::extendedDynamicState3DepthClampEnable), + structure->extendedDynamicState3DepthClampEnable); + + skip |= ValidateBool32(pNext_loc.dot(Field::extendedDynamicState3PolygonMode), + structure->extendedDynamicState3PolygonMode); + + skip |= ValidateBool32(pNext_loc.dot(Field::extendedDynamicState3RasterizationSamples), + structure->extendedDynamicState3RasterizationSamples); + + skip |= ValidateBool32(pNext_loc.dot(Field::extendedDynamicState3SampleMask), + structure->extendedDynamicState3SampleMask); + + skip |= ValidateBool32(pNext_loc.dot(Field::extendedDynamicState3AlphaToCoverageEnable), + structure->extendedDynamicState3AlphaToCoverageEnable); + + skip |= ValidateBool32(pNext_loc.dot(Field::extendedDynamicState3AlphaToOneEnable), + structure->extendedDynamicState3AlphaToOneEnable); + + skip |= ValidateBool32(pNext_loc.dot(Field::extendedDynamicState3LogicOpEnable), + structure->extendedDynamicState3LogicOpEnable); + + skip |= ValidateBool32(pNext_loc.dot(Field::extendedDynamicState3ColorBlendEnable), + structure->extendedDynamicState3ColorBlendEnable); + + skip |= ValidateBool32(pNext_loc.dot(Field::extendedDynamicState3ColorBlendEquation), + structure->extendedDynamicState3ColorBlendEquation); + + skip |= ValidateBool32(pNext_loc.dot(Field::extendedDynamicState3ColorWriteMask), + structure->extendedDynamicState3ColorWriteMask); + + skip |= ValidateBool32(pNext_loc.dot(Field::extendedDynamicState3RasterizationStream), + structure->extendedDynamicState3RasterizationStream); + + skip |= ValidateBool32(pNext_loc.dot(Field::extendedDynamicState3ConservativeRasterizationMode), + structure->extendedDynamicState3ConservativeRasterizationMode); + + skip |= ValidateBool32(pNext_loc.dot(Field::extendedDynamicState3ExtraPrimitiveOverestimationSize), + structure->extendedDynamicState3ExtraPrimitiveOverestimationSize); + + skip |= ValidateBool32(pNext_loc.dot(Field::extendedDynamicState3DepthClipEnable), + structure->extendedDynamicState3DepthClipEnable); + + skip |= ValidateBool32(pNext_loc.dot(Field::extendedDynamicState3SampleLocationsEnable), + structure->extendedDynamicState3SampleLocationsEnable); + + skip |= ValidateBool32(pNext_loc.dot(Field::extendedDynamicState3ColorBlendAdvanced), + structure->extendedDynamicState3ColorBlendAdvanced); + + skip |= ValidateBool32(pNext_loc.dot(Field::extendedDynamicState3ProvokingVertexMode), + structure->extendedDynamicState3ProvokingVertexMode); + + skip |= ValidateBool32(pNext_loc.dot(Field::extendedDynamicState3LineRasterizationMode), + structure->extendedDynamicState3LineRasterizationMode); + + skip |= ValidateBool32(pNext_loc.dot(Field::extendedDynamicState3LineStippleEnable), + structure->extendedDynamicState3LineStippleEnable); + + skip |= ValidateBool32(pNext_loc.dot(Field::extendedDynamicState3DepthClipNegativeOneToOne), + structure->extendedDynamicState3DepthClipNegativeOneToOne); + + skip |= ValidateBool32(pNext_loc.dot(Field::extendedDynamicState3ViewportWScalingEnable), + structure->extendedDynamicState3ViewportWScalingEnable); + + skip |= ValidateBool32(pNext_loc.dot(Field::extendedDynamicState3ViewportSwizzle), + structure->extendedDynamicState3ViewportSwizzle); + + skip |= ValidateBool32(pNext_loc.dot(Field::extendedDynamicState3CoverageToColorEnable), + structure->extendedDynamicState3CoverageToColorEnable); + + skip |= ValidateBool32(pNext_loc.dot(Field::extendedDynamicState3CoverageToColorLocation), + structure->extendedDynamicState3CoverageToColorLocation); + + skip |= ValidateBool32(pNext_loc.dot(Field::extendedDynamicState3CoverageModulationMode), + structure->extendedDynamicState3CoverageModulationMode); + + skip |= ValidateBool32(pNext_loc.dot(Field::extendedDynamicState3CoverageModulationTableEnable), + structure->extendedDynamicState3CoverageModulationTableEnable); + + skip |= ValidateBool32(pNext_loc.dot(Field::extendedDynamicState3CoverageModulationTable), + structure->extendedDynamicState3CoverageModulationTable); + + skip |= ValidateBool32(pNext_loc.dot(Field::extendedDynamicState3CoverageReductionMode), + structure->extendedDynamicState3CoverageReductionMode); + + skip |= ValidateBool32(pNext_loc.dot(Field::extendedDynamicState3RepresentativeFragmentTestEnable), + structure->extendedDynamicState3RepresentativeFragmentTestEnable); + + skip |= ValidateBool32(pNext_loc.dot(Field::extendedDynamicState3ShadingRateImageEnable), + structure->extendedDynamicState3ShadingRateImageEnable); + } + } break; + + // Validation code for VkPhysicalDeviceSubpassMergeFeedbackFeaturesEXT structure members + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SUBPASS_MERGE_FEEDBACK_FEATURES_EXT: { // Covers + // VUID-VkPhysicalDeviceSubpassMergeFeedbackFeaturesEXT-sType-sType + if (is_const_param) { + [[maybe_unused]] const Location pNext_loc = loc.pNext(Struct::VkPhysicalDeviceSubpassMergeFeedbackFeaturesEXT); + if (!IsExtEnabled(device_extensions.vk_ext_subpass_merge_feedback)) { + skip |= LogError(pnext_vuid, instance, pNext_loc, + "includes a pointer to a VkPhysicalDeviceSubpassMergeFeedbackFeaturesEXT, but when creating " + "VkDevice, the parent extension " + "(VK_EXT_subpass_merge_feedback) was not included in ppEnabledExtensionNames."); + } + VkPhysicalDeviceSubpassMergeFeedbackFeaturesEXT* structure = + (VkPhysicalDeviceSubpassMergeFeedbackFeaturesEXT*)header; + skip |= ValidateBool32(pNext_loc.dot(Field::subpassMergeFeedback), structure->subpassMergeFeedback); + } + } break; + + // Validation code for VkPhysicalDeviceShaderModuleIdentifierFeaturesEXT structure members + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_MODULE_IDENTIFIER_FEATURES_EXT: { // Covers + // VUID-VkPhysicalDeviceShaderModuleIdentifierFeaturesEXT-sType-sType + if (is_const_param) { + [[maybe_unused]] const Location pNext_loc = loc.pNext(Struct::VkPhysicalDeviceShaderModuleIdentifierFeaturesEXT); + if (!IsExtEnabled(device_extensions.vk_ext_shader_module_identifier)) { + skip |= LogError(pnext_vuid, instance, pNext_loc, + "includes a pointer to a VkPhysicalDeviceShaderModuleIdentifierFeaturesEXT, but when creating " + "VkDevice, the parent extension " + "(VK_EXT_shader_module_identifier) was not included in ppEnabledExtensionNames."); + } + VkPhysicalDeviceShaderModuleIdentifierFeaturesEXT* structure = + (VkPhysicalDeviceShaderModuleIdentifierFeaturesEXT*)header; + skip |= ValidateBool32(pNext_loc.dot(Field::shaderModuleIdentifier), structure->shaderModuleIdentifier); + } + } break; + + // Validation code for VkPhysicalDeviceOpticalFlowFeaturesNV structure members + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_OPTICAL_FLOW_FEATURES_NV: { // Covers + // VUID-VkPhysicalDeviceOpticalFlowFeaturesNV-sType-sType + if (is_const_param) { + [[maybe_unused]] const Location pNext_loc = loc.pNext(Struct::VkPhysicalDeviceOpticalFlowFeaturesNV); + if (!IsExtEnabled(device_extensions.vk_nv_optical_flow)) { + skip |= LogError(pnext_vuid, instance, pNext_loc, + "includes a pointer to a VkPhysicalDeviceOpticalFlowFeaturesNV, but when creating VkDevice, " + "the parent extension " + "(VK_NV_optical_flow) was not included in ppEnabledExtensionNames."); + } + VkPhysicalDeviceOpticalFlowFeaturesNV* structure = (VkPhysicalDeviceOpticalFlowFeaturesNV*)header; + skip |= ValidateBool32(pNext_loc.dot(Field::opticalFlow), structure->opticalFlow); + } + } break; + + // Validation code for VkPhysicalDeviceLegacyDitheringFeaturesEXT structure members + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_LEGACY_DITHERING_FEATURES_EXT: { // Covers + // VUID-VkPhysicalDeviceLegacyDitheringFeaturesEXT-sType-sType + if (is_const_param) { + [[maybe_unused]] const Location pNext_loc = loc.pNext(Struct::VkPhysicalDeviceLegacyDitheringFeaturesEXT); + if (!IsExtEnabled(device_extensions.vk_ext_legacy_dithering)) { + skip |= LogError(pnext_vuid, instance, pNext_loc, + "includes a pointer to a VkPhysicalDeviceLegacyDitheringFeaturesEXT, but when creating " + "VkDevice, the parent extension " + "(VK_EXT_legacy_dithering) was not included in ppEnabledExtensionNames."); + } + VkPhysicalDeviceLegacyDitheringFeaturesEXT* structure = (VkPhysicalDeviceLegacyDitheringFeaturesEXT*)header; + skip |= ValidateBool32(pNext_loc.dot(Field::legacyDithering), structure->legacyDithering); + } + } break; + + // Validation code for VkPhysicalDevicePipelineProtectedAccessFeaturesEXT structure members + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PIPELINE_PROTECTED_ACCESS_FEATURES_EXT: { // Covers + // VUID-VkPhysicalDevicePipelineProtectedAccessFeaturesEXT-sType-sType + if (is_const_param) { + [[maybe_unused]] const Location pNext_loc = loc.pNext(Struct::VkPhysicalDevicePipelineProtectedAccessFeaturesEXT); + if (!IsExtEnabled(device_extensions.vk_ext_pipeline_protected_access)) { + skip |= LogError(pnext_vuid, instance, pNext_loc, + "includes a pointer to a VkPhysicalDevicePipelineProtectedAccessFeaturesEXT, but when " + "creating VkDevice, the parent extension " + "(VK_EXT_pipeline_protected_access) was not included in ppEnabledExtensionNames."); + } + VkPhysicalDevicePipelineProtectedAccessFeaturesEXT* structure = + (VkPhysicalDevicePipelineProtectedAccessFeaturesEXT*)header; + skip |= ValidateBool32(pNext_loc.dot(Field::pipelineProtectedAccess), structure->pipelineProtectedAccess); + } + } break; +#ifdef VK_USE_PLATFORM_ANDROID_KHR + + // Validation code for VkPhysicalDeviceExternalFormatResolveFeaturesANDROID structure members + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTERNAL_FORMAT_RESOLVE_FEATURES_ANDROID: { // Covers + // VUID-VkPhysicalDeviceExternalFormatResolveFeaturesANDROID-sType-sType + if (is_const_param) { + [[maybe_unused]] const Location pNext_loc = loc.pNext(Struct::VkPhysicalDeviceExternalFormatResolveFeaturesANDROID); + if (!IsExtEnabled(device_extensions.vk_android_external_format_resolve)) { + skip |= LogError(pnext_vuid, instance, pNext_loc, + "includes a pointer to a VkPhysicalDeviceExternalFormatResolveFeaturesANDROID, but when " + "creating VkDevice, the parent extension " + "(VK_ANDROID_external_format_resolve) was not included in ppEnabledExtensionNames."); + } + VkPhysicalDeviceExternalFormatResolveFeaturesANDROID* structure = + (VkPhysicalDeviceExternalFormatResolveFeaturesANDROID*)header; + skip |= ValidateBool32(pNext_loc.dot(Field::externalFormatResolve), structure->externalFormatResolve); + } + } break; +#endif // VK_USE_PLATFORM_ANDROID_KHR + + // Validation code for VkPhysicalDeviceShaderObjectFeaturesEXT structure members + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_OBJECT_FEATURES_EXT: { // Covers + // VUID-VkPhysicalDeviceShaderObjectFeaturesEXT-sType-sType + if (is_const_param) { + [[maybe_unused]] const Location pNext_loc = loc.pNext(Struct::VkPhysicalDeviceShaderObjectFeaturesEXT); + if (!IsExtEnabled(device_extensions.vk_ext_shader_object)) { + skip |= LogError(pnext_vuid, instance, pNext_loc, + "includes a pointer to a VkPhysicalDeviceShaderObjectFeaturesEXT, but when creating VkDevice, " + "the parent extension " + "(VK_EXT_shader_object) was not included in ppEnabledExtensionNames."); + } + VkPhysicalDeviceShaderObjectFeaturesEXT* structure = (VkPhysicalDeviceShaderObjectFeaturesEXT*)header; + skip |= ValidateBool32(pNext_loc.dot(Field::shaderObject), structure->shaderObject); + } + } break; + + // Validation code for VkPhysicalDeviceTilePropertiesFeaturesQCOM structure members + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TILE_PROPERTIES_FEATURES_QCOM: { // Covers + // VUID-VkPhysicalDeviceTilePropertiesFeaturesQCOM-sType-sType + if (is_const_param) { + [[maybe_unused]] const Location pNext_loc = loc.pNext(Struct::VkPhysicalDeviceTilePropertiesFeaturesQCOM); + if (!IsExtEnabled(device_extensions.vk_qcom_tile_properties)) { + skip |= LogError(pnext_vuid, instance, pNext_loc, + "includes a pointer to a VkPhysicalDeviceTilePropertiesFeaturesQCOM, but when creating " + "VkDevice, the parent extension " + "(VK_QCOM_tile_properties) was not included in ppEnabledExtensionNames."); + } + VkPhysicalDeviceTilePropertiesFeaturesQCOM* structure = (VkPhysicalDeviceTilePropertiesFeaturesQCOM*)header; + skip |= ValidateBool32(pNext_loc.dot(Field::tileProperties), structure->tileProperties); + } + } break; + + // Validation code for VkPhysicalDeviceAmigoProfilingFeaturesSEC structure members + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_AMIGO_PROFILING_FEATURES_SEC: { // Covers + // VUID-VkPhysicalDeviceAmigoProfilingFeaturesSEC-sType-sType + if (is_const_param) { + [[maybe_unused]] const Location pNext_loc = loc.pNext(Struct::VkPhysicalDeviceAmigoProfilingFeaturesSEC); + if (!IsExtEnabled(device_extensions.vk_sec_amigo_profiling)) { + skip |= LogError(pnext_vuid, instance, pNext_loc, + "includes a pointer to a VkPhysicalDeviceAmigoProfilingFeaturesSEC, but when creating " + "VkDevice, the parent extension " + "(VK_SEC_amigo_profiling) was not included in ppEnabledExtensionNames."); + } + VkPhysicalDeviceAmigoProfilingFeaturesSEC* structure = (VkPhysicalDeviceAmigoProfilingFeaturesSEC*)header; + skip |= ValidateBool32(pNext_loc.dot(Field::amigoProfiling), structure->amigoProfiling); + } + } break; + + // Validation code for VkPhysicalDeviceMultiviewPerViewViewportsFeaturesQCOM structure members + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MULTIVIEW_PER_VIEW_VIEWPORTS_FEATURES_QCOM: { // Covers + // VUID-VkPhysicalDeviceMultiviewPerViewViewportsFeaturesQCOM-sType-sType + if (is_const_param) { + [[maybe_unused]] const Location pNext_loc = + loc.pNext(Struct::VkPhysicalDeviceMultiviewPerViewViewportsFeaturesQCOM); + if (!IsExtEnabled(device_extensions.vk_qcom_multiview_per_view_viewports)) { + skip |= LogError(pnext_vuid, instance, pNext_loc, + "includes a pointer to a VkPhysicalDeviceMultiviewPerViewViewportsFeaturesQCOM, but when " + "creating VkDevice, the parent extension " + "(VK_QCOM_multiview_per_view_viewports) was not included in ppEnabledExtensionNames."); + } + VkPhysicalDeviceMultiviewPerViewViewportsFeaturesQCOM* structure = + (VkPhysicalDeviceMultiviewPerViewViewportsFeaturesQCOM*)header; + skip |= ValidateBool32(pNext_loc.dot(Field::multiviewPerViewViewports), structure->multiviewPerViewViewports); + } + } break; + + // Validation code for VkPhysicalDeviceRayTracingInvocationReorderFeaturesNV structure members + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RAY_TRACING_INVOCATION_REORDER_FEATURES_NV: { // Covers + // VUID-VkPhysicalDeviceRayTracingInvocationReorderFeaturesNV-sType-sType + if (is_const_param) { + [[maybe_unused]] const Location pNext_loc = + loc.pNext(Struct::VkPhysicalDeviceRayTracingInvocationReorderFeaturesNV); + if (!IsExtEnabled(device_extensions.vk_nv_ray_tracing_invocation_reorder)) { + skip |= LogError(pnext_vuid, instance, pNext_loc, + "includes a pointer to a VkPhysicalDeviceRayTracingInvocationReorderFeaturesNV, but when " + "creating VkDevice, the parent extension " + "(VK_NV_ray_tracing_invocation_reorder) was not included in ppEnabledExtensionNames."); + } + VkPhysicalDeviceRayTracingInvocationReorderFeaturesNV* structure = + (VkPhysicalDeviceRayTracingInvocationReorderFeaturesNV*)header; + skip |= ValidateBool32(pNext_loc.dot(Field::rayTracingInvocationReorder), structure->rayTracingInvocationReorder); + } + } break; + + // Validation code for VkPhysicalDeviceExtendedSparseAddressSpaceFeaturesNV structure members + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTENDED_SPARSE_ADDRESS_SPACE_FEATURES_NV: { // Covers + // VUID-VkPhysicalDeviceExtendedSparseAddressSpaceFeaturesNV-sType-sType + if (is_const_param) { + [[maybe_unused]] const Location pNext_loc = loc.pNext(Struct::VkPhysicalDeviceExtendedSparseAddressSpaceFeaturesNV); + if (!IsExtEnabled(device_extensions.vk_nv_extended_sparse_address_space)) { + skip |= LogError(pnext_vuid, instance, pNext_loc, + "includes a pointer to a VkPhysicalDeviceExtendedSparseAddressSpaceFeaturesNV, but when " + "creating VkDevice, the parent extension " + "(VK_NV_extended_sparse_address_space) was not included in ppEnabledExtensionNames."); + } + VkPhysicalDeviceExtendedSparseAddressSpaceFeaturesNV* structure = + (VkPhysicalDeviceExtendedSparseAddressSpaceFeaturesNV*)header; + skip |= ValidateBool32(pNext_loc.dot(Field::extendedSparseAddressSpace), structure->extendedSparseAddressSpace); + } + } break; + + // Validation code for VkPhysicalDeviceShaderCoreBuiltinsFeaturesARM structure members + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_CORE_BUILTINS_FEATURES_ARM: { // Covers + // VUID-VkPhysicalDeviceShaderCoreBuiltinsFeaturesARM-sType-sType + if (is_const_param) { + [[maybe_unused]] const Location pNext_loc = loc.pNext(Struct::VkPhysicalDeviceShaderCoreBuiltinsFeaturesARM); + if (!IsExtEnabled(device_extensions.vk_arm_shader_core_builtins)) { + skip |= LogError(pnext_vuid, instance, pNext_loc, + "includes a pointer to a VkPhysicalDeviceShaderCoreBuiltinsFeaturesARM, but when creating " + "VkDevice, the parent extension " + "(VK_ARM_shader_core_builtins) was not included in ppEnabledExtensionNames."); + } + VkPhysicalDeviceShaderCoreBuiltinsFeaturesARM* structure = (VkPhysicalDeviceShaderCoreBuiltinsFeaturesARM*)header; + skip |= ValidateBool32(pNext_loc.dot(Field::shaderCoreBuiltins), structure->shaderCoreBuiltins); + } + } break; + + // Validation code for VkPhysicalDevicePipelineLibraryGroupHandlesFeaturesEXT structure members + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PIPELINE_LIBRARY_GROUP_HANDLES_FEATURES_EXT: { // Covers + // VUID-VkPhysicalDevicePipelineLibraryGroupHandlesFeaturesEXT-sType-sType + if (is_const_param) { + [[maybe_unused]] const Location pNext_loc = + loc.pNext(Struct::VkPhysicalDevicePipelineLibraryGroupHandlesFeaturesEXT); + if (!IsExtEnabled(device_extensions.vk_ext_pipeline_library_group_handles)) { + skip |= LogError(pnext_vuid, instance, pNext_loc, + "includes a pointer to a VkPhysicalDevicePipelineLibraryGroupHandlesFeaturesEXT, but when " + "creating VkDevice, the parent extension " + "(VK_EXT_pipeline_library_group_handles) was not included in ppEnabledExtensionNames."); + } + VkPhysicalDevicePipelineLibraryGroupHandlesFeaturesEXT* structure = + (VkPhysicalDevicePipelineLibraryGroupHandlesFeaturesEXT*)header; + skip |= ValidateBool32(pNext_loc.dot(Field::pipelineLibraryGroupHandles), structure->pipelineLibraryGroupHandles); + } + } break; + + // Validation code for VkPhysicalDeviceDynamicRenderingUnusedAttachmentsFeaturesEXT structure members + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DYNAMIC_RENDERING_UNUSED_ATTACHMENTS_FEATURES_EXT: { // Covers + // VUID-VkPhysicalDeviceDynamicRenderingUnusedAttachmentsFeaturesEXT-sType-sType + if (is_const_param) { + [[maybe_unused]] const Location pNext_loc = + loc.pNext(Struct::VkPhysicalDeviceDynamicRenderingUnusedAttachmentsFeaturesEXT); + if (!IsExtEnabled(device_extensions.vk_ext_dynamic_rendering_unused_attachments)) { + skip |= LogError(pnext_vuid, instance, pNext_loc, + "includes a pointer to a VkPhysicalDeviceDynamicRenderingUnusedAttachmentsFeaturesEXT, but " + "when creating VkDevice, the parent extension " + "(VK_EXT_dynamic_rendering_unused_attachments) was not included in ppEnabledExtensionNames."); + } + VkPhysicalDeviceDynamicRenderingUnusedAttachmentsFeaturesEXT* structure = + (VkPhysicalDeviceDynamicRenderingUnusedAttachmentsFeaturesEXT*)header; + skip |= ValidateBool32(pNext_loc.dot(Field::dynamicRenderingUnusedAttachments), + structure->dynamicRenderingUnusedAttachments); + } + } break; + + // Validation code for VkPhysicalDeviceMultiviewPerViewRenderAreasFeaturesQCOM structure members + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MULTIVIEW_PER_VIEW_RENDER_AREAS_FEATURES_QCOM: { // Covers + // VUID-VkPhysicalDeviceMultiviewPerViewRenderAreasFeaturesQCOM-sType-sType + if (is_const_param) { + [[maybe_unused]] const Location pNext_loc = + loc.pNext(Struct::VkPhysicalDeviceMultiviewPerViewRenderAreasFeaturesQCOM); + if (!IsExtEnabled(device_extensions.vk_qcom_multiview_per_view_render_areas)) { + skip |= LogError(pnext_vuid, instance, pNext_loc, + "includes a pointer to a VkPhysicalDeviceMultiviewPerViewRenderAreasFeaturesQCOM, but when " + "creating VkDevice, the parent extension " + "(VK_QCOM_multiview_per_view_render_areas) was not included in ppEnabledExtensionNames."); + } + VkPhysicalDeviceMultiviewPerViewRenderAreasFeaturesQCOM* structure = + (VkPhysicalDeviceMultiviewPerViewRenderAreasFeaturesQCOM*)header; + skip |= ValidateBool32(pNext_loc.dot(Field::multiviewPerViewRenderAreas), structure->multiviewPerViewRenderAreas); + } + } break; + + // Validation code for VkPhysicalDevicePerStageDescriptorSetFeaturesNV structure members + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PER_STAGE_DESCRIPTOR_SET_FEATURES_NV: { // Covers + // VUID-VkPhysicalDevicePerStageDescriptorSetFeaturesNV-sType-sType + if (is_const_param) { + [[maybe_unused]] const Location pNext_loc = loc.pNext(Struct::VkPhysicalDevicePerStageDescriptorSetFeaturesNV); + if (!IsExtEnabled(device_extensions.vk_nv_per_stage_descriptor_set)) { + skip |= LogError(pnext_vuid, instance, pNext_loc, + "includes a pointer to a VkPhysicalDevicePerStageDescriptorSetFeaturesNV, but when creating " + "VkDevice, the parent extension " + "(VK_NV_per_stage_descriptor_set) was not included in ppEnabledExtensionNames."); + } + VkPhysicalDevicePerStageDescriptorSetFeaturesNV* structure = + (VkPhysicalDevicePerStageDescriptorSetFeaturesNV*)header; + skip |= ValidateBool32(pNext_loc.dot(Field::perStageDescriptorSet), structure->perStageDescriptorSet); + + skip |= ValidateBool32(pNext_loc.dot(Field::dynamicPipelineLayout), structure->dynamicPipelineLayout); + } + } break; + + // Validation code for VkPhysicalDeviceImageProcessing2FeaturesQCOM structure members + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_PROCESSING_2_FEATURES_QCOM: { // Covers + // VUID-VkPhysicalDeviceImageProcessing2FeaturesQCOM-sType-sType + if (is_const_param) { + [[maybe_unused]] const Location pNext_loc = loc.pNext(Struct::VkPhysicalDeviceImageProcessing2FeaturesQCOM); + if (!IsExtEnabled(device_extensions.vk_qcom_image_processing2)) { + skip |= LogError(pnext_vuid, instance, pNext_loc, + "includes a pointer to a VkPhysicalDeviceImageProcessing2FeaturesQCOM, but when creating " + "VkDevice, the parent extension " + "(VK_QCOM_image_processing2) was not included in ppEnabledExtensionNames."); + } + VkPhysicalDeviceImageProcessing2FeaturesQCOM* structure = (VkPhysicalDeviceImageProcessing2FeaturesQCOM*)header; + skip |= ValidateBool32(pNext_loc.dot(Field::textureBlockMatch2), structure->textureBlockMatch2); + } + } break; + + // Validation code for VkPhysicalDeviceCubicWeightsFeaturesQCOM structure members + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_CUBIC_WEIGHTS_FEATURES_QCOM: { // Covers + // VUID-VkPhysicalDeviceCubicWeightsFeaturesQCOM-sType-sType + if (is_const_param) { + [[maybe_unused]] const Location pNext_loc = loc.pNext(Struct::VkPhysicalDeviceCubicWeightsFeaturesQCOM); + if (!IsExtEnabled(device_extensions.vk_qcom_filter_cubic_weights)) { + skip |= LogError(pnext_vuid, instance, pNext_loc, + "includes a pointer to a VkPhysicalDeviceCubicWeightsFeaturesQCOM, but when creating " + "VkDevice, the parent extension " + "(VK_QCOM_filter_cubic_weights) was not included in ppEnabledExtensionNames."); + } + VkPhysicalDeviceCubicWeightsFeaturesQCOM* structure = (VkPhysicalDeviceCubicWeightsFeaturesQCOM*)header; + skip |= ValidateBool32(pNext_loc.dot(Field::selectableCubicWeights), structure->selectableCubicWeights); + } + } break; + + // Validation code for VkPhysicalDeviceYcbcrDegammaFeaturesQCOM structure members + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_YCBCR_DEGAMMA_FEATURES_QCOM: { // Covers + // VUID-VkPhysicalDeviceYcbcrDegammaFeaturesQCOM-sType-sType + if (is_const_param) { + [[maybe_unused]] const Location pNext_loc = loc.pNext(Struct::VkPhysicalDeviceYcbcrDegammaFeaturesQCOM); + if (!IsExtEnabled(device_extensions.vk_qcom_ycbcr_degamma)) { + skip |= LogError(pnext_vuid, instance, pNext_loc, + "includes a pointer to a VkPhysicalDeviceYcbcrDegammaFeaturesQCOM, but when creating " + "VkDevice, the parent extension " + "(VK_QCOM_ycbcr_degamma) was not included in ppEnabledExtensionNames."); + } + VkPhysicalDeviceYcbcrDegammaFeaturesQCOM* structure = (VkPhysicalDeviceYcbcrDegammaFeaturesQCOM*)header; + skip |= ValidateBool32(pNext_loc.dot(Field::ycbcrDegamma), structure->ycbcrDegamma); + } + } break; + + // Validation code for VkPhysicalDeviceCubicClampFeaturesQCOM structure members + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_CUBIC_CLAMP_FEATURES_QCOM: { // Covers + // VUID-VkPhysicalDeviceCubicClampFeaturesQCOM-sType-sType + if (is_const_param) { + [[maybe_unused]] const Location pNext_loc = loc.pNext(Struct::VkPhysicalDeviceCubicClampFeaturesQCOM); + if (!IsExtEnabled(device_extensions.vk_qcom_filter_cubic_clamp)) { + skip |= LogError(pnext_vuid, instance, pNext_loc, + "includes a pointer to a VkPhysicalDeviceCubicClampFeaturesQCOM, but when creating VkDevice, " + "the parent extension " + "(VK_QCOM_filter_cubic_clamp) was not included in ppEnabledExtensionNames."); + } + VkPhysicalDeviceCubicClampFeaturesQCOM* structure = (VkPhysicalDeviceCubicClampFeaturesQCOM*)header; + skip |= ValidateBool32(pNext_loc.dot(Field::cubicRangeClamp), structure->cubicRangeClamp); + } + } break; + + // Validation code for VkPhysicalDeviceAttachmentFeedbackLoopDynamicStateFeaturesEXT structure members + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ATTACHMENT_FEEDBACK_LOOP_DYNAMIC_STATE_FEATURES_EXT: { // Covers + // VUID-VkPhysicalDeviceAttachmentFeedbackLoopDynamicStateFeaturesEXT-sType-sType + if (is_const_param) { + [[maybe_unused]] const Location pNext_loc = + loc.pNext(Struct::VkPhysicalDeviceAttachmentFeedbackLoopDynamicStateFeaturesEXT); + if (!IsExtEnabled(device_extensions.vk_ext_attachment_feedback_loop_dynamic_state)) { + skip |= + LogError(pnext_vuid, instance, pNext_loc, + "includes a pointer to a VkPhysicalDeviceAttachmentFeedbackLoopDynamicStateFeaturesEXT, but when " + "creating VkDevice, the parent extension " + "(VK_EXT_attachment_feedback_loop_dynamic_state) was not included in ppEnabledExtensionNames."); + } + VkPhysicalDeviceAttachmentFeedbackLoopDynamicStateFeaturesEXT* structure = + (VkPhysicalDeviceAttachmentFeedbackLoopDynamicStateFeaturesEXT*)header; + skip |= ValidateBool32(pNext_loc.dot(Field::attachmentFeedbackLoopDynamicState), + structure->attachmentFeedbackLoopDynamicState); + } + } break; +#ifdef VK_USE_PLATFORM_SCREEN_QNX + + // Validation code for VkPhysicalDeviceExternalMemoryScreenBufferFeaturesQNX structure members + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTERNAL_MEMORY_SCREEN_BUFFER_FEATURES_QNX: { // Covers + // VUID-VkPhysicalDeviceExternalMemoryScreenBufferFeaturesQNX-sType-sType + if (is_const_param) { + [[maybe_unused]] const Location pNext_loc = + loc.pNext(Struct::VkPhysicalDeviceExternalMemoryScreenBufferFeaturesQNX); + if (!IsExtEnabled(device_extensions.vk_qnx_external_memory_screen_buffer)) { + skip |= LogError(pnext_vuid, instance, pNext_loc, + "includes a pointer to a VkPhysicalDeviceExternalMemoryScreenBufferFeaturesQNX, but when " + "creating VkDevice, the parent extension " + "(VK_QNX_external_memory_screen_buffer) was not included in ppEnabledExtensionNames."); + } + VkPhysicalDeviceExternalMemoryScreenBufferFeaturesQNX* structure = + (VkPhysicalDeviceExternalMemoryScreenBufferFeaturesQNX*)header; + skip |= ValidateBool32(pNext_loc.dot(Field::screenBufferImport), structure->screenBufferImport); + } + } break; +#endif // VK_USE_PLATFORM_SCREEN_QNX + + // Validation code for VkPhysicalDeviceDescriptorPoolOverallocationFeaturesNV structure members + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DESCRIPTOR_POOL_OVERALLOCATION_FEATURES_NV: { // Covers + // VUID-VkPhysicalDeviceDescriptorPoolOverallocationFeaturesNV-sType-sType + if (is_const_param) { + [[maybe_unused]] const Location pNext_loc = + loc.pNext(Struct::VkPhysicalDeviceDescriptorPoolOverallocationFeaturesNV); + if (!IsExtEnabled(device_extensions.vk_nv_descriptor_pool_overallocation)) { + skip |= LogError(pnext_vuid, instance, pNext_loc, + "includes a pointer to a VkPhysicalDeviceDescriptorPoolOverallocationFeaturesNV, but when " + "creating VkDevice, the parent extension " + "(VK_NV_descriptor_pool_overallocation) was not included in ppEnabledExtensionNames."); + } + VkPhysicalDeviceDescriptorPoolOverallocationFeaturesNV* structure = + (VkPhysicalDeviceDescriptorPoolOverallocationFeaturesNV*)header; + skip |= ValidateBool32(pNext_loc.dot(Field::descriptorPoolOverallocation), structure->descriptorPoolOverallocation); + } + } break; + + // Validation code for VkPhysicalDeviceRawAccessChainsFeaturesNV structure members + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RAW_ACCESS_CHAINS_FEATURES_NV: { // Covers + // VUID-VkPhysicalDeviceRawAccessChainsFeaturesNV-sType-sType + if (is_const_param) { + [[maybe_unused]] const Location pNext_loc = loc.pNext(Struct::VkPhysicalDeviceRawAccessChainsFeaturesNV); + if (!IsExtEnabled(device_extensions.vk_nv_raw_access_chains)) { + skip |= LogError(pnext_vuid, instance, pNext_loc, + "includes a pointer to a VkPhysicalDeviceRawAccessChainsFeaturesNV, but when creating " + "VkDevice, the parent extension " + "(VK_NV_raw_access_chains) was not included in ppEnabledExtensionNames."); + } + VkPhysicalDeviceRawAccessChainsFeaturesNV* structure = (VkPhysicalDeviceRawAccessChainsFeaturesNV*)header; + skip |= ValidateBool32(pNext_loc.dot(Field::shaderRawAccessChains), structure->shaderRawAccessChains); + } + } break; + + // Validation code for VkPhysicalDeviceShaderAtomicFloat16VectorFeaturesNV structure members + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_ATOMIC_FLOAT16_VECTOR_FEATURES_NV: { // Covers + // VUID-VkPhysicalDeviceShaderAtomicFloat16VectorFeaturesNV-sType-sType + if (is_const_param) { + [[maybe_unused]] const Location pNext_loc = loc.pNext(Struct::VkPhysicalDeviceShaderAtomicFloat16VectorFeaturesNV); + if (!IsExtEnabled(device_extensions.vk_nv_shader_atomic_float16_vector)) { + skip |= LogError(pnext_vuid, instance, pNext_loc, + "includes a pointer to a VkPhysicalDeviceShaderAtomicFloat16VectorFeaturesNV, but when " + "creating VkDevice, the parent extension " + "(VK_NV_shader_atomic_float16_vector) was not included in ppEnabledExtensionNames."); + } + VkPhysicalDeviceShaderAtomicFloat16VectorFeaturesNV* structure = + (VkPhysicalDeviceShaderAtomicFloat16VectorFeaturesNV*)header; + skip |= ValidateBool32(pNext_loc.dot(Field::shaderFloat16VectorAtomics), structure->shaderFloat16VectorAtomics); + } + } break; + + // Validation code for VkPhysicalDeviceRayTracingValidationFeaturesNV structure members + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RAY_TRACING_VALIDATION_FEATURES_NV: { // Covers + // VUID-VkPhysicalDeviceRayTracingValidationFeaturesNV-sType-sType + if (is_const_param) { + [[maybe_unused]] const Location pNext_loc = loc.pNext(Struct::VkPhysicalDeviceRayTracingValidationFeaturesNV); + if (!IsExtEnabled(device_extensions.vk_nv_ray_tracing_validation)) { + skip |= LogError(pnext_vuid, instance, pNext_loc, + "includes a pointer to a VkPhysicalDeviceRayTracingValidationFeaturesNV, but when creating " + "VkDevice, the parent extension " + "(VK_NV_ray_tracing_validation) was not included in ppEnabledExtensionNames."); + } + VkPhysicalDeviceRayTracingValidationFeaturesNV* structure = (VkPhysicalDeviceRayTracingValidationFeaturesNV*)header; + skip |= ValidateBool32(pNext_loc.dot(Field::rayTracingValidation), structure->rayTracingValidation); + } + } break; + + // Validation code for VkPhysicalDeviceAccelerationStructureFeaturesKHR structure members + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ACCELERATION_STRUCTURE_FEATURES_KHR: { // Covers + // VUID-VkPhysicalDeviceAccelerationStructureFeaturesKHR-sType-sType + if (is_const_param) { + [[maybe_unused]] const Location pNext_loc = loc.pNext(Struct::VkPhysicalDeviceAccelerationStructureFeaturesKHR); + if (!IsExtEnabled(device_extensions.vk_khr_acceleration_structure)) { + skip |= LogError(pnext_vuid, instance, pNext_loc, + "includes a pointer to a VkPhysicalDeviceAccelerationStructureFeaturesKHR, but when creating " + "VkDevice, the parent extension " + "(VK_KHR_acceleration_structure) was not included in ppEnabledExtensionNames."); + } + VkPhysicalDeviceAccelerationStructureFeaturesKHR* structure = + (VkPhysicalDeviceAccelerationStructureFeaturesKHR*)header; + skip |= ValidateBool32(pNext_loc.dot(Field::accelerationStructure), structure->accelerationStructure); + + skip |= ValidateBool32(pNext_loc.dot(Field::accelerationStructureCaptureReplay), + structure->accelerationStructureCaptureReplay); + + skip |= ValidateBool32(pNext_loc.dot(Field::accelerationStructureIndirectBuild), + structure->accelerationStructureIndirectBuild); + + skip |= ValidateBool32(pNext_loc.dot(Field::accelerationStructureHostCommands), + structure->accelerationStructureHostCommands); + + skip |= ValidateBool32(pNext_loc.dot(Field::descriptorBindingAccelerationStructureUpdateAfterBind), + structure->descriptorBindingAccelerationStructureUpdateAfterBind); + } + } break; + + // Validation code for VkPhysicalDeviceRayTracingPipelineFeaturesKHR structure members + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RAY_TRACING_PIPELINE_FEATURES_KHR: { // Covers + // VUID-VkPhysicalDeviceRayTracingPipelineFeaturesKHR-sType-sType + if (is_const_param) { + [[maybe_unused]] const Location pNext_loc = loc.pNext(Struct::VkPhysicalDeviceRayTracingPipelineFeaturesKHR); + if (!IsExtEnabled(device_extensions.vk_khr_ray_tracing_pipeline)) { + skip |= LogError(pnext_vuid, instance, pNext_loc, + "includes a pointer to a VkPhysicalDeviceRayTracingPipelineFeaturesKHR, but when creating " + "VkDevice, the parent extension " + "(VK_KHR_ray_tracing_pipeline) was not included in ppEnabledExtensionNames."); + } + VkPhysicalDeviceRayTracingPipelineFeaturesKHR* structure = (VkPhysicalDeviceRayTracingPipelineFeaturesKHR*)header; + skip |= ValidateBool32(pNext_loc.dot(Field::rayTracingPipeline), structure->rayTracingPipeline); + + skip |= ValidateBool32(pNext_loc.dot(Field::rayTracingPipelineShaderGroupHandleCaptureReplay), + structure->rayTracingPipelineShaderGroupHandleCaptureReplay); + + skip |= ValidateBool32(pNext_loc.dot(Field::rayTracingPipelineShaderGroupHandleCaptureReplayMixed), + structure->rayTracingPipelineShaderGroupHandleCaptureReplayMixed); + + skip |= ValidateBool32(pNext_loc.dot(Field::rayTracingPipelineTraceRaysIndirect), + structure->rayTracingPipelineTraceRaysIndirect); + + skip |= ValidateBool32(pNext_loc.dot(Field::rayTraversalPrimitiveCulling), structure->rayTraversalPrimitiveCulling); + } + } break; + + // Validation code for VkPhysicalDeviceRayQueryFeaturesKHR structure members + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RAY_QUERY_FEATURES_KHR: { // Covers + // VUID-VkPhysicalDeviceRayQueryFeaturesKHR-sType-sType + if (is_const_param) { + [[maybe_unused]] const Location pNext_loc = loc.pNext(Struct::VkPhysicalDeviceRayQueryFeaturesKHR); + if (!IsExtEnabled(device_extensions.vk_khr_ray_query)) { + skip |= LogError(pnext_vuid, instance, pNext_loc, + "includes a pointer to a VkPhysicalDeviceRayQueryFeaturesKHR, but when creating VkDevice, the " + "parent extension " + "(VK_KHR_ray_query) was not included in ppEnabledExtensionNames."); + } + VkPhysicalDeviceRayQueryFeaturesKHR* structure = (VkPhysicalDeviceRayQueryFeaturesKHR*)header; + skip |= ValidateBool32(pNext_loc.dot(Field::rayQuery), structure->rayQuery); + } + } break; + + // Validation code for VkPhysicalDeviceMeshShaderFeaturesEXT structure members + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MESH_SHADER_FEATURES_EXT: { // Covers + // VUID-VkPhysicalDeviceMeshShaderFeaturesEXT-sType-sType + if (is_const_param) { + [[maybe_unused]] const Location pNext_loc = loc.pNext(Struct::VkPhysicalDeviceMeshShaderFeaturesEXT); + if (!IsExtEnabled(device_extensions.vk_ext_mesh_shader)) { + skip |= LogError(pnext_vuid, instance, pNext_loc, + "includes a pointer to a VkPhysicalDeviceMeshShaderFeaturesEXT, but when creating VkDevice, " + "the parent extension " + "(VK_EXT_mesh_shader) was not included in ppEnabledExtensionNames."); + } + VkPhysicalDeviceMeshShaderFeaturesEXT* structure = (VkPhysicalDeviceMeshShaderFeaturesEXT*)header; + skip |= ValidateBool32(pNext_loc.dot(Field::taskShader), structure->taskShader); + + skip |= ValidateBool32(pNext_loc.dot(Field::meshShader), structure->meshShader); + + skip |= ValidateBool32(pNext_loc.dot(Field::multiviewMeshShader), structure->multiviewMeshShader); + + skip |= ValidateBool32(pNext_loc.dot(Field::primitiveFragmentShadingRateMeshShader), + structure->primitiveFragmentShadingRateMeshShader); + + skip |= ValidateBool32(pNext_loc.dot(Field::meshShaderQueries), structure->meshShaderQueries); + } + } break; + + default: + skip = false; + } + return skip; +} + +bool StatelessValidation::ValidatePnextPropertyStructContents(const Location& loc, const VkBaseOutStructure* header, + const char* pnext_vuid, VkPhysicalDevice caller_physical_device, + bool is_const_param) const { + bool skip = false; + const bool is_physdev_api = caller_physical_device != VK_NULL_HANDLE; + switch (header->sType) { + // Validation code for VkPhysicalDeviceSubgroupProperties structure members + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SUBGROUP_PROPERTIES: { // Covers VUID-VkPhysicalDeviceSubgroupProperties-sType-sType + + if (is_physdev_api) { + VkPhysicalDeviceProperties device_properties = {}; + DispatchGetPhysicalDeviceProperties(caller_physical_device, &device_properties); + if (device_properties.apiVersion < VK_API_VERSION_1_1) { + skip |= + LogError(pnext_vuid, instance, loc.dot(Field::pNext), + "includes a pointer to a VkStructureType (VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SUBGROUP_PROPERTIES) " + "which was added in VK_API_VERSION_1_1 but the " + "current effective API version is %s.", + StringAPIVersion(api_version).c_str()); + } + } + } break; + + // Validation code for VkPhysicalDevicePointClippingProperties structure members + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_POINT_CLIPPING_PROPERTIES: { // Covers + // VUID-VkPhysicalDevicePointClippingProperties-sType-sType + + if ((is_physdev_api && !SupportedByPdev(physical_device, vvl::Extension::_VK_KHR_maintenance2)) || + (!is_physdev_api && !IsExtEnabled(device_extensions.vk_khr_maintenance2))) { + skip |= LogError(pnext_vuid, instance, loc.dot(Field::pNext), + "includes a pointer to a VkStructureType " + "(VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_POINT_CLIPPING_PROPERTIES), but its parent extension " + "VK_KHR_maintenance2 has not been enabled."); + } + } break; + + // Validation code for VkPhysicalDeviceMultiviewProperties structure members + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MULTIVIEW_PROPERTIES: { // Covers + // VUID-VkPhysicalDeviceMultiviewProperties-sType-sType + + if ((is_physdev_api && !SupportedByPdev(physical_device, vvl::Extension::_VK_KHR_multiview)) || + (!is_physdev_api && !IsExtEnabled(device_extensions.vk_khr_multiview))) { + skip |= LogError(pnext_vuid, instance, loc.dot(Field::pNext), + "includes a pointer to a VkStructureType " + "(VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MULTIVIEW_PROPERTIES), but its parent extension " + "VK_KHR_multiview has not been enabled."); + } + } break; + + // Validation code for VkPhysicalDeviceProtectedMemoryProperties structure members + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PROTECTED_MEMORY_PROPERTIES: { // Covers + // VUID-VkPhysicalDeviceProtectedMemoryProperties-sType-sType + + if (is_physdev_api) { + VkPhysicalDeviceProperties device_properties = {}; + DispatchGetPhysicalDeviceProperties(caller_physical_device, &device_properties); + if (device_properties.apiVersion < VK_API_VERSION_1_1) { + skip |= LogError( + pnext_vuid, instance, loc.dot(Field::pNext), + "includes a pointer to a VkStructureType (VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PROTECTED_MEMORY_PROPERTIES) " + "which was added in VK_API_VERSION_1_1 but the " + "current effective API version is %s.", + StringAPIVersion(api_version).c_str()); + } + } + } break; + + // Validation code for VkPhysicalDeviceIDProperties structure members + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ID_PROPERTIES: { // Covers VUID-VkPhysicalDeviceIDProperties-sType-sType + + if (!IsExtEnabled(instance_extensions.vk_khr_external_fence_capabilities)) { + skip |= LogError(pnext_vuid, instance, loc.dot(Field::pNext), + "includes a pointer to a VkStructureType (VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ID_PROPERTIES), but " + "its parent extension " + "VK_KHR_external_fence_capabilities has not been enabled."); + } + } break; + + // Validation code for VkPhysicalDeviceMaintenance3Properties structure members + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MAINTENANCE_3_PROPERTIES: { // Covers + // VUID-VkPhysicalDeviceMaintenance3Properties-sType-sType + + if ((is_physdev_api && !SupportedByPdev(physical_device, vvl::Extension::_VK_KHR_maintenance3)) || + (!is_physdev_api && !IsExtEnabled(device_extensions.vk_khr_maintenance3))) { + skip |= LogError(pnext_vuid, instance, loc.dot(Field::pNext), + "includes a pointer to a VkStructureType " + "(VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MAINTENANCE_3_PROPERTIES), but its parent extension " + "VK_KHR_maintenance3 has not been enabled."); + } + } break; + + // Validation code for VkPhysicalDeviceVulkan11Properties structure members + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_1_1_PROPERTIES: { // Covers + // VUID-VkPhysicalDeviceVulkan11Properties-sType-sType + + if (is_physdev_api) { + VkPhysicalDeviceProperties device_properties = {}; + DispatchGetPhysicalDeviceProperties(caller_physical_device, &device_properties); + if (device_properties.apiVersion < VK_API_VERSION_1_2) { + skip |= LogError( + pnext_vuid, instance, loc.dot(Field::pNext), + "includes a pointer to a VkStructureType (VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_1_1_PROPERTIES) which " + "was added in VK_API_VERSION_1_2 but the " + "current effective API version is %s.", + StringAPIVersion(api_version).c_str()); + } + } + } break; + + // Validation code for VkPhysicalDeviceVulkan12Properties structure members + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_1_2_PROPERTIES: { // Covers + // VUID-VkPhysicalDeviceVulkan12Properties-sType-sType + + if (is_physdev_api) { + VkPhysicalDeviceProperties device_properties = {}; + DispatchGetPhysicalDeviceProperties(caller_physical_device, &device_properties); + if (device_properties.apiVersion < VK_API_VERSION_1_2) { + skip |= LogError( + pnext_vuid, instance, loc.dot(Field::pNext), + "includes a pointer to a VkStructureType (VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_1_2_PROPERTIES) which " + "was added in VK_API_VERSION_1_2 but the " + "current effective API version is %s.", + StringAPIVersion(api_version).c_str()); + } + } + } break; + + // Validation code for VkPhysicalDeviceDriverProperties structure members + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DRIVER_PROPERTIES: { // Covers VUID-VkPhysicalDeviceDriverProperties-sType-sType + + if ((is_physdev_api && !SupportedByPdev(physical_device, vvl::Extension::_VK_KHR_driver_properties)) || + (!is_physdev_api && !IsExtEnabled(device_extensions.vk_khr_driver_properties))) { + skip |= LogError(pnext_vuid, instance, loc.dot(Field::pNext), + "includes a pointer to a VkStructureType (VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DRIVER_PROPERTIES), " + "but its parent extension " + "VK_KHR_driver_properties has not been enabled."); + } + } break; + + // Validation code for VkPhysicalDeviceFloatControlsProperties structure members + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FLOAT_CONTROLS_PROPERTIES: { // Covers + // VUID-VkPhysicalDeviceFloatControlsProperties-sType-sType + + if ((is_physdev_api && !SupportedByPdev(physical_device, vvl::Extension::_VK_KHR_shader_float_controls)) || + (!is_physdev_api && !IsExtEnabled(device_extensions.vk_khr_shader_float_controls))) { + skip |= LogError(pnext_vuid, instance, loc.dot(Field::pNext), + "includes a pointer to a VkStructureType " + "(VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FLOAT_CONTROLS_PROPERTIES), but its parent extension " + "VK_KHR_shader_float_controls has not been enabled."); + } + } break; + + // Validation code for VkPhysicalDeviceDescriptorIndexingProperties structure members + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DESCRIPTOR_INDEXING_PROPERTIES: { // Covers + // VUID-VkPhysicalDeviceDescriptorIndexingProperties-sType-sType + + if ((is_physdev_api && !SupportedByPdev(physical_device, vvl::Extension::_VK_EXT_descriptor_indexing)) || + (!is_physdev_api && !IsExtEnabled(device_extensions.vk_ext_descriptor_indexing))) { + skip |= LogError(pnext_vuid, instance, loc.dot(Field::pNext), + "includes a pointer to a VkStructureType " + "(VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DESCRIPTOR_INDEXING_PROPERTIES), but its parent extension " + "VK_EXT_descriptor_indexing has not been enabled."); + } + } break; + + // Validation code for VkPhysicalDeviceDepthStencilResolveProperties structure members + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DEPTH_STENCIL_RESOLVE_PROPERTIES: { // Covers + // VUID-VkPhysicalDeviceDepthStencilResolveProperties-sType-sType + + if ((is_physdev_api && !SupportedByPdev(physical_device, vvl::Extension::_VK_KHR_depth_stencil_resolve)) || + (!is_physdev_api && !IsExtEnabled(device_extensions.vk_khr_depth_stencil_resolve))) { + skip |= LogError(pnext_vuid, instance, loc.dot(Field::pNext), + "includes a pointer to a VkStructureType " + "(VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DEPTH_STENCIL_RESOLVE_PROPERTIES), but its parent extension " + "VK_KHR_depth_stencil_resolve has not been enabled."); + } + } break; + + // Validation code for VkPhysicalDeviceSamplerFilterMinmaxProperties structure members + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SAMPLER_FILTER_MINMAX_PROPERTIES: { // Covers + // VUID-VkPhysicalDeviceSamplerFilterMinmaxProperties-sType-sType + + if ((is_physdev_api && !SupportedByPdev(physical_device, vvl::Extension::_VK_EXT_sampler_filter_minmax)) || + (!is_physdev_api && !IsExtEnabled(device_extensions.vk_ext_sampler_filter_minmax))) { + skip |= LogError(pnext_vuid, instance, loc.dot(Field::pNext), + "includes a pointer to a VkStructureType " + "(VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SAMPLER_FILTER_MINMAX_PROPERTIES), but its parent extension " + "VK_EXT_sampler_filter_minmax has not been enabled."); + } + } break; + + // Validation code for VkPhysicalDeviceTimelineSemaphoreProperties structure members + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TIMELINE_SEMAPHORE_PROPERTIES: { // Covers + // VUID-VkPhysicalDeviceTimelineSemaphoreProperties-sType-sType + + if ((is_physdev_api && !SupportedByPdev(physical_device, vvl::Extension::_VK_KHR_timeline_semaphore)) || + (!is_physdev_api && !IsExtEnabled(device_extensions.vk_khr_timeline_semaphore))) { + skip |= LogError(pnext_vuid, instance, loc.dot(Field::pNext), + "includes a pointer to a VkStructureType " + "(VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TIMELINE_SEMAPHORE_PROPERTIES), but its parent extension " + "VK_KHR_timeline_semaphore has not been enabled."); + } + } break; + + // Validation code for VkPhysicalDeviceVulkan13Properties structure members + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_1_3_PROPERTIES: { // Covers + // VUID-VkPhysicalDeviceVulkan13Properties-sType-sType + + if (is_physdev_api) { + VkPhysicalDeviceProperties device_properties = {}; + DispatchGetPhysicalDeviceProperties(caller_physical_device, &device_properties); + if (device_properties.apiVersion < VK_API_VERSION_1_3) { + skip |= LogError( + pnext_vuid, instance, loc.dot(Field::pNext), + "includes a pointer to a VkStructureType (VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_1_3_PROPERTIES) which " + "was added in VK_API_VERSION_1_3 but the " + "current effective API version is %s.", + StringAPIVersion(api_version).c_str()); + } + } + } break; + + // Validation code for VkPhysicalDeviceSubgroupSizeControlProperties structure members + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SUBGROUP_SIZE_CONTROL_PROPERTIES: { // Covers + // VUID-VkPhysicalDeviceSubgroupSizeControlProperties-sType-sType + + if ((is_physdev_api && !SupportedByPdev(physical_device, vvl::Extension::_VK_EXT_subgroup_size_control)) || + (!is_physdev_api && !IsExtEnabled(device_extensions.vk_ext_subgroup_size_control))) { + skip |= LogError(pnext_vuid, instance, loc.dot(Field::pNext), + "includes a pointer to a VkStructureType " + "(VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SUBGROUP_SIZE_CONTROL_PROPERTIES), but its parent extension " + "VK_EXT_subgroup_size_control has not been enabled."); + } + } break; + + // Validation code for VkPhysicalDeviceInlineUniformBlockProperties structure members + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_INLINE_UNIFORM_BLOCK_PROPERTIES: { // Covers + // VUID-VkPhysicalDeviceInlineUniformBlockProperties-sType-sType + + if ((is_physdev_api && !SupportedByPdev(physical_device, vvl::Extension::_VK_EXT_inline_uniform_block)) || + (!is_physdev_api && !IsExtEnabled(device_extensions.vk_ext_inline_uniform_block))) { + skip |= LogError(pnext_vuid, instance, loc.dot(Field::pNext), + "includes a pointer to a VkStructureType " + "(VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_INLINE_UNIFORM_BLOCK_PROPERTIES), but its parent extension " + "VK_EXT_inline_uniform_block has not been enabled."); + } + } break; + + // Validation code for VkPhysicalDeviceShaderIntegerDotProductProperties structure members + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_INTEGER_DOT_PRODUCT_PROPERTIES: { // Covers + // VUID-VkPhysicalDeviceShaderIntegerDotProductProperties-sType-sType + + if ((is_physdev_api && !SupportedByPdev(physical_device, vvl::Extension::_VK_KHR_shader_integer_dot_product)) || + (!is_physdev_api && !IsExtEnabled(device_extensions.vk_khr_shader_integer_dot_product))) { + skip |= + LogError(pnext_vuid, instance, loc.dot(Field::pNext), + "includes a pointer to a VkStructureType " + "(VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_INTEGER_DOT_PRODUCT_PROPERTIES), but its parent extension " + "VK_KHR_shader_integer_dot_product has not been enabled."); + } + } break; + + // Validation code for VkPhysicalDeviceTexelBufferAlignmentProperties structure members + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TEXEL_BUFFER_ALIGNMENT_PROPERTIES: { // Covers + // VUID-VkPhysicalDeviceTexelBufferAlignmentProperties-sType-sType + + if ((is_physdev_api && !SupportedByPdev(physical_device, vvl::Extension::_VK_EXT_texel_buffer_alignment)) || + (!is_physdev_api && !IsExtEnabled(device_extensions.vk_ext_texel_buffer_alignment))) { + skip |= LogError(pnext_vuid, instance, loc.dot(Field::pNext), + "includes a pointer to a VkStructureType " + "(VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TEXEL_BUFFER_ALIGNMENT_PROPERTIES), but its parent extension " + "VK_EXT_texel_buffer_alignment has not been enabled."); + } + } break; + + // Validation code for VkPhysicalDeviceMaintenance4Properties structure members + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MAINTENANCE_4_PROPERTIES: { // Covers + // VUID-VkPhysicalDeviceMaintenance4Properties-sType-sType + + if ((is_physdev_api && !SupportedByPdev(physical_device, vvl::Extension::_VK_KHR_maintenance4)) || + (!is_physdev_api && !IsExtEnabled(device_extensions.vk_khr_maintenance4))) { + skip |= LogError(pnext_vuid, instance, loc.dot(Field::pNext), + "includes a pointer to a VkStructureType " + "(VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MAINTENANCE_4_PROPERTIES), but its parent extension " + "VK_KHR_maintenance4 has not been enabled."); + } + } break; + + // No Validation code for VkPhysicalDevicePushDescriptorPropertiesKHR structure members -- Covers + // VUID-VkPhysicalDevicePushDescriptorPropertiesKHR-sType-sType + + // No Validation code for VkPhysicalDevicePerformanceQueryPropertiesKHR structure members -- Covers + // VUID-VkPhysicalDevicePerformanceQueryPropertiesKHR-sType-sType +#ifdef VK_ENABLE_BETA_EXTENSIONS + + // No Validation code for VkPhysicalDevicePortabilitySubsetPropertiesKHR structure members -- Covers + // VUID-VkPhysicalDevicePortabilitySubsetPropertiesKHR-sType-sType +#endif // VK_ENABLE_BETA_EXTENSIONS + + // No Validation code for VkPhysicalDeviceFragmentShadingRatePropertiesKHR structure members -- Covers + // VUID-VkPhysicalDeviceFragmentShadingRatePropertiesKHR-sType-sType + + // No Validation code for VkPhysicalDeviceFragmentShaderBarycentricPropertiesKHR structure members -- Covers + // VUID-VkPhysicalDeviceFragmentShaderBarycentricPropertiesKHR-sType-sType + + // No Validation code for VkPhysicalDeviceMaintenance5PropertiesKHR structure members -- Covers + // VUID-VkPhysicalDeviceMaintenance5PropertiesKHR-sType-sType + + // No Validation code for VkPhysicalDeviceCooperativeMatrixPropertiesKHR structure members -- Covers + // VUID-VkPhysicalDeviceCooperativeMatrixPropertiesKHR-sType-sType + + // No Validation code for VkPhysicalDeviceVertexAttributeDivisorPropertiesKHR structure members -- Covers + // VUID-VkPhysicalDeviceVertexAttributeDivisorPropertiesKHR-sType-sType + + // No Validation code for VkPhysicalDeviceLineRasterizationPropertiesKHR structure members -- Covers + // VUID-VkPhysicalDeviceLineRasterizationPropertiesKHR-sType-sType + + // No Validation code for VkPhysicalDeviceMaintenance6PropertiesKHR structure members -- Covers + // VUID-VkPhysicalDeviceMaintenance6PropertiesKHR-sType-sType + + // No Validation code for VkPhysicalDeviceTransformFeedbackPropertiesEXT structure members -- Covers + // VUID-VkPhysicalDeviceTransformFeedbackPropertiesEXT-sType-sType + + // No Validation code for VkPhysicalDevicePipelineRobustnessPropertiesEXT structure members -- Covers + // VUID-VkPhysicalDevicePipelineRobustnessPropertiesEXT-sType-sType + + // No Validation code for VkPhysicalDeviceMultiviewPerViewAttributesPropertiesNVX structure members -- Covers + // VUID-VkPhysicalDeviceMultiviewPerViewAttributesPropertiesNVX-sType-sType + + // No Validation code for VkPhysicalDeviceDiscardRectanglePropertiesEXT structure members -- Covers + // VUID-VkPhysicalDeviceDiscardRectanglePropertiesEXT-sType-sType + + // No Validation code for VkPhysicalDeviceConservativeRasterizationPropertiesEXT structure members -- Covers + // VUID-VkPhysicalDeviceConservativeRasterizationPropertiesEXT-sType-sType +#ifdef VK_ENABLE_BETA_EXTENSIONS + + // No Validation code for VkPhysicalDeviceShaderEnqueuePropertiesAMDX structure members -- Covers + // VUID-VkPhysicalDeviceShaderEnqueuePropertiesAMDX-sType-sType +#endif // VK_ENABLE_BETA_EXTENSIONS + + // No Validation code for VkPhysicalDeviceSampleLocationsPropertiesEXT structure members -- Covers + // VUID-VkPhysicalDeviceSampleLocationsPropertiesEXT-sType-sType + + // No Validation code for VkPhysicalDeviceBlendOperationAdvancedPropertiesEXT structure members -- Covers + // VUID-VkPhysicalDeviceBlendOperationAdvancedPropertiesEXT-sType-sType + + // No Validation code for VkPhysicalDeviceShaderSMBuiltinsPropertiesNV structure members -- Covers + // VUID-VkPhysicalDeviceShaderSMBuiltinsPropertiesNV-sType-sType + + // No Validation code for VkPhysicalDeviceShadingRateImagePropertiesNV structure members -- Covers + // VUID-VkPhysicalDeviceShadingRateImagePropertiesNV-sType-sType + + // No Validation code for VkPhysicalDeviceRayTracingPropertiesNV structure members -- Covers + // VUID-VkPhysicalDeviceRayTracingPropertiesNV-sType-sType + + // No Validation code for VkPhysicalDeviceExternalMemoryHostPropertiesEXT structure members -- Covers + // VUID-VkPhysicalDeviceExternalMemoryHostPropertiesEXT-sType-sType + + // No Validation code for VkPhysicalDeviceShaderCorePropertiesAMD structure members -- Covers + // VUID-VkPhysicalDeviceShaderCorePropertiesAMD-sType-sType + + // No Validation code for VkPhysicalDeviceVertexAttributeDivisorPropertiesEXT structure members -- Covers + // VUID-VkPhysicalDeviceVertexAttributeDivisorPropertiesEXT-sType-sType + + // No Validation code for VkPhysicalDeviceMeshShaderPropertiesNV structure members -- Covers + // VUID-VkPhysicalDeviceMeshShaderPropertiesNV-sType-sType + + // No Validation code for VkPhysicalDevicePCIBusInfoPropertiesEXT structure members -- Covers + // VUID-VkPhysicalDevicePCIBusInfoPropertiesEXT-sType-sType + + // No Validation code for VkPhysicalDeviceFragmentDensityMapPropertiesEXT structure members -- Covers + // VUID-VkPhysicalDeviceFragmentDensityMapPropertiesEXT-sType-sType + + // No Validation code for VkPhysicalDeviceShaderCoreProperties2AMD structure members -- Covers + // VUID-VkPhysicalDeviceShaderCoreProperties2AMD-sType-sType + + // No Validation code for VkPhysicalDeviceCooperativeMatrixPropertiesNV structure members -- Covers + // VUID-VkPhysicalDeviceCooperativeMatrixPropertiesNV-sType-sType + + // No Validation code for VkPhysicalDeviceProvokingVertexPropertiesEXT structure members -- Covers + // VUID-VkPhysicalDeviceProvokingVertexPropertiesEXT-sType-sType + + // Validation code for VkPhysicalDeviceHostImageCopyPropertiesEXT structure members + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_HOST_IMAGE_COPY_PROPERTIES_EXT: { // Covers + // VUID-VkPhysicalDeviceHostImageCopyPropertiesEXT-sType-sType + if (is_const_param) { + [[maybe_unused]] const Location pNext_loc = loc.pNext(Struct::VkPhysicalDeviceHostImageCopyPropertiesEXT); + if (!IsExtEnabled(device_extensions.vk_ext_host_image_copy)) { + skip |= + LogError(pnext_vuid, instance, pNext_loc, "extended struct requires the extensions VK_EXT_host_image_copy"); + } + VkPhysicalDeviceHostImageCopyPropertiesEXT* structure = (VkPhysicalDeviceHostImageCopyPropertiesEXT*)header; + skip |= ValidateBool32(pNext_loc.dot(Field::identicalMemoryTypeRequirements), + structure->identicalMemoryTypeRequirements); + } + } break; + + // No Validation code for VkPhysicalDeviceMapMemoryPlacedPropertiesEXT structure members -- Covers + // VUID-VkPhysicalDeviceMapMemoryPlacedPropertiesEXT-sType-sType + + // No Validation code for VkPhysicalDeviceDeviceGeneratedCommandsPropertiesNV structure members -- Covers + // VUID-VkPhysicalDeviceDeviceGeneratedCommandsPropertiesNV-sType-sType + + // No Validation code for VkPhysicalDeviceRobustness2PropertiesEXT structure members -- Covers + // VUID-VkPhysicalDeviceRobustness2PropertiesEXT-sType-sType + + // No Validation code for VkPhysicalDeviceCustomBorderColorPropertiesEXT structure members -- Covers + // VUID-VkPhysicalDeviceCustomBorderColorPropertiesEXT-sType-sType + + // No Validation code for VkPhysicalDeviceCudaKernelLaunchPropertiesNV structure members -- Covers + // VUID-VkPhysicalDeviceCudaKernelLaunchPropertiesNV-sType-sType + + // No Validation code for VkPhysicalDeviceDescriptorBufferPropertiesEXT structure members -- Covers + // VUID-VkPhysicalDeviceDescriptorBufferPropertiesEXT-sType-sType + + // No Validation code for VkPhysicalDeviceDescriptorBufferDensityMapPropertiesEXT structure members -- Covers + // VUID-VkPhysicalDeviceDescriptorBufferDensityMapPropertiesEXT-sType-sType + + // Validation code for VkPhysicalDeviceGraphicsPipelineLibraryPropertiesEXT structure members + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_GRAPHICS_PIPELINE_LIBRARY_PROPERTIES_EXT: { // Covers + // VUID-VkPhysicalDeviceGraphicsPipelineLibraryPropertiesEXT-sType-sType + if (is_const_param) { + [[maybe_unused]] const Location pNext_loc = loc.pNext(Struct::VkPhysicalDeviceGraphicsPipelineLibraryPropertiesEXT); + if (!IsExtEnabled(device_extensions.vk_ext_graphics_pipeline_library)) { + skip |= LogError(pnext_vuid, instance, pNext_loc, + "extended struct requires the extensions VK_EXT_graphics_pipeline_library"); + } + VkPhysicalDeviceGraphicsPipelineLibraryPropertiesEXT* structure = + (VkPhysicalDeviceGraphicsPipelineLibraryPropertiesEXT*)header; + skip |= ValidateBool32(pNext_loc.dot(Field::graphicsPipelineLibraryFastLinking), + structure->graphicsPipelineLibraryFastLinking); + + skip |= ValidateBool32(pNext_loc.dot(Field::graphicsPipelineLibraryIndependentInterpolationDecoration), + structure->graphicsPipelineLibraryIndependentInterpolationDecoration); + } + } break; + + // Validation code for VkPhysicalDeviceFragmentShadingRateEnumsPropertiesNV structure members + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_SHADING_RATE_ENUMS_PROPERTIES_NV: { // Covers + // VUID-VkPhysicalDeviceFragmentShadingRateEnumsPropertiesNV-sType-sType + if (is_const_param) { + [[maybe_unused]] const Location pNext_loc = loc.pNext(Struct::VkPhysicalDeviceFragmentShadingRateEnumsPropertiesNV); + if (!IsExtEnabled(device_extensions.vk_nv_fragment_shading_rate_enums)) { + skip |= LogError(pnext_vuid, instance, pNext_loc, + "extended struct requires the extensions VK_NV_fragment_shading_rate_enums"); + } + VkPhysicalDeviceFragmentShadingRateEnumsPropertiesNV* structure = + (VkPhysicalDeviceFragmentShadingRateEnumsPropertiesNV*)header; + skip |= ValidateFlags( + pNext_loc.dot(Field::maxFragmentShadingRateInvocationCount), vvl::FlagBitmask::VkSampleCountFlagBits, + AllVkSampleCountFlagBits, structure->maxFragmentShadingRateInvocationCount, kRequiredSingleBit, + "VUID-VkPhysicalDeviceFragmentShadingRateEnumsPropertiesNV-maxFragmentShadingRateInvocationCount-parameter", + "VUID-VkPhysicalDeviceFragmentShadingRateEnumsPropertiesNV-maxFragmentShadingRateInvocationCount-parameter"); + } + } break; + + // No Validation code for VkPhysicalDeviceFragmentDensityMap2PropertiesEXT structure members -- Covers + // VUID-VkPhysicalDeviceFragmentDensityMap2PropertiesEXT-sType-sType + + // No Validation code for VkPhysicalDeviceDrmPropertiesEXT structure members -- Covers + // VUID-VkPhysicalDeviceDrmPropertiesEXT-sType-sType + + // No Validation code for VkPhysicalDeviceSubpassShadingPropertiesHUAWEI structure members -- Covers + // VUID-VkPhysicalDeviceSubpassShadingPropertiesHUAWEI-sType-sType + + // No Validation code for VkPhysicalDeviceMultiDrawPropertiesEXT structure members -- Covers + // VUID-VkPhysicalDeviceMultiDrawPropertiesEXT-sType-sType + + // No Validation code for VkPhysicalDeviceShaderTileImagePropertiesEXT structure members -- Covers + // VUID-VkPhysicalDeviceShaderTileImagePropertiesEXT-sType-sType + + // No Validation code for VkPhysicalDeviceOpacityMicromapPropertiesEXT structure members -- Covers + // VUID-VkPhysicalDeviceOpacityMicromapPropertiesEXT-sType-sType +#ifdef VK_ENABLE_BETA_EXTENSIONS + + // No Validation code for VkPhysicalDeviceDisplacementMicromapPropertiesNV structure members -- Covers + // VUID-VkPhysicalDeviceDisplacementMicromapPropertiesNV-sType-sType +#endif // VK_ENABLE_BETA_EXTENSIONS + + // No Validation code for VkPhysicalDeviceClusterCullingShaderPropertiesHUAWEI structure members -- Covers + // VUID-VkPhysicalDeviceClusterCullingShaderPropertiesHUAWEI-sType-sType + + // No Validation code for VkPhysicalDeviceShaderCorePropertiesARM structure members -- Covers + // VUID-VkPhysicalDeviceShaderCorePropertiesARM-sType-sType + + // Validation code for VkPhysicalDeviceSchedulingControlsPropertiesARM structure members + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SCHEDULING_CONTROLS_PROPERTIES_ARM: { // Covers + // VUID-VkPhysicalDeviceSchedulingControlsPropertiesARM-sType-sType + if (is_const_param) { + [[maybe_unused]] const Location pNext_loc = loc.pNext(Struct::VkPhysicalDeviceSchedulingControlsPropertiesARM); + if (!IsExtEnabled(device_extensions.vk_arm_scheduling_controls)) { + skip |= LogError(pnext_vuid, instance, pNext_loc, + "extended struct requires the extensions VK_ARM_scheduling_controls"); + } + VkPhysicalDeviceSchedulingControlsPropertiesARM* structure = + (VkPhysicalDeviceSchedulingControlsPropertiesARM*)header; + skip |= ValidateFlags( + pNext_loc.dot(Field::schedulingControlsFlags), vvl::FlagBitmask::VkPhysicalDeviceSchedulingControlsFlagBitsARM, + AllVkPhysicalDeviceSchedulingControlsFlagBitsARM, structure->schedulingControlsFlags, kRequiredFlags, + "VUID-VkPhysicalDeviceSchedulingControlsPropertiesARM-schedulingControlsFlags-parameter", + "VUID-VkPhysicalDeviceSchedulingControlsPropertiesARM-schedulingControlsFlags-requiredbitmask"); + } + } break; + + // No Validation code for VkPhysicalDeviceRenderPassStripedPropertiesARM structure members -- Covers + // VUID-VkPhysicalDeviceRenderPassStripedPropertiesARM-sType-sType + + // No Validation code for VkPhysicalDeviceFragmentDensityMapOffsetPropertiesQCOM structure members -- Covers + // VUID-VkPhysicalDeviceFragmentDensityMapOffsetPropertiesQCOM-sType-sType + + // No Validation code for VkPhysicalDeviceCopyMemoryIndirectPropertiesNV structure members -- Covers + // VUID-VkPhysicalDeviceCopyMemoryIndirectPropertiesNV-sType-sType + + // No Validation code for VkPhysicalDeviceMemoryDecompressionPropertiesNV structure members -- Covers + // VUID-VkPhysicalDeviceMemoryDecompressionPropertiesNV-sType-sType + + // No Validation code for VkPhysicalDeviceImageProcessingPropertiesQCOM structure members -- Covers + // VUID-VkPhysicalDeviceImageProcessingPropertiesQCOM-sType-sType + + // No Validation code for VkPhysicalDeviceNestedCommandBufferPropertiesEXT structure members -- Covers + // VUID-VkPhysicalDeviceNestedCommandBufferPropertiesEXT-sType-sType + + // Validation code for VkPhysicalDeviceExtendedDynamicState3PropertiesEXT structure members + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTENDED_DYNAMIC_STATE_3_PROPERTIES_EXT: { // Covers + // VUID-VkPhysicalDeviceExtendedDynamicState3PropertiesEXT-sType-sType + if (is_const_param) { + [[maybe_unused]] const Location pNext_loc = loc.pNext(Struct::VkPhysicalDeviceExtendedDynamicState3PropertiesEXT); + if (!IsExtEnabled(device_extensions.vk_ext_extended_dynamic_state3)) { + skip |= LogError(pnext_vuid, instance, pNext_loc, + "extended struct requires the extensions VK_EXT_extended_dynamic_state3"); + } + VkPhysicalDeviceExtendedDynamicState3PropertiesEXT* structure = + (VkPhysicalDeviceExtendedDynamicState3PropertiesEXT*)header; + skip |= ValidateBool32(pNext_loc.dot(Field::dynamicPrimitiveTopologyUnrestricted), + structure->dynamicPrimitiveTopologyUnrestricted); + } + } break; + + // No Validation code for VkPhysicalDeviceShaderModuleIdentifierPropertiesEXT structure members -- Covers + // VUID-VkPhysicalDeviceShaderModuleIdentifierPropertiesEXT-sType-sType + + // No Validation code for VkPhysicalDeviceOpticalFlowPropertiesNV structure members -- Covers + // VUID-VkPhysicalDeviceOpticalFlowPropertiesNV-sType-sType +#ifdef VK_USE_PLATFORM_ANDROID_KHR + + // No Validation code for VkPhysicalDeviceExternalFormatResolvePropertiesANDROID structure members -- Covers + // VUID-VkPhysicalDeviceExternalFormatResolvePropertiesANDROID-sType-sType +#endif // VK_USE_PLATFORM_ANDROID_KHR + + // No Validation code for VkPhysicalDeviceShaderObjectPropertiesEXT structure members -- Covers + // VUID-VkPhysicalDeviceShaderObjectPropertiesEXT-sType-sType + + // No Validation code for VkPhysicalDeviceRayTracingInvocationReorderPropertiesNV structure members -- Covers + // VUID-VkPhysicalDeviceRayTracingInvocationReorderPropertiesNV-sType-sType + + // No Validation code for VkPhysicalDeviceExtendedSparseAddressSpacePropertiesNV structure members -- Covers + // VUID-VkPhysicalDeviceExtendedSparseAddressSpacePropertiesNV-sType-sType + + // No Validation code for VkPhysicalDeviceShaderCoreBuiltinsPropertiesARM structure members -- Covers + // VUID-VkPhysicalDeviceShaderCoreBuiltinsPropertiesARM-sType-sType + + // No Validation code for VkPhysicalDeviceImageProcessing2PropertiesQCOM structure members -- Covers + // VUID-VkPhysicalDeviceImageProcessing2PropertiesQCOM-sType-sType + + // No Validation code for VkPhysicalDeviceLayeredDriverPropertiesMSFT structure members -- Covers + // VUID-VkPhysicalDeviceLayeredDriverPropertiesMSFT-sType-sType + + // No Validation code for VkPhysicalDeviceAccelerationStructurePropertiesKHR structure members -- Covers + // VUID-VkPhysicalDeviceAccelerationStructurePropertiesKHR-sType-sType + + // No Validation code for VkPhysicalDeviceRayTracingPipelinePropertiesKHR structure members -- Covers + // VUID-VkPhysicalDeviceRayTracingPipelinePropertiesKHR-sType-sType + + // No Validation code for VkPhysicalDeviceMeshShaderPropertiesEXT structure members -- Covers + // VUID-VkPhysicalDeviceMeshShaderPropertiesEXT-sType-sType + + default: + skip = false; + } + return skip; +} + +// All structs that are not a Feature or Property struct bool StatelessValidation::ValidatePnextStructContents(const Location& loc, const VkBaseOutStructure* header, const char* pnext_vuid, VkPhysicalDevice caller_physical_device, bool is_const_param) const { bool skip = false; @@ -75,54 +4703,6 @@ } } break; - // Validation code for VkPhysicalDeviceSubgroupProperties structure members - case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SUBGROUP_PROPERTIES: { // Covers VUID-VkPhysicalDeviceSubgroupProperties-sType-sType - - if (is_physdev_api) { - VkPhysicalDeviceProperties device_properties = {}; - DispatchGetPhysicalDeviceProperties(caller_physical_device, &device_properties); - if (device_properties.apiVersion < VK_API_VERSION_1_1) { - skip |= - LogError(pnext_vuid, instance, loc.dot(Field::pNext), - "includes a pointer to a VkStructureType (VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SUBGROUP_PROPERTIES) " - "which was added in VK_API_VERSION_1_1 but the " - "current effective API version is %s.", - StringAPIVersion(api_version).c_str()); - } - } - } break; - - // Validation code for VkPhysicalDevice16BitStorageFeatures structure members - case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_16BIT_STORAGE_FEATURES: { // Covers - // VUID-VkPhysicalDevice16BitStorageFeatures-sType-sType - - if ((is_physdev_api && !SupportedByPdev(physical_device, vvl::Extension::_VK_KHR_16bit_storage)) || - (!is_physdev_api && !IsExtEnabled(device_extensions.vk_khr_16bit_storage))) { - skip |= LogError(pnext_vuid, instance, loc.dot(Field::pNext), - "includes a pointer to a VkStructureType " - "(VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_16BIT_STORAGE_FEATURES), but its parent extension " - "VK_KHR_16bit_storage has not been enabled."); - } - if (is_const_param) { - [[maybe_unused]] const Location pNext_loc = loc.pNext(Struct::VkPhysicalDevice16BitStorageFeatures); - if (!IsExtEnabled(device_extensions.vk_khr_16bit_storage)) { - skip |= LogError(pnext_vuid, instance, pNext_loc, - "includes a pointer to a VkPhysicalDevice16BitStorageFeatures, but when creating VkDevice, " - "the parent extension " - "(VK_KHR_16bit_storage) was not included in ppEnabledExtensionNames."); - } - VkPhysicalDevice16BitStorageFeatures* structure = (VkPhysicalDevice16BitStorageFeatures*)header; - skip |= ValidateBool32(pNext_loc.dot(Field::storageBuffer16BitAccess), structure->storageBuffer16BitAccess); - - skip |= ValidateBool32(pNext_loc.dot(Field::uniformAndStorageBuffer16BitAccess), - structure->uniformAndStorageBuffer16BitAccess); - - skip |= ValidateBool32(pNext_loc.dot(Field::storagePushConstant16), structure->storagePushConstant16); - - skip |= ValidateBool32(pNext_loc.dot(Field::storageInputOutput16), structure->storageInputOutput16); - } - } break; - // Validation code for VkMemoryDedicatedRequirements structure members case VK_STRUCTURE_TYPE_MEMORY_DEDICATED_REQUIREMENTS: { // Covers VUID-VkMemoryDedicatedRequirements-sType-sType @@ -474,19 +5054,6 @@ } } break; - // Validation code for VkPhysicalDevicePointClippingProperties structure members - case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_POINT_CLIPPING_PROPERTIES: { // Covers - // VUID-VkPhysicalDevicePointClippingProperties-sType-sType - - if ((is_physdev_api && !SupportedByPdev(physical_device, vvl::Extension::_VK_KHR_maintenance2)) || - (!is_physdev_api && !IsExtEnabled(device_extensions.vk_khr_maintenance2))) { - skip |= LogError(pnext_vuid, instance, loc.dot(Field::pNext), - "includes a pointer to a VkStructureType " - "(VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_POINT_CLIPPING_PROPERTIES), but its parent extension " - "VK_KHR_maintenance2 has not been enabled."); - } - } break; - // Validation code for VkRenderPassInputAttachmentAspectCreateInfo structure members case VK_STRUCTURE_TYPE_RENDER_PASS_INPUT_ATTACHMENT_ASPECT_CREATE_INFO: { // Covers // VUID-VkRenderPassInputAttachmentAspectCreateInfo-sType-sType @@ -604,114 +5171,6 @@ } } break; - // Validation code for VkPhysicalDeviceMultiviewFeatures structure members - case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MULTIVIEW_FEATURES: { // Covers VUID-VkPhysicalDeviceMultiviewFeatures-sType-sType - - if ((is_physdev_api && !SupportedByPdev(physical_device, vvl::Extension::_VK_KHR_multiview)) || - (!is_physdev_api && !IsExtEnabled(device_extensions.vk_khr_multiview))) { - skip |= LogError(pnext_vuid, instance, loc.dot(Field::pNext), - "includes a pointer to a VkStructureType (VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MULTIVIEW_FEATURES), " - "but its parent extension " - "VK_KHR_multiview has not been enabled."); - } - if (is_const_param) { - [[maybe_unused]] const Location pNext_loc = loc.pNext(Struct::VkPhysicalDeviceMultiviewFeatures); - if (!IsExtEnabled(device_extensions.vk_khr_multiview)) { - skip |= LogError(pnext_vuid, instance, pNext_loc, - "includes a pointer to a VkPhysicalDeviceMultiviewFeatures, but when creating VkDevice, the " - "parent extension " - "(VK_KHR_multiview) was not included in ppEnabledExtensionNames."); - } - VkPhysicalDeviceMultiviewFeatures* structure = (VkPhysicalDeviceMultiviewFeatures*)header; - skip |= ValidateBool32(pNext_loc.dot(Field::multiview), structure->multiview); - - skip |= ValidateBool32(pNext_loc.dot(Field::multiviewGeometryShader), structure->multiviewGeometryShader); - - skip |= ValidateBool32(pNext_loc.dot(Field::multiviewTessellationShader), structure->multiviewTessellationShader); - } - } break; - - // Validation code for VkPhysicalDeviceMultiviewProperties structure members - case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MULTIVIEW_PROPERTIES: { // Covers - // VUID-VkPhysicalDeviceMultiviewProperties-sType-sType - - if ((is_physdev_api && !SupportedByPdev(physical_device, vvl::Extension::_VK_KHR_multiview)) || - (!is_physdev_api && !IsExtEnabled(device_extensions.vk_khr_multiview))) { - skip |= LogError(pnext_vuid, instance, loc.dot(Field::pNext), - "includes a pointer to a VkStructureType " - "(VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MULTIVIEW_PROPERTIES), but its parent extension " - "VK_KHR_multiview has not been enabled."); - } - } break; - - // Validation code for VkPhysicalDeviceVariablePointersFeatures structure members - case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VARIABLE_POINTERS_FEATURES: { // Covers - // VUID-VkPhysicalDeviceVariablePointersFeatures-sType-sType - - if ((is_physdev_api && !SupportedByPdev(physical_device, vvl::Extension::_VK_KHR_variable_pointers)) || - (!is_physdev_api && !IsExtEnabled(device_extensions.vk_khr_variable_pointers))) { - skip |= LogError(pnext_vuid, instance, loc.dot(Field::pNext), - "includes a pointer to a VkStructureType " - "(VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VARIABLE_POINTERS_FEATURES), but its parent extension " - "VK_KHR_variable_pointers has not been enabled."); - } - if (is_const_param) { - [[maybe_unused]] const Location pNext_loc = loc.pNext(Struct::VkPhysicalDeviceVariablePointersFeatures); - if (!IsExtEnabled(device_extensions.vk_khr_variable_pointers)) { - skip |= LogError(pnext_vuid, instance, pNext_loc, - "includes a pointer to a VkPhysicalDeviceVariablePointersFeatures, but when creating " - "VkDevice, the parent extension " - "(VK_KHR_variable_pointers) was not included in ppEnabledExtensionNames."); - } - VkPhysicalDeviceVariablePointersFeatures* structure = (VkPhysicalDeviceVariablePointersFeatures*)header; - skip |= - ValidateBool32(pNext_loc.dot(Field::variablePointersStorageBuffer), structure->variablePointersStorageBuffer); - - skip |= ValidateBool32(pNext_loc.dot(Field::variablePointers), structure->variablePointers); - } - } break; - - // Validation code for VkPhysicalDeviceProtectedMemoryFeatures structure members - case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PROTECTED_MEMORY_FEATURES: { // Covers - // VUID-VkPhysicalDeviceProtectedMemoryFeatures-sType-sType - - if (is_physdev_api) { - VkPhysicalDeviceProperties device_properties = {}; - DispatchGetPhysicalDeviceProperties(caller_physical_device, &device_properties); - if (device_properties.apiVersion < VK_API_VERSION_1_1) { - skip |= LogError( - pnext_vuid, instance, loc.dot(Field::pNext), - "includes a pointer to a VkStructureType (VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PROTECTED_MEMORY_FEATURES) " - "which was added in VK_API_VERSION_1_1 but the " - "current effective API version is %s.", - StringAPIVersion(api_version).c_str()); - } - } - if (is_const_param) { - [[maybe_unused]] const Location pNext_loc = loc.pNext(Struct::VkPhysicalDeviceProtectedMemoryFeatures); - VkPhysicalDeviceProtectedMemoryFeatures* structure = (VkPhysicalDeviceProtectedMemoryFeatures*)header; - skip |= ValidateBool32(pNext_loc.dot(Field::protectedMemory), structure->protectedMemory); - } - } break; - - // Validation code for VkPhysicalDeviceProtectedMemoryProperties structure members - case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PROTECTED_MEMORY_PROPERTIES: { // Covers - // VUID-VkPhysicalDeviceProtectedMemoryProperties-sType-sType - - if (is_physdev_api) { - VkPhysicalDeviceProperties device_properties = {}; - DispatchGetPhysicalDeviceProperties(caller_physical_device, &device_properties); - if (device_properties.apiVersion < VK_API_VERSION_1_1) { - skip |= LogError( - pnext_vuid, instance, loc.dot(Field::pNext), - "includes a pointer to a VkStructureType (VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PROTECTED_MEMORY_PROPERTIES) " - "which was added in VK_API_VERSION_1_1 but the " - "current effective API version is %s.", - StringAPIVersion(api_version).c_str()); - } - } - } break; - // Validation code for VkProtectedSubmitInfo structure members case VK_STRUCTURE_TYPE_PROTECTED_SUBMIT_INFO: { // Covers VUID-VkProtectedSubmitInfo-sType-sType @@ -803,30 +5262,6 @@ } } break; - // Validation code for VkPhysicalDeviceSamplerYcbcrConversionFeatures structure members - case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SAMPLER_YCBCR_CONVERSION_FEATURES: { // Covers - // VUID-VkPhysicalDeviceSamplerYcbcrConversionFeatures-sType-sType - - if ((is_physdev_api && !SupportedByPdev(physical_device, vvl::Extension::_VK_KHR_sampler_ycbcr_conversion)) || - (!is_physdev_api && !IsExtEnabled(device_extensions.vk_khr_sampler_ycbcr_conversion))) { - skip |= LogError(pnext_vuid, instance, loc.dot(Field::pNext), - "includes a pointer to a VkStructureType " - "(VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SAMPLER_YCBCR_CONVERSION_FEATURES), but its parent extension " - "VK_KHR_sampler_ycbcr_conversion has not been enabled."); - } - if (is_const_param) { - [[maybe_unused]] const Location pNext_loc = loc.pNext(Struct::VkPhysicalDeviceSamplerYcbcrConversionFeatures); - if (!IsExtEnabled(device_extensions.vk_khr_sampler_ycbcr_conversion)) { - skip |= LogError(pnext_vuid, instance, pNext_loc, - "includes a pointer to a VkPhysicalDeviceSamplerYcbcrConversionFeatures, but when creating " - "VkDevice, the parent extension " - "(VK_KHR_sampler_ycbcr_conversion) was not included in ppEnabledExtensionNames."); - } - VkPhysicalDeviceSamplerYcbcrConversionFeatures* structure = (VkPhysicalDeviceSamplerYcbcrConversionFeatures*)header; - skip |= ValidateBool32(pNext_loc.dot(Field::samplerYcbcrConversion), structure->samplerYcbcrConversion); - } - } break; - // Validation code for VkSamplerYcbcrConversionImageFormatProperties structure members case VK_STRUCTURE_TYPE_SAMPLER_YCBCR_CONVERSION_IMAGE_FORMAT_PROPERTIES: { // Covers // VUID-VkSamplerYcbcrConversionImageFormatProperties-sType-sType @@ -870,17 +5305,6 @@ } } break; - // Validation code for VkPhysicalDeviceIDProperties structure members - case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ID_PROPERTIES: { // Covers VUID-VkPhysicalDeviceIDProperties-sType-sType - - if (!IsExtEnabled(instance_extensions.vk_khr_external_fence_capabilities)) { - skip |= LogError(pnext_vuid, instance, loc.dot(Field::pNext), - "includes a pointer to a VkStructureType (VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ID_PROPERTIES), but " - "its parent extension " - "VK_KHR_external_fence_capabilities has not been enabled."); - } - } break; - // Validation code for VkExternalMemoryImageCreateInfo structure members case VK_STRUCTURE_TYPE_EXTERNAL_MEMORY_IMAGE_CREATE_INFO: { // Covers VUID-VkExternalMemoryImageCreateInfo-sType-sType @@ -996,261 +5420,6 @@ } } break; - // Validation code for VkPhysicalDeviceMaintenance3Properties structure members - case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MAINTENANCE_3_PROPERTIES: { // Covers - // VUID-VkPhysicalDeviceMaintenance3Properties-sType-sType - - if ((is_physdev_api && !SupportedByPdev(physical_device, vvl::Extension::_VK_KHR_maintenance3)) || - (!is_physdev_api && !IsExtEnabled(device_extensions.vk_khr_maintenance3))) { - skip |= LogError(pnext_vuid, instance, loc.dot(Field::pNext), - "includes a pointer to a VkStructureType " - "(VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MAINTENANCE_3_PROPERTIES), but its parent extension " - "VK_KHR_maintenance3 has not been enabled."); - } - } break; - - // Validation code for VkPhysicalDeviceShaderDrawParametersFeatures structure members - case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_DRAW_PARAMETERS_FEATURES: { // Covers - // VUID-VkPhysicalDeviceShaderDrawParametersFeatures-sType-sType - - if (is_physdev_api) { - VkPhysicalDeviceProperties device_properties = {}; - DispatchGetPhysicalDeviceProperties(caller_physical_device, &device_properties); - if (device_properties.apiVersion < VK_API_VERSION_1_1) { - skip |= LogError(pnext_vuid, instance, loc.dot(Field::pNext), - "includes a pointer to a VkStructureType " - "(VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_DRAW_PARAMETERS_FEATURES) which was added in " - "VK_API_VERSION_1_1 but the " - "current effective API version is %s.", - StringAPIVersion(api_version).c_str()); - } - } - if (is_const_param) { - [[maybe_unused]] const Location pNext_loc = loc.pNext(Struct::VkPhysicalDeviceShaderDrawParametersFeatures); - VkPhysicalDeviceShaderDrawParametersFeatures* structure = (VkPhysicalDeviceShaderDrawParametersFeatures*)header; - skip |= ValidateBool32(pNext_loc.dot(Field::shaderDrawParameters), structure->shaderDrawParameters); - } - } break; - - // Validation code for VkPhysicalDeviceVulkan11Features structure members - case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_1_1_FEATURES: { // Covers VUID-VkPhysicalDeviceVulkan11Features-sType-sType - - if (is_physdev_api) { - VkPhysicalDeviceProperties device_properties = {}; - DispatchGetPhysicalDeviceProperties(caller_physical_device, &device_properties); - if (device_properties.apiVersion < VK_API_VERSION_1_2) { - skip |= - LogError(pnext_vuid, instance, loc.dot(Field::pNext), - "includes a pointer to a VkStructureType (VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_1_1_FEATURES) " - "which was added in VK_API_VERSION_1_2 but the " - "current effective API version is %s.", - StringAPIVersion(api_version).c_str()); - } - } - if (is_const_param) { - [[maybe_unused]] const Location pNext_loc = loc.pNext(Struct::VkPhysicalDeviceVulkan11Features); - VkPhysicalDeviceVulkan11Features* structure = (VkPhysicalDeviceVulkan11Features*)header; - skip |= ValidateBool32(pNext_loc.dot(Field::storageBuffer16BitAccess), structure->storageBuffer16BitAccess); - - skip |= ValidateBool32(pNext_loc.dot(Field::uniformAndStorageBuffer16BitAccess), - structure->uniformAndStorageBuffer16BitAccess); - - skip |= ValidateBool32(pNext_loc.dot(Field::storagePushConstant16), structure->storagePushConstant16); - - skip |= ValidateBool32(pNext_loc.dot(Field::storageInputOutput16), structure->storageInputOutput16); - - skip |= ValidateBool32(pNext_loc.dot(Field::multiview), structure->multiview); - - skip |= ValidateBool32(pNext_loc.dot(Field::multiviewGeometryShader), structure->multiviewGeometryShader); - - skip |= ValidateBool32(pNext_loc.dot(Field::multiviewTessellationShader), structure->multiviewTessellationShader); - - skip |= - ValidateBool32(pNext_loc.dot(Field::variablePointersStorageBuffer), structure->variablePointersStorageBuffer); - - skip |= ValidateBool32(pNext_loc.dot(Field::variablePointers), structure->variablePointers); - - skip |= ValidateBool32(pNext_loc.dot(Field::protectedMemory), structure->protectedMemory); - - skip |= ValidateBool32(pNext_loc.dot(Field::samplerYcbcrConversion), structure->samplerYcbcrConversion); - - skip |= ValidateBool32(pNext_loc.dot(Field::shaderDrawParameters), structure->shaderDrawParameters); - } - } break; - - // Validation code for VkPhysicalDeviceVulkan11Properties structure members - case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_1_1_PROPERTIES: { // Covers - // VUID-VkPhysicalDeviceVulkan11Properties-sType-sType - - if (is_physdev_api) { - VkPhysicalDeviceProperties device_properties = {}; - DispatchGetPhysicalDeviceProperties(caller_physical_device, &device_properties); - if (device_properties.apiVersion < VK_API_VERSION_1_2) { - skip |= LogError( - pnext_vuid, instance, loc.dot(Field::pNext), - "includes a pointer to a VkStructureType (VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_1_1_PROPERTIES) which " - "was added in VK_API_VERSION_1_2 but the " - "current effective API version is %s.", - StringAPIVersion(api_version).c_str()); - } - } - } break; - - // Validation code for VkPhysicalDeviceVulkan12Features structure members - case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_1_2_FEATURES: { // Covers VUID-VkPhysicalDeviceVulkan12Features-sType-sType - - if (is_physdev_api) { - VkPhysicalDeviceProperties device_properties = {}; - DispatchGetPhysicalDeviceProperties(caller_physical_device, &device_properties); - if (device_properties.apiVersion < VK_API_VERSION_1_2) { - skip |= - LogError(pnext_vuid, instance, loc.dot(Field::pNext), - "includes a pointer to a VkStructureType (VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_1_2_FEATURES) " - "which was added in VK_API_VERSION_1_2 but the " - "current effective API version is %s.", - StringAPIVersion(api_version).c_str()); - } - } - if (is_const_param) { - [[maybe_unused]] const Location pNext_loc = loc.pNext(Struct::VkPhysicalDeviceVulkan12Features); - VkPhysicalDeviceVulkan12Features* structure = (VkPhysicalDeviceVulkan12Features*)header; - skip |= ValidateBool32(pNext_loc.dot(Field::samplerMirrorClampToEdge), structure->samplerMirrorClampToEdge); - - skip |= ValidateBool32(pNext_loc.dot(Field::drawIndirectCount), structure->drawIndirectCount); - - skip |= ValidateBool32(pNext_loc.dot(Field::storageBuffer8BitAccess), structure->storageBuffer8BitAccess); - - skip |= ValidateBool32(pNext_loc.dot(Field::uniformAndStorageBuffer8BitAccess), - structure->uniformAndStorageBuffer8BitAccess); - - skip |= ValidateBool32(pNext_loc.dot(Field::storagePushConstant8), structure->storagePushConstant8); - - skip |= ValidateBool32(pNext_loc.dot(Field::shaderBufferInt64Atomics), structure->shaderBufferInt64Atomics); - - skip |= ValidateBool32(pNext_loc.dot(Field::shaderSharedInt64Atomics), structure->shaderSharedInt64Atomics); - - skip |= ValidateBool32(pNext_loc.dot(Field::shaderFloat16), structure->shaderFloat16); - - skip |= ValidateBool32(pNext_loc.dot(Field::shaderInt8), structure->shaderInt8); - - skip |= ValidateBool32(pNext_loc.dot(Field::descriptorIndexing), structure->descriptorIndexing); - - skip |= ValidateBool32(pNext_loc.dot(Field::shaderInputAttachmentArrayDynamicIndexing), - structure->shaderInputAttachmentArrayDynamicIndexing); - - skip |= ValidateBool32(pNext_loc.dot(Field::shaderUniformTexelBufferArrayDynamicIndexing), - structure->shaderUniformTexelBufferArrayDynamicIndexing); - - skip |= ValidateBool32(pNext_loc.dot(Field::shaderStorageTexelBufferArrayDynamicIndexing), - structure->shaderStorageTexelBufferArrayDynamicIndexing); - - skip |= ValidateBool32(pNext_loc.dot(Field::shaderUniformBufferArrayNonUniformIndexing), - structure->shaderUniformBufferArrayNonUniformIndexing); - - skip |= ValidateBool32(pNext_loc.dot(Field::shaderSampledImageArrayNonUniformIndexing), - structure->shaderSampledImageArrayNonUniformIndexing); - - skip |= ValidateBool32(pNext_loc.dot(Field::shaderStorageBufferArrayNonUniformIndexing), - structure->shaderStorageBufferArrayNonUniformIndexing); - - skip |= ValidateBool32(pNext_loc.dot(Field::shaderStorageImageArrayNonUniformIndexing), - structure->shaderStorageImageArrayNonUniformIndexing); - - skip |= ValidateBool32(pNext_loc.dot(Field::shaderInputAttachmentArrayNonUniformIndexing), - structure->shaderInputAttachmentArrayNonUniformIndexing); - - skip |= ValidateBool32(pNext_loc.dot(Field::shaderUniformTexelBufferArrayNonUniformIndexing), - structure->shaderUniformTexelBufferArrayNonUniformIndexing); - - skip |= ValidateBool32(pNext_loc.dot(Field::shaderStorageTexelBufferArrayNonUniformIndexing), - structure->shaderStorageTexelBufferArrayNonUniformIndexing); - - skip |= ValidateBool32(pNext_loc.dot(Field::descriptorBindingUniformBufferUpdateAfterBind), - structure->descriptorBindingUniformBufferUpdateAfterBind); - - skip |= ValidateBool32(pNext_loc.dot(Field::descriptorBindingSampledImageUpdateAfterBind), - structure->descriptorBindingSampledImageUpdateAfterBind); - - skip |= ValidateBool32(pNext_loc.dot(Field::descriptorBindingStorageImageUpdateAfterBind), - structure->descriptorBindingStorageImageUpdateAfterBind); - - skip |= ValidateBool32(pNext_loc.dot(Field::descriptorBindingStorageBufferUpdateAfterBind), - structure->descriptorBindingStorageBufferUpdateAfterBind); - - skip |= ValidateBool32(pNext_loc.dot(Field::descriptorBindingUniformTexelBufferUpdateAfterBind), - structure->descriptorBindingUniformTexelBufferUpdateAfterBind); - - skip |= ValidateBool32(pNext_loc.dot(Field::descriptorBindingStorageTexelBufferUpdateAfterBind), - structure->descriptorBindingStorageTexelBufferUpdateAfterBind); - - skip |= ValidateBool32(pNext_loc.dot(Field::descriptorBindingUpdateUnusedWhilePending), - structure->descriptorBindingUpdateUnusedWhilePending); - - skip |= ValidateBool32(pNext_loc.dot(Field::descriptorBindingPartiallyBound), - structure->descriptorBindingPartiallyBound); - - skip |= ValidateBool32(pNext_loc.dot(Field::descriptorBindingVariableDescriptorCount), - structure->descriptorBindingVariableDescriptorCount); - - skip |= ValidateBool32(pNext_loc.dot(Field::runtimeDescriptorArray), structure->runtimeDescriptorArray); - - skip |= ValidateBool32(pNext_loc.dot(Field::samplerFilterMinmax), structure->samplerFilterMinmax); - - skip |= ValidateBool32(pNext_loc.dot(Field::scalarBlockLayout), structure->scalarBlockLayout); - - skip |= ValidateBool32(pNext_loc.dot(Field::imagelessFramebuffer), structure->imagelessFramebuffer); - - skip |= ValidateBool32(pNext_loc.dot(Field::uniformBufferStandardLayout), structure->uniformBufferStandardLayout); - - skip |= ValidateBool32(pNext_loc.dot(Field::shaderSubgroupExtendedTypes), structure->shaderSubgroupExtendedTypes); - - skip |= ValidateBool32(pNext_loc.dot(Field::separateDepthStencilLayouts), structure->separateDepthStencilLayouts); - - skip |= ValidateBool32(pNext_loc.dot(Field::hostQueryReset), structure->hostQueryReset); - - skip |= ValidateBool32(pNext_loc.dot(Field::timelineSemaphore), structure->timelineSemaphore); - - skip |= ValidateBool32(pNext_loc.dot(Field::bufferDeviceAddress), structure->bufferDeviceAddress); - - skip |= ValidateBool32(pNext_loc.dot(Field::bufferDeviceAddressCaptureReplay), - structure->bufferDeviceAddressCaptureReplay); - - skip |= - ValidateBool32(pNext_loc.dot(Field::bufferDeviceAddressMultiDevice), structure->bufferDeviceAddressMultiDevice); - - skip |= ValidateBool32(pNext_loc.dot(Field::vulkanMemoryModel), structure->vulkanMemoryModel); - - skip |= ValidateBool32(pNext_loc.dot(Field::vulkanMemoryModelDeviceScope), structure->vulkanMemoryModelDeviceScope); - - skip |= ValidateBool32(pNext_loc.dot(Field::vulkanMemoryModelAvailabilityVisibilityChains), - structure->vulkanMemoryModelAvailabilityVisibilityChains); - - skip |= ValidateBool32(pNext_loc.dot(Field::shaderOutputViewportIndex), structure->shaderOutputViewportIndex); - - skip |= ValidateBool32(pNext_loc.dot(Field::shaderOutputLayer), structure->shaderOutputLayer); - - skip |= ValidateBool32(pNext_loc.dot(Field::subgroupBroadcastDynamicId), structure->subgroupBroadcastDynamicId); - } - } break; - - // Validation code for VkPhysicalDeviceVulkan12Properties structure members - case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_1_2_PROPERTIES: { // Covers - // VUID-VkPhysicalDeviceVulkan12Properties-sType-sType - - if (is_physdev_api) { - VkPhysicalDeviceProperties device_properties = {}; - DispatchGetPhysicalDeviceProperties(caller_physical_device, &device_properties); - if (device_properties.apiVersion < VK_API_VERSION_1_2) { - skip |= LogError( - pnext_vuid, instance, loc.dot(Field::pNext), - "includes a pointer to a VkStructureType (VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_1_2_PROPERTIES) which " - "was added in VK_API_VERSION_1_2 but the " - "current effective API version is %s.", - StringAPIVersion(api_version).c_str()); - } - } - } break; - // Validation code for VkImageFormatListCreateInfo structure members case VK_STRUCTURE_TYPE_IMAGE_FORMAT_LIST_CREATE_INFO: { // Covers VUID-VkImageFormatListCreateInfo-sType-sType @@ -1274,112 +5443,6 @@ } } break; - // Validation code for VkPhysicalDevice8BitStorageFeatures structure members - case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_8BIT_STORAGE_FEATURES: { // Covers - // VUID-VkPhysicalDevice8BitStorageFeatures-sType-sType - - if ((is_physdev_api && !SupportedByPdev(physical_device, vvl::Extension::_VK_KHR_8bit_storage)) || - (!is_physdev_api && !IsExtEnabled(device_extensions.vk_khr_8bit_storage))) { - skip |= LogError(pnext_vuid, instance, loc.dot(Field::pNext), - "includes a pointer to a VkStructureType " - "(VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_8BIT_STORAGE_FEATURES), but its parent extension " - "VK_KHR_8bit_storage has not been enabled."); - } - if (is_const_param) { - [[maybe_unused]] const Location pNext_loc = loc.pNext(Struct::VkPhysicalDevice8BitStorageFeatures); - if (!IsExtEnabled(device_extensions.vk_khr_8bit_storage)) { - skip |= LogError(pnext_vuid, instance, pNext_loc, - "includes a pointer to a VkPhysicalDevice8BitStorageFeatures, but when creating VkDevice, the " - "parent extension " - "(VK_KHR_8bit_storage) was not included in ppEnabledExtensionNames."); - } - VkPhysicalDevice8BitStorageFeatures* structure = (VkPhysicalDevice8BitStorageFeatures*)header; - skip |= ValidateBool32(pNext_loc.dot(Field::storageBuffer8BitAccess), structure->storageBuffer8BitAccess); - - skip |= ValidateBool32(pNext_loc.dot(Field::uniformAndStorageBuffer8BitAccess), - structure->uniformAndStorageBuffer8BitAccess); - - skip |= ValidateBool32(pNext_loc.dot(Field::storagePushConstant8), structure->storagePushConstant8); - } - } break; - - // Validation code for VkPhysicalDeviceDriverProperties structure members - case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DRIVER_PROPERTIES: { // Covers VUID-VkPhysicalDeviceDriverProperties-sType-sType - - if ((is_physdev_api && !SupportedByPdev(physical_device, vvl::Extension::_VK_KHR_driver_properties)) || - (!is_physdev_api && !IsExtEnabled(device_extensions.vk_khr_driver_properties))) { - skip |= LogError(pnext_vuid, instance, loc.dot(Field::pNext), - "includes a pointer to a VkStructureType (VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DRIVER_PROPERTIES), " - "but its parent extension " - "VK_KHR_driver_properties has not been enabled."); - } - } break; - - // Validation code for VkPhysicalDeviceShaderAtomicInt64Features structure members - case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_ATOMIC_INT64_FEATURES: { // Covers - // VUID-VkPhysicalDeviceShaderAtomicInt64Features-sType-sType - - if ((is_physdev_api && !SupportedByPdev(physical_device, vvl::Extension::_VK_KHR_shader_atomic_int64)) || - (!is_physdev_api && !IsExtEnabled(device_extensions.vk_khr_shader_atomic_int64))) { - skip |= LogError(pnext_vuid, instance, loc.dot(Field::pNext), - "includes a pointer to a VkStructureType " - "(VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_ATOMIC_INT64_FEATURES), but its parent extension " - "VK_KHR_shader_atomic_int64 has not been enabled."); - } - if (is_const_param) { - [[maybe_unused]] const Location pNext_loc = loc.pNext(Struct::VkPhysicalDeviceShaderAtomicInt64Features); - if (!IsExtEnabled(device_extensions.vk_khr_shader_atomic_int64)) { - skip |= LogError(pnext_vuid, instance, pNext_loc, - "includes a pointer to a VkPhysicalDeviceShaderAtomicInt64Features, but when creating " - "VkDevice, the parent extension " - "(VK_KHR_shader_atomic_int64) was not included in ppEnabledExtensionNames."); - } - VkPhysicalDeviceShaderAtomicInt64Features* structure = (VkPhysicalDeviceShaderAtomicInt64Features*)header; - skip |= ValidateBool32(pNext_loc.dot(Field::shaderBufferInt64Atomics), structure->shaderBufferInt64Atomics); - - skip |= ValidateBool32(pNext_loc.dot(Field::shaderSharedInt64Atomics), structure->shaderSharedInt64Atomics); - } - } break; - - // Validation code for VkPhysicalDeviceShaderFloat16Int8Features structure members - case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_FLOAT16_INT8_FEATURES: { // Covers - // VUID-VkPhysicalDeviceShaderFloat16Int8Features-sType-sType - - if ((is_physdev_api && !SupportedByPdev(physical_device, vvl::Extension::_VK_KHR_shader_float16_int8)) || - (!is_physdev_api && !IsExtEnabled(device_extensions.vk_khr_shader_float16_int8))) { - skip |= LogError(pnext_vuid, instance, loc.dot(Field::pNext), - "includes a pointer to a VkStructureType " - "(VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_FLOAT16_INT8_FEATURES), but its parent extension " - "VK_KHR_shader_float16_int8 has not been enabled."); - } - if (is_const_param) { - [[maybe_unused]] const Location pNext_loc = loc.pNext(Struct::VkPhysicalDeviceShaderFloat16Int8Features); - if (!IsExtEnabled(device_extensions.vk_khr_shader_float16_int8)) { - skip |= LogError(pnext_vuid, instance, pNext_loc, - "includes a pointer to a VkPhysicalDeviceShaderFloat16Int8Features, but when creating " - "VkDevice, the parent extension " - "(VK_KHR_shader_float16_int8) was not included in ppEnabledExtensionNames."); - } - VkPhysicalDeviceShaderFloat16Int8Features* structure = (VkPhysicalDeviceShaderFloat16Int8Features*)header; - skip |= ValidateBool32(pNext_loc.dot(Field::shaderFloat16), structure->shaderFloat16); - - skip |= ValidateBool32(pNext_loc.dot(Field::shaderInt8), structure->shaderInt8); - } - } break; - - // Validation code for VkPhysicalDeviceFloatControlsProperties structure members - case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FLOAT_CONTROLS_PROPERTIES: { // Covers - // VUID-VkPhysicalDeviceFloatControlsProperties-sType-sType - - if ((is_physdev_api && !SupportedByPdev(physical_device, vvl::Extension::_VK_KHR_shader_float_controls)) || - (!is_physdev_api && !IsExtEnabled(device_extensions.vk_khr_shader_float_controls))) { - skip |= LogError(pnext_vuid, instance, loc.dot(Field::pNext), - "includes a pointer to a VkStructureType " - "(VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FLOAT_CONTROLS_PROPERTIES), but its parent extension " - "VK_KHR_shader_float_controls has not been enabled."); - } - } break; - // Validation code for VkDescriptorSetLayoutBindingFlagsCreateInfo structure members case VK_STRUCTURE_TYPE_DESCRIPTOR_SET_LAYOUT_BINDING_FLAGS_CREATE_INFO: { // Covers // VUID-VkDescriptorSetLayoutBindingFlagsCreateInfo-sType-sType @@ -1405,100 +5468,6 @@ } } break; - // Validation code for VkPhysicalDeviceDescriptorIndexingFeatures structure members - case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DESCRIPTOR_INDEXING_FEATURES: { // Covers - // VUID-VkPhysicalDeviceDescriptorIndexingFeatures-sType-sType - - if ((is_physdev_api && !SupportedByPdev(physical_device, vvl::Extension::_VK_EXT_descriptor_indexing)) || - (!is_physdev_api && !IsExtEnabled(device_extensions.vk_ext_descriptor_indexing))) { - skip |= LogError(pnext_vuid, instance, loc.dot(Field::pNext), - "includes a pointer to a VkStructureType " - "(VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DESCRIPTOR_INDEXING_FEATURES), but its parent extension " - "VK_EXT_descriptor_indexing has not been enabled."); - } - if (is_const_param) { - [[maybe_unused]] const Location pNext_loc = loc.pNext(Struct::VkPhysicalDeviceDescriptorIndexingFeatures); - if (!IsExtEnabled(device_extensions.vk_ext_descriptor_indexing)) { - skip |= LogError(pnext_vuid, instance, pNext_loc, - "includes a pointer to a VkPhysicalDeviceDescriptorIndexingFeatures, but when creating " - "VkDevice, the parent extension " - "(VK_EXT_descriptor_indexing) was not included in ppEnabledExtensionNames."); - } - VkPhysicalDeviceDescriptorIndexingFeatures* structure = (VkPhysicalDeviceDescriptorIndexingFeatures*)header; - skip |= ValidateBool32(pNext_loc.dot(Field::shaderInputAttachmentArrayDynamicIndexing), - structure->shaderInputAttachmentArrayDynamicIndexing); - - skip |= ValidateBool32(pNext_loc.dot(Field::shaderUniformTexelBufferArrayDynamicIndexing), - structure->shaderUniformTexelBufferArrayDynamicIndexing); - - skip |= ValidateBool32(pNext_loc.dot(Field::shaderStorageTexelBufferArrayDynamicIndexing), - structure->shaderStorageTexelBufferArrayDynamicIndexing); - - skip |= ValidateBool32(pNext_loc.dot(Field::shaderUniformBufferArrayNonUniformIndexing), - structure->shaderUniformBufferArrayNonUniformIndexing); - - skip |= ValidateBool32(pNext_loc.dot(Field::shaderSampledImageArrayNonUniformIndexing), - structure->shaderSampledImageArrayNonUniformIndexing); - - skip |= ValidateBool32(pNext_loc.dot(Field::shaderStorageBufferArrayNonUniformIndexing), - structure->shaderStorageBufferArrayNonUniformIndexing); - - skip |= ValidateBool32(pNext_loc.dot(Field::shaderStorageImageArrayNonUniformIndexing), - structure->shaderStorageImageArrayNonUniformIndexing); - - skip |= ValidateBool32(pNext_loc.dot(Field::shaderInputAttachmentArrayNonUniformIndexing), - structure->shaderInputAttachmentArrayNonUniformIndexing); - - skip |= ValidateBool32(pNext_loc.dot(Field::shaderUniformTexelBufferArrayNonUniformIndexing), - structure->shaderUniformTexelBufferArrayNonUniformIndexing); - - skip |= ValidateBool32(pNext_loc.dot(Field::shaderStorageTexelBufferArrayNonUniformIndexing), - structure->shaderStorageTexelBufferArrayNonUniformIndexing); - - skip |= ValidateBool32(pNext_loc.dot(Field::descriptorBindingUniformBufferUpdateAfterBind), - structure->descriptorBindingUniformBufferUpdateAfterBind); - - skip |= ValidateBool32(pNext_loc.dot(Field::descriptorBindingSampledImageUpdateAfterBind), - structure->descriptorBindingSampledImageUpdateAfterBind); - - skip |= ValidateBool32(pNext_loc.dot(Field::descriptorBindingStorageImageUpdateAfterBind), - structure->descriptorBindingStorageImageUpdateAfterBind); - - skip |= ValidateBool32(pNext_loc.dot(Field::descriptorBindingStorageBufferUpdateAfterBind), - structure->descriptorBindingStorageBufferUpdateAfterBind); - - skip |= ValidateBool32(pNext_loc.dot(Field::descriptorBindingUniformTexelBufferUpdateAfterBind), - structure->descriptorBindingUniformTexelBufferUpdateAfterBind); - - skip |= ValidateBool32(pNext_loc.dot(Field::descriptorBindingStorageTexelBufferUpdateAfterBind), - structure->descriptorBindingStorageTexelBufferUpdateAfterBind); - - skip |= ValidateBool32(pNext_loc.dot(Field::descriptorBindingUpdateUnusedWhilePending), - structure->descriptorBindingUpdateUnusedWhilePending); - - skip |= ValidateBool32(pNext_loc.dot(Field::descriptorBindingPartiallyBound), - structure->descriptorBindingPartiallyBound); - - skip |= ValidateBool32(pNext_loc.dot(Field::descriptorBindingVariableDescriptorCount), - structure->descriptorBindingVariableDescriptorCount); - - skip |= ValidateBool32(pNext_loc.dot(Field::runtimeDescriptorArray), structure->runtimeDescriptorArray); - } - } break; - - // Validation code for VkPhysicalDeviceDescriptorIndexingProperties structure members - case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DESCRIPTOR_INDEXING_PROPERTIES: { // Covers - // VUID-VkPhysicalDeviceDescriptorIndexingProperties-sType-sType - - if ((is_physdev_api && !SupportedByPdev(physical_device, vvl::Extension::_VK_EXT_descriptor_indexing)) || - (!is_physdev_api && !IsExtEnabled(device_extensions.vk_ext_descriptor_indexing))) { - skip |= LogError(pnext_vuid, instance, loc.dot(Field::pNext), - "includes a pointer to a VkStructureType " - "(VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DESCRIPTOR_INDEXING_PROPERTIES), but its parent extension " - "VK_EXT_descriptor_indexing has not been enabled."); - } - } break; - // Validation code for VkDescriptorSetVariableDescriptorCountAllocateInfo structure members case VK_STRUCTURE_TYPE_DESCRIPTOR_SET_VARIABLE_DESCRIPTOR_COUNT_ALLOCATE_INFO: { // Covers // VUID-VkDescriptorSetVariableDescriptorCountAllocateInfo-sType-sType @@ -1573,43 +5542,6 @@ } } break; - // Validation code for VkPhysicalDeviceDepthStencilResolveProperties structure members - case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DEPTH_STENCIL_RESOLVE_PROPERTIES: { // Covers - // VUID-VkPhysicalDeviceDepthStencilResolveProperties-sType-sType - - if ((is_physdev_api && !SupportedByPdev(physical_device, vvl::Extension::_VK_KHR_depth_stencil_resolve)) || - (!is_physdev_api && !IsExtEnabled(device_extensions.vk_khr_depth_stencil_resolve))) { - skip |= LogError(pnext_vuid, instance, loc.dot(Field::pNext), - "includes a pointer to a VkStructureType " - "(VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DEPTH_STENCIL_RESOLVE_PROPERTIES), but its parent extension " - "VK_KHR_depth_stencil_resolve has not been enabled."); - } - } break; - - // Validation code for VkPhysicalDeviceScalarBlockLayoutFeatures structure members - case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SCALAR_BLOCK_LAYOUT_FEATURES: { // Covers - // VUID-VkPhysicalDeviceScalarBlockLayoutFeatures-sType-sType - - if ((is_physdev_api && !SupportedByPdev(physical_device, vvl::Extension::_VK_EXT_scalar_block_layout)) || - (!is_physdev_api && !IsExtEnabled(device_extensions.vk_ext_scalar_block_layout))) { - skip |= LogError(pnext_vuid, instance, loc.dot(Field::pNext), - "includes a pointer to a VkStructureType " - "(VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SCALAR_BLOCK_LAYOUT_FEATURES), but its parent extension " - "VK_EXT_scalar_block_layout has not been enabled."); - } - if (is_const_param) { - [[maybe_unused]] const Location pNext_loc = loc.pNext(Struct::VkPhysicalDeviceScalarBlockLayoutFeatures); - if (!IsExtEnabled(device_extensions.vk_ext_scalar_block_layout)) { - skip |= LogError(pnext_vuid, instance, pNext_loc, - "includes a pointer to a VkPhysicalDeviceScalarBlockLayoutFeatures, but when creating " - "VkDevice, the parent extension " - "(VK_EXT_scalar_block_layout) was not included in ppEnabledExtensionNames."); - } - VkPhysicalDeviceScalarBlockLayoutFeatures* structure = (VkPhysicalDeviceScalarBlockLayoutFeatures*)header; - skip |= ValidateBool32(pNext_loc.dot(Field::scalarBlockLayout), structure->scalarBlockLayout); - } - } break; - // Validation code for VkImageStencilUsageCreateInfo structure members case VK_STRUCTURE_TYPE_IMAGE_STENCIL_USAGE_CREATE_INFO: { // Covers VUID-VkImageStencilUsageCreateInfo-sType-sType @@ -1657,72 +5589,6 @@ } } break; - // Validation code for VkPhysicalDeviceSamplerFilterMinmaxProperties structure members - case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SAMPLER_FILTER_MINMAX_PROPERTIES: { // Covers - // VUID-VkPhysicalDeviceSamplerFilterMinmaxProperties-sType-sType - - if ((is_physdev_api && !SupportedByPdev(physical_device, vvl::Extension::_VK_EXT_sampler_filter_minmax)) || - (!is_physdev_api && !IsExtEnabled(device_extensions.vk_ext_sampler_filter_minmax))) { - skip |= LogError(pnext_vuid, instance, loc.dot(Field::pNext), - "includes a pointer to a VkStructureType " - "(VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SAMPLER_FILTER_MINMAX_PROPERTIES), but its parent extension " - "VK_EXT_sampler_filter_minmax has not been enabled."); - } - } break; - - // Validation code for VkPhysicalDeviceVulkanMemoryModelFeatures structure members - case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_MEMORY_MODEL_FEATURES: { // Covers - // VUID-VkPhysicalDeviceVulkanMemoryModelFeatures-sType-sType - - if ((is_physdev_api && !SupportedByPdev(physical_device, vvl::Extension::_VK_KHR_vulkan_memory_model)) || - (!is_physdev_api && !IsExtEnabled(device_extensions.vk_khr_vulkan_memory_model))) { - skip |= LogError(pnext_vuid, instance, loc.dot(Field::pNext), - "includes a pointer to a VkStructureType " - "(VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_MEMORY_MODEL_FEATURES), but its parent extension " - "VK_KHR_vulkan_memory_model has not been enabled."); - } - if (is_const_param) { - [[maybe_unused]] const Location pNext_loc = loc.pNext(Struct::VkPhysicalDeviceVulkanMemoryModelFeatures); - if (!IsExtEnabled(device_extensions.vk_khr_vulkan_memory_model)) { - skip |= LogError(pnext_vuid, instance, pNext_loc, - "includes a pointer to a VkPhysicalDeviceVulkanMemoryModelFeatures, but when creating " - "VkDevice, the parent extension " - "(VK_KHR_vulkan_memory_model) was not included in ppEnabledExtensionNames."); - } - VkPhysicalDeviceVulkanMemoryModelFeatures* structure = (VkPhysicalDeviceVulkanMemoryModelFeatures*)header; - skip |= ValidateBool32(pNext_loc.dot(Field::vulkanMemoryModel), structure->vulkanMemoryModel); - - skip |= ValidateBool32(pNext_loc.dot(Field::vulkanMemoryModelDeviceScope), structure->vulkanMemoryModelDeviceScope); - - skip |= ValidateBool32(pNext_loc.dot(Field::vulkanMemoryModelAvailabilityVisibilityChains), - structure->vulkanMemoryModelAvailabilityVisibilityChains); - } - } break; - - // Validation code for VkPhysicalDeviceImagelessFramebufferFeatures structure members - case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGELESS_FRAMEBUFFER_FEATURES: { // Covers - // VUID-VkPhysicalDeviceImagelessFramebufferFeatures-sType-sType - - if ((is_physdev_api && !SupportedByPdev(physical_device, vvl::Extension::_VK_KHR_imageless_framebuffer)) || - (!is_physdev_api && !IsExtEnabled(device_extensions.vk_khr_imageless_framebuffer))) { - skip |= LogError(pnext_vuid, instance, loc.dot(Field::pNext), - "includes a pointer to a VkStructureType " - "(VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGELESS_FRAMEBUFFER_FEATURES), but its parent extension " - "VK_KHR_imageless_framebuffer has not been enabled."); - } - if (is_const_param) { - [[maybe_unused]] const Location pNext_loc = loc.pNext(Struct::VkPhysicalDeviceImagelessFramebufferFeatures); - if (!IsExtEnabled(device_extensions.vk_khr_imageless_framebuffer)) { - skip |= LogError(pnext_vuid, instance, pNext_loc, - "includes a pointer to a VkPhysicalDeviceImagelessFramebufferFeatures, but when creating " - "VkDevice, the parent extension " - "(VK_KHR_imageless_framebuffer) was not included in ppEnabledExtensionNames."); - } - VkPhysicalDeviceImagelessFramebufferFeatures* structure = (VkPhysicalDeviceImagelessFramebufferFeatures*)header; - skip |= ValidateBool32(pNext_loc.dot(Field::imagelessFramebuffer), structure->imagelessFramebuffer); - } - } break; - // Validation code for VkFramebufferAttachmentsCreateInfo structure members case VK_STRUCTURE_TYPE_FRAMEBUFFER_ATTACHMENTS_CREATE_INFO: { // Covers VUID-VkFramebufferAttachmentsCreateInfo-sType-sType @@ -1797,72 +5663,6 @@ } } break; - // Validation code for VkPhysicalDeviceUniformBufferStandardLayoutFeatures structure members - case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_UNIFORM_BUFFER_STANDARD_LAYOUT_FEATURES: { // Covers - // VUID-VkPhysicalDeviceUniformBufferStandardLayoutFeatures-sType-sType - - if ((is_physdev_api && !SupportedByPdev(physical_device, vvl::Extension::_VK_KHR_uniform_buffer_standard_layout)) || - (!is_physdev_api && !IsExtEnabled(device_extensions.vk_khr_uniform_buffer_standard_layout))) { - skip |= LogError( - pnext_vuid, instance, loc.dot(Field::pNext), - "includes a pointer to a VkStructureType " - "(VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_UNIFORM_BUFFER_STANDARD_LAYOUT_FEATURES), but its parent extension " - "VK_KHR_uniform_buffer_standard_layout has not been enabled."); - } - if (is_const_param) { - [[maybe_unused]] const Location pNext_loc = loc.pNext(Struct::VkPhysicalDeviceUniformBufferStandardLayoutFeatures); - if (!IsExtEnabled(device_extensions.vk_khr_uniform_buffer_standard_layout)) { - skip |= LogError(pnext_vuid, instance, pNext_loc, - "includes a pointer to a VkPhysicalDeviceUniformBufferStandardLayoutFeatures, but when " - "creating VkDevice, the parent extension " - "(VK_KHR_uniform_buffer_standard_layout) was not included in ppEnabledExtensionNames."); - } - VkPhysicalDeviceUniformBufferStandardLayoutFeatures* structure = - (VkPhysicalDeviceUniformBufferStandardLayoutFeatures*)header; - skip |= ValidateBool32(pNext_loc.dot(Field::uniformBufferStandardLayout), structure->uniformBufferStandardLayout); - } - } break; - - // Validation code for VkPhysicalDeviceShaderSubgroupExtendedTypesFeatures structure members - case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_SUBGROUP_EXTENDED_TYPES_FEATURES: { // Covers - // VUID-VkPhysicalDeviceShaderSubgroupExtendedTypesFeatures-sType-sType - - if ((is_physdev_api && !SupportedByPdev(physical_device, vvl::Extension::_VK_KHR_shader_subgroup_extended_types)) || - (!is_physdev_api && !IsExtEnabled(device_extensions.vk_khr_shader_subgroup_extended_types))) { - skip |= LogError( - pnext_vuid, instance, loc.dot(Field::pNext), - "includes a pointer to a VkStructureType " - "(VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_SUBGROUP_EXTENDED_TYPES_FEATURES), but its parent extension " - "VK_KHR_shader_subgroup_extended_types has not been enabled."); - } - } break; - - // Validation code for VkPhysicalDeviceSeparateDepthStencilLayoutsFeatures structure members - case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SEPARATE_DEPTH_STENCIL_LAYOUTS_FEATURES: { // Covers - // VUID-VkPhysicalDeviceSeparateDepthStencilLayoutsFeatures-sType-sType - - if ((is_physdev_api && !SupportedByPdev(physical_device, vvl::Extension::_VK_KHR_separate_depth_stencil_layouts)) || - (!is_physdev_api && !IsExtEnabled(device_extensions.vk_khr_separate_depth_stencil_layouts))) { - skip |= LogError( - pnext_vuid, instance, loc.dot(Field::pNext), - "includes a pointer to a VkStructureType " - "(VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SEPARATE_DEPTH_STENCIL_LAYOUTS_FEATURES), but its parent extension " - "VK_KHR_separate_depth_stencil_layouts has not been enabled."); - } - if (is_const_param) { - [[maybe_unused]] const Location pNext_loc = loc.pNext(Struct::VkPhysicalDeviceSeparateDepthStencilLayoutsFeatures); - if (!IsExtEnabled(device_extensions.vk_khr_separate_depth_stencil_layouts)) { - skip |= LogError(pnext_vuid, instance, pNext_loc, - "includes a pointer to a VkPhysicalDeviceSeparateDepthStencilLayoutsFeatures, but when " - "creating VkDevice, the parent extension " - "(VK_KHR_separate_depth_stencil_layouts) was not included in ppEnabledExtensionNames."); - } - VkPhysicalDeviceSeparateDepthStencilLayoutsFeatures* structure = - (VkPhysicalDeviceSeparateDepthStencilLayoutsFeatures*)header; - skip |= ValidateBool32(pNext_loc.dot(Field::separateDepthStencilLayouts), structure->separateDepthStencilLayouts); - } - } break; - // Validation code for VkAttachmentReferenceStencilLayout structure members case VK_STRUCTURE_TYPE_ATTACHMENT_REFERENCE_STENCIL_LAYOUT: { // Covers VUID-VkAttachmentReferenceStencilLayout-sType-sType @@ -1913,67 +5713,6 @@ } } break; - // Validation code for VkPhysicalDeviceHostQueryResetFeatures structure members - case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_HOST_QUERY_RESET_FEATURES: { // Covers - // VUID-VkPhysicalDeviceHostQueryResetFeatures-sType-sType - - if ((is_physdev_api && !SupportedByPdev(physical_device, vvl::Extension::_VK_EXT_host_query_reset)) || - (!is_physdev_api && !IsExtEnabled(device_extensions.vk_ext_host_query_reset))) { - skip |= LogError(pnext_vuid, instance, loc.dot(Field::pNext), - "includes a pointer to a VkStructureType " - "(VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_HOST_QUERY_RESET_FEATURES), but its parent extension " - "VK_EXT_host_query_reset has not been enabled."); - } - if (is_const_param) { - [[maybe_unused]] const Location pNext_loc = loc.pNext(Struct::VkPhysicalDeviceHostQueryResetFeatures); - if (!IsExtEnabled(device_extensions.vk_ext_host_query_reset)) { - skip |= LogError(pnext_vuid, instance, pNext_loc, - "includes a pointer to a VkPhysicalDeviceHostQueryResetFeatures, but when creating VkDevice, " - "the parent extension " - "(VK_EXT_host_query_reset) was not included in ppEnabledExtensionNames."); - } - VkPhysicalDeviceHostQueryResetFeatures* structure = (VkPhysicalDeviceHostQueryResetFeatures*)header; - skip |= ValidateBool32(pNext_loc.dot(Field::hostQueryReset), structure->hostQueryReset); - } - } break; - - // Validation code for VkPhysicalDeviceTimelineSemaphoreFeatures structure members - case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TIMELINE_SEMAPHORE_FEATURES: { // Covers - // VUID-VkPhysicalDeviceTimelineSemaphoreFeatures-sType-sType - - if ((is_physdev_api && !SupportedByPdev(physical_device, vvl::Extension::_VK_KHR_timeline_semaphore)) || - (!is_physdev_api && !IsExtEnabled(device_extensions.vk_khr_timeline_semaphore))) { - skip |= LogError(pnext_vuid, instance, loc.dot(Field::pNext), - "includes a pointer to a VkStructureType " - "(VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TIMELINE_SEMAPHORE_FEATURES), but its parent extension " - "VK_KHR_timeline_semaphore has not been enabled."); - } - if (is_const_param) { - [[maybe_unused]] const Location pNext_loc = loc.pNext(Struct::VkPhysicalDeviceTimelineSemaphoreFeatures); - if (!IsExtEnabled(device_extensions.vk_khr_timeline_semaphore)) { - skip |= LogError(pnext_vuid, instance, pNext_loc, - "includes a pointer to a VkPhysicalDeviceTimelineSemaphoreFeatures, but when creating " - "VkDevice, the parent extension " - "(VK_KHR_timeline_semaphore) was not included in ppEnabledExtensionNames."); - } - VkPhysicalDeviceTimelineSemaphoreFeatures* structure = (VkPhysicalDeviceTimelineSemaphoreFeatures*)header; - skip |= ValidateBool32(pNext_loc.dot(Field::timelineSemaphore), structure->timelineSemaphore); - } - } break; - - // Validation code for VkPhysicalDeviceTimelineSemaphoreProperties structure members - case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TIMELINE_SEMAPHORE_PROPERTIES: { // Covers - // VUID-VkPhysicalDeviceTimelineSemaphoreProperties-sType-sType - - if ((is_physdev_api && !SupportedByPdev(physical_device, vvl::Extension::_VK_KHR_timeline_semaphore)) || - (!is_physdev_api && !IsExtEnabled(device_extensions.vk_khr_timeline_semaphore))) { - skip |= LogError(pnext_vuid, instance, loc.dot(Field::pNext), - "includes a pointer to a VkStructureType " - "(VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TIMELINE_SEMAPHORE_PROPERTIES), but its parent extension " - "VK_KHR_timeline_semaphore has not been enabled."); - } - } break; - // Validation code for VkSemaphoreTypeCreateInfo structure members case VK_STRUCTURE_TYPE_SEMAPHORE_TYPE_CREATE_INFO: { // Covers VUID-VkSemaphoreTypeCreateInfo-sType-sType @@ -2008,36 +5747,6 @@ } } break; - // Validation code for VkPhysicalDeviceBufferDeviceAddressFeatures structure members - case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_BUFFER_DEVICE_ADDRESS_FEATURES: { // Covers - // VUID-VkPhysicalDeviceBufferDeviceAddressFeatures-sType-sType - - if ((is_physdev_api && !SupportedByPdev(physical_device, vvl::Extension::_VK_KHR_buffer_device_address)) || - (!is_physdev_api && !IsExtEnabled(device_extensions.vk_khr_buffer_device_address))) { - skip |= LogError(pnext_vuid, instance, loc.dot(Field::pNext), - "includes a pointer to a VkStructureType " - "(VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_BUFFER_DEVICE_ADDRESS_FEATURES), but its parent extension " - "VK_KHR_buffer_device_address has not been enabled."); - } - if (is_const_param) { - [[maybe_unused]] const Location pNext_loc = loc.pNext(Struct::VkPhysicalDeviceBufferDeviceAddressFeatures); - if (!IsExtEnabled(device_extensions.vk_khr_buffer_device_address)) { - skip |= LogError(pnext_vuid, instance, pNext_loc, - "includes a pointer to a VkPhysicalDeviceBufferDeviceAddressFeatures, but when creating " - "VkDevice, the parent extension " - "(VK_KHR_buffer_device_address) was not included in ppEnabledExtensionNames."); - } - VkPhysicalDeviceBufferDeviceAddressFeatures* structure = (VkPhysicalDeviceBufferDeviceAddressFeatures*)header; - skip |= ValidateBool32(pNext_loc.dot(Field::bufferDeviceAddress), structure->bufferDeviceAddress); - - skip |= ValidateBool32(pNext_loc.dot(Field::bufferDeviceAddressCaptureReplay), - structure->bufferDeviceAddressCaptureReplay); - - skip |= - ValidateBool32(pNext_loc.dot(Field::bufferDeviceAddressMultiDevice), structure->bufferDeviceAddressMultiDevice); - } - } break; - // Validation code for VkBufferOpaqueCaptureAddressCreateInfo structure members case VK_STRUCTURE_TYPE_BUFFER_OPAQUE_CAPTURE_ADDRESS_CREATE_INFO: { // Covers // VUID-VkBufferOpaqueCaptureAddressCreateInfo-sType-sType @@ -2064,77 +5773,6 @@ } } break; - // Validation code for VkPhysicalDeviceVulkan13Features structure members - case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_1_3_FEATURES: { // Covers VUID-VkPhysicalDeviceVulkan13Features-sType-sType - - if (is_physdev_api) { - VkPhysicalDeviceProperties device_properties = {}; - DispatchGetPhysicalDeviceProperties(caller_physical_device, &device_properties); - if (device_properties.apiVersion < VK_API_VERSION_1_3) { - skip |= - LogError(pnext_vuid, instance, loc.dot(Field::pNext), - "includes a pointer to a VkStructureType (VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_1_3_FEATURES) " - "which was added in VK_API_VERSION_1_3 but the " - "current effective API version is %s.", - StringAPIVersion(api_version).c_str()); - } - } - if (is_const_param) { - [[maybe_unused]] const Location pNext_loc = loc.pNext(Struct::VkPhysicalDeviceVulkan13Features); - VkPhysicalDeviceVulkan13Features* structure = (VkPhysicalDeviceVulkan13Features*)header; - skip |= ValidateBool32(pNext_loc.dot(Field::robustImageAccess), structure->robustImageAccess); - - skip |= ValidateBool32(pNext_loc.dot(Field::inlineUniformBlock), structure->inlineUniformBlock); - - skip |= ValidateBool32(pNext_loc.dot(Field::descriptorBindingInlineUniformBlockUpdateAfterBind), - structure->descriptorBindingInlineUniformBlockUpdateAfterBind); - - skip |= ValidateBool32(pNext_loc.dot(Field::pipelineCreationCacheControl), structure->pipelineCreationCacheControl); - - skip |= ValidateBool32(pNext_loc.dot(Field::privateData), structure->privateData); - - skip |= - ValidateBool32(pNext_loc.dot(Field::shaderDemoteToHelperInvocation), structure->shaderDemoteToHelperInvocation); - - skip |= ValidateBool32(pNext_loc.dot(Field::shaderTerminateInvocation), structure->shaderTerminateInvocation); - - skip |= ValidateBool32(pNext_loc.dot(Field::subgroupSizeControl), structure->subgroupSizeControl); - - skip |= ValidateBool32(pNext_loc.dot(Field::computeFullSubgroups), structure->computeFullSubgroups); - - skip |= ValidateBool32(pNext_loc.dot(Field::synchronization2), structure->synchronization2); - - skip |= ValidateBool32(pNext_loc.dot(Field::textureCompressionASTC_HDR), structure->textureCompressionASTC_HDR); - - skip |= ValidateBool32(pNext_loc.dot(Field::shaderZeroInitializeWorkgroupMemory), - structure->shaderZeroInitializeWorkgroupMemory); - - skip |= ValidateBool32(pNext_loc.dot(Field::dynamicRendering), structure->dynamicRendering); - - skip |= ValidateBool32(pNext_loc.dot(Field::shaderIntegerDotProduct), structure->shaderIntegerDotProduct); - - skip |= ValidateBool32(pNext_loc.dot(Field::maintenance4), structure->maintenance4); - } - } break; - - // Validation code for VkPhysicalDeviceVulkan13Properties structure members - case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_1_3_PROPERTIES: { // Covers - // VUID-VkPhysicalDeviceVulkan13Properties-sType-sType - - if (is_physdev_api) { - VkPhysicalDeviceProperties device_properties = {}; - DispatchGetPhysicalDeviceProperties(caller_physical_device, &device_properties); - if (device_properties.apiVersion < VK_API_VERSION_1_3) { - skip |= LogError( - pnext_vuid, instance, loc.dot(Field::pNext), - "includes a pointer to a VkStructureType (VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_1_3_PROPERTIES) which " - "was added in VK_API_VERSION_1_3 but the " - "current effective API version is %s.", - StringAPIVersion(api_version).c_str()); - } - } - } break; - // Validation code for VkPipelineCreationFeedbackCreateInfo structure members case VK_STRUCTURE_TYPE_PIPELINE_CREATION_FEEDBACK_CREATE_INFO: { // Covers // VUID-VkPipelineCreationFeedbackCreateInfo-sType-sType @@ -2177,84 +5815,6 @@ } } break; - // Validation code for VkPhysicalDeviceShaderTerminateInvocationFeatures structure members - case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_TERMINATE_INVOCATION_FEATURES: { // Covers - // VUID-VkPhysicalDeviceShaderTerminateInvocationFeatures-sType-sType - - if ((is_physdev_api && !SupportedByPdev(physical_device, vvl::Extension::_VK_KHR_shader_terminate_invocation)) || - (!is_physdev_api && !IsExtEnabled(device_extensions.vk_khr_shader_terminate_invocation))) { - skip |= - LogError(pnext_vuid, instance, loc.dot(Field::pNext), - "includes a pointer to a VkStructureType " - "(VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_TERMINATE_INVOCATION_FEATURES), but its parent extension " - "VK_KHR_shader_terminate_invocation has not been enabled."); - } - if (is_const_param) { - [[maybe_unused]] const Location pNext_loc = loc.pNext(Struct::VkPhysicalDeviceShaderTerminateInvocationFeatures); - if (!IsExtEnabled(device_extensions.vk_khr_shader_terminate_invocation)) { - skip |= LogError(pnext_vuid, instance, pNext_loc, - "includes a pointer to a VkPhysicalDeviceShaderTerminateInvocationFeatures, but when creating " - "VkDevice, the parent extension " - "(VK_KHR_shader_terminate_invocation) was not included in ppEnabledExtensionNames."); - } - VkPhysicalDeviceShaderTerminateInvocationFeatures* structure = - (VkPhysicalDeviceShaderTerminateInvocationFeatures*)header; - skip |= ValidateBool32(pNext_loc.dot(Field::shaderTerminateInvocation), structure->shaderTerminateInvocation); - } - } break; - - // Validation code for VkPhysicalDeviceShaderDemoteToHelperInvocationFeatures structure members - case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_DEMOTE_TO_HELPER_INVOCATION_FEATURES: { // Covers - // VUID-VkPhysicalDeviceShaderDemoteToHelperInvocationFeatures-sType-sType - - if ((is_physdev_api && !SupportedByPdev(physical_device, vvl::Extension::_VK_EXT_shader_demote_to_helper_invocation)) || - (!is_physdev_api && !IsExtEnabled(device_extensions.vk_ext_shader_demote_to_helper_invocation))) { - skip |= LogError( - pnext_vuid, instance, loc.dot(Field::pNext), - "includes a pointer to a VkStructureType " - "(VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_DEMOTE_TO_HELPER_INVOCATION_FEATURES), but its parent extension " - "VK_EXT_shader_demote_to_helper_invocation has not been enabled."); - } - if (is_const_param) { - [[maybe_unused]] const Location pNext_loc = - loc.pNext(Struct::VkPhysicalDeviceShaderDemoteToHelperInvocationFeatures); - if (!IsExtEnabled(device_extensions.vk_ext_shader_demote_to_helper_invocation)) { - skip |= LogError(pnext_vuid, instance, pNext_loc, - "includes a pointer to a VkPhysicalDeviceShaderDemoteToHelperInvocationFeatures, but when " - "creating VkDevice, the parent extension " - "(VK_EXT_shader_demote_to_helper_invocation) was not included in ppEnabledExtensionNames."); - } - VkPhysicalDeviceShaderDemoteToHelperInvocationFeatures* structure = - (VkPhysicalDeviceShaderDemoteToHelperInvocationFeatures*)header; - skip |= - ValidateBool32(pNext_loc.dot(Field::shaderDemoteToHelperInvocation), structure->shaderDemoteToHelperInvocation); - } - } break; - - // Validation code for VkPhysicalDevicePrivateDataFeatures structure members - case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PRIVATE_DATA_FEATURES: { // Covers - // VUID-VkPhysicalDevicePrivateDataFeatures-sType-sType - - if ((is_physdev_api && !SupportedByPdev(physical_device, vvl::Extension::_VK_EXT_private_data)) || - (!is_physdev_api && !IsExtEnabled(device_extensions.vk_ext_private_data))) { - skip |= LogError(pnext_vuid, instance, loc.dot(Field::pNext), - "includes a pointer to a VkStructureType " - "(VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PRIVATE_DATA_FEATURES), but its parent extension " - "VK_EXT_private_data has not been enabled."); - } - if (is_const_param) { - [[maybe_unused]] const Location pNext_loc = loc.pNext(Struct::VkPhysicalDevicePrivateDataFeatures); - if (!IsExtEnabled(device_extensions.vk_ext_private_data)) { - skip |= LogError(pnext_vuid, instance, pNext_loc, - "includes a pointer to a VkPhysicalDevicePrivateDataFeatures, but when creating VkDevice, the " - "parent extension " - "(VK_EXT_private_data) was not included in ppEnabledExtensionNames."); - } - VkPhysicalDevicePrivateDataFeatures* structure = (VkPhysicalDevicePrivateDataFeatures*)header; - skip |= ValidateBool32(pNext_loc.dot(Field::privateData), structure->privateData); - } - } break; - // Validation code for VkDevicePrivateDataCreateInfo structure members case VK_STRUCTURE_TYPE_DEVICE_PRIVATE_DATA_CREATE_INFO: { // Covers VUID-VkDevicePrivateDataCreateInfo-sType-sType @@ -2267,32 +5827,6 @@ } } break; - // Validation code for VkPhysicalDevicePipelineCreationCacheControlFeatures structure members - case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PIPELINE_CREATION_CACHE_CONTROL_FEATURES: { // Covers - // VUID-VkPhysicalDevicePipelineCreationCacheControlFeatures-sType-sType - - if ((is_physdev_api && !SupportedByPdev(physical_device, vvl::Extension::_VK_EXT_pipeline_creation_cache_control)) || - (!is_physdev_api && !IsExtEnabled(device_extensions.vk_ext_pipeline_creation_cache_control))) { - skip |= LogError( - pnext_vuid, instance, loc.dot(Field::pNext), - "includes a pointer to a VkStructureType " - "(VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PIPELINE_CREATION_CACHE_CONTROL_FEATURES), but its parent extension " - "VK_EXT_pipeline_creation_cache_control has not been enabled."); - } - if (is_const_param) { - [[maybe_unused]] const Location pNext_loc = loc.pNext(Struct::VkPhysicalDevicePipelineCreationCacheControlFeatures); - if (!IsExtEnabled(device_extensions.vk_ext_pipeline_creation_cache_control)) { - skip |= LogError(pnext_vuid, instance, pNext_loc, - "includes a pointer to a VkPhysicalDevicePipelineCreationCacheControlFeatures, but when " - "creating VkDevice, the parent extension " - "(VK_EXT_pipeline_creation_cache_control) was not included in ppEnabledExtensionNames."); - } - VkPhysicalDevicePipelineCreationCacheControlFeatures* structure = - (VkPhysicalDevicePipelineCreationCacheControlFeatures*)header; - skip |= ValidateBool32(pNext_loc.dot(Field::pipelineCreationCacheControl), structure->pipelineCreationCacheControl); - } - } break; - // Validation code for VkMemoryBarrier2 structure members case VK_STRUCTURE_TYPE_MEMORY_BARRIER_2: { // Covers VUID-VkMemoryBarrier2-sType-sType @@ -2328,121 +5862,6 @@ } } break; - // Validation code for VkPhysicalDeviceSynchronization2Features structure members - case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SYNCHRONIZATION_2_FEATURES: { // Covers - // VUID-VkPhysicalDeviceSynchronization2Features-sType-sType - - if ((is_physdev_api && !SupportedByPdev(physical_device, vvl::Extension::_VK_KHR_synchronization2)) || - (!is_physdev_api && !IsExtEnabled(device_extensions.vk_khr_synchronization2))) { - skip |= LogError(pnext_vuid, instance, loc.dot(Field::pNext), - "includes a pointer to a VkStructureType " - "(VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SYNCHRONIZATION_2_FEATURES), but its parent extension " - "VK_KHR_synchronization2 has not been enabled."); - } - if (is_const_param) { - [[maybe_unused]] const Location pNext_loc = loc.pNext(Struct::VkPhysicalDeviceSynchronization2Features); - if (!IsExtEnabled(device_extensions.vk_khr_synchronization2)) { - skip |= LogError(pnext_vuid, instance, pNext_loc, - "includes a pointer to a VkPhysicalDeviceSynchronization2Features, but when creating " - "VkDevice, the parent extension " - "(VK_KHR_synchronization2) was not included in ppEnabledExtensionNames."); - } - VkPhysicalDeviceSynchronization2Features* structure = (VkPhysicalDeviceSynchronization2Features*)header; - skip |= ValidateBool32(pNext_loc.dot(Field::synchronization2), structure->synchronization2); - } - } break; - - // Validation code for VkPhysicalDeviceZeroInitializeWorkgroupMemoryFeatures structure members - case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ZERO_INITIALIZE_WORKGROUP_MEMORY_FEATURES: { // Covers - // VUID-VkPhysicalDeviceZeroInitializeWorkgroupMemoryFeatures-sType-sType - - if ((is_physdev_api && !SupportedByPdev(physical_device, vvl::Extension::_VK_KHR_zero_initialize_workgroup_memory)) || - (!is_physdev_api && !IsExtEnabled(device_extensions.vk_khr_zero_initialize_workgroup_memory))) { - skip |= LogError( - pnext_vuid, instance, loc.dot(Field::pNext), - "includes a pointer to a VkStructureType " - "(VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ZERO_INITIALIZE_WORKGROUP_MEMORY_FEATURES), but its parent extension " - "VK_KHR_zero_initialize_workgroup_memory has not been enabled."); - } - if (is_const_param) { - [[maybe_unused]] const Location pNext_loc = - loc.pNext(Struct::VkPhysicalDeviceZeroInitializeWorkgroupMemoryFeatures); - if (!IsExtEnabled(device_extensions.vk_khr_zero_initialize_workgroup_memory)) { - skip |= LogError(pnext_vuid, instance, pNext_loc, - "includes a pointer to a VkPhysicalDeviceZeroInitializeWorkgroupMemoryFeatures, but when " - "creating VkDevice, the parent extension " - "(VK_KHR_zero_initialize_workgroup_memory) was not included in ppEnabledExtensionNames."); - } - VkPhysicalDeviceZeroInitializeWorkgroupMemoryFeatures* structure = - (VkPhysicalDeviceZeroInitializeWorkgroupMemoryFeatures*)header; - skip |= ValidateBool32(pNext_loc.dot(Field::shaderZeroInitializeWorkgroupMemory), - structure->shaderZeroInitializeWorkgroupMemory); - } - } break; - - // Validation code for VkPhysicalDeviceImageRobustnessFeatures structure members - case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_ROBUSTNESS_FEATURES: { // Covers - // VUID-VkPhysicalDeviceImageRobustnessFeatures-sType-sType - - if ((is_physdev_api && !SupportedByPdev(physical_device, vvl::Extension::_VK_EXT_image_robustness)) || - (!is_physdev_api && !IsExtEnabled(device_extensions.vk_ext_image_robustness))) { - skip |= LogError(pnext_vuid, instance, loc.dot(Field::pNext), - "includes a pointer to a VkStructureType " - "(VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_ROBUSTNESS_FEATURES), but its parent extension " - "VK_EXT_image_robustness has not been enabled."); - } - if (is_const_param) { - [[maybe_unused]] const Location pNext_loc = loc.pNext(Struct::VkPhysicalDeviceImageRobustnessFeatures); - if (!IsExtEnabled(device_extensions.vk_ext_image_robustness)) { - skip |= LogError(pnext_vuid, instance, pNext_loc, - "includes a pointer to a VkPhysicalDeviceImageRobustnessFeatures, but when creating VkDevice, " - "the parent extension " - "(VK_EXT_image_robustness) was not included in ppEnabledExtensionNames."); - } - VkPhysicalDeviceImageRobustnessFeatures* structure = (VkPhysicalDeviceImageRobustnessFeatures*)header; - skip |= ValidateBool32(pNext_loc.dot(Field::robustImageAccess), structure->robustImageAccess); - } - } break; - - // Validation code for VkPhysicalDeviceSubgroupSizeControlFeatures structure members - case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SUBGROUP_SIZE_CONTROL_FEATURES: { // Covers - // VUID-VkPhysicalDeviceSubgroupSizeControlFeatures-sType-sType - - if ((is_physdev_api && !SupportedByPdev(physical_device, vvl::Extension::_VK_EXT_subgroup_size_control)) || - (!is_physdev_api && !IsExtEnabled(device_extensions.vk_ext_subgroup_size_control))) { - skip |= LogError(pnext_vuid, instance, loc.dot(Field::pNext), - "includes a pointer to a VkStructureType " - "(VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SUBGROUP_SIZE_CONTROL_FEATURES), but its parent extension " - "VK_EXT_subgroup_size_control has not been enabled."); - } - if (is_const_param) { - [[maybe_unused]] const Location pNext_loc = loc.pNext(Struct::VkPhysicalDeviceSubgroupSizeControlFeatures); - if (!IsExtEnabled(device_extensions.vk_ext_subgroup_size_control)) { - skip |= LogError(pnext_vuid, instance, pNext_loc, - "includes a pointer to a VkPhysicalDeviceSubgroupSizeControlFeatures, but when creating " - "VkDevice, the parent extension " - "(VK_EXT_subgroup_size_control) was not included in ppEnabledExtensionNames."); - } - VkPhysicalDeviceSubgroupSizeControlFeatures* structure = (VkPhysicalDeviceSubgroupSizeControlFeatures*)header; - skip |= ValidateBool32(pNext_loc.dot(Field::subgroupSizeControl), structure->subgroupSizeControl); - - skip |= ValidateBool32(pNext_loc.dot(Field::computeFullSubgroups), structure->computeFullSubgroups); - } - } break; - - // Validation code for VkPhysicalDeviceSubgroupSizeControlProperties structure members - case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SUBGROUP_SIZE_CONTROL_PROPERTIES: { // Covers - // VUID-VkPhysicalDeviceSubgroupSizeControlProperties-sType-sType - - if ((is_physdev_api && !SupportedByPdev(physical_device, vvl::Extension::_VK_EXT_subgroup_size_control)) || - (!is_physdev_api && !IsExtEnabled(device_extensions.vk_ext_subgroup_size_control))) { - skip |= LogError(pnext_vuid, instance, loc.dot(Field::pNext), - "includes a pointer to a VkStructureType " - "(VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SUBGROUP_SIZE_CONTROL_PROPERTIES), but its parent extension " - "VK_EXT_subgroup_size_control has not been enabled."); - } - } break; - // Validation code for VkPipelineShaderStageRequiredSubgroupSizeCreateInfo structure members case VK_STRUCTURE_TYPE_PIPELINE_SHADER_STAGE_REQUIRED_SUBGROUP_SIZE_CREATE_INFO: { // Covers // VUID-VkPipelineShaderStageRequiredSubgroupSizeCreateInfo-sType-sType @@ -2457,46 +5876,6 @@ } } break; - // Validation code for VkPhysicalDeviceInlineUniformBlockFeatures structure members - case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_INLINE_UNIFORM_BLOCK_FEATURES: { // Covers - // VUID-VkPhysicalDeviceInlineUniformBlockFeatures-sType-sType - - if ((is_physdev_api && !SupportedByPdev(physical_device, vvl::Extension::_VK_EXT_inline_uniform_block)) || - (!is_physdev_api && !IsExtEnabled(device_extensions.vk_ext_inline_uniform_block))) { - skip |= LogError(pnext_vuid, instance, loc.dot(Field::pNext), - "includes a pointer to a VkStructureType " - "(VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_INLINE_UNIFORM_BLOCK_FEATURES), but its parent extension " - "VK_EXT_inline_uniform_block has not been enabled."); - } - if (is_const_param) { - [[maybe_unused]] const Location pNext_loc = loc.pNext(Struct::VkPhysicalDeviceInlineUniformBlockFeatures); - if (!IsExtEnabled(device_extensions.vk_ext_inline_uniform_block)) { - skip |= LogError(pnext_vuid, instance, pNext_loc, - "includes a pointer to a VkPhysicalDeviceInlineUniformBlockFeatures, but when creating " - "VkDevice, the parent extension " - "(VK_EXT_inline_uniform_block) was not included in ppEnabledExtensionNames."); - } - VkPhysicalDeviceInlineUniformBlockFeatures* structure = (VkPhysicalDeviceInlineUniformBlockFeatures*)header; - skip |= ValidateBool32(pNext_loc.dot(Field::inlineUniformBlock), structure->inlineUniformBlock); - - skip |= ValidateBool32(pNext_loc.dot(Field::descriptorBindingInlineUniformBlockUpdateAfterBind), - structure->descriptorBindingInlineUniformBlockUpdateAfterBind); - } - } break; - - // Validation code for VkPhysicalDeviceInlineUniformBlockProperties structure members - case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_INLINE_UNIFORM_BLOCK_PROPERTIES: { // Covers - // VUID-VkPhysicalDeviceInlineUniformBlockProperties-sType-sType - - if ((is_physdev_api && !SupportedByPdev(physical_device, vvl::Extension::_VK_EXT_inline_uniform_block)) || - (!is_physdev_api && !IsExtEnabled(device_extensions.vk_ext_inline_uniform_block))) { - skip |= LogError(pnext_vuid, instance, loc.dot(Field::pNext), - "includes a pointer to a VkStructureType " - "(VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_INLINE_UNIFORM_BLOCK_PROPERTIES), but its parent extension " - "VK_EXT_inline_uniform_block has not been enabled."); - } - } break; - // Validation code for VkWriteDescriptorSetInlineUniformBlock structure members case VK_STRUCTURE_TYPE_WRITE_DESCRIPTOR_SET_INLINE_UNIFORM_BLOCK: { // Covers // VUID-VkWriteDescriptorSetInlineUniformBlock-sType-sType @@ -2535,32 +5914,6 @@ } } break; - // Validation code for VkPhysicalDeviceTextureCompressionASTCHDRFeatures structure members - case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TEXTURE_COMPRESSION_ASTC_HDR_FEATURES: { // Covers - // VUID-VkPhysicalDeviceTextureCompressionASTCHDRFeatures-sType-sType - - if ((is_physdev_api && !SupportedByPdev(physical_device, vvl::Extension::_VK_EXT_texture_compression_astc_hdr)) || - (!is_physdev_api && !IsExtEnabled(device_extensions.vk_ext_texture_compression_astc_hdr))) { - skip |= - LogError(pnext_vuid, instance, loc.dot(Field::pNext), - "includes a pointer to a VkStructureType " - "(VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TEXTURE_COMPRESSION_ASTC_HDR_FEATURES), but its parent extension " - "VK_EXT_texture_compression_astc_hdr has not been enabled."); - } - if (is_const_param) { - [[maybe_unused]] const Location pNext_loc = loc.pNext(Struct::VkPhysicalDeviceTextureCompressionASTCHDRFeatures); - if (!IsExtEnabled(device_extensions.vk_ext_texture_compression_astc_hdr)) { - skip |= LogError(pnext_vuid, instance, pNext_loc, - "includes a pointer to a VkPhysicalDeviceTextureCompressionASTCHDRFeatures, but when creating " - "VkDevice, the parent extension " - "(VK_EXT_texture_compression_astc_hdr) was not included in ppEnabledExtensionNames."); - } - VkPhysicalDeviceTextureCompressionASTCHDRFeatures* structure = - (VkPhysicalDeviceTextureCompressionASTCHDRFeatures*)header; - skip |= ValidateBool32(pNext_loc.dot(Field::textureCompressionASTC_HDR), structure->textureCompressionASTC_HDR); - } - } break; - // Validation code for VkPipelineRenderingCreateInfo structure members case VK_STRUCTURE_TYPE_PIPELINE_RENDERING_CREATE_INFO: { // Covers VUID-VkPipelineRenderingCreateInfo-sType-sType @@ -2573,30 +5926,6 @@ } } break; - // Validation code for VkPhysicalDeviceDynamicRenderingFeatures structure members - case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DYNAMIC_RENDERING_FEATURES: { // Covers - // VUID-VkPhysicalDeviceDynamicRenderingFeatures-sType-sType - - if ((is_physdev_api && !SupportedByPdev(physical_device, vvl::Extension::_VK_KHR_dynamic_rendering)) || - (!is_physdev_api && !IsExtEnabled(device_extensions.vk_khr_dynamic_rendering))) { - skip |= LogError(pnext_vuid, instance, loc.dot(Field::pNext), - "includes a pointer to a VkStructureType " - "(VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DYNAMIC_RENDERING_FEATURES), but its parent extension " - "VK_KHR_dynamic_rendering has not been enabled."); - } - if (is_const_param) { - [[maybe_unused]] const Location pNext_loc = loc.pNext(Struct::VkPhysicalDeviceDynamicRenderingFeatures); - if (!IsExtEnabled(device_extensions.vk_khr_dynamic_rendering)) { - skip |= LogError(pnext_vuid, instance, pNext_loc, - "includes a pointer to a VkPhysicalDeviceDynamicRenderingFeatures, but when creating " - "VkDevice, the parent extension " - "(VK_KHR_dynamic_rendering) was not included in ppEnabledExtensionNames."); - } - VkPhysicalDeviceDynamicRenderingFeatures* structure = (VkPhysicalDeviceDynamicRenderingFeatures*)header; - skip |= ValidateBool32(pNext_loc.dot(Field::dynamicRendering), structure->dynamicRendering); - } - } break; - // Validation code for VkCommandBufferInheritanceRenderingInfo structure members case VK_STRUCTURE_TYPE_COMMAND_BUFFER_INHERITANCE_RENDERING_INFO: { // Covers // VUID-VkCommandBufferInheritanceRenderingInfo-sType-sType @@ -2638,59 +5967,6 @@ } } break; - // Validation code for VkPhysicalDeviceShaderIntegerDotProductFeatures structure members - case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_INTEGER_DOT_PRODUCT_FEATURES: { // Covers - // VUID-VkPhysicalDeviceShaderIntegerDotProductFeatures-sType-sType - - if ((is_physdev_api && !SupportedByPdev(physical_device, vvl::Extension::_VK_KHR_shader_integer_dot_product)) || - (!is_physdev_api && !IsExtEnabled(device_extensions.vk_khr_shader_integer_dot_product))) { - skip |= - LogError(pnext_vuid, instance, loc.dot(Field::pNext), - "includes a pointer to a VkStructureType " - "(VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_INTEGER_DOT_PRODUCT_FEATURES), but its parent extension " - "VK_KHR_shader_integer_dot_product has not been enabled."); - } - if (is_const_param) { - [[maybe_unused]] const Location pNext_loc = loc.pNext(Struct::VkPhysicalDeviceShaderIntegerDotProductFeatures); - if (!IsExtEnabled(device_extensions.vk_khr_shader_integer_dot_product)) { - skip |= LogError(pnext_vuid, instance, pNext_loc, - "includes a pointer to a VkPhysicalDeviceShaderIntegerDotProductFeatures, but when creating " - "VkDevice, the parent extension " - "(VK_KHR_shader_integer_dot_product) was not included in ppEnabledExtensionNames."); - } - VkPhysicalDeviceShaderIntegerDotProductFeatures* structure = - (VkPhysicalDeviceShaderIntegerDotProductFeatures*)header; - skip |= ValidateBool32(pNext_loc.dot(Field::shaderIntegerDotProduct), structure->shaderIntegerDotProduct); - } - } break; - - // Validation code for VkPhysicalDeviceShaderIntegerDotProductProperties structure members - case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_INTEGER_DOT_PRODUCT_PROPERTIES: { // Covers - // VUID-VkPhysicalDeviceShaderIntegerDotProductProperties-sType-sType - - if ((is_physdev_api && !SupportedByPdev(physical_device, vvl::Extension::_VK_KHR_shader_integer_dot_product)) || - (!is_physdev_api && !IsExtEnabled(device_extensions.vk_khr_shader_integer_dot_product))) { - skip |= - LogError(pnext_vuid, instance, loc.dot(Field::pNext), - "includes a pointer to a VkStructureType " - "(VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_INTEGER_DOT_PRODUCT_PROPERTIES), but its parent extension " - "VK_KHR_shader_integer_dot_product has not been enabled."); - } - } break; - - // Validation code for VkPhysicalDeviceTexelBufferAlignmentProperties structure members - case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TEXEL_BUFFER_ALIGNMENT_PROPERTIES: { // Covers - // VUID-VkPhysicalDeviceTexelBufferAlignmentProperties-sType-sType - - if ((is_physdev_api && !SupportedByPdev(physical_device, vvl::Extension::_VK_EXT_texel_buffer_alignment)) || - (!is_physdev_api && !IsExtEnabled(device_extensions.vk_ext_texel_buffer_alignment))) { - skip |= LogError(pnext_vuid, instance, loc.dot(Field::pNext), - "includes a pointer to a VkStructureType " - "(VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TEXEL_BUFFER_ALIGNMENT_PROPERTIES), but its parent extension " - "VK_EXT_texel_buffer_alignment has not been enabled."); - } - } break; - // Validation code for VkFormatProperties3 structure members case VK_STRUCTURE_TYPE_FORMAT_PROPERTIES_3: { // Covers VUID-VkFormatProperties3-sType-sType @@ -2703,43 +5979,6 @@ } } break; - // Validation code for VkPhysicalDeviceMaintenance4Features structure members - case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MAINTENANCE_4_FEATURES: { // Covers - // VUID-VkPhysicalDeviceMaintenance4Features-sType-sType - - if ((is_physdev_api && !SupportedByPdev(physical_device, vvl::Extension::_VK_KHR_maintenance4)) || - (!is_physdev_api && !IsExtEnabled(device_extensions.vk_khr_maintenance4))) { - skip |= LogError(pnext_vuid, instance, loc.dot(Field::pNext), - "includes a pointer to a VkStructureType " - "(VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MAINTENANCE_4_FEATURES), but its parent extension " - "VK_KHR_maintenance4 has not been enabled."); - } - if (is_const_param) { - [[maybe_unused]] const Location pNext_loc = loc.pNext(Struct::VkPhysicalDeviceMaintenance4Features); - if (!IsExtEnabled(device_extensions.vk_khr_maintenance4)) { - skip |= LogError(pnext_vuid, instance, pNext_loc, - "includes a pointer to a VkPhysicalDeviceMaintenance4Features, but when creating VkDevice, " - "the parent extension " - "(VK_KHR_maintenance4) was not included in ppEnabledExtensionNames."); - } - VkPhysicalDeviceMaintenance4Features* structure = (VkPhysicalDeviceMaintenance4Features*)header; - skip |= ValidateBool32(pNext_loc.dot(Field::maintenance4), structure->maintenance4); - } - } break; - - // Validation code for VkPhysicalDeviceMaintenance4Properties structure members - case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MAINTENANCE_4_PROPERTIES: { // Covers - // VUID-VkPhysicalDeviceMaintenance4Properties-sType-sType - - if ((is_physdev_api && !SupportedByPdev(physical_device, vvl::Extension::_VK_KHR_maintenance4)) || - (!is_physdev_api && !IsExtEnabled(device_extensions.vk_khr_maintenance4))) { - skip |= LogError(pnext_vuid, instance, loc.dot(Field::pNext), - "includes a pointer to a VkStructureType " - "(VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MAINTENANCE_4_PROPERTIES), but its parent extension " - "VK_KHR_maintenance4 has not been enabled."); - } - } break; - // No Validation code for VkImageSwapchainCreateInfoKHR structure members -- Covers // VUID-VkImageSwapchainCreateInfoKHR-sType-sType @@ -3380,9 +6619,6 @@ // No Validation code for VkD3D12FenceSubmitInfoKHR structure members -- Covers VUID-VkD3D12FenceSubmitInfoKHR-sType-sType #endif // VK_USE_PLATFORM_WIN32_KHR - // No Validation code for VkPhysicalDevicePushDescriptorPropertiesKHR structure members -- Covers - // VUID-VkPhysicalDevicePushDescriptorPropertiesKHR-sType-sType - // Validation code for VkPresentRegionsKHR structure members case VK_STRUCTURE_TYPE_PRESENT_REGIONS_KHR: { // Covers VUID-VkPresentRegionsKHR-sType-sType if (is_const_param) { @@ -3420,28 +6656,6 @@ // VUID-VkExportFenceWin32HandleInfoKHR-sType-sType #endif // VK_USE_PLATFORM_WIN32_KHR - // Validation code for VkPhysicalDevicePerformanceQueryFeaturesKHR structure members - case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PERFORMANCE_QUERY_FEATURES_KHR: { // Covers - // VUID-VkPhysicalDevicePerformanceQueryFeaturesKHR-sType-sType - if (is_const_param) { - [[maybe_unused]] const Location pNext_loc = loc.pNext(Struct::VkPhysicalDevicePerformanceQueryFeaturesKHR); - if (!IsExtEnabled(device_extensions.vk_khr_performance_query)) { - skip |= LogError(pnext_vuid, instance, pNext_loc, - "includes a pointer to a VkPhysicalDevicePerformanceQueryFeaturesKHR, but when creating " - "VkDevice, the parent extension " - "(VK_KHR_performance_query) was not included in ppEnabledExtensionNames."); - } - VkPhysicalDevicePerformanceQueryFeaturesKHR* structure = (VkPhysicalDevicePerformanceQueryFeaturesKHR*)header; - skip |= ValidateBool32(pNext_loc.dot(Field::performanceCounterQueryPools), structure->performanceCounterQueryPools); - - skip |= ValidateBool32(pNext_loc.dot(Field::performanceCounterMultipleQueryPools), - structure->performanceCounterMultipleQueryPools); - } - } break; - - // No Validation code for VkPhysicalDevicePerformanceQueryPropertiesKHR structure members -- Covers - // VUID-VkPhysicalDevicePerformanceQueryPropertiesKHR-sType-sType - // Validation code for VkQueryPoolPerformanceCreateInfoKHR structure members case VK_STRUCTURE_TYPE_QUERY_POOL_PERFORMANCE_CREATE_INFO_KHR: { // Covers // VUID-VkQueryPoolPerformanceCreateInfoKHR-sType-sType @@ -3461,77 +6675,6 @@ // No Validation code for VkPerformanceQuerySubmitInfoKHR structure members -- Covers // VUID-VkPerformanceQuerySubmitInfoKHR-sType-sType -#ifdef VK_ENABLE_BETA_EXTENSIONS - - // Validation code for VkPhysicalDevicePortabilitySubsetFeaturesKHR structure members - case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PORTABILITY_SUBSET_FEATURES_KHR: { // Covers - // VUID-VkPhysicalDevicePortabilitySubsetFeaturesKHR-sType-sType - if (is_const_param) { - [[maybe_unused]] const Location pNext_loc = loc.pNext(Struct::VkPhysicalDevicePortabilitySubsetFeaturesKHR); - if (!IsExtEnabled(device_extensions.vk_khr_portability_subset)) { - skip |= LogError(pnext_vuid, instance, pNext_loc, - "includes a pointer to a VkPhysicalDevicePortabilitySubsetFeaturesKHR, but when creating " - "VkDevice, the parent extension " - "(VK_KHR_portability_subset) was not included in ppEnabledExtensionNames."); - } - VkPhysicalDevicePortabilitySubsetFeaturesKHR* structure = (VkPhysicalDevicePortabilitySubsetFeaturesKHR*)header; - skip |= - ValidateBool32(pNext_loc.dot(Field::constantAlphaColorBlendFactors), structure->constantAlphaColorBlendFactors); - - skip |= ValidateBool32(pNext_loc.dot(Field::events), structure->events); - - skip |= ValidateBool32(pNext_loc.dot(Field::imageViewFormatReinterpretation), - structure->imageViewFormatReinterpretation); - - skip |= ValidateBool32(pNext_loc.dot(Field::imageViewFormatSwizzle), structure->imageViewFormatSwizzle); - - skip |= ValidateBool32(pNext_loc.dot(Field::imageView2DOn3DImage), structure->imageView2DOn3DImage); - - skip |= ValidateBool32(pNext_loc.dot(Field::multisampleArrayImage), structure->multisampleArrayImage); - - skip |= ValidateBool32(pNext_loc.dot(Field::mutableComparisonSamplers), structure->mutableComparisonSamplers); - - skip |= ValidateBool32(pNext_loc.dot(Field::pointPolygons), structure->pointPolygons); - - skip |= ValidateBool32(pNext_loc.dot(Field::samplerMipLodBias), structure->samplerMipLodBias); - - skip |= ValidateBool32(pNext_loc.dot(Field::separateStencilMaskRef), structure->separateStencilMaskRef); - - skip |= ValidateBool32(pNext_loc.dot(Field::shaderSampleRateInterpolationFunctions), - structure->shaderSampleRateInterpolationFunctions); - - skip |= ValidateBool32(pNext_loc.dot(Field::tessellationIsolines), structure->tessellationIsolines); - - skip |= ValidateBool32(pNext_loc.dot(Field::tessellationPointMode), structure->tessellationPointMode); - - skip |= ValidateBool32(pNext_loc.dot(Field::triangleFans), structure->triangleFans); - - skip |= ValidateBool32(pNext_loc.dot(Field::vertexAttributeAccessBeyondStride), - structure->vertexAttributeAccessBeyondStride); - } - } break; - - // No Validation code for VkPhysicalDevicePortabilitySubsetPropertiesKHR structure members -- Covers - // VUID-VkPhysicalDevicePortabilitySubsetPropertiesKHR-sType-sType -#endif // VK_ENABLE_BETA_EXTENSIONS - - // Validation code for VkPhysicalDeviceShaderClockFeaturesKHR structure members - case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_CLOCK_FEATURES_KHR: { // Covers - // VUID-VkPhysicalDeviceShaderClockFeaturesKHR-sType-sType - if (is_const_param) { - [[maybe_unused]] const Location pNext_loc = loc.pNext(Struct::VkPhysicalDeviceShaderClockFeaturesKHR); - if (!IsExtEnabled(device_extensions.vk_khr_shader_clock)) { - skip |= LogError(pnext_vuid, instance, pNext_loc, - "includes a pointer to a VkPhysicalDeviceShaderClockFeaturesKHR, but when creating VkDevice, " - "the parent extension " - "(VK_KHR_shader_clock) was not included in ppEnabledExtensionNames."); - } - VkPhysicalDeviceShaderClockFeaturesKHR* structure = (VkPhysicalDeviceShaderClockFeaturesKHR*)header; - skip |= ValidateBool32(pNext_loc.dot(Field::shaderSubgroupClock), structure->shaderSubgroupClock); - - skip |= ValidateBool32(pNext_loc.dot(Field::shaderDeviceClock), structure->shaderDeviceClock); - } - } break; // No Validation code for VkVideoDecodeH265ProfileInfoKHR structure members -- Covers // VUID-VkVideoDecodeH265ProfileInfoKHR-sType-sType @@ -3634,24 +6777,6 @@ } } break; - // Validation code for VkPhysicalDeviceGlobalPriorityQueryFeaturesKHR structure members - case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_GLOBAL_PRIORITY_QUERY_FEATURES_KHR: { // Covers - // VUID-VkPhysicalDeviceGlobalPriorityQueryFeaturesKHR-sType-sType - if (is_const_param) { - [[maybe_unused]] const Location pNext_loc = loc.pNext(Struct::VkPhysicalDeviceGlobalPriorityQueryFeaturesKHR); - if (!IsExtEnabled(device_extensions.vk_khr_global_priority) && - !IsExtEnabled(device_extensions.vk_ext_global_priority_query)) { - skip |= LogError( - pnext_vuid, instance, pNext_loc, - "includes a pointer to a VkPhysicalDeviceGlobalPriorityQueryFeaturesKHR, but when creating VkDevice, the " - "parent extension " - "(VK_KHR_global_priority or VK_EXT_global_priority_query) was not included in ppEnabledExtensionNames."); - } - VkPhysicalDeviceGlobalPriorityQueryFeaturesKHR* structure = (VkPhysicalDeviceGlobalPriorityQueryFeaturesKHR*)header; - skip |= ValidateBool32(pNext_loc.dot(Field::globalPriorityQuery), structure->globalPriorityQuery); - } - } break; - // No Validation code for VkQueueFamilyGlobalPriorityPropertiesKHR structure members -- Covers // VUID-VkQueueFamilyGlobalPriorityPropertiesKHR-sType-sType @@ -3684,69 +6809,12 @@ // No Validation code for VkPipelineFragmentShadingRateStateCreateInfoKHR structure members -- Covers // VUID-VkPipelineFragmentShadingRateStateCreateInfoKHR-sType-sType - // Validation code for VkPhysicalDeviceFragmentShadingRateFeaturesKHR structure members - case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_SHADING_RATE_FEATURES_KHR: { // Covers - // VUID-VkPhysicalDeviceFragmentShadingRateFeaturesKHR-sType-sType - if (is_const_param) { - [[maybe_unused]] const Location pNext_loc = loc.pNext(Struct::VkPhysicalDeviceFragmentShadingRateFeaturesKHR); - if (!IsExtEnabled(device_extensions.vk_khr_fragment_shading_rate)) { - skip |= LogError(pnext_vuid, instance, pNext_loc, - "includes a pointer to a VkPhysicalDeviceFragmentShadingRateFeaturesKHR, but when creating " - "VkDevice, the parent extension " - "(VK_KHR_fragment_shading_rate) was not included in ppEnabledExtensionNames."); - } - VkPhysicalDeviceFragmentShadingRateFeaturesKHR* structure = (VkPhysicalDeviceFragmentShadingRateFeaturesKHR*)header; - skip |= ValidateBool32(pNext_loc.dot(Field::pipelineFragmentShadingRate), structure->pipelineFragmentShadingRate); - - skip |= ValidateBool32(pNext_loc.dot(Field::primitiveFragmentShadingRate), structure->primitiveFragmentShadingRate); - - skip |= - ValidateBool32(pNext_loc.dot(Field::attachmentFragmentShadingRate), structure->attachmentFragmentShadingRate); - } - } break; - - // No Validation code for VkPhysicalDeviceFragmentShadingRatePropertiesKHR structure members -- Covers - // VUID-VkPhysicalDeviceFragmentShadingRatePropertiesKHR-sType-sType - - // Validation code for VkPhysicalDeviceDynamicRenderingLocalReadFeaturesKHR structure members - case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DYNAMIC_RENDERING_LOCAL_READ_FEATURES_KHR: { // Covers - // VUID-VkPhysicalDeviceDynamicRenderingLocalReadFeaturesKHR-sType-sType - if (is_const_param) { - [[maybe_unused]] const Location pNext_loc = loc.pNext(Struct::VkPhysicalDeviceDynamicRenderingLocalReadFeaturesKHR); - if (!IsExtEnabled(device_extensions.vk_khr_dynamic_rendering_local_read)) { - skip |= LogError(pnext_vuid, instance, pNext_loc, - "includes a pointer to a VkPhysicalDeviceDynamicRenderingLocalReadFeaturesKHR, but when " - "creating VkDevice, the parent extension " - "(VK_KHR_dynamic_rendering_local_read) was not included in ppEnabledExtensionNames."); - } - VkPhysicalDeviceDynamicRenderingLocalReadFeaturesKHR* structure = - (VkPhysicalDeviceDynamicRenderingLocalReadFeaturesKHR*)header; - skip |= ValidateBool32(pNext_loc.dot(Field::dynamicRenderingLocalRead), structure->dynamicRenderingLocalRead); - } - } break; - // No Validation code for VkRenderingAttachmentLocationInfoKHR structure members -- Covers // VUID-VkRenderingAttachmentLocationInfoKHR-sType-sType // No Validation code for VkRenderingInputAttachmentIndexInfoKHR structure members -- Covers // VUID-VkRenderingInputAttachmentIndexInfoKHR-sType-sType - // Validation code for VkPhysicalDeviceShaderQuadControlFeaturesKHR structure members - case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_QUAD_CONTROL_FEATURES_KHR: { // Covers - // VUID-VkPhysicalDeviceShaderQuadControlFeaturesKHR-sType-sType - if (is_const_param) { - [[maybe_unused]] const Location pNext_loc = loc.pNext(Struct::VkPhysicalDeviceShaderQuadControlFeaturesKHR); - if (!IsExtEnabled(device_extensions.vk_khr_shader_quad_control)) { - skip |= LogError(pnext_vuid, instance, pNext_loc, - "includes a pointer to a VkPhysicalDeviceShaderQuadControlFeaturesKHR, but when creating " - "VkDevice, the parent extension " - "(VK_KHR_shader_quad_control) was not included in ppEnabledExtensionNames."); - } - VkPhysicalDeviceShaderQuadControlFeaturesKHR* structure = (VkPhysicalDeviceShaderQuadControlFeaturesKHR*)header; - skip |= ValidateBool32(pNext_loc.dot(Field::shaderQuadControl), structure->shaderQuadControl); - } - } break; - // Validation code for VkSurfaceProtectedCapabilitiesKHR structure members case VK_STRUCTURE_TYPE_SURFACE_PROTECTED_CAPABILITIES_KHR: { // Covers VUID-VkSurfaceProtectedCapabilitiesKHR-sType-sType if (is_const_param) { @@ -3756,40 +6824,6 @@ } } break; - // Validation code for VkPhysicalDevicePresentWaitFeaturesKHR structure members - case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PRESENT_WAIT_FEATURES_KHR: { // Covers - // VUID-VkPhysicalDevicePresentWaitFeaturesKHR-sType-sType - if (is_const_param) { - [[maybe_unused]] const Location pNext_loc = loc.pNext(Struct::VkPhysicalDevicePresentWaitFeaturesKHR); - if (!IsExtEnabled(device_extensions.vk_khr_present_wait)) { - skip |= LogError(pnext_vuid, instance, pNext_loc, - "includes a pointer to a VkPhysicalDevicePresentWaitFeaturesKHR, but when creating VkDevice, " - "the parent extension " - "(VK_KHR_present_wait) was not included in ppEnabledExtensionNames."); - } - VkPhysicalDevicePresentWaitFeaturesKHR* structure = (VkPhysicalDevicePresentWaitFeaturesKHR*)header; - skip |= ValidateBool32(pNext_loc.dot(Field::presentWait), structure->presentWait); - } - } break; - - // Validation code for VkPhysicalDevicePipelineExecutablePropertiesFeaturesKHR structure members - case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PIPELINE_EXECUTABLE_PROPERTIES_FEATURES_KHR: { // Covers - // VUID-VkPhysicalDevicePipelineExecutablePropertiesFeaturesKHR-sType-sType - if (is_const_param) { - [[maybe_unused]] const Location pNext_loc = - loc.pNext(Struct::VkPhysicalDevicePipelineExecutablePropertiesFeaturesKHR); - if (!IsExtEnabled(device_extensions.vk_khr_pipeline_executable_properties)) { - skip |= LogError(pnext_vuid, instance, pNext_loc, - "includes a pointer to a VkPhysicalDevicePipelineExecutablePropertiesFeaturesKHR, but when " - "creating VkDevice, the parent extension " - "(VK_KHR_pipeline_executable_properties) was not included in ppEnabledExtensionNames."); - } - VkPhysicalDevicePipelineExecutablePropertiesFeaturesKHR* structure = - (VkPhysicalDevicePipelineExecutablePropertiesFeaturesKHR*)header; - skip |= ValidateBool32(pNext_loc.dot(Field::pipelineExecutableInfo), structure->pipelineExecutableInfo); - } - } break; - // Validation code for VkPipelineLibraryCreateInfoKHR structure members case VK_STRUCTURE_TYPE_PIPELINE_LIBRARY_CREATE_INFO_KHR: { // Covers VUID-VkPipelineLibraryCreateInfoKHR-sType-sType if (is_const_param) { @@ -3820,22 +6854,6 @@ } } break; - // Validation code for VkPhysicalDevicePresentIdFeaturesKHR structure members - case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PRESENT_ID_FEATURES_KHR: { // Covers - // VUID-VkPhysicalDevicePresentIdFeaturesKHR-sType-sType - if (is_const_param) { - [[maybe_unused]] const Location pNext_loc = loc.pNext(Struct::VkPhysicalDevicePresentIdFeaturesKHR); - if (!IsExtEnabled(device_extensions.vk_khr_present_id)) { - skip |= LogError(pnext_vuid, instance, pNext_loc, - "includes a pointer to a VkPhysicalDevicePresentIdFeaturesKHR, but when creating VkDevice, " - "the parent extension " - "(VK_KHR_present_id) was not included in ppEnabledExtensionNames."); - } - VkPhysicalDevicePresentIdFeaturesKHR* structure = (VkPhysicalDevicePresentIdFeaturesKHR*)header; - skip |= ValidateBool32(pNext_loc.dot(Field::presentId), structure->presentId); - } - } break; - // No Validation code for VkVideoEncodeCapabilitiesKHR structure members -- Covers // VUID-VkVideoEncodeCapabilitiesKHR-sType-sType @@ -3903,152 +6921,6 @@ // No Validation code for VkQueueFamilyCheckpointProperties2NV structure members -- Covers // VUID-VkQueueFamilyCheckpointProperties2NV-sType-sType - // Validation code for VkPhysicalDeviceFragmentShaderBarycentricFeaturesKHR structure members - case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_SHADER_BARYCENTRIC_FEATURES_KHR: { // Covers - // VUID-VkPhysicalDeviceFragmentShaderBarycentricFeaturesKHR-sType-sType - if (is_const_param) { - [[maybe_unused]] const Location pNext_loc = loc.pNext(Struct::VkPhysicalDeviceFragmentShaderBarycentricFeaturesKHR); - if (!IsExtEnabled(device_extensions.vk_khr_fragment_shader_barycentric) && - !IsExtEnabled(device_extensions.vk_nv_fragment_shader_barycentric)) { - skip |= LogError(pnext_vuid, instance, pNext_loc, - "includes a pointer to a VkPhysicalDeviceFragmentShaderBarycentricFeaturesKHR, but when " - "creating VkDevice, the parent extension " - "(VK_KHR_fragment_shader_barycentric or VK_NV_fragment_shader_barycentric) was not included " - "in ppEnabledExtensionNames."); - } - VkPhysicalDeviceFragmentShaderBarycentricFeaturesKHR* structure = - (VkPhysicalDeviceFragmentShaderBarycentricFeaturesKHR*)header; - skip |= ValidateBool32(pNext_loc.dot(Field::fragmentShaderBarycentric), structure->fragmentShaderBarycentric); - } - } break; - - // No Validation code for VkPhysicalDeviceFragmentShaderBarycentricPropertiesKHR structure members -- Covers - // VUID-VkPhysicalDeviceFragmentShaderBarycentricPropertiesKHR-sType-sType - - // Validation code for VkPhysicalDeviceShaderSubgroupUniformControlFlowFeaturesKHR structure members - case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_SUBGROUP_UNIFORM_CONTROL_FLOW_FEATURES_KHR: { // Covers - // VUID-VkPhysicalDeviceShaderSubgroupUniformControlFlowFeaturesKHR-sType-sType - if (is_const_param) { - [[maybe_unused]] const Location pNext_loc = - loc.pNext(Struct::VkPhysicalDeviceShaderSubgroupUniformControlFlowFeaturesKHR); - if (!IsExtEnabled(device_extensions.vk_khr_shader_subgroup_uniform_control_flow)) { - skip |= LogError(pnext_vuid, instance, pNext_loc, - "includes a pointer to a VkPhysicalDeviceShaderSubgroupUniformControlFlowFeaturesKHR, but " - "when creating VkDevice, the parent extension " - "(VK_KHR_shader_subgroup_uniform_control_flow) was not included in ppEnabledExtensionNames."); - } - VkPhysicalDeviceShaderSubgroupUniformControlFlowFeaturesKHR* structure = - (VkPhysicalDeviceShaderSubgroupUniformControlFlowFeaturesKHR*)header; - skip |= ValidateBool32(pNext_loc.dot(Field::shaderSubgroupUniformControlFlow), - structure->shaderSubgroupUniformControlFlow); - } - } break; - - // Validation code for VkPhysicalDeviceWorkgroupMemoryExplicitLayoutFeaturesKHR structure members - case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_WORKGROUP_MEMORY_EXPLICIT_LAYOUT_FEATURES_KHR: { // Covers - // VUID-VkPhysicalDeviceWorkgroupMemoryExplicitLayoutFeaturesKHR-sType-sType - if (is_const_param) { - [[maybe_unused]] const Location pNext_loc = - loc.pNext(Struct::VkPhysicalDeviceWorkgroupMemoryExplicitLayoutFeaturesKHR); - if (!IsExtEnabled(device_extensions.vk_khr_workgroup_memory_explicit_layout)) { - skip |= LogError(pnext_vuid, instance, pNext_loc, - "includes a pointer to a VkPhysicalDeviceWorkgroupMemoryExplicitLayoutFeaturesKHR, but when " - "creating VkDevice, the parent extension " - "(VK_KHR_workgroup_memory_explicit_layout) was not included in ppEnabledExtensionNames."); - } - VkPhysicalDeviceWorkgroupMemoryExplicitLayoutFeaturesKHR* structure = - (VkPhysicalDeviceWorkgroupMemoryExplicitLayoutFeaturesKHR*)header; - skip |= - ValidateBool32(pNext_loc.dot(Field::workgroupMemoryExplicitLayout), structure->workgroupMemoryExplicitLayout); - - skip |= ValidateBool32(pNext_loc.dot(Field::workgroupMemoryExplicitLayoutScalarBlockLayout), - structure->workgroupMemoryExplicitLayoutScalarBlockLayout); - - skip |= ValidateBool32(pNext_loc.dot(Field::workgroupMemoryExplicitLayout8BitAccess), - structure->workgroupMemoryExplicitLayout8BitAccess); - - skip |= ValidateBool32(pNext_loc.dot(Field::workgroupMemoryExplicitLayout16BitAccess), - structure->workgroupMemoryExplicitLayout16BitAccess); - } - } break; - - // Validation code for VkPhysicalDeviceRayTracingMaintenance1FeaturesKHR structure members - case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RAY_TRACING_MAINTENANCE_1_FEATURES_KHR: { // Covers - // VUID-VkPhysicalDeviceRayTracingMaintenance1FeaturesKHR-sType-sType - if (is_const_param) { - [[maybe_unused]] const Location pNext_loc = loc.pNext(Struct::VkPhysicalDeviceRayTracingMaintenance1FeaturesKHR); - if (!IsExtEnabled(device_extensions.vk_khr_ray_tracing_maintenance1)) { - skip |= LogError(pnext_vuid, instance, pNext_loc, - "includes a pointer to a VkPhysicalDeviceRayTracingMaintenance1FeaturesKHR, but when creating " - "VkDevice, the parent extension " - "(VK_KHR_ray_tracing_maintenance1) was not included in ppEnabledExtensionNames."); - } - VkPhysicalDeviceRayTracingMaintenance1FeaturesKHR* structure = - (VkPhysicalDeviceRayTracingMaintenance1FeaturesKHR*)header; - skip |= ValidateBool32(pNext_loc.dot(Field::rayTracingMaintenance1), structure->rayTracingMaintenance1); - - skip |= ValidateBool32(pNext_loc.dot(Field::rayTracingPipelineTraceRaysIndirect2), - structure->rayTracingPipelineTraceRaysIndirect2); - } - } break; - - // Validation code for VkPhysicalDeviceShaderSubgroupRotateFeaturesKHR structure members - case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_SUBGROUP_ROTATE_FEATURES_KHR: { // Covers - // VUID-VkPhysicalDeviceShaderSubgroupRotateFeaturesKHR-sType-sType - if (is_const_param) { - [[maybe_unused]] const Location pNext_loc = loc.pNext(Struct::VkPhysicalDeviceShaderSubgroupRotateFeaturesKHR); - if (!IsExtEnabled(device_extensions.vk_khr_shader_subgroup_rotate)) { - skip |= LogError(pnext_vuid, instance, pNext_loc, - "includes a pointer to a VkPhysicalDeviceShaderSubgroupRotateFeaturesKHR, but when creating " - "VkDevice, the parent extension " - "(VK_KHR_shader_subgroup_rotate) was not included in ppEnabledExtensionNames."); - } - VkPhysicalDeviceShaderSubgroupRotateFeaturesKHR* structure = - (VkPhysicalDeviceShaderSubgroupRotateFeaturesKHR*)header; - skip |= ValidateBool32(pNext_loc.dot(Field::shaderSubgroupRotate), structure->shaderSubgroupRotate); - - skip |= - ValidateBool32(pNext_loc.dot(Field::shaderSubgroupRotateClustered), structure->shaderSubgroupRotateClustered); - } - } break; - - // Validation code for VkPhysicalDeviceShaderMaximalReconvergenceFeaturesKHR structure members - case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_MAXIMAL_RECONVERGENCE_FEATURES_KHR: { // Covers - // VUID-VkPhysicalDeviceShaderMaximalReconvergenceFeaturesKHR-sType-sType - if (is_const_param) { - [[maybe_unused]] const Location pNext_loc = - loc.pNext(Struct::VkPhysicalDeviceShaderMaximalReconvergenceFeaturesKHR); - if (!IsExtEnabled(device_extensions.vk_khr_shader_maximal_reconvergence)) { - skip |= LogError(pnext_vuid, instance, pNext_loc, - "includes a pointer to a VkPhysicalDeviceShaderMaximalReconvergenceFeaturesKHR, but when " - "creating VkDevice, the parent extension " - "(VK_KHR_shader_maximal_reconvergence) was not included in ppEnabledExtensionNames."); - } - VkPhysicalDeviceShaderMaximalReconvergenceFeaturesKHR* structure = - (VkPhysicalDeviceShaderMaximalReconvergenceFeaturesKHR*)header; - skip |= ValidateBool32(pNext_loc.dot(Field::shaderMaximalReconvergence), structure->shaderMaximalReconvergence); - } - } break; - - // Validation code for VkPhysicalDeviceMaintenance5FeaturesKHR structure members - case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MAINTENANCE_5_FEATURES_KHR: { // Covers - // VUID-VkPhysicalDeviceMaintenance5FeaturesKHR-sType-sType - if (is_const_param) { - [[maybe_unused]] const Location pNext_loc = loc.pNext(Struct::VkPhysicalDeviceMaintenance5FeaturesKHR); - if (!IsExtEnabled(device_extensions.vk_khr_maintenance5)) { - skip |= LogError(pnext_vuid, instance, pNext_loc, - "includes a pointer to a VkPhysicalDeviceMaintenance5FeaturesKHR, but when creating VkDevice, " - "the parent extension " - "(VK_KHR_maintenance5) was not included in ppEnabledExtensionNames."); - } - VkPhysicalDeviceMaintenance5FeaturesKHR* structure = (VkPhysicalDeviceMaintenance5FeaturesKHR*)header; - skip |= ValidateBool32(pNext_loc.dot(Field::maintenance5), structure->maintenance5); - } - } break; - - // No Validation code for VkPhysicalDeviceMaintenance5PropertiesKHR structure members -- Covers - // VUID-VkPhysicalDeviceMaintenance5PropertiesKHR-sType-sType - // Validation code for VkPipelineCreateFlags2CreateInfoKHR structure members case VK_STRUCTURE_TYPE_PIPELINE_CREATE_FLAGS_2_CREATE_INFO_KHR: { // Covers // VUID-VkPipelineCreateFlags2CreateInfoKHR-sType-sType @@ -4082,45 +6954,6 @@ } } break; - // Validation code for VkPhysicalDeviceRayTracingPositionFetchFeaturesKHR structure members - case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RAY_TRACING_POSITION_FETCH_FEATURES_KHR: { // Covers - // VUID-VkPhysicalDeviceRayTracingPositionFetchFeaturesKHR-sType-sType - if (is_const_param) { - [[maybe_unused]] const Location pNext_loc = loc.pNext(Struct::VkPhysicalDeviceRayTracingPositionFetchFeaturesKHR); - if (!IsExtEnabled(device_extensions.vk_khr_ray_tracing_position_fetch)) { - skip |= LogError(pnext_vuid, instance, pNext_loc, - "includes a pointer to a VkPhysicalDeviceRayTracingPositionFetchFeaturesKHR, but when " - "creating VkDevice, the parent extension " - "(VK_KHR_ray_tracing_position_fetch) was not included in ppEnabledExtensionNames."); - } - VkPhysicalDeviceRayTracingPositionFetchFeaturesKHR* structure = - (VkPhysicalDeviceRayTracingPositionFetchFeaturesKHR*)header; - skip |= ValidateBool32(pNext_loc.dot(Field::rayTracingPositionFetch), structure->rayTracingPositionFetch); - } - } break; - - // Validation code for VkPhysicalDeviceCooperativeMatrixFeaturesKHR structure members - case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COOPERATIVE_MATRIX_FEATURES_KHR: { // Covers - // VUID-VkPhysicalDeviceCooperativeMatrixFeaturesKHR-sType-sType - if (is_const_param) { - [[maybe_unused]] const Location pNext_loc = loc.pNext(Struct::VkPhysicalDeviceCooperativeMatrixFeaturesKHR); - if (!IsExtEnabled(device_extensions.vk_khr_cooperative_matrix)) { - skip |= LogError(pnext_vuid, instance, pNext_loc, - "includes a pointer to a VkPhysicalDeviceCooperativeMatrixFeaturesKHR, but when creating " - "VkDevice, the parent extension " - "(VK_KHR_cooperative_matrix) was not included in ppEnabledExtensionNames."); - } - VkPhysicalDeviceCooperativeMatrixFeaturesKHR* structure = (VkPhysicalDeviceCooperativeMatrixFeaturesKHR*)header; - skip |= ValidateBool32(pNext_loc.dot(Field::cooperativeMatrix), structure->cooperativeMatrix); - - skip |= ValidateBool32(pNext_loc.dot(Field::cooperativeMatrixRobustBufferAccess), - structure->cooperativeMatrixRobustBufferAccess); - } - } break; - - // No Validation code for VkPhysicalDeviceCooperativeMatrixPropertiesKHR structure members -- Covers - // VUID-VkPhysicalDeviceCooperativeMatrixPropertiesKHR-sType-sType - // Validation code for VkVideoDecodeAV1ProfileInfoKHR structure members case VK_STRUCTURE_TYPE_VIDEO_DECODE_AV1_PROFILE_INFO_KHR: { // Covers VUID-VkVideoDecodeAV1ProfileInfoKHR-sType-sType if (is_const_param) { @@ -4174,21 +7007,8 @@ } } break; - // Validation code for VkPhysicalDeviceVideoMaintenance1FeaturesKHR structure members - case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VIDEO_MAINTENANCE_1_FEATURES_KHR: { // Covers - // VUID-VkPhysicalDeviceVideoMaintenance1FeaturesKHR-sType-sType - if (is_const_param) { - [[maybe_unused]] const Location pNext_loc = loc.pNext(Struct::VkPhysicalDeviceVideoMaintenance1FeaturesKHR); - VkPhysicalDeviceVideoMaintenance1FeaturesKHR* structure = (VkPhysicalDeviceVideoMaintenance1FeaturesKHR*)header; - skip |= ValidateBool32(pNext_loc.dot(Field::videoMaintenance1), structure->videoMaintenance1); - } - } break; - // No Validation code for VkVideoInlineQueryInfoKHR structure members -- Covers VUID-VkVideoInlineQueryInfoKHR-sType-sType - // No Validation code for VkPhysicalDeviceVertexAttributeDivisorPropertiesKHR structure members -- Covers - // VUID-VkPhysicalDeviceVertexAttributeDivisorPropertiesKHR-sType-sType - // Validation code for VkPipelineVertexInputDivisorStateCreateInfoKHR structure members case VK_STRUCTURE_TYPE_PIPELINE_VERTEX_INPUT_DIVISOR_STATE_CREATE_INFO_KHR: { // Covers // VUID-VkPipelineVertexInputDivisorStateCreateInfoKHR-sType-sType @@ -4216,95 +7036,6 @@ } } break; - // Validation code for VkPhysicalDeviceVertexAttributeDivisorFeaturesKHR structure members - case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VERTEX_ATTRIBUTE_DIVISOR_FEATURES_KHR: { // Covers - // VUID-VkPhysicalDeviceVertexAttributeDivisorFeaturesKHR-sType-sType - if (is_const_param) { - [[maybe_unused]] const Location pNext_loc = loc.pNext(Struct::VkPhysicalDeviceVertexAttributeDivisorFeaturesKHR); - if (!IsExtEnabled(device_extensions.vk_khr_vertex_attribute_divisor) && - !IsExtEnabled(device_extensions.vk_ext_vertex_attribute_divisor)) { - skip |= LogError(pnext_vuid, instance, pNext_loc, - "includes a pointer to a VkPhysicalDeviceVertexAttributeDivisorFeaturesKHR, but when creating " - "VkDevice, the parent extension " - "(VK_KHR_vertex_attribute_divisor or VK_EXT_vertex_attribute_divisor) was not included in " - "ppEnabledExtensionNames."); - } - VkPhysicalDeviceVertexAttributeDivisorFeaturesKHR* structure = - (VkPhysicalDeviceVertexAttributeDivisorFeaturesKHR*)header; - skip |= ValidateBool32(pNext_loc.dot(Field::vertexAttributeInstanceRateDivisor), - structure->vertexAttributeInstanceRateDivisor); - - skip |= ValidateBool32(pNext_loc.dot(Field::vertexAttributeInstanceRateZeroDivisor), - structure->vertexAttributeInstanceRateZeroDivisor); - } - } break; - - // Validation code for VkPhysicalDeviceShaderFloatControls2FeaturesKHR structure members - case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_FLOAT_CONTROLS_2_FEATURES_KHR: { // Covers - // VUID-VkPhysicalDeviceShaderFloatControls2FeaturesKHR-sType-sType - if (is_const_param) { - [[maybe_unused]] const Location pNext_loc = loc.pNext(Struct::VkPhysicalDeviceShaderFloatControls2FeaturesKHR); - if (!IsExtEnabled(device_extensions.vk_khr_shader_float_controls2)) { - skip |= LogError(pnext_vuid, instance, pNext_loc, - "includes a pointer to a VkPhysicalDeviceShaderFloatControls2FeaturesKHR, but when creating " - "VkDevice, the parent extension " - "(VK_KHR_shader_float_controls2) was not included in ppEnabledExtensionNames."); - } - VkPhysicalDeviceShaderFloatControls2FeaturesKHR* structure = - (VkPhysicalDeviceShaderFloatControls2FeaturesKHR*)header; - skip |= ValidateBool32(pNext_loc.dot(Field::shaderFloatControls2), structure->shaderFloatControls2); - } - } break; - - // Validation code for VkPhysicalDeviceIndexTypeUint8FeaturesKHR structure members - case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_INDEX_TYPE_UINT8_FEATURES_KHR: { // Covers - // VUID-VkPhysicalDeviceIndexTypeUint8FeaturesKHR-sType-sType - if (is_const_param) { - [[maybe_unused]] const Location pNext_loc = loc.pNext(Struct::VkPhysicalDeviceIndexTypeUint8FeaturesKHR); - if (!IsExtEnabled(device_extensions.vk_khr_index_type_uint8) && - !IsExtEnabled(device_extensions.vk_ext_index_type_uint8)) { - skip |= LogError( - pnext_vuid, instance, pNext_loc, - "includes a pointer to a VkPhysicalDeviceIndexTypeUint8FeaturesKHR, but when creating VkDevice, the parent " - "extension " - "(VK_KHR_index_type_uint8 or VK_EXT_index_type_uint8) was not included in ppEnabledExtensionNames."); - } - VkPhysicalDeviceIndexTypeUint8FeaturesKHR* structure = (VkPhysicalDeviceIndexTypeUint8FeaturesKHR*)header; - skip |= ValidateBool32(pNext_loc.dot(Field::indexTypeUint8), structure->indexTypeUint8); - } - } break; - - // Validation code for VkPhysicalDeviceLineRasterizationFeaturesKHR structure members - case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_LINE_RASTERIZATION_FEATURES_KHR: { // Covers - // VUID-VkPhysicalDeviceLineRasterizationFeaturesKHR-sType-sType - if (is_const_param) { - [[maybe_unused]] const Location pNext_loc = loc.pNext(Struct::VkPhysicalDeviceLineRasterizationFeaturesKHR); - if (!IsExtEnabled(device_extensions.vk_khr_line_rasterization) && - !IsExtEnabled(device_extensions.vk_ext_line_rasterization)) { - skip |= LogError( - pnext_vuid, instance, pNext_loc, - "includes a pointer to a VkPhysicalDeviceLineRasterizationFeaturesKHR, but when creating VkDevice, the " - "parent extension " - "(VK_KHR_line_rasterization or VK_EXT_line_rasterization) was not included in ppEnabledExtensionNames."); - } - VkPhysicalDeviceLineRasterizationFeaturesKHR* structure = (VkPhysicalDeviceLineRasterizationFeaturesKHR*)header; - skip |= ValidateBool32(pNext_loc.dot(Field::rectangularLines), structure->rectangularLines); - - skip |= ValidateBool32(pNext_loc.dot(Field::bresenhamLines), structure->bresenhamLines); - - skip |= ValidateBool32(pNext_loc.dot(Field::smoothLines), structure->smoothLines); - - skip |= ValidateBool32(pNext_loc.dot(Field::stippledRectangularLines), structure->stippledRectangularLines); - - skip |= ValidateBool32(pNext_loc.dot(Field::stippledBresenhamLines), structure->stippledBresenhamLines); - - skip |= ValidateBool32(pNext_loc.dot(Field::stippledSmoothLines), structure->stippledSmoothLines); - } - } break; - - // No Validation code for VkPhysicalDeviceLineRasterizationPropertiesKHR structure members -- Covers - // VUID-VkPhysicalDeviceLineRasterizationPropertiesKHR-sType-sType - // Validation code for VkPipelineRasterizationLineStateCreateInfoKHR structure members case VK_STRUCTURE_TYPE_PIPELINE_RASTERIZATION_LINE_STATE_CREATE_INFO_KHR: { // Covers // VUID-VkPipelineRasterizationLineStateCreateInfoKHR-sType-sType @@ -4325,41 +7056,6 @@ } } break; - // Validation code for VkPhysicalDeviceShaderExpectAssumeFeaturesKHR structure members - case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_EXPECT_ASSUME_FEATURES_KHR: { // Covers - // VUID-VkPhysicalDeviceShaderExpectAssumeFeaturesKHR-sType-sType - if (is_const_param) { - [[maybe_unused]] const Location pNext_loc = loc.pNext(Struct::VkPhysicalDeviceShaderExpectAssumeFeaturesKHR); - if (!IsExtEnabled(device_extensions.vk_khr_shader_expect_assume)) { - skip |= LogError(pnext_vuid, instance, pNext_loc, - "includes a pointer to a VkPhysicalDeviceShaderExpectAssumeFeaturesKHR, but when creating " - "VkDevice, the parent extension " - "(VK_KHR_shader_expect_assume) was not included in ppEnabledExtensionNames."); - } - VkPhysicalDeviceShaderExpectAssumeFeaturesKHR* structure = (VkPhysicalDeviceShaderExpectAssumeFeaturesKHR*)header; - skip |= ValidateBool32(pNext_loc.dot(Field::shaderExpectAssume), structure->shaderExpectAssume); - } - } break; - - // Validation code for VkPhysicalDeviceMaintenance6FeaturesKHR structure members - case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MAINTENANCE_6_FEATURES_KHR: { // Covers - // VUID-VkPhysicalDeviceMaintenance6FeaturesKHR-sType-sType - if (is_const_param) { - [[maybe_unused]] const Location pNext_loc = loc.pNext(Struct::VkPhysicalDeviceMaintenance6FeaturesKHR); - if (!IsExtEnabled(device_extensions.vk_khr_maintenance6)) { - skip |= LogError(pnext_vuid, instance, pNext_loc, - "includes a pointer to a VkPhysicalDeviceMaintenance6FeaturesKHR, but when creating VkDevice, " - "the parent extension " - "(VK_KHR_maintenance6) was not included in ppEnabledExtensionNames."); - } - VkPhysicalDeviceMaintenance6FeaturesKHR* structure = (VkPhysicalDeviceMaintenance6FeaturesKHR*)header; - skip |= ValidateBool32(pNext_loc.dot(Field::maintenance6), structure->maintenance6); - } - } break; - - // No Validation code for VkPhysicalDeviceMaintenance6PropertiesKHR structure members -- Covers - // VUID-VkPhysicalDeviceMaintenance6PropertiesKHR-sType-sType - // Validation code for VkBindMemoryStatusKHR structure members case VK_STRUCTURE_TYPE_BIND_MEMORY_STATUS_KHR: { // Covers VUID-VkBindMemoryStatusKHR-sType-sType if (is_const_param) { @@ -4438,27 +7134,6 @@ // No Validation code for VkDedicatedAllocationMemoryAllocateInfoNV structure members -- Covers // VUID-VkDedicatedAllocationMemoryAllocateInfoNV-sType-sType - // Validation code for VkPhysicalDeviceTransformFeedbackFeaturesEXT structure members - case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TRANSFORM_FEEDBACK_FEATURES_EXT: { // Covers - // VUID-VkPhysicalDeviceTransformFeedbackFeaturesEXT-sType-sType - if (is_const_param) { - [[maybe_unused]] const Location pNext_loc = loc.pNext(Struct::VkPhysicalDeviceTransformFeedbackFeaturesEXT); - if (!IsExtEnabled(device_extensions.vk_ext_transform_feedback)) { - skip |= LogError(pnext_vuid, instance, pNext_loc, - "includes a pointer to a VkPhysicalDeviceTransformFeedbackFeaturesEXT, but when creating " - "VkDevice, the parent extension " - "(VK_EXT_transform_feedback) was not included in ppEnabledExtensionNames."); - } - VkPhysicalDeviceTransformFeedbackFeaturesEXT* structure = (VkPhysicalDeviceTransformFeedbackFeaturesEXT*)header; - skip |= ValidateBool32(pNext_loc.dot(Field::transformFeedback), structure->transformFeedback); - - skip |= ValidateBool32(pNext_loc.dot(Field::geometryStreams), structure->geometryStreams); - } - } break; - - // No Validation code for VkPhysicalDeviceTransformFeedbackPropertiesEXT structure members -- Covers - // VUID-VkPhysicalDeviceTransformFeedbackPropertiesEXT-sType-sType - // Validation code for VkPipelineRasterizationStateStreamCreateInfoEXT structure members case VK_STRUCTURE_TYPE_PIPELINE_RASTERIZATION_STATE_STREAM_CREATE_INFO_EXT: { // Covers // VUID-VkPipelineRasterizationStateStreamCreateInfoEXT-sType-sType @@ -4478,22 +7153,6 @@ // No Validation code for VkTextureLODGatherFormatPropertiesAMD structure members -- Covers // VUID-VkTextureLODGatherFormatPropertiesAMD-sType-sType - // Validation code for VkPhysicalDeviceCornerSampledImageFeaturesNV structure members - case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_CORNER_SAMPLED_IMAGE_FEATURES_NV: { // Covers - // VUID-VkPhysicalDeviceCornerSampledImageFeaturesNV-sType-sType - if (is_const_param) { - [[maybe_unused]] const Location pNext_loc = loc.pNext(Struct::VkPhysicalDeviceCornerSampledImageFeaturesNV); - if (!IsExtEnabled(device_extensions.vk_nv_corner_sampled_image)) { - skip |= LogError(pnext_vuid, instance, pNext_loc, - "includes a pointer to a VkPhysicalDeviceCornerSampledImageFeaturesNV, but when creating " - "VkDevice, the parent extension " - "(VK_NV_corner_sampled_image) was not included in ppEnabledExtensionNames."); - } - VkPhysicalDeviceCornerSampledImageFeaturesNV* structure = (VkPhysicalDeviceCornerSampledImageFeaturesNV*)header; - skip |= ValidateBool32(pNext_loc.dot(Field::cornerSampledImage), structure->cornerSampledImage); - } - } break; - // Validation code for VkExternalMemoryImageCreateInfoNV structure members case VK_STRUCTURE_TYPE_EXTERNAL_MEMORY_IMAGE_CREATE_INFO_NV: { // Covers VUID-VkExternalMemoryImageCreateInfoNV-sType-sType if (is_const_param) { @@ -4603,41 +7262,6 @@ } } break; - // Validation code for VkPhysicalDeviceASTCDecodeFeaturesEXT structure members - case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ASTC_DECODE_FEATURES_EXT: { // Covers - // VUID-VkPhysicalDeviceASTCDecodeFeaturesEXT-sType-sType - if (is_const_param) { - [[maybe_unused]] const Location pNext_loc = loc.pNext(Struct::VkPhysicalDeviceASTCDecodeFeaturesEXT); - if (!IsExtEnabled(device_extensions.vk_ext_astc_decode_mode)) { - skip |= LogError(pnext_vuid, instance, pNext_loc, - "includes a pointer to a VkPhysicalDeviceASTCDecodeFeaturesEXT, but when creating VkDevice, " - "the parent extension " - "(VK_EXT_astc_decode_mode) was not included in ppEnabledExtensionNames."); - } - VkPhysicalDeviceASTCDecodeFeaturesEXT* structure = (VkPhysicalDeviceASTCDecodeFeaturesEXT*)header; - skip |= ValidateBool32(pNext_loc.dot(Field::decodeModeSharedExponent), structure->decodeModeSharedExponent); - } - } break; - - // Validation code for VkPhysicalDevicePipelineRobustnessFeaturesEXT structure members - case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PIPELINE_ROBUSTNESS_FEATURES_EXT: { // Covers - // VUID-VkPhysicalDevicePipelineRobustnessFeaturesEXT-sType-sType - if (is_const_param) { - [[maybe_unused]] const Location pNext_loc = loc.pNext(Struct::VkPhysicalDevicePipelineRobustnessFeaturesEXT); - if (!IsExtEnabled(device_extensions.vk_ext_pipeline_robustness)) { - skip |= LogError(pnext_vuid, instance, pNext_loc, - "includes a pointer to a VkPhysicalDevicePipelineRobustnessFeaturesEXT, but when creating " - "VkDevice, the parent extension " - "(VK_EXT_pipeline_robustness) was not included in ppEnabledExtensionNames."); - } - VkPhysicalDevicePipelineRobustnessFeaturesEXT* structure = (VkPhysicalDevicePipelineRobustnessFeaturesEXT*)header; - skip |= ValidateBool32(pNext_loc.dot(Field::pipelineRobustness), structure->pipelineRobustness); - } - } break; - - // No Validation code for VkPhysicalDevicePipelineRobustnessPropertiesEXT structure members -- Covers - // VUID-VkPhysicalDevicePipelineRobustnessPropertiesEXT-sType-sType - // Validation code for VkPipelineRobustnessCreateInfoEXT structure members case VK_STRUCTURE_TYPE_PIPELINE_ROBUSTNESS_CREATE_INFO_EXT: { // Covers VUID-VkPipelineRobustnessCreateInfoEXT-sType-sType if (is_const_param) { @@ -4664,26 +7288,6 @@ } } break; - // Validation code for VkPhysicalDeviceConditionalRenderingFeaturesEXT structure members - case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_CONDITIONAL_RENDERING_FEATURES_EXT: { // Covers - // VUID-VkPhysicalDeviceConditionalRenderingFeaturesEXT-sType-sType - if (is_const_param) { - [[maybe_unused]] const Location pNext_loc = loc.pNext(Struct::VkPhysicalDeviceConditionalRenderingFeaturesEXT); - if (!IsExtEnabled(device_extensions.vk_ext_conditional_rendering)) { - skip |= LogError(pnext_vuid, instance, pNext_loc, - "includes a pointer to a VkPhysicalDeviceConditionalRenderingFeaturesEXT, but when creating " - "VkDevice, the parent extension " - "(VK_EXT_conditional_rendering) was not included in ppEnabledExtensionNames."); - } - VkPhysicalDeviceConditionalRenderingFeaturesEXT* structure = - (VkPhysicalDeviceConditionalRenderingFeaturesEXT*)header; - skip |= ValidateBool32(pNext_loc.dot(Field::conditionalRendering), structure->conditionalRendering); - - skip |= - ValidateBool32(pNext_loc.dot(Field::inheritedConditionalRendering), structure->inheritedConditionalRendering); - } - } break; - // Validation code for VkCommandBufferInheritanceConditionalRenderingInfoEXT structure members case VK_STRUCTURE_TYPE_COMMAND_BUFFER_INHERITANCE_CONDITIONAL_RENDERING_INFO_EXT: { // Covers // VUID-VkCommandBufferInheritanceConditionalRenderingInfoEXT-sType-sType @@ -4754,9 +7358,6 @@ } } break; - // No Validation code for VkPhysicalDeviceMultiviewPerViewAttributesPropertiesNVX structure members -- Covers - // VUID-VkPhysicalDeviceMultiviewPerViewAttributesPropertiesNVX-sType-sType - // Validation code for VkPipelineViewportSwizzleStateCreateInfoNV structure members case VK_STRUCTURE_TYPE_PIPELINE_VIEWPORT_SWIZZLE_STATE_CREATE_INFO_NV: { // Covers // VUID-VkPipelineViewportSwizzleStateCreateInfoNV-sType-sType @@ -4799,9 +7400,6 @@ } } break; - // No Validation code for VkPhysicalDeviceDiscardRectanglePropertiesEXT structure members -- Covers - // VUID-VkPhysicalDeviceDiscardRectanglePropertiesEXT-sType-sType - // Validation code for VkPipelineDiscardRectangleStateCreateInfoEXT structure members case VK_STRUCTURE_TYPE_PIPELINE_DISCARD_RECTANGLE_STATE_CREATE_INFO_EXT: { // Covers // VUID-VkPipelineDiscardRectangleStateCreateInfoEXT-sType-sType @@ -4821,9 +7419,6 @@ } } break; - // No Validation code for VkPhysicalDeviceConservativeRasterizationPropertiesEXT structure members -- Covers - // VUID-VkPhysicalDeviceConservativeRasterizationPropertiesEXT-sType-sType - // Validation code for VkPipelineRasterizationConservativeStateCreateInfoEXT structure members case VK_STRUCTURE_TYPE_PIPELINE_RASTERIZATION_CONSERVATIVE_STATE_CREATE_INFO_EXT: { // Covers // VUID-VkPipelineRasterizationConservativeStateCreateInfoEXT-sType-sType @@ -4846,22 +7441,6 @@ } } break; - // Validation code for VkPhysicalDeviceDepthClipEnableFeaturesEXT structure members - case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DEPTH_CLIP_ENABLE_FEATURES_EXT: { // Covers - // VUID-VkPhysicalDeviceDepthClipEnableFeaturesEXT-sType-sType - if (is_const_param) { - [[maybe_unused]] const Location pNext_loc = loc.pNext(Struct::VkPhysicalDeviceDepthClipEnableFeaturesEXT); - if (!IsExtEnabled(device_extensions.vk_ext_depth_clip_enable)) { - skip |= LogError(pnext_vuid, instance, pNext_loc, - "includes a pointer to a VkPhysicalDeviceDepthClipEnableFeaturesEXT, but when creating " - "VkDevice, the parent extension " - "(VK_EXT_depth_clip_enable) was not included in ppEnabledExtensionNames."); - } - VkPhysicalDeviceDepthClipEnableFeaturesEXT* structure = (VkPhysicalDeviceDepthClipEnableFeaturesEXT*)header; - skip |= ValidateBool32(pNext_loc.dot(Field::depthClipEnable), structure->depthClipEnable); - } - } break; - // Validation code for VkPipelineRasterizationDepthClipStateCreateInfoEXT structure members case VK_STRUCTURE_TYPE_PIPELINE_RASTERIZATION_DEPTH_CLIP_STATE_CREATE_INFO_EXT: { // Covers // VUID-VkPipelineRasterizationDepthClipStateCreateInfoEXT-sType-sType @@ -4880,23 +7459,6 @@ } } break; - // Validation code for VkPhysicalDeviceRelaxedLineRasterizationFeaturesIMG structure members - case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RELAXED_LINE_RASTERIZATION_FEATURES_IMG: { // Covers - // VUID-VkPhysicalDeviceRelaxedLineRasterizationFeaturesIMG-sType-sType - if (is_const_param) { - [[maybe_unused]] const Location pNext_loc = loc.pNext(Struct::VkPhysicalDeviceRelaxedLineRasterizationFeaturesIMG); - if (!IsExtEnabled(device_extensions.vk_img_relaxed_line_rasterization)) { - skip |= LogError(pnext_vuid, instance, pNext_loc, - "includes a pointer to a VkPhysicalDeviceRelaxedLineRasterizationFeaturesIMG, but when " - "creating VkDevice, the parent extension " - "(VK_IMG_relaxed_line_rasterization) was not included in ppEnabledExtensionNames."); - } - VkPhysicalDeviceRelaxedLineRasterizationFeaturesIMG* structure = - (VkPhysicalDeviceRelaxedLineRasterizationFeaturesIMG*)header; - skip |= ValidateBool32(pNext_loc.dot(Field::relaxedLineRasterization), structure->relaxedLineRasterization); - } - } break; - // Validation code for VkDebugUtilsObjectNameInfoEXT structure members case VK_STRUCTURE_TYPE_DEBUG_UTILS_OBJECT_NAME_INFO_EXT: { // Covers VUID-VkDebugUtilsObjectNameInfoEXT-sType-sType if (is_const_param) { @@ -4962,25 +7524,6 @@ #endif // VK_USE_PLATFORM_ANDROID_KHR #ifdef VK_ENABLE_BETA_EXTENSIONS - // Validation code for VkPhysicalDeviceShaderEnqueueFeaturesAMDX structure members - case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_ENQUEUE_FEATURES_AMDX: { // Covers - // VUID-VkPhysicalDeviceShaderEnqueueFeaturesAMDX-sType-sType - if (is_const_param) { - [[maybe_unused]] const Location pNext_loc = loc.pNext(Struct::VkPhysicalDeviceShaderEnqueueFeaturesAMDX); - if (!IsExtEnabled(device_extensions.vk_amdx_shader_enqueue)) { - skip |= LogError(pnext_vuid, instance, pNext_loc, - "includes a pointer to a VkPhysicalDeviceShaderEnqueueFeaturesAMDX, but when creating " - "VkDevice, the parent extension " - "(VK_AMDX_shader_enqueue) was not included in ppEnabledExtensionNames."); - } - VkPhysicalDeviceShaderEnqueueFeaturesAMDX* structure = (VkPhysicalDeviceShaderEnqueueFeaturesAMDX*)header; - skip |= ValidateBool32(pNext_loc.dot(Field::shaderEnqueue), structure->shaderEnqueue); - } - } break; - - // No Validation code for VkPhysicalDeviceShaderEnqueuePropertiesAMDX structure members -- Covers - // VUID-VkPhysicalDeviceShaderEnqueuePropertiesAMDX-sType-sType - // No Validation code for VkPipelineShaderStageNodeCreateInfoAMDX structure members -- Covers // VUID-VkPipelineShaderStageNodeCreateInfoAMDX-sType-sType #endif // VK_ENABLE_BETA_EXTENSIONS @@ -5134,30 +7677,6 @@ } } break; - // No Validation code for VkPhysicalDeviceSampleLocationsPropertiesEXT structure members -- Covers - // VUID-VkPhysicalDeviceSampleLocationsPropertiesEXT-sType-sType - - // Validation code for VkPhysicalDeviceBlendOperationAdvancedFeaturesEXT structure members - case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_BLEND_OPERATION_ADVANCED_FEATURES_EXT: { // Covers - // VUID-VkPhysicalDeviceBlendOperationAdvancedFeaturesEXT-sType-sType - if (is_const_param) { - [[maybe_unused]] const Location pNext_loc = loc.pNext(Struct::VkPhysicalDeviceBlendOperationAdvancedFeaturesEXT); - if (!IsExtEnabled(device_extensions.vk_ext_blend_operation_advanced)) { - skip |= LogError(pnext_vuid, instance, pNext_loc, - "includes a pointer to a VkPhysicalDeviceBlendOperationAdvancedFeaturesEXT, but when creating " - "VkDevice, the parent extension " - "(VK_EXT_blend_operation_advanced) was not included in ppEnabledExtensionNames."); - } - VkPhysicalDeviceBlendOperationAdvancedFeaturesEXT* structure = - (VkPhysicalDeviceBlendOperationAdvancedFeaturesEXT*)header; - skip |= ValidateBool32(pNext_loc.dot(Field::advancedBlendCoherentOperations), - structure->advancedBlendCoherentOperations); - } - } break; - - // No Validation code for VkPhysicalDeviceBlendOperationAdvancedPropertiesEXT structure members -- Covers - // VUID-VkPhysicalDeviceBlendOperationAdvancedPropertiesEXT-sType-sType - // Validation code for VkPipelineColorBlendAdvancedStateCreateInfoEXT structure members case VK_STRUCTURE_TYPE_PIPELINE_COLOR_BLEND_ADVANCED_STATE_CREATE_INFO_EXT: { // Covers // VUID-VkPipelineColorBlendAdvancedStateCreateInfoEXT-sType-sType @@ -5217,25 +7736,6 @@ } } break; - // No Validation code for VkPhysicalDeviceShaderSMBuiltinsPropertiesNV structure members -- Covers - // VUID-VkPhysicalDeviceShaderSMBuiltinsPropertiesNV-sType-sType - - // Validation code for VkPhysicalDeviceShaderSMBuiltinsFeaturesNV structure members - case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_SM_BUILTINS_FEATURES_NV: { // Covers - // VUID-VkPhysicalDeviceShaderSMBuiltinsFeaturesNV-sType-sType - if (is_const_param) { - [[maybe_unused]] const Location pNext_loc = loc.pNext(Struct::VkPhysicalDeviceShaderSMBuiltinsFeaturesNV); - if (!IsExtEnabled(device_extensions.vk_nv_shader_sm_builtins)) { - skip |= LogError(pnext_vuid, instance, pNext_loc, - "includes a pointer to a VkPhysicalDeviceShaderSMBuiltinsFeaturesNV, but when creating " - "VkDevice, the parent extension " - "(VK_NV_shader_sm_builtins) was not included in ppEnabledExtensionNames."); - } - VkPhysicalDeviceShaderSMBuiltinsFeaturesNV* structure = (VkPhysicalDeviceShaderSMBuiltinsFeaturesNV*)header; - skip |= ValidateBool32(pNext_loc.dot(Field::shaderSMBuiltins), structure->shaderSMBuiltins); - } - } break; - // No Validation code for VkDrmFormatModifierPropertiesListEXT structure members -- Covers // VUID-VkDrmFormatModifierPropertiesListEXT-sType-sType @@ -5328,27 +7828,6 @@ } } break; - // Validation code for VkPhysicalDeviceShadingRateImageFeaturesNV structure members - case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADING_RATE_IMAGE_FEATURES_NV: { // Covers - // VUID-VkPhysicalDeviceShadingRateImageFeaturesNV-sType-sType - if (is_const_param) { - [[maybe_unused]] const Location pNext_loc = loc.pNext(Struct::VkPhysicalDeviceShadingRateImageFeaturesNV); - if (!IsExtEnabled(device_extensions.vk_nv_shading_rate_image)) { - skip |= LogError(pnext_vuid, instance, pNext_loc, - "includes a pointer to a VkPhysicalDeviceShadingRateImageFeaturesNV, but when creating " - "VkDevice, the parent extension " - "(VK_NV_shading_rate_image) was not included in ppEnabledExtensionNames."); - } - VkPhysicalDeviceShadingRateImageFeaturesNV* structure = (VkPhysicalDeviceShadingRateImageFeaturesNV*)header; - skip |= ValidateBool32(pNext_loc.dot(Field::shadingRateImage), structure->shadingRateImage); - - skip |= ValidateBool32(pNext_loc.dot(Field::shadingRateCoarseSampleOrder), structure->shadingRateCoarseSampleOrder); - } - } break; - - // No Validation code for VkPhysicalDeviceShadingRateImagePropertiesNV structure members -- Covers - // VUID-VkPhysicalDeviceShadingRateImagePropertiesNV-sType-sType - // Validation code for VkPipelineViewportCoarseSampleOrderStateCreateInfoNV structure members case VK_STRUCTURE_TYPE_PIPELINE_VIEWPORT_COARSE_SAMPLE_ORDER_STATE_CREATE_INFO_NV: { // Covers // VUID-VkPipelineViewportCoarseSampleOrderStateCreateInfoNV-sType-sType @@ -5416,26 +7895,6 @@ } } break; - // No Validation code for VkPhysicalDeviceRayTracingPropertiesNV structure members -- Covers - // VUID-VkPhysicalDeviceRayTracingPropertiesNV-sType-sType - - // Validation code for VkPhysicalDeviceRepresentativeFragmentTestFeaturesNV structure members - case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_REPRESENTATIVE_FRAGMENT_TEST_FEATURES_NV: { // Covers - // VUID-VkPhysicalDeviceRepresentativeFragmentTestFeaturesNV-sType-sType - if (is_const_param) { - [[maybe_unused]] const Location pNext_loc = loc.pNext(Struct::VkPhysicalDeviceRepresentativeFragmentTestFeaturesNV); - if (!IsExtEnabled(device_extensions.vk_nv_representative_fragment_test)) { - skip |= LogError(pnext_vuid, instance, pNext_loc, - "includes a pointer to a VkPhysicalDeviceRepresentativeFragmentTestFeaturesNV, but when " - "creating VkDevice, the parent extension " - "(VK_NV_representative_fragment_test) was not included in ppEnabledExtensionNames."); - } - VkPhysicalDeviceRepresentativeFragmentTestFeaturesNV* structure = - (VkPhysicalDeviceRepresentativeFragmentTestFeaturesNV*)header; - skip |= ValidateBool32(pNext_loc.dot(Field::representativeFragmentTest), structure->representativeFragmentTest); - } - } break; - // Validation code for VkPipelineRepresentativeFragmentTestStateCreateInfoNV structure members case VK_STRUCTURE_TYPE_PIPELINE_REPRESENTATIVE_FRAGMENT_TEST_STATE_CREATE_INFO_NV: { // Covers // VUID-VkPipelineRepresentativeFragmentTestStateCreateInfoNV-sType-sType @@ -5491,9 +7950,6 @@ } } break; - // No Validation code for VkPhysicalDeviceExternalMemoryHostPropertiesEXT structure members -- Covers - // VUID-VkPhysicalDeviceExternalMemoryHostPropertiesEXT-sType-sType - // Validation code for VkPipelineCompilerControlCreateInfoAMD structure members case VK_STRUCTURE_TYPE_PIPELINE_COMPILER_CONTROL_CREATE_INFO_AMD: { // Covers // VUID-VkPipelineCompilerControlCreateInfoAMD-sType-sType @@ -5509,9 +7965,6 @@ } } break; - // No Validation code for VkPhysicalDeviceShaderCorePropertiesAMD structure members -- Covers - // VUID-VkPhysicalDeviceShaderCorePropertiesAMD-sType-sType - // Validation code for VkDeviceMemoryOverallocationCreateInfoAMD structure members case VK_STRUCTURE_TYPE_DEVICE_MEMORY_OVERALLOCATION_CREATE_INFO_AMD: { // Covers // VUID-VkDeviceMemoryOverallocationCreateInfoAMD-sType-sType @@ -5527,109 +7980,17 @@ "VUID-VkDeviceMemoryOverallocationCreateInfoAMD-overallocationBehavior-parameter"); } } break; - - // No Validation code for VkPhysicalDeviceVertexAttributeDivisorPropertiesEXT structure members -- Covers - // VUID-VkPhysicalDeviceVertexAttributeDivisorPropertiesEXT-sType-sType #ifdef VK_USE_PLATFORM_GGP // No Validation code for VkPresentFrameTokenGGP structure members -- Covers VUID-VkPresentFrameTokenGGP-sType-sType #endif // VK_USE_PLATFORM_GGP - // Validation code for VkPhysicalDeviceComputeShaderDerivativesFeaturesNV structure members - case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COMPUTE_SHADER_DERIVATIVES_FEATURES_NV: { // Covers - // VUID-VkPhysicalDeviceComputeShaderDerivativesFeaturesNV-sType-sType - if (is_const_param) { - [[maybe_unused]] const Location pNext_loc = loc.pNext(Struct::VkPhysicalDeviceComputeShaderDerivativesFeaturesNV); - if (!IsExtEnabled(device_extensions.vk_nv_compute_shader_derivatives)) { - skip |= LogError(pnext_vuid, instance, pNext_loc, - "includes a pointer to a VkPhysicalDeviceComputeShaderDerivativesFeaturesNV, but when " - "creating VkDevice, the parent extension " - "(VK_NV_compute_shader_derivatives) was not included in ppEnabledExtensionNames."); - } - VkPhysicalDeviceComputeShaderDerivativesFeaturesNV* structure = - (VkPhysicalDeviceComputeShaderDerivativesFeaturesNV*)header; - skip |= ValidateBool32(pNext_loc.dot(Field::computeDerivativeGroupQuads), structure->computeDerivativeGroupQuads); - - skip |= ValidateBool32(pNext_loc.dot(Field::computeDerivativeGroupLinear), structure->computeDerivativeGroupLinear); - } - } break; - - // Validation code for VkPhysicalDeviceMeshShaderFeaturesNV structure members - case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MESH_SHADER_FEATURES_NV: { // Covers - // VUID-VkPhysicalDeviceMeshShaderFeaturesNV-sType-sType - if (is_const_param) { - [[maybe_unused]] const Location pNext_loc = loc.pNext(Struct::VkPhysicalDeviceMeshShaderFeaturesNV); - if (!IsExtEnabled(device_extensions.vk_nv_mesh_shader)) { - skip |= LogError(pnext_vuid, instance, pNext_loc, - "includes a pointer to a VkPhysicalDeviceMeshShaderFeaturesNV, but when creating VkDevice, " - "the parent extension " - "(VK_NV_mesh_shader) was not included in ppEnabledExtensionNames."); - } - VkPhysicalDeviceMeshShaderFeaturesNV* structure = (VkPhysicalDeviceMeshShaderFeaturesNV*)header; - skip |= ValidateBool32(pNext_loc.dot(Field::taskShader), structure->taskShader); - - skip |= ValidateBool32(pNext_loc.dot(Field::meshShader), structure->meshShader); - } - } break; - - // No Validation code for VkPhysicalDeviceMeshShaderPropertiesNV structure members -- Covers - // VUID-VkPhysicalDeviceMeshShaderPropertiesNV-sType-sType - - // Validation code for VkPhysicalDeviceShaderImageFootprintFeaturesNV structure members - case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_IMAGE_FOOTPRINT_FEATURES_NV: { // Covers - // VUID-VkPhysicalDeviceShaderImageFootprintFeaturesNV-sType-sType - if (is_const_param) { - [[maybe_unused]] const Location pNext_loc = loc.pNext(Struct::VkPhysicalDeviceShaderImageFootprintFeaturesNV); - if (!IsExtEnabled(device_extensions.vk_nv_shader_image_footprint)) { - skip |= LogError(pnext_vuid, instance, pNext_loc, - "includes a pointer to a VkPhysicalDeviceShaderImageFootprintFeaturesNV, but when creating " - "VkDevice, the parent extension " - "(VK_NV_shader_image_footprint) was not included in ppEnabledExtensionNames."); - } - VkPhysicalDeviceShaderImageFootprintFeaturesNV* structure = (VkPhysicalDeviceShaderImageFootprintFeaturesNV*)header; - skip |= ValidateBool32(pNext_loc.dot(Field::imageFootprint), structure->imageFootprint); - } - } break; - // No Validation code for VkPipelineViewportExclusiveScissorStateCreateInfoNV structure members -- Covers // VUID-VkPipelineViewportExclusiveScissorStateCreateInfoNV-sType-sType - // Validation code for VkPhysicalDeviceExclusiveScissorFeaturesNV structure members - case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXCLUSIVE_SCISSOR_FEATURES_NV: { // Covers - // VUID-VkPhysicalDeviceExclusiveScissorFeaturesNV-sType-sType - if (is_const_param) { - [[maybe_unused]] const Location pNext_loc = loc.pNext(Struct::VkPhysicalDeviceExclusiveScissorFeaturesNV); - if (!IsExtEnabled(device_extensions.vk_nv_scissor_exclusive)) { - skip |= LogError(pnext_vuid, instance, pNext_loc, - "includes a pointer to a VkPhysicalDeviceExclusiveScissorFeaturesNV, but when creating " - "VkDevice, the parent extension " - "(VK_NV_scissor_exclusive) was not included in ppEnabledExtensionNames."); - } - VkPhysicalDeviceExclusiveScissorFeaturesNV* structure = (VkPhysicalDeviceExclusiveScissorFeaturesNV*)header; - skip |= ValidateBool32(pNext_loc.dot(Field::exclusiveScissor), structure->exclusiveScissor); - } - } break; - // No Validation code for VkQueueFamilyCheckpointPropertiesNV structure members -- Covers // VUID-VkQueueFamilyCheckpointPropertiesNV-sType-sType - // Validation code for VkPhysicalDeviceShaderIntegerFunctions2FeaturesINTEL structure members - case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_INTEGER_FUNCTIONS_2_FEATURES_INTEL: { // Covers - // VUID-VkPhysicalDeviceShaderIntegerFunctions2FeaturesINTEL-sType-sType - if (is_const_param) { - [[maybe_unused]] const Location pNext_loc = loc.pNext(Struct::VkPhysicalDeviceShaderIntegerFunctions2FeaturesINTEL); - if (!IsExtEnabled(device_extensions.vk_intel_shader_integer_functions2)) { - skip |= LogError(pnext_vuid, instance, pNext_loc, - "includes a pointer to a VkPhysicalDeviceShaderIntegerFunctions2FeaturesINTEL, but when " - "creating VkDevice, the parent extension " - "(VK_INTEL_shader_integer_functions2) was not included in ppEnabledExtensionNames."); - } - VkPhysicalDeviceShaderIntegerFunctions2FeaturesINTEL* structure = - (VkPhysicalDeviceShaderIntegerFunctions2FeaturesINTEL*)header; - skip |= ValidateBool32(pNext_loc.dot(Field::shaderIntegerFunctions2), structure->shaderIntegerFunctions2); - } - } break; - // Validation code for VkQueryPoolPerformanceQueryCreateInfoINTEL structure members case VK_STRUCTURE_TYPE_QUERY_POOL_PERFORMANCE_QUERY_CREATE_INFO_INTEL: { // Covers // VUID-VkQueryPoolPerformanceQueryCreateInfoINTEL-sType-sType @@ -5646,9 +8007,6 @@ } } break; - // No Validation code for VkPhysicalDevicePCIBusInfoPropertiesEXT structure members -- Covers - // VUID-VkPhysicalDevicePCIBusInfoPropertiesEXT-sType-sType - // No Validation code for VkDisplayNativeHdrSurfaceCapabilitiesAMD structure members -- Covers // VUID-VkDisplayNativeHdrSurfaceCapabilitiesAMD-sType-sType @@ -5666,30 +8024,6 @@ } } break; - // Validation code for VkPhysicalDeviceFragmentDensityMapFeaturesEXT structure members - case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_DENSITY_MAP_FEATURES_EXT: { // Covers - // VUID-VkPhysicalDeviceFragmentDensityMapFeaturesEXT-sType-sType - if (is_const_param) { - [[maybe_unused]] const Location pNext_loc = loc.pNext(Struct::VkPhysicalDeviceFragmentDensityMapFeaturesEXT); - if (!IsExtEnabled(device_extensions.vk_ext_fragment_density_map)) { - skip |= LogError(pnext_vuid, instance, pNext_loc, - "includes a pointer to a VkPhysicalDeviceFragmentDensityMapFeaturesEXT, but when creating " - "VkDevice, the parent extension " - "(VK_EXT_fragment_density_map) was not included in ppEnabledExtensionNames."); - } - VkPhysicalDeviceFragmentDensityMapFeaturesEXT* structure = (VkPhysicalDeviceFragmentDensityMapFeaturesEXT*)header; - skip |= ValidateBool32(pNext_loc.dot(Field::fragmentDensityMap), structure->fragmentDensityMap); - - skip |= ValidateBool32(pNext_loc.dot(Field::fragmentDensityMapDynamic), structure->fragmentDensityMapDynamic); - - skip |= ValidateBool32(pNext_loc.dot(Field::fragmentDensityMapNonSubsampledImages), - structure->fragmentDensityMapNonSubsampledImages); - } - } break; - - // No Validation code for VkPhysicalDeviceFragmentDensityMapPropertiesEXT structure members -- Covers - // VUID-VkPhysicalDeviceFragmentDensityMapPropertiesEXT-sType-sType - // Validation code for VkRenderPassFragmentDensityMapCreateInfoEXT structure members case VK_STRUCTURE_TYPE_RENDER_PASS_FRAGMENT_DENSITY_MAP_CREATE_INFO_EXT: { // Covers // VUID-VkRenderPassFragmentDensityMapCreateInfoEXT-sType-sType @@ -5706,107 +8040,12 @@ } } break; - // No Validation code for VkPhysicalDeviceShaderCoreProperties2AMD structure members -- Covers - // VUID-VkPhysicalDeviceShaderCoreProperties2AMD-sType-sType - - // Validation code for VkPhysicalDeviceCoherentMemoryFeaturesAMD structure members - case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COHERENT_MEMORY_FEATURES_AMD: { // Covers - // VUID-VkPhysicalDeviceCoherentMemoryFeaturesAMD-sType-sType - if (is_const_param) { - [[maybe_unused]] const Location pNext_loc = loc.pNext(Struct::VkPhysicalDeviceCoherentMemoryFeaturesAMD); - if (!IsExtEnabled(device_extensions.vk_amd_device_coherent_memory)) { - skip |= LogError(pnext_vuid, instance, pNext_loc, - "includes a pointer to a VkPhysicalDeviceCoherentMemoryFeaturesAMD, but when creating " - "VkDevice, the parent extension " - "(VK_AMD_device_coherent_memory) was not included in ppEnabledExtensionNames."); - } - VkPhysicalDeviceCoherentMemoryFeaturesAMD* structure = (VkPhysicalDeviceCoherentMemoryFeaturesAMD*)header; - skip |= ValidateBool32(pNext_loc.dot(Field::deviceCoherentMemory), structure->deviceCoherentMemory); - } - } break; - - // Validation code for VkPhysicalDeviceShaderImageAtomicInt64FeaturesEXT structure members - case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_IMAGE_ATOMIC_INT64_FEATURES_EXT: { // Covers - // VUID-VkPhysicalDeviceShaderImageAtomicInt64FeaturesEXT-sType-sType - if (is_const_param) { - [[maybe_unused]] const Location pNext_loc = loc.pNext(Struct::VkPhysicalDeviceShaderImageAtomicInt64FeaturesEXT); - if (!IsExtEnabled(device_extensions.vk_ext_shader_image_atomic_int64)) { - skip |= LogError(pnext_vuid, instance, pNext_loc, - "includes a pointer to a VkPhysicalDeviceShaderImageAtomicInt64FeaturesEXT, but when creating " - "VkDevice, the parent extension " - "(VK_EXT_shader_image_atomic_int64) was not included in ppEnabledExtensionNames."); - } - VkPhysicalDeviceShaderImageAtomicInt64FeaturesEXT* structure = - (VkPhysicalDeviceShaderImageAtomicInt64FeaturesEXT*)header; - skip |= ValidateBool32(pNext_loc.dot(Field::shaderImageInt64Atomics), structure->shaderImageInt64Atomics); - - skip |= ValidateBool32(pNext_loc.dot(Field::sparseImageInt64Atomics), structure->sparseImageInt64Atomics); - } - } break; - // No Validation code for VkPhysicalDeviceMemoryBudgetPropertiesEXT structure members -- Covers // VUID-VkPhysicalDeviceMemoryBudgetPropertiesEXT-sType-sType - // Validation code for VkPhysicalDeviceMemoryPriorityFeaturesEXT structure members - case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MEMORY_PRIORITY_FEATURES_EXT: { // Covers - // VUID-VkPhysicalDeviceMemoryPriorityFeaturesEXT-sType-sType - if (is_const_param) { - [[maybe_unused]] const Location pNext_loc = loc.pNext(Struct::VkPhysicalDeviceMemoryPriorityFeaturesEXT); - if (!IsExtEnabled(device_extensions.vk_ext_memory_priority)) { - skip |= LogError(pnext_vuid, instance, pNext_loc, - "includes a pointer to a VkPhysicalDeviceMemoryPriorityFeaturesEXT, but when creating " - "VkDevice, the parent extension " - "(VK_EXT_memory_priority) was not included in ppEnabledExtensionNames."); - } - VkPhysicalDeviceMemoryPriorityFeaturesEXT* structure = (VkPhysicalDeviceMemoryPriorityFeaturesEXT*)header; - skip |= ValidateBool32(pNext_loc.dot(Field::memoryPriority), structure->memoryPriority); - } - } break; - // No Validation code for VkMemoryPriorityAllocateInfoEXT structure members -- Covers // VUID-VkMemoryPriorityAllocateInfoEXT-sType-sType - // Validation code for VkPhysicalDeviceDedicatedAllocationImageAliasingFeaturesNV structure members - case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DEDICATED_ALLOCATION_IMAGE_ALIASING_FEATURES_NV: { // Covers - // VUID-VkPhysicalDeviceDedicatedAllocationImageAliasingFeaturesNV-sType-sType - if (is_const_param) { - [[maybe_unused]] const Location pNext_loc = - loc.pNext(Struct::VkPhysicalDeviceDedicatedAllocationImageAliasingFeaturesNV); - if (!IsExtEnabled(device_extensions.vk_nv_dedicated_allocation_image_aliasing)) { - skip |= LogError(pnext_vuid, instance, pNext_loc, - "includes a pointer to a VkPhysicalDeviceDedicatedAllocationImageAliasingFeaturesNV, but when " - "creating VkDevice, the parent extension " - "(VK_NV_dedicated_allocation_image_aliasing) was not included in ppEnabledExtensionNames."); - } - VkPhysicalDeviceDedicatedAllocationImageAliasingFeaturesNV* structure = - (VkPhysicalDeviceDedicatedAllocationImageAliasingFeaturesNV*)header; - skip |= ValidateBool32(pNext_loc.dot(Field::dedicatedAllocationImageAliasing), - structure->dedicatedAllocationImageAliasing); - } - } break; - - // Validation code for VkPhysicalDeviceBufferDeviceAddressFeaturesEXT structure members - case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_BUFFER_DEVICE_ADDRESS_FEATURES_EXT: { // Covers - // VUID-VkPhysicalDeviceBufferDeviceAddressFeaturesEXT-sType-sType - if (is_const_param) { - [[maybe_unused]] const Location pNext_loc = loc.pNext(Struct::VkPhysicalDeviceBufferDeviceAddressFeaturesEXT); - if (!IsExtEnabled(device_extensions.vk_ext_buffer_device_address)) { - skip |= LogError(pnext_vuid, instance, pNext_loc, - "includes a pointer to a VkPhysicalDeviceBufferDeviceAddressFeaturesEXT, but when creating " - "VkDevice, the parent extension " - "(VK_EXT_buffer_device_address) was not included in ppEnabledExtensionNames."); - } - VkPhysicalDeviceBufferDeviceAddressFeaturesEXT* structure = (VkPhysicalDeviceBufferDeviceAddressFeaturesEXT*)header; - skip |= ValidateBool32(pNext_loc.dot(Field::bufferDeviceAddress), structure->bufferDeviceAddress); - - skip |= ValidateBool32(pNext_loc.dot(Field::bufferDeviceAddressCaptureReplay), - structure->bufferDeviceAddressCaptureReplay); - - skip |= - ValidateBool32(pNext_loc.dot(Field::bufferDeviceAddressMultiDevice), structure->bufferDeviceAddressMultiDevice); - } - } break; - // No Validation code for VkBufferDeviceAddressCreateInfoEXT structure members -- Covers // VUID-VkBufferDeviceAddressCreateInfoEXT-sType-sType @@ -5829,45 +8068,6 @@ } } break; - // Validation code for VkPhysicalDeviceCooperativeMatrixFeaturesNV structure members - case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COOPERATIVE_MATRIX_FEATURES_NV: { // Covers - // VUID-VkPhysicalDeviceCooperativeMatrixFeaturesNV-sType-sType - if (is_const_param) { - [[maybe_unused]] const Location pNext_loc = loc.pNext(Struct::VkPhysicalDeviceCooperativeMatrixFeaturesNV); - if (!IsExtEnabled(device_extensions.vk_nv_cooperative_matrix)) { - skip |= LogError(pnext_vuid, instance, pNext_loc, - "includes a pointer to a VkPhysicalDeviceCooperativeMatrixFeaturesNV, but when creating " - "VkDevice, the parent extension " - "(VK_NV_cooperative_matrix) was not included in ppEnabledExtensionNames."); - } - VkPhysicalDeviceCooperativeMatrixFeaturesNV* structure = (VkPhysicalDeviceCooperativeMatrixFeaturesNV*)header; - skip |= ValidateBool32(pNext_loc.dot(Field::cooperativeMatrix), structure->cooperativeMatrix); - - skip |= ValidateBool32(pNext_loc.dot(Field::cooperativeMatrixRobustBufferAccess), - structure->cooperativeMatrixRobustBufferAccess); - } - } break; - - // No Validation code for VkPhysicalDeviceCooperativeMatrixPropertiesNV structure members -- Covers - // VUID-VkPhysicalDeviceCooperativeMatrixPropertiesNV-sType-sType - - // Validation code for VkPhysicalDeviceCoverageReductionModeFeaturesNV structure members - case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COVERAGE_REDUCTION_MODE_FEATURES_NV: { // Covers - // VUID-VkPhysicalDeviceCoverageReductionModeFeaturesNV-sType-sType - if (is_const_param) { - [[maybe_unused]] const Location pNext_loc = loc.pNext(Struct::VkPhysicalDeviceCoverageReductionModeFeaturesNV); - if (!IsExtEnabled(device_extensions.vk_nv_coverage_reduction_mode)) { - skip |= LogError(pnext_vuid, instance, pNext_loc, - "includes a pointer to a VkPhysicalDeviceCoverageReductionModeFeaturesNV, but when creating " - "VkDevice, the parent extension " - "(VK_NV_coverage_reduction_mode) was not included in ppEnabledExtensionNames."); - } - VkPhysicalDeviceCoverageReductionModeFeaturesNV* structure = - (VkPhysicalDeviceCoverageReductionModeFeaturesNV*)header; - skip |= ValidateBool32(pNext_loc.dot(Field::coverageReductionMode), structure->coverageReductionMode); - } - } break; - // Validation code for VkPipelineCoverageReductionStateCreateInfoNV structure members case VK_STRUCTURE_TYPE_PIPELINE_COVERAGE_REDUCTION_STATE_CREATE_INFO_NV: { // Covers // VUID-VkPipelineCoverageReductionStateCreateInfoNV-sType-sType @@ -5887,67 +8087,6 @@ } } break; - // Validation code for VkPhysicalDeviceFragmentShaderInterlockFeaturesEXT structure members - case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_SHADER_INTERLOCK_FEATURES_EXT: { // Covers - // VUID-VkPhysicalDeviceFragmentShaderInterlockFeaturesEXT-sType-sType - if (is_const_param) { - [[maybe_unused]] const Location pNext_loc = loc.pNext(Struct::VkPhysicalDeviceFragmentShaderInterlockFeaturesEXT); - if (!IsExtEnabled(device_extensions.vk_ext_fragment_shader_interlock)) { - skip |= LogError(pnext_vuid, instance, pNext_loc, - "includes a pointer to a VkPhysicalDeviceFragmentShaderInterlockFeaturesEXT, but when " - "creating VkDevice, the parent extension " - "(VK_EXT_fragment_shader_interlock) was not included in ppEnabledExtensionNames."); - } - VkPhysicalDeviceFragmentShaderInterlockFeaturesEXT* structure = - (VkPhysicalDeviceFragmentShaderInterlockFeaturesEXT*)header; - skip |= - ValidateBool32(pNext_loc.dot(Field::fragmentShaderSampleInterlock), structure->fragmentShaderSampleInterlock); - - skip |= ValidateBool32(pNext_loc.dot(Field::fragmentShaderPixelInterlock), structure->fragmentShaderPixelInterlock); - - skip |= ValidateBool32(pNext_loc.dot(Field::fragmentShaderShadingRateInterlock), - structure->fragmentShaderShadingRateInterlock); - } - } break; - - // Validation code for VkPhysicalDeviceYcbcrImageArraysFeaturesEXT structure members - case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_YCBCR_IMAGE_ARRAYS_FEATURES_EXT: { // Covers - // VUID-VkPhysicalDeviceYcbcrImageArraysFeaturesEXT-sType-sType - if (is_const_param) { - [[maybe_unused]] const Location pNext_loc = loc.pNext(Struct::VkPhysicalDeviceYcbcrImageArraysFeaturesEXT); - if (!IsExtEnabled(device_extensions.vk_ext_ycbcr_image_arrays)) { - skip |= LogError(pnext_vuid, instance, pNext_loc, - "includes a pointer to a VkPhysicalDeviceYcbcrImageArraysFeaturesEXT, but when creating " - "VkDevice, the parent extension " - "(VK_EXT_ycbcr_image_arrays) was not included in ppEnabledExtensionNames."); - } - VkPhysicalDeviceYcbcrImageArraysFeaturesEXT* structure = (VkPhysicalDeviceYcbcrImageArraysFeaturesEXT*)header; - skip |= ValidateBool32(pNext_loc.dot(Field::ycbcrImageArrays), structure->ycbcrImageArrays); - } - } break; - - // Validation code for VkPhysicalDeviceProvokingVertexFeaturesEXT structure members - case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PROVOKING_VERTEX_FEATURES_EXT: { // Covers - // VUID-VkPhysicalDeviceProvokingVertexFeaturesEXT-sType-sType - if (is_const_param) { - [[maybe_unused]] const Location pNext_loc = loc.pNext(Struct::VkPhysicalDeviceProvokingVertexFeaturesEXT); - if (!IsExtEnabled(device_extensions.vk_ext_provoking_vertex)) { - skip |= LogError(pnext_vuid, instance, pNext_loc, - "includes a pointer to a VkPhysicalDeviceProvokingVertexFeaturesEXT, but when creating " - "VkDevice, the parent extension " - "(VK_EXT_provoking_vertex) was not included in ppEnabledExtensionNames."); - } - VkPhysicalDeviceProvokingVertexFeaturesEXT* structure = (VkPhysicalDeviceProvokingVertexFeaturesEXT*)header; - skip |= ValidateBool32(pNext_loc.dot(Field::provokingVertexLast), structure->provokingVertexLast); - - skip |= ValidateBool32(pNext_loc.dot(Field::transformFeedbackPreservesProvokingVertex), - structure->transformFeedbackPreservesProvokingVertex); - } - } break; - - // No Validation code for VkPhysicalDeviceProvokingVertexPropertiesEXT structure members -- Covers - // VUID-VkPhysicalDeviceProvokingVertexPropertiesEXT-sType-sType - // Validation code for VkPipelineRasterizationProvokingVertexStateCreateInfoEXT structure members case VK_STRUCTURE_TYPE_PIPELINE_RASTERIZATION_PROVOKING_VERTEX_STATE_CREATE_INFO_EXT: { // Covers // VUID-VkPipelineRasterizationProvokingVertexStateCreateInfoEXT-sType-sType @@ -6001,169 +8140,14 @@ // VUID-VkSurfaceFullScreenExclusiveWin32InfoEXT-sType-sType #endif // VK_USE_PLATFORM_WIN32_KHR - // Validation code for VkPhysicalDeviceShaderAtomicFloatFeaturesEXT structure members - case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_ATOMIC_FLOAT_FEATURES_EXT: { // Covers - // VUID-VkPhysicalDeviceShaderAtomicFloatFeaturesEXT-sType-sType - if (is_const_param) { - [[maybe_unused]] const Location pNext_loc = loc.pNext(Struct::VkPhysicalDeviceShaderAtomicFloatFeaturesEXT); - if (!IsExtEnabled(device_extensions.vk_ext_shader_atomic_float)) { - skip |= LogError(pnext_vuid, instance, pNext_loc, - "includes a pointer to a VkPhysicalDeviceShaderAtomicFloatFeaturesEXT, but when creating " - "VkDevice, the parent extension " - "(VK_EXT_shader_atomic_float) was not included in ppEnabledExtensionNames."); - } - VkPhysicalDeviceShaderAtomicFloatFeaturesEXT* structure = (VkPhysicalDeviceShaderAtomicFloatFeaturesEXT*)header; - skip |= ValidateBool32(pNext_loc.dot(Field::shaderBufferFloat32Atomics), structure->shaderBufferFloat32Atomics); - - skip |= ValidateBool32(pNext_loc.dot(Field::shaderBufferFloat32AtomicAdd), structure->shaderBufferFloat32AtomicAdd); - - skip |= ValidateBool32(pNext_loc.dot(Field::shaderBufferFloat64Atomics), structure->shaderBufferFloat64Atomics); - - skip |= ValidateBool32(pNext_loc.dot(Field::shaderBufferFloat64AtomicAdd), structure->shaderBufferFloat64AtomicAdd); - - skip |= ValidateBool32(pNext_loc.dot(Field::shaderSharedFloat32Atomics), structure->shaderSharedFloat32Atomics); - - skip |= ValidateBool32(pNext_loc.dot(Field::shaderSharedFloat32AtomicAdd), structure->shaderSharedFloat32AtomicAdd); - - skip |= ValidateBool32(pNext_loc.dot(Field::shaderSharedFloat64Atomics), structure->shaderSharedFloat64Atomics); - - skip |= ValidateBool32(pNext_loc.dot(Field::shaderSharedFloat64AtomicAdd), structure->shaderSharedFloat64AtomicAdd); - - skip |= ValidateBool32(pNext_loc.dot(Field::shaderImageFloat32Atomics), structure->shaderImageFloat32Atomics); - - skip |= ValidateBool32(pNext_loc.dot(Field::shaderImageFloat32AtomicAdd), structure->shaderImageFloat32AtomicAdd); - - skip |= ValidateBool32(pNext_loc.dot(Field::sparseImageFloat32Atomics), structure->sparseImageFloat32Atomics); - - skip |= ValidateBool32(pNext_loc.dot(Field::sparseImageFloat32AtomicAdd), structure->sparseImageFloat32AtomicAdd); - } - } break; - - // Validation code for VkPhysicalDeviceExtendedDynamicStateFeaturesEXT structure members - case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTENDED_DYNAMIC_STATE_FEATURES_EXT: { // Covers - // VUID-VkPhysicalDeviceExtendedDynamicStateFeaturesEXT-sType-sType - if (is_const_param) { - [[maybe_unused]] const Location pNext_loc = loc.pNext(Struct::VkPhysicalDeviceExtendedDynamicStateFeaturesEXT); - if (!IsExtEnabled(device_extensions.vk_ext_extended_dynamic_state)) { - skip |= LogError(pnext_vuid, instance, pNext_loc, - "includes a pointer to a VkPhysicalDeviceExtendedDynamicStateFeaturesEXT, but when creating " - "VkDevice, the parent extension " - "(VK_EXT_extended_dynamic_state) was not included in ppEnabledExtensionNames."); - } - VkPhysicalDeviceExtendedDynamicStateFeaturesEXT* structure = - (VkPhysicalDeviceExtendedDynamicStateFeaturesEXT*)header; - skip |= ValidateBool32(pNext_loc.dot(Field::extendedDynamicState), structure->extendedDynamicState); - } - } break; - - // Validation code for VkPhysicalDeviceHostImageCopyFeaturesEXT structure members - case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_HOST_IMAGE_COPY_FEATURES_EXT: { // Covers - // VUID-VkPhysicalDeviceHostImageCopyFeaturesEXT-sType-sType - if (is_const_param) { - [[maybe_unused]] const Location pNext_loc = loc.pNext(Struct::VkPhysicalDeviceHostImageCopyFeaturesEXT); - if (!IsExtEnabled(device_extensions.vk_ext_host_image_copy)) { - skip |= LogError(pnext_vuid, instance, pNext_loc, - "includes a pointer to a VkPhysicalDeviceHostImageCopyFeaturesEXT, but when creating " - "VkDevice, the parent extension " - "(VK_EXT_host_image_copy) was not included in ppEnabledExtensionNames."); - } - VkPhysicalDeviceHostImageCopyFeaturesEXT* structure = (VkPhysicalDeviceHostImageCopyFeaturesEXT*)header; - skip |= ValidateBool32(pNext_loc.dot(Field::hostImageCopy), structure->hostImageCopy); - } - } break; - - // Validation code for VkPhysicalDeviceHostImageCopyPropertiesEXT structure members - case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_HOST_IMAGE_COPY_PROPERTIES_EXT: { // Covers - // VUID-VkPhysicalDeviceHostImageCopyPropertiesEXT-sType-sType - if (is_const_param) { - [[maybe_unused]] const Location pNext_loc = loc.pNext(Struct::VkPhysicalDeviceHostImageCopyPropertiesEXT); - if (!IsExtEnabled(device_extensions.vk_ext_host_image_copy)) { - skip |= - LogError(pnext_vuid, instance, pNext_loc, "extended struct requires the extensions VK_EXT_host_image_copy"); - } - VkPhysicalDeviceHostImageCopyPropertiesEXT* structure = (VkPhysicalDeviceHostImageCopyPropertiesEXT*)header; - skip |= ValidateBool32(pNext_loc.dot(Field::identicalMemoryTypeRequirements), - structure->identicalMemoryTypeRequirements); - } - } break; - // No Validation code for VkSubresourceHostMemcpySizeEXT structure members -- Covers // VUID-VkSubresourceHostMemcpySizeEXT-sType-sType // No Validation code for VkHostImageCopyDevicePerformanceQueryEXT structure members -- Covers // VUID-VkHostImageCopyDevicePerformanceQueryEXT-sType-sType - // Validation code for VkPhysicalDeviceMapMemoryPlacedFeaturesEXT structure members - case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MAP_MEMORY_PLACED_FEATURES_EXT: { // Covers - // VUID-VkPhysicalDeviceMapMemoryPlacedFeaturesEXT-sType-sType - if (is_const_param) { - [[maybe_unused]] const Location pNext_loc = loc.pNext(Struct::VkPhysicalDeviceMapMemoryPlacedFeaturesEXT); - if (!IsExtEnabled(device_extensions.vk_ext_map_memory_placed)) { - skip |= LogError(pnext_vuid, instance, pNext_loc, - "includes a pointer to a VkPhysicalDeviceMapMemoryPlacedFeaturesEXT, but when creating " - "VkDevice, the parent extension " - "(VK_EXT_map_memory_placed) was not included in ppEnabledExtensionNames."); - } - VkPhysicalDeviceMapMemoryPlacedFeaturesEXT* structure = (VkPhysicalDeviceMapMemoryPlacedFeaturesEXT*)header; - skip |= ValidateBool32(pNext_loc.dot(Field::memoryMapPlaced), structure->memoryMapPlaced); - - skip |= ValidateBool32(pNext_loc.dot(Field::memoryMapRangePlaced), structure->memoryMapRangePlaced); - - skip |= ValidateBool32(pNext_loc.dot(Field::memoryUnmapReserve), structure->memoryUnmapReserve); - } - } break; - - // No Validation code for VkPhysicalDeviceMapMemoryPlacedPropertiesEXT structure members -- Covers - // VUID-VkPhysicalDeviceMapMemoryPlacedPropertiesEXT-sType-sType - // No Validation code for VkMemoryMapPlacedInfoEXT structure members -- Covers VUID-VkMemoryMapPlacedInfoEXT-sType-sType - // Validation code for VkPhysicalDeviceShaderAtomicFloat2FeaturesEXT structure members - case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_ATOMIC_FLOAT_2_FEATURES_EXT: { // Covers - // VUID-VkPhysicalDeviceShaderAtomicFloat2FeaturesEXT-sType-sType - if (is_const_param) { - [[maybe_unused]] const Location pNext_loc = loc.pNext(Struct::VkPhysicalDeviceShaderAtomicFloat2FeaturesEXT); - if (!IsExtEnabled(device_extensions.vk_ext_shader_atomic_float2)) { - skip |= LogError(pnext_vuid, instance, pNext_loc, - "includes a pointer to a VkPhysicalDeviceShaderAtomicFloat2FeaturesEXT, but when creating " - "VkDevice, the parent extension " - "(VK_EXT_shader_atomic_float2) was not included in ppEnabledExtensionNames."); - } - VkPhysicalDeviceShaderAtomicFloat2FeaturesEXT* structure = (VkPhysicalDeviceShaderAtomicFloat2FeaturesEXT*)header; - skip |= ValidateBool32(pNext_loc.dot(Field::shaderBufferFloat16Atomics), structure->shaderBufferFloat16Atomics); - - skip |= ValidateBool32(pNext_loc.dot(Field::shaderBufferFloat16AtomicAdd), structure->shaderBufferFloat16AtomicAdd); - - skip |= ValidateBool32(pNext_loc.dot(Field::shaderBufferFloat16AtomicMinMax), - structure->shaderBufferFloat16AtomicMinMax); - - skip |= ValidateBool32(pNext_loc.dot(Field::shaderBufferFloat32AtomicMinMax), - structure->shaderBufferFloat32AtomicMinMax); - - skip |= ValidateBool32(pNext_loc.dot(Field::shaderBufferFloat64AtomicMinMax), - structure->shaderBufferFloat64AtomicMinMax); - - skip |= ValidateBool32(pNext_loc.dot(Field::shaderSharedFloat16Atomics), structure->shaderSharedFloat16Atomics); - - skip |= ValidateBool32(pNext_loc.dot(Field::shaderSharedFloat16AtomicAdd), structure->shaderSharedFloat16AtomicAdd); - - skip |= ValidateBool32(pNext_loc.dot(Field::shaderSharedFloat16AtomicMinMax), - structure->shaderSharedFloat16AtomicMinMax); - - skip |= ValidateBool32(pNext_loc.dot(Field::shaderSharedFloat32AtomicMinMax), - structure->shaderSharedFloat32AtomicMinMax); - - skip |= ValidateBool32(pNext_loc.dot(Field::shaderSharedFloat64AtomicMinMax), - structure->shaderSharedFloat64AtomicMinMax); - - skip |= - ValidateBool32(pNext_loc.dot(Field::shaderImageFloat32AtomicMinMax), structure->shaderImageFloat32AtomicMinMax); - - skip |= - ValidateBool32(pNext_loc.dot(Field::sparseImageFloat32AtomicMinMax), structure->sparseImageFloat32AtomicMinMax); - } - } break; - // Validation code for VkSurfacePresentModeEXT structure members case VK_STRUCTURE_TYPE_SURFACE_PRESENT_MODE_EXT: { // Covers VUID-VkSurfacePresentModeEXT-sType-sType if (is_const_param) { @@ -6197,23 +8181,6 @@ // No Validation code for VkSurfacePresentModeCompatibilityEXT structure members -- Covers // VUID-VkSurfacePresentModeCompatibilityEXT-sType-sType - // Validation code for VkPhysicalDeviceSwapchainMaintenance1FeaturesEXT structure members - case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SWAPCHAIN_MAINTENANCE_1_FEATURES_EXT: { // Covers - // VUID-VkPhysicalDeviceSwapchainMaintenance1FeaturesEXT-sType-sType - if (is_const_param) { - [[maybe_unused]] const Location pNext_loc = loc.pNext(Struct::VkPhysicalDeviceSwapchainMaintenance1FeaturesEXT); - if (!IsExtEnabled(device_extensions.vk_ext_swapchain_maintenance1)) { - skip |= LogError(pnext_vuid, instance, pNext_loc, - "includes a pointer to a VkPhysicalDeviceSwapchainMaintenance1FeaturesEXT, but when creating " - "VkDevice, the parent extension " - "(VK_EXT_swapchain_maintenance1) was not included in ppEnabledExtensionNames."); - } - VkPhysicalDeviceSwapchainMaintenance1FeaturesEXT* structure = - (VkPhysicalDeviceSwapchainMaintenance1FeaturesEXT*)header; - skip |= ValidateBool32(pNext_loc.dot(Field::swapchainMaintenance1), structure->swapchainMaintenance1); - } - } break; - // Validation code for VkSwapchainPresentFenceInfoEXT structure members case VK_STRUCTURE_TYPE_SWAPCHAIN_PRESENT_FENCE_INFO_EXT: { // Covers VUID-VkSwapchainPresentFenceInfoEXT-sType-sType if (is_const_param) { @@ -6287,26 +8254,6 @@ } } break; - // No Validation code for VkPhysicalDeviceDeviceGeneratedCommandsPropertiesNV structure members -- Covers - // VUID-VkPhysicalDeviceDeviceGeneratedCommandsPropertiesNV-sType-sType - - // Validation code for VkPhysicalDeviceDeviceGeneratedCommandsFeaturesNV structure members - case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DEVICE_GENERATED_COMMANDS_FEATURES_NV: { // Covers - // VUID-VkPhysicalDeviceDeviceGeneratedCommandsFeaturesNV-sType-sType - if (is_const_param) { - [[maybe_unused]] const Location pNext_loc = loc.pNext(Struct::VkPhysicalDeviceDeviceGeneratedCommandsFeaturesNV); - if (!IsExtEnabled(device_extensions.vk_nv_device_generated_commands)) { - skip |= LogError(pnext_vuid, instance, pNext_loc, - "includes a pointer to a VkPhysicalDeviceDeviceGeneratedCommandsFeaturesNV, but when creating " - "VkDevice, the parent extension " - "(VK_NV_device_generated_commands) was not included in ppEnabledExtensionNames."); - } - VkPhysicalDeviceDeviceGeneratedCommandsFeaturesNV* structure = - (VkPhysicalDeviceDeviceGeneratedCommandsFeaturesNV*)header; - skip |= ValidateBool32(pNext_loc.dot(Field::deviceGeneratedCommands), structure->deviceGeneratedCommands); - } - } break; - // Validation code for VkGraphicsPipelineShaderGroupsCreateInfoNV structure members case VK_STRUCTURE_TYPE_GRAPHICS_PIPELINE_SHADER_GROUPS_CREATE_INFO_NV: { // Covers // VUID-VkGraphicsPipelineShaderGroupsCreateInfoNV-sType-sType @@ -6392,23 +8339,6 @@ } } break; - // Validation code for VkPhysicalDeviceInheritedViewportScissorFeaturesNV structure members - case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_INHERITED_VIEWPORT_SCISSOR_FEATURES_NV: { // Covers - // VUID-VkPhysicalDeviceInheritedViewportScissorFeaturesNV-sType-sType - if (is_const_param) { - [[maybe_unused]] const Location pNext_loc = loc.pNext(Struct::VkPhysicalDeviceInheritedViewportScissorFeaturesNV); - if (!IsExtEnabled(device_extensions.vk_nv_inherited_viewport_scissor)) { - skip |= LogError(pnext_vuid, instance, pNext_loc, - "includes a pointer to a VkPhysicalDeviceInheritedViewportScissorFeaturesNV, but when " - "creating VkDevice, the parent extension " - "(VK_NV_inherited_viewport_scissor) was not included in ppEnabledExtensionNames."); - } - VkPhysicalDeviceInheritedViewportScissorFeaturesNV* structure = - (VkPhysicalDeviceInheritedViewportScissorFeaturesNV*)header; - skip |= ValidateBool32(pNext_loc.dot(Field::inheritedViewportScissor2D), structure->inheritedViewportScissor2D); - } - } break; - // Validation code for VkCommandBufferInheritanceViewportScissorInfoNV structure members case VK_STRUCTURE_TYPE_COMMAND_BUFFER_INHERITANCE_VIEWPORT_SCISSOR_INFO_NV: { // Covers // VUID-VkCommandBufferInheritanceViewportScissorInfoNV-sType-sType @@ -6424,52 +8354,12 @@ } } break; - // Validation code for VkPhysicalDeviceTexelBufferAlignmentFeaturesEXT structure members - case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TEXEL_BUFFER_ALIGNMENT_FEATURES_EXT: { // Covers - // VUID-VkPhysicalDeviceTexelBufferAlignmentFeaturesEXT-sType-sType - if (is_const_param) { - [[maybe_unused]] const Location pNext_loc = loc.pNext(Struct::VkPhysicalDeviceTexelBufferAlignmentFeaturesEXT); - if (!IsExtEnabled(device_extensions.vk_ext_texel_buffer_alignment)) { - skip |= LogError(pnext_vuid, instance, pNext_loc, - "includes a pointer to a VkPhysicalDeviceTexelBufferAlignmentFeaturesEXT, but when creating " - "VkDevice, the parent extension " - "(VK_EXT_texel_buffer_alignment) was not included in ppEnabledExtensionNames."); - } - VkPhysicalDeviceTexelBufferAlignmentFeaturesEXT* structure = - (VkPhysicalDeviceTexelBufferAlignmentFeaturesEXT*)header; - skip |= ValidateBool32(pNext_loc.dot(Field::texelBufferAlignment), structure->texelBufferAlignment); - } - } break; - // No Validation code for VkRenderPassTransformBeginInfoQCOM structure members -- Covers // VUID-VkRenderPassTransformBeginInfoQCOM-sType-sType // No Validation code for VkCommandBufferInheritanceRenderPassTransformInfoQCOM structure members -- Covers // VUID-VkCommandBufferInheritanceRenderPassTransformInfoQCOM-sType-sType - // Validation code for VkPhysicalDeviceDepthBiasControlFeaturesEXT structure members - case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DEPTH_BIAS_CONTROL_FEATURES_EXT: { // Covers - // VUID-VkPhysicalDeviceDepthBiasControlFeaturesEXT-sType-sType - if (is_const_param) { - [[maybe_unused]] const Location pNext_loc = loc.pNext(Struct::VkPhysicalDeviceDepthBiasControlFeaturesEXT); - if (!IsExtEnabled(device_extensions.vk_ext_depth_bias_control)) { - skip |= LogError(pnext_vuid, instance, pNext_loc, - "includes a pointer to a VkPhysicalDeviceDepthBiasControlFeaturesEXT, but when creating " - "VkDevice, the parent extension " - "(VK_EXT_depth_bias_control) was not included in ppEnabledExtensionNames."); - } - VkPhysicalDeviceDepthBiasControlFeaturesEXT* structure = (VkPhysicalDeviceDepthBiasControlFeaturesEXT*)header; - skip |= ValidateBool32(pNext_loc.dot(Field::depthBiasControl), structure->depthBiasControl); - - skip |= ValidateBool32(pNext_loc.dot(Field::leastRepresentableValueForceUnormRepresentation), - structure->leastRepresentableValueForceUnormRepresentation); - - skip |= ValidateBool32(pNext_loc.dot(Field::floatRepresentation), structure->floatRepresentation); - - skip |= ValidateBool32(pNext_loc.dot(Field::depthBiasExact), structure->depthBiasExact); - } - } break; - // Validation code for VkDepthBiasRepresentationInfoEXT structure members case VK_STRUCTURE_TYPE_DEPTH_BIAS_REPRESENTATION_INFO_EXT: { // Covers VUID-VkDepthBiasRepresentationInfoEXT-sType-sType if (is_const_param) { @@ -6487,22 +8377,6 @@ } } break; - // Validation code for VkPhysicalDeviceDeviceMemoryReportFeaturesEXT structure members - case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DEVICE_MEMORY_REPORT_FEATURES_EXT: { // Covers - // VUID-VkPhysicalDeviceDeviceMemoryReportFeaturesEXT-sType-sType - if (is_const_param) { - [[maybe_unused]] const Location pNext_loc = loc.pNext(Struct::VkPhysicalDeviceDeviceMemoryReportFeaturesEXT); - if (!IsExtEnabled(device_extensions.vk_ext_device_memory_report)) { - skip |= LogError(pnext_vuid, instance, pNext_loc, - "includes a pointer to a VkPhysicalDeviceDeviceMemoryReportFeaturesEXT, but when creating " - "VkDevice, the parent extension " - "(VK_EXT_device_memory_report) was not included in ppEnabledExtensionNames."); - } - VkPhysicalDeviceDeviceMemoryReportFeaturesEXT* structure = (VkPhysicalDeviceDeviceMemoryReportFeaturesEXT*)header; - skip |= ValidateBool32(pNext_loc.dot(Field::deviceMemoryReport), structure->deviceMemoryReport); - } - } break; - // Validation code for VkDeviceDeviceMemoryReportCreateInfoEXT structure members case VK_STRUCTURE_TYPE_DEVICE_DEVICE_MEMORY_REPORT_CREATE_INFO_EXT: { // Covers // VUID-VkDeviceDeviceMemoryReportCreateInfoEXT-sType-sType @@ -6525,29 +8399,6 @@ } } break; - // Validation code for VkPhysicalDeviceRobustness2FeaturesEXT structure members - case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ROBUSTNESS_2_FEATURES_EXT: { // Covers - // VUID-VkPhysicalDeviceRobustness2FeaturesEXT-sType-sType - if (is_const_param) { - [[maybe_unused]] const Location pNext_loc = loc.pNext(Struct::VkPhysicalDeviceRobustness2FeaturesEXT); - if (!IsExtEnabled(device_extensions.vk_ext_robustness2)) { - skip |= LogError(pnext_vuid, instance, pNext_loc, - "includes a pointer to a VkPhysicalDeviceRobustness2FeaturesEXT, but when creating VkDevice, " - "the parent extension " - "(VK_EXT_robustness2) was not included in ppEnabledExtensionNames."); - } - VkPhysicalDeviceRobustness2FeaturesEXT* structure = (VkPhysicalDeviceRobustness2FeaturesEXT*)header; - skip |= ValidateBool32(pNext_loc.dot(Field::robustBufferAccess2), structure->robustBufferAccess2); - - skip |= ValidateBool32(pNext_loc.dot(Field::robustImageAccess2), structure->robustImageAccess2); - - skip |= ValidateBool32(pNext_loc.dot(Field::nullDescriptor), structure->nullDescriptor); - } - } break; - - // No Validation code for VkPhysicalDeviceRobustness2PropertiesEXT structure members -- Covers - // VUID-VkPhysicalDeviceRobustness2PropertiesEXT-sType-sType - // Validation code for VkSamplerCustomBorderColorCreateInfoEXT structure members case VK_STRUCTURE_TYPE_SAMPLER_CUSTOM_BORDER_COLOR_CREATE_INFO_EXT: { // Covers // VUID-VkSamplerCustomBorderColorCreateInfoEXT-sType-sType @@ -6563,44 +8414,6 @@ } } break; - // No Validation code for VkPhysicalDeviceCustomBorderColorPropertiesEXT structure members -- Covers - // VUID-VkPhysicalDeviceCustomBorderColorPropertiesEXT-sType-sType - - // Validation code for VkPhysicalDeviceCustomBorderColorFeaturesEXT structure members - case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_CUSTOM_BORDER_COLOR_FEATURES_EXT: { // Covers - // VUID-VkPhysicalDeviceCustomBorderColorFeaturesEXT-sType-sType - if (is_const_param) { - [[maybe_unused]] const Location pNext_loc = loc.pNext(Struct::VkPhysicalDeviceCustomBorderColorFeaturesEXT); - if (!IsExtEnabled(device_extensions.vk_ext_custom_border_color)) { - skip |= LogError(pnext_vuid, instance, pNext_loc, - "includes a pointer to a VkPhysicalDeviceCustomBorderColorFeaturesEXT, but when creating " - "VkDevice, the parent extension " - "(VK_EXT_custom_border_color) was not included in ppEnabledExtensionNames."); - } - VkPhysicalDeviceCustomBorderColorFeaturesEXT* structure = (VkPhysicalDeviceCustomBorderColorFeaturesEXT*)header; - skip |= ValidateBool32(pNext_loc.dot(Field::customBorderColors), structure->customBorderColors); - - skip |= - ValidateBool32(pNext_loc.dot(Field::customBorderColorWithoutFormat), structure->customBorderColorWithoutFormat); - } - } break; - - // Validation code for VkPhysicalDevicePresentBarrierFeaturesNV structure members - case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PRESENT_BARRIER_FEATURES_NV: { // Covers - // VUID-VkPhysicalDevicePresentBarrierFeaturesNV-sType-sType - if (is_const_param) { - [[maybe_unused]] const Location pNext_loc = loc.pNext(Struct::VkPhysicalDevicePresentBarrierFeaturesNV); - if (!IsExtEnabled(device_extensions.vk_nv_present_barrier)) { - skip |= LogError(pnext_vuid, instance, pNext_loc, - "includes a pointer to a VkPhysicalDevicePresentBarrierFeaturesNV, but when creating " - "VkDevice, the parent extension " - "(VK_NV_present_barrier) was not included in ppEnabledExtensionNames."); - } - VkPhysicalDevicePresentBarrierFeaturesNV* structure = (VkPhysicalDevicePresentBarrierFeaturesNV*)header; - skip |= ValidateBool32(pNext_loc.dot(Field::presentBarrier), structure->presentBarrier); - } - } break; - // Validation code for VkSurfaceCapabilitiesPresentBarrierNV structure members case VK_STRUCTURE_TYPE_SURFACE_CAPABILITIES_PRESENT_BARRIER_NV: { // Covers // VUID-VkSurfaceCapabilitiesPresentBarrierNV-sType-sType @@ -6629,22 +8442,6 @@ } } break; - // Validation code for VkPhysicalDeviceDiagnosticsConfigFeaturesNV structure members - case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DIAGNOSTICS_CONFIG_FEATURES_NV: { // Covers - // VUID-VkPhysicalDeviceDiagnosticsConfigFeaturesNV-sType-sType - if (is_const_param) { - [[maybe_unused]] const Location pNext_loc = loc.pNext(Struct::VkPhysicalDeviceDiagnosticsConfigFeaturesNV); - if (!IsExtEnabled(device_extensions.vk_nv_device_diagnostics_config)) { - skip |= LogError(pnext_vuid, instance, pNext_loc, - "includes a pointer to a VkPhysicalDeviceDiagnosticsConfigFeaturesNV, but when creating " - "VkDevice, the parent extension " - "(VK_NV_device_diagnostics_config) was not included in ppEnabledExtensionNames."); - } - VkPhysicalDeviceDiagnosticsConfigFeaturesNV* structure = (VkPhysicalDeviceDiagnosticsConfigFeaturesNV*)header; - skip |= ValidateBool32(pNext_loc.dot(Field::diagnosticsConfig), structure->diagnosticsConfig); - } - } break; - // Validation code for VkDeviceDiagnosticsConfigCreateInfoNV structure members case VK_STRUCTURE_TYPE_DEVICE_DIAGNOSTICS_CONFIG_CREATE_INFO_NV: { // Covers // VUID-VkDeviceDiagnosticsConfigCreateInfoNV-sType-sType @@ -6661,25 +8458,6 @@ } } break; - // Validation code for VkPhysicalDeviceCudaKernelLaunchFeaturesNV structure members - case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_CUDA_KERNEL_LAUNCH_FEATURES_NV: { // Covers - // VUID-VkPhysicalDeviceCudaKernelLaunchFeaturesNV-sType-sType - if (is_const_param) { - [[maybe_unused]] const Location pNext_loc = loc.pNext(Struct::VkPhysicalDeviceCudaKernelLaunchFeaturesNV); - if (!IsExtEnabled(device_extensions.vk_nv_cuda_kernel_launch)) { - skip |= LogError(pnext_vuid, instance, pNext_loc, - "includes a pointer to a VkPhysicalDeviceCudaKernelLaunchFeaturesNV, but when creating " - "VkDevice, the parent extension " - "(VK_NV_cuda_kernel_launch) was not included in ppEnabledExtensionNames."); - } - VkPhysicalDeviceCudaKernelLaunchFeaturesNV* structure = (VkPhysicalDeviceCudaKernelLaunchFeaturesNV*)header; - skip |= ValidateBool32(pNext_loc.dot(Field::cudaKernelLaunchFeatures), structure->cudaKernelLaunchFeatures); - } - } break; - - // No Validation code for VkPhysicalDeviceCudaKernelLaunchPropertiesNV structure members -- Covers - // VUID-VkPhysicalDeviceCudaKernelLaunchPropertiesNV-sType-sType - // Validation code for VkQueryLowLatencySupportNV structure members case VK_STRUCTURE_TYPE_QUERY_LOW_LATENCY_SUPPORT_NV: { // Covers VUID-VkQueryLowLatencySupportNV-sType-sType if (is_const_param) { @@ -6796,37 +8574,6 @@ // VUID-VkImportMetalSharedEventInfoEXT-sType-sType #endif // VK_USE_PLATFORM_METAL_EXT - // No Validation code for VkPhysicalDeviceDescriptorBufferPropertiesEXT structure members -- Covers - // VUID-VkPhysicalDeviceDescriptorBufferPropertiesEXT-sType-sType - - // No Validation code for VkPhysicalDeviceDescriptorBufferDensityMapPropertiesEXT structure members -- Covers - // VUID-VkPhysicalDeviceDescriptorBufferDensityMapPropertiesEXT-sType-sType - - // Validation code for VkPhysicalDeviceDescriptorBufferFeaturesEXT structure members - case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DESCRIPTOR_BUFFER_FEATURES_EXT: { // Covers - // VUID-VkPhysicalDeviceDescriptorBufferFeaturesEXT-sType-sType - if (is_const_param) { - [[maybe_unused]] const Location pNext_loc = loc.pNext(Struct::VkPhysicalDeviceDescriptorBufferFeaturesEXT); - if (!IsExtEnabled(device_extensions.vk_ext_descriptor_buffer)) { - skip |= LogError(pnext_vuid, instance, pNext_loc, - "includes a pointer to a VkPhysicalDeviceDescriptorBufferFeaturesEXT, but when creating " - "VkDevice, the parent extension " - "(VK_EXT_descriptor_buffer) was not included in ppEnabledExtensionNames."); - } - VkPhysicalDeviceDescriptorBufferFeaturesEXT* structure = (VkPhysicalDeviceDescriptorBufferFeaturesEXT*)header; - skip |= ValidateBool32(pNext_loc.dot(Field::descriptorBuffer), structure->descriptorBuffer); - - skip |= - ValidateBool32(pNext_loc.dot(Field::descriptorBufferCaptureReplay), structure->descriptorBufferCaptureReplay); - - skip |= ValidateBool32(pNext_loc.dot(Field::descriptorBufferImageLayoutIgnored), - structure->descriptorBufferImageLayoutIgnored); - - skip |= ValidateBool32(pNext_loc.dot(Field::descriptorBufferPushDescriptors), - structure->descriptorBufferPushDescriptors); - } - } break; - // Validation code for VkDescriptorBufferBindingPushDescriptorBufferHandleEXT structure members case VK_STRUCTURE_TYPE_DESCRIPTOR_BUFFER_BINDING_PUSH_DESCRIPTOR_BUFFER_HANDLE_EXT: { // Covers // VUID-VkDescriptorBufferBindingPushDescriptorBufferHandleEXT-sType-sType @@ -6859,42 +8606,6 @@ } } break; - // Validation code for VkPhysicalDeviceGraphicsPipelineLibraryFeaturesEXT structure members - case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_GRAPHICS_PIPELINE_LIBRARY_FEATURES_EXT: { // Covers - // VUID-VkPhysicalDeviceGraphicsPipelineLibraryFeaturesEXT-sType-sType - if (is_const_param) { - [[maybe_unused]] const Location pNext_loc = loc.pNext(Struct::VkPhysicalDeviceGraphicsPipelineLibraryFeaturesEXT); - if (!IsExtEnabled(device_extensions.vk_ext_graphics_pipeline_library)) { - skip |= LogError(pnext_vuid, instance, pNext_loc, - "includes a pointer to a VkPhysicalDeviceGraphicsPipelineLibraryFeaturesEXT, but when " - "creating VkDevice, the parent extension " - "(VK_EXT_graphics_pipeline_library) was not included in ppEnabledExtensionNames."); - } - VkPhysicalDeviceGraphicsPipelineLibraryFeaturesEXT* structure = - (VkPhysicalDeviceGraphicsPipelineLibraryFeaturesEXT*)header; - skip |= ValidateBool32(pNext_loc.dot(Field::graphicsPipelineLibrary), structure->graphicsPipelineLibrary); - } - } break; - - // Validation code for VkPhysicalDeviceGraphicsPipelineLibraryPropertiesEXT structure members - case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_GRAPHICS_PIPELINE_LIBRARY_PROPERTIES_EXT: { // Covers - // VUID-VkPhysicalDeviceGraphicsPipelineLibraryPropertiesEXT-sType-sType - if (is_const_param) { - [[maybe_unused]] const Location pNext_loc = loc.pNext(Struct::VkPhysicalDeviceGraphicsPipelineLibraryPropertiesEXT); - if (!IsExtEnabled(device_extensions.vk_ext_graphics_pipeline_library)) { - skip |= LogError(pnext_vuid, instance, pNext_loc, - "extended struct requires the extensions VK_EXT_graphics_pipeline_library"); - } - VkPhysicalDeviceGraphicsPipelineLibraryPropertiesEXT* structure = - (VkPhysicalDeviceGraphicsPipelineLibraryPropertiesEXT*)header; - skip |= ValidateBool32(pNext_loc.dot(Field::graphicsPipelineLibraryFastLinking), - structure->graphicsPipelineLibraryFastLinking); - - skip |= ValidateBool32(pNext_loc.dot(Field::graphicsPipelineLibraryIndependentInterpolationDecoration), - structure->graphicsPipelineLibraryIndependentInterpolationDecoration); - } - } break; - // Validation code for VkGraphicsPipelineLibraryCreateInfoEXT structure members case VK_STRUCTURE_TYPE_GRAPHICS_PIPELINE_LIBRARY_CREATE_INFO_EXT: { // Covers // VUID-VkGraphicsPipelineLibraryCreateInfoEXT-sType-sType @@ -6912,67 +8623,6 @@ } } break; - // Validation code for VkPhysicalDeviceShaderEarlyAndLateFragmentTestsFeaturesAMD structure members - case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_EARLY_AND_LATE_FRAGMENT_TESTS_FEATURES_AMD: { // Covers - // VUID-VkPhysicalDeviceShaderEarlyAndLateFragmentTestsFeaturesAMD-sType-sType - if (is_const_param) { - [[maybe_unused]] const Location pNext_loc = - loc.pNext(Struct::VkPhysicalDeviceShaderEarlyAndLateFragmentTestsFeaturesAMD); - if (!IsExtEnabled(device_extensions.vk_amd_shader_early_and_late_fragment_tests)) { - skip |= LogError(pnext_vuid, instance, pNext_loc, - "includes a pointer to a VkPhysicalDeviceShaderEarlyAndLateFragmentTestsFeaturesAMD, but when " - "creating VkDevice, the parent extension " - "(VK_AMD_shader_early_and_late_fragment_tests) was not included in ppEnabledExtensionNames."); - } - VkPhysicalDeviceShaderEarlyAndLateFragmentTestsFeaturesAMD* structure = - (VkPhysicalDeviceShaderEarlyAndLateFragmentTestsFeaturesAMD*)header; - skip |= ValidateBool32(pNext_loc.dot(Field::shaderEarlyAndLateFragmentTests), - structure->shaderEarlyAndLateFragmentTests); - } - } break; - - // Validation code for VkPhysicalDeviceFragmentShadingRateEnumsFeaturesNV structure members - case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_SHADING_RATE_ENUMS_FEATURES_NV: { // Covers - // VUID-VkPhysicalDeviceFragmentShadingRateEnumsFeaturesNV-sType-sType - if (is_const_param) { - [[maybe_unused]] const Location pNext_loc = loc.pNext(Struct::VkPhysicalDeviceFragmentShadingRateEnumsFeaturesNV); - if (!IsExtEnabled(device_extensions.vk_nv_fragment_shading_rate_enums)) { - skip |= LogError(pnext_vuid, instance, pNext_loc, - "includes a pointer to a VkPhysicalDeviceFragmentShadingRateEnumsFeaturesNV, but when " - "creating VkDevice, the parent extension " - "(VK_NV_fragment_shading_rate_enums) was not included in ppEnabledExtensionNames."); - } - VkPhysicalDeviceFragmentShadingRateEnumsFeaturesNV* structure = - (VkPhysicalDeviceFragmentShadingRateEnumsFeaturesNV*)header; - skip |= ValidateBool32(pNext_loc.dot(Field::fragmentShadingRateEnums), structure->fragmentShadingRateEnums); - - skip |= ValidateBool32(pNext_loc.dot(Field::supersampleFragmentShadingRates), - structure->supersampleFragmentShadingRates); - - skip |= ValidateBool32(pNext_loc.dot(Field::noInvocationFragmentShadingRates), - structure->noInvocationFragmentShadingRates); - } - } break; - - // Validation code for VkPhysicalDeviceFragmentShadingRateEnumsPropertiesNV structure members - case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_SHADING_RATE_ENUMS_PROPERTIES_NV: { // Covers - // VUID-VkPhysicalDeviceFragmentShadingRateEnumsPropertiesNV-sType-sType - if (is_const_param) { - [[maybe_unused]] const Location pNext_loc = loc.pNext(Struct::VkPhysicalDeviceFragmentShadingRateEnumsPropertiesNV); - if (!IsExtEnabled(device_extensions.vk_nv_fragment_shading_rate_enums)) { - skip |= LogError(pnext_vuid, instance, pNext_loc, - "extended struct requires the extensions VK_NV_fragment_shading_rate_enums"); - } - VkPhysicalDeviceFragmentShadingRateEnumsPropertiesNV* structure = - (VkPhysicalDeviceFragmentShadingRateEnumsPropertiesNV*)header; - skip |= ValidateFlags( - pNext_loc.dot(Field::maxFragmentShadingRateInvocationCount), vvl::FlagBitmask::VkSampleCountFlagBits, - AllVkSampleCountFlagBits, structure->maxFragmentShadingRateInvocationCount, kRequiredSingleBit, - "VUID-VkPhysicalDeviceFragmentShadingRateEnumsPropertiesNV-maxFragmentShadingRateInvocationCount-parameter", - "VUID-VkPhysicalDeviceFragmentShadingRateEnumsPropertiesNV-maxFragmentShadingRateInvocationCount-parameter"); - } - } break; - // No Validation code for VkPipelineFragmentShadingRateEnumStateCreateInfoNV structure members -- Covers // VUID-VkPipelineFragmentShadingRateEnumStateCreateInfoNV-sType-sType @@ -6994,203 +8644,15 @@ } } break; - // Validation code for VkPhysicalDeviceRayTracingMotionBlurFeaturesNV structure members - case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RAY_TRACING_MOTION_BLUR_FEATURES_NV: { // Covers - // VUID-VkPhysicalDeviceRayTracingMotionBlurFeaturesNV-sType-sType - if (is_const_param) { - [[maybe_unused]] const Location pNext_loc = loc.pNext(Struct::VkPhysicalDeviceRayTracingMotionBlurFeaturesNV); - if (!IsExtEnabled(device_extensions.vk_nv_ray_tracing_motion_blur)) { - skip |= LogError(pnext_vuid, instance, pNext_loc, - "includes a pointer to a VkPhysicalDeviceRayTracingMotionBlurFeaturesNV, but when creating " - "VkDevice, the parent extension " - "(VK_NV_ray_tracing_motion_blur) was not included in ppEnabledExtensionNames."); - } - VkPhysicalDeviceRayTracingMotionBlurFeaturesNV* structure = (VkPhysicalDeviceRayTracingMotionBlurFeaturesNV*)header; - skip |= ValidateBool32(pNext_loc.dot(Field::rayTracingMotionBlur), structure->rayTracingMotionBlur); - - skip |= ValidateBool32(pNext_loc.dot(Field::rayTracingMotionBlurPipelineTraceRaysIndirect), - structure->rayTracingMotionBlurPipelineTraceRaysIndirect); - } - } break; - - // Validation code for VkPhysicalDeviceYcbcr2Plane444FormatsFeaturesEXT structure members - case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_YCBCR_2_PLANE_444_FORMATS_FEATURES_EXT: { // Covers - // VUID-VkPhysicalDeviceYcbcr2Plane444FormatsFeaturesEXT-sType-sType - if (is_const_param) { - [[maybe_unused]] const Location pNext_loc = loc.pNext(Struct::VkPhysicalDeviceYcbcr2Plane444FormatsFeaturesEXT); - if (!IsExtEnabled(device_extensions.vk_ext_ycbcr_2plane_444_formats)) { - skip |= LogError(pnext_vuid, instance, pNext_loc, - "includes a pointer to a VkPhysicalDeviceYcbcr2Plane444FormatsFeaturesEXT, but when creating " - "VkDevice, the parent extension " - "(VK_EXT_ycbcr_2plane_444_formats) was not included in ppEnabledExtensionNames."); - } - VkPhysicalDeviceYcbcr2Plane444FormatsFeaturesEXT* structure = - (VkPhysicalDeviceYcbcr2Plane444FormatsFeaturesEXT*)header; - skip |= ValidateBool32(pNext_loc.dot(Field::ycbcr2plane444Formats), structure->ycbcr2plane444Formats); - } - } break; - - // Validation code for VkPhysicalDeviceFragmentDensityMap2FeaturesEXT structure members - case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_DENSITY_MAP_2_FEATURES_EXT: { // Covers - // VUID-VkPhysicalDeviceFragmentDensityMap2FeaturesEXT-sType-sType - if (is_const_param) { - [[maybe_unused]] const Location pNext_loc = loc.pNext(Struct::VkPhysicalDeviceFragmentDensityMap2FeaturesEXT); - if (!IsExtEnabled(device_extensions.vk_ext_fragment_density_map2)) { - skip |= LogError(pnext_vuid, instance, pNext_loc, - "includes a pointer to a VkPhysicalDeviceFragmentDensityMap2FeaturesEXT, but when creating " - "VkDevice, the parent extension " - "(VK_EXT_fragment_density_map2) was not included in ppEnabledExtensionNames."); - } - VkPhysicalDeviceFragmentDensityMap2FeaturesEXT* structure = (VkPhysicalDeviceFragmentDensityMap2FeaturesEXT*)header; - skip |= ValidateBool32(pNext_loc.dot(Field::fragmentDensityMapDeferred), structure->fragmentDensityMapDeferred); - } - } break; - - // No Validation code for VkPhysicalDeviceFragmentDensityMap2PropertiesEXT structure members -- Covers - // VUID-VkPhysicalDeviceFragmentDensityMap2PropertiesEXT-sType-sType - // No Validation code for VkCopyCommandTransformInfoQCOM structure members -- Covers // VUID-VkCopyCommandTransformInfoQCOM-sType-sType - // Validation code for VkPhysicalDeviceImageCompressionControlFeaturesEXT structure members - case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_COMPRESSION_CONTROL_FEATURES_EXT: { // Covers - // VUID-VkPhysicalDeviceImageCompressionControlFeaturesEXT-sType-sType - if (is_const_param) { - [[maybe_unused]] const Location pNext_loc = loc.pNext(Struct::VkPhysicalDeviceImageCompressionControlFeaturesEXT); - if (!IsExtEnabled(device_extensions.vk_ext_image_compression_control)) { - skip |= LogError(pnext_vuid, instance, pNext_loc, - "includes a pointer to a VkPhysicalDeviceImageCompressionControlFeaturesEXT, but when " - "creating VkDevice, the parent extension " - "(VK_EXT_image_compression_control) was not included in ppEnabledExtensionNames."); - } - VkPhysicalDeviceImageCompressionControlFeaturesEXT* structure = - (VkPhysicalDeviceImageCompressionControlFeaturesEXT*)header; - skip |= ValidateBool32(pNext_loc.dot(Field::imageCompressionControl), structure->imageCompressionControl); - } - } break; - // No Validation code for VkImageCompressionControlEXT structure members -- Covers // VUID-VkImageCompressionControlEXT-sType-sType // No Validation code for VkImageCompressionPropertiesEXT structure members -- Covers // VUID-VkImageCompressionPropertiesEXT-sType-sType - // Validation code for VkPhysicalDeviceAttachmentFeedbackLoopLayoutFeaturesEXT structure members - case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ATTACHMENT_FEEDBACK_LOOP_LAYOUT_FEATURES_EXT: { // Covers - // VUID-VkPhysicalDeviceAttachmentFeedbackLoopLayoutFeaturesEXT-sType-sType - if (is_const_param) { - [[maybe_unused]] const Location pNext_loc = - loc.pNext(Struct::VkPhysicalDeviceAttachmentFeedbackLoopLayoutFeaturesEXT); - if (!IsExtEnabled(device_extensions.vk_ext_attachment_feedback_loop_layout)) { - skip |= LogError(pnext_vuid, instance, pNext_loc, - "includes a pointer to a VkPhysicalDeviceAttachmentFeedbackLoopLayoutFeaturesEXT, but when " - "creating VkDevice, the parent extension " - "(VK_EXT_attachment_feedback_loop_layout) was not included in ppEnabledExtensionNames."); - } - VkPhysicalDeviceAttachmentFeedbackLoopLayoutFeaturesEXT* structure = - (VkPhysicalDeviceAttachmentFeedbackLoopLayoutFeaturesEXT*)header; - skip |= ValidateBool32(pNext_loc.dot(Field::attachmentFeedbackLoopLayout), structure->attachmentFeedbackLoopLayout); - } - } break; - - // Validation code for VkPhysicalDevice4444FormatsFeaturesEXT structure members - case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_4444_FORMATS_FEATURES_EXT: { // Covers - // VUID-VkPhysicalDevice4444FormatsFeaturesEXT-sType-sType - if (is_const_param) { - [[maybe_unused]] const Location pNext_loc = loc.pNext(Struct::VkPhysicalDevice4444FormatsFeaturesEXT); - if (!IsExtEnabled(device_extensions.vk_ext_4444_formats)) { - skip |= LogError(pnext_vuid, instance, pNext_loc, - "includes a pointer to a VkPhysicalDevice4444FormatsFeaturesEXT, but when creating VkDevice, " - "the parent extension " - "(VK_EXT_4444_formats) was not included in ppEnabledExtensionNames."); - } - VkPhysicalDevice4444FormatsFeaturesEXT* structure = (VkPhysicalDevice4444FormatsFeaturesEXT*)header; - skip |= ValidateBool32(pNext_loc.dot(Field::formatA4R4G4B4), structure->formatA4R4G4B4); - - skip |= ValidateBool32(pNext_loc.dot(Field::formatA4B4G4R4), structure->formatA4B4G4R4); - } - } break; - - // Validation code for VkPhysicalDeviceFaultFeaturesEXT structure members - case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FAULT_FEATURES_EXT: { // Covers VUID-VkPhysicalDeviceFaultFeaturesEXT-sType-sType - if (is_const_param) { - [[maybe_unused]] const Location pNext_loc = loc.pNext(Struct::VkPhysicalDeviceFaultFeaturesEXT); - if (!IsExtEnabled(device_extensions.vk_ext_device_fault)) { - skip |= LogError(pnext_vuid, instance, pNext_loc, - "includes a pointer to a VkPhysicalDeviceFaultFeaturesEXT, but when creating VkDevice, the " - "parent extension " - "(VK_EXT_device_fault) was not included in ppEnabledExtensionNames."); - } - VkPhysicalDeviceFaultFeaturesEXT* structure = (VkPhysicalDeviceFaultFeaturesEXT*)header; - skip |= ValidateBool32(pNext_loc.dot(Field::deviceFault), structure->deviceFault); - - skip |= ValidateBool32(pNext_loc.dot(Field::deviceFaultVendorBinary), structure->deviceFaultVendorBinary); - } - } break; - - // Validation code for VkPhysicalDeviceRasterizationOrderAttachmentAccessFeaturesEXT structure members - case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RASTERIZATION_ORDER_ATTACHMENT_ACCESS_FEATURES_EXT: { // Covers - // VUID-VkPhysicalDeviceRasterizationOrderAttachmentAccessFeaturesEXT-sType-sType - if (is_const_param) { - [[maybe_unused]] const Location pNext_loc = - loc.pNext(Struct::VkPhysicalDeviceRasterizationOrderAttachmentAccessFeaturesEXT); - if (!IsExtEnabled(device_extensions.vk_arm_rasterization_order_attachment_access) && - !IsExtEnabled(device_extensions.vk_ext_rasterization_order_attachment_access)) { - skip |= LogError(pnext_vuid, instance, pNext_loc, - "includes a pointer to a VkPhysicalDeviceRasterizationOrderAttachmentAccessFeaturesEXT, but " - "when creating VkDevice, the parent extension " - "(VK_ARM_rasterization_order_attachment_access or " - "VK_EXT_rasterization_order_attachment_access) was not included in ppEnabledExtensionNames."); - } - VkPhysicalDeviceRasterizationOrderAttachmentAccessFeaturesEXT* structure = - (VkPhysicalDeviceRasterizationOrderAttachmentAccessFeaturesEXT*)header; - skip |= ValidateBool32(pNext_loc.dot(Field::rasterizationOrderColorAttachmentAccess), - structure->rasterizationOrderColorAttachmentAccess); - - skip |= ValidateBool32(pNext_loc.dot(Field::rasterizationOrderDepthAttachmentAccess), - structure->rasterizationOrderDepthAttachmentAccess); - - skip |= ValidateBool32(pNext_loc.dot(Field::rasterizationOrderStencilAttachmentAccess), - structure->rasterizationOrderStencilAttachmentAccess); - } - } break; - - // Validation code for VkPhysicalDeviceRGBA10X6FormatsFeaturesEXT structure members - case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RGBA10X6_FORMATS_FEATURES_EXT: { // Covers - // VUID-VkPhysicalDeviceRGBA10X6FormatsFeaturesEXT-sType-sType - if (is_const_param) { - [[maybe_unused]] const Location pNext_loc = loc.pNext(Struct::VkPhysicalDeviceRGBA10X6FormatsFeaturesEXT); - if (!IsExtEnabled(device_extensions.vk_ext_rgba10x6_formats)) { - skip |= LogError(pnext_vuid, instance, pNext_loc, - "includes a pointer to a VkPhysicalDeviceRGBA10X6FormatsFeaturesEXT, but when creating " - "VkDevice, the parent extension " - "(VK_EXT_rgba10x6_formats) was not included in ppEnabledExtensionNames."); - } - VkPhysicalDeviceRGBA10X6FormatsFeaturesEXT* structure = (VkPhysicalDeviceRGBA10X6FormatsFeaturesEXT*)header; - skip |= ValidateBool32(pNext_loc.dot(Field::formatRgba10x6WithoutYCbCrSampler), - structure->formatRgba10x6WithoutYCbCrSampler); - } - } break; - - // Validation code for VkPhysicalDeviceMutableDescriptorTypeFeaturesEXT structure members - case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MUTABLE_DESCRIPTOR_TYPE_FEATURES_EXT: { // Covers - // VUID-VkPhysicalDeviceMutableDescriptorTypeFeaturesEXT-sType-sType - if (is_const_param) { - [[maybe_unused]] const Location pNext_loc = loc.pNext(Struct::VkPhysicalDeviceMutableDescriptorTypeFeaturesEXT); - if (!IsExtEnabled(device_extensions.vk_valve_mutable_descriptor_type) && - !IsExtEnabled(device_extensions.vk_ext_mutable_descriptor_type)) { - skip |= LogError(pnext_vuid, instance, pNext_loc, - "includes a pointer to a VkPhysicalDeviceMutableDescriptorTypeFeaturesEXT, but when creating " - "VkDevice, the parent extension " - "(VK_VALVE_mutable_descriptor_type or VK_EXT_mutable_descriptor_type) was not included in " - "ppEnabledExtensionNames."); - } - VkPhysicalDeviceMutableDescriptorTypeFeaturesEXT* structure = - (VkPhysicalDeviceMutableDescriptorTypeFeaturesEXT*)header; - skip |= ValidateBool32(pNext_loc.dot(Field::mutableDescriptorType), structure->mutableDescriptorType); - } - } break; - // Validation code for VkMutableDescriptorTypeCreateInfoEXT structure members case VK_STRUCTURE_TYPE_MUTABLE_DESCRIPTOR_TYPE_CREATE_INFO_EXT: { // Covers // VUID-VkMutableDescriptorTypeCreateInfoEXT-sType-sType @@ -7225,43 +8687,6 @@ } } break; - // Validation code for VkPhysicalDeviceVertexInputDynamicStateFeaturesEXT structure members - case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VERTEX_INPUT_DYNAMIC_STATE_FEATURES_EXT: { // Covers - // VUID-VkPhysicalDeviceVertexInputDynamicStateFeaturesEXT-sType-sType - if (is_const_param) { - [[maybe_unused]] const Location pNext_loc = loc.pNext(Struct::VkPhysicalDeviceVertexInputDynamicStateFeaturesEXT); - if (!IsExtEnabled(device_extensions.vk_ext_vertex_input_dynamic_state)) { - skip |= LogError(pnext_vuid, instance, pNext_loc, - "includes a pointer to a VkPhysicalDeviceVertexInputDynamicStateFeaturesEXT, but when " - "creating VkDevice, the parent extension " - "(VK_EXT_vertex_input_dynamic_state) was not included in ppEnabledExtensionNames."); - } - VkPhysicalDeviceVertexInputDynamicStateFeaturesEXT* structure = - (VkPhysicalDeviceVertexInputDynamicStateFeaturesEXT*)header; - skip |= ValidateBool32(pNext_loc.dot(Field::vertexInputDynamicState), structure->vertexInputDynamicState); - } - } break; - - // No Validation code for VkPhysicalDeviceDrmPropertiesEXT structure members -- Covers - // VUID-VkPhysicalDeviceDrmPropertiesEXT-sType-sType - - // Validation code for VkPhysicalDeviceAddressBindingReportFeaturesEXT structure members - case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ADDRESS_BINDING_REPORT_FEATURES_EXT: { // Covers - // VUID-VkPhysicalDeviceAddressBindingReportFeaturesEXT-sType-sType - if (is_const_param) { - [[maybe_unused]] const Location pNext_loc = loc.pNext(Struct::VkPhysicalDeviceAddressBindingReportFeaturesEXT); - if (!IsExtEnabled(device_extensions.vk_ext_device_address_binding_report)) { - skip |= LogError(pnext_vuid, instance, pNext_loc, - "includes a pointer to a VkPhysicalDeviceAddressBindingReportFeaturesEXT, but when creating " - "VkDevice, the parent extension " - "(VK_EXT_device_address_binding_report) was not included in ppEnabledExtensionNames."); - } - VkPhysicalDeviceAddressBindingReportFeaturesEXT* structure = - (VkPhysicalDeviceAddressBindingReportFeaturesEXT*)header; - skip |= ValidateBool32(pNext_loc.dot(Field::reportAddressBinding), structure->reportAddressBinding); - } - } break; - // Validation code for VkDeviceAddressBindingCallbackDataEXT structure members case VK_STRUCTURE_TYPE_DEVICE_ADDRESS_BINDING_CALLBACK_DATA_EXT: { // Covers // VUID-VkDeviceAddressBindingCallbackDataEXT-sType-sType @@ -7282,22 +8707,6 @@ } } break; - // Validation code for VkPhysicalDeviceDepthClipControlFeaturesEXT structure members - case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DEPTH_CLIP_CONTROL_FEATURES_EXT: { // Covers - // VUID-VkPhysicalDeviceDepthClipControlFeaturesEXT-sType-sType - if (is_const_param) { - [[maybe_unused]] const Location pNext_loc = loc.pNext(Struct::VkPhysicalDeviceDepthClipControlFeaturesEXT); - if (!IsExtEnabled(device_extensions.vk_ext_depth_clip_control)) { - skip |= LogError(pnext_vuid, instance, pNext_loc, - "includes a pointer to a VkPhysicalDeviceDepthClipControlFeaturesEXT, but when creating " - "VkDevice, the parent extension " - "(VK_EXT_depth_clip_control) was not included in ppEnabledExtensionNames."); - } - VkPhysicalDeviceDepthClipControlFeaturesEXT* structure = (VkPhysicalDeviceDepthClipControlFeaturesEXT*)header; - skip |= ValidateBool32(pNext_loc.dot(Field::depthClipControl), structure->depthClipControl); - } - } break; - // Validation code for VkPipelineViewportDepthClipControlCreateInfoEXT structure members case VK_STRUCTURE_TYPE_PIPELINE_VIEWPORT_DEPTH_CLIP_CONTROL_CREATE_INFO_EXT: { // Covers // VUID-VkPipelineViewportDepthClipControlCreateInfoEXT-sType-sType @@ -7312,27 +8721,6 @@ skip |= ValidateBool32(pNext_loc.dot(Field::negativeOneToOne), structure->negativeOneToOne); } } break; - - // Validation code for VkPhysicalDevicePrimitiveTopologyListRestartFeaturesEXT structure members - case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PRIMITIVE_TOPOLOGY_LIST_RESTART_FEATURES_EXT: { // Covers - // VUID-VkPhysicalDevicePrimitiveTopologyListRestartFeaturesEXT-sType-sType - if (is_const_param) { - [[maybe_unused]] const Location pNext_loc = - loc.pNext(Struct::VkPhysicalDevicePrimitiveTopologyListRestartFeaturesEXT); - if (!IsExtEnabled(device_extensions.vk_ext_primitive_topology_list_restart)) { - skip |= LogError(pnext_vuid, instance, pNext_loc, - "includes a pointer to a VkPhysicalDevicePrimitiveTopologyListRestartFeaturesEXT, but when " - "creating VkDevice, the parent extension " - "(VK_EXT_primitive_topology_list_restart) was not included in ppEnabledExtensionNames."); - } - VkPhysicalDevicePrimitiveTopologyListRestartFeaturesEXT* structure = - (VkPhysicalDevicePrimitiveTopologyListRestartFeaturesEXT*)header; - skip |= ValidateBool32(pNext_loc.dot(Field::primitiveTopologyListRestart), structure->primitiveTopologyListRestart); - - skip |= ValidateBool32(pNext_loc.dot(Field::primitiveTopologyPatchListRestart), - structure->primitiveTopologyPatchListRestart); - } - } break; #ifdef VK_USE_PLATFORM_FUCHSIA // Validation code for VkImportMemoryZirconHandleInfoFUCHSIA structure members @@ -7408,89 +8796,6 @@ } } break; - // Validation code for VkPhysicalDeviceSubpassShadingFeaturesHUAWEI structure members - case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SUBPASS_SHADING_FEATURES_HUAWEI: { // Covers - // VUID-VkPhysicalDeviceSubpassShadingFeaturesHUAWEI-sType-sType - if (is_const_param) { - [[maybe_unused]] const Location pNext_loc = loc.pNext(Struct::VkPhysicalDeviceSubpassShadingFeaturesHUAWEI); - if (!IsExtEnabled(device_extensions.vk_huawei_subpass_shading)) { - skip |= LogError(pnext_vuid, instance, pNext_loc, - "includes a pointer to a VkPhysicalDeviceSubpassShadingFeaturesHUAWEI, but when creating " - "VkDevice, the parent extension " - "(VK_HUAWEI_subpass_shading) was not included in ppEnabledExtensionNames."); - } - VkPhysicalDeviceSubpassShadingFeaturesHUAWEI* structure = (VkPhysicalDeviceSubpassShadingFeaturesHUAWEI*)header; - skip |= ValidateBool32(pNext_loc.dot(Field::subpassShading), structure->subpassShading); - } - } break; - - // No Validation code for VkPhysicalDeviceSubpassShadingPropertiesHUAWEI structure members -- Covers - // VUID-VkPhysicalDeviceSubpassShadingPropertiesHUAWEI-sType-sType - - // Validation code for VkPhysicalDeviceInvocationMaskFeaturesHUAWEI structure members - case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_INVOCATION_MASK_FEATURES_HUAWEI: { // Covers - // VUID-VkPhysicalDeviceInvocationMaskFeaturesHUAWEI-sType-sType - if (is_const_param) { - [[maybe_unused]] const Location pNext_loc = loc.pNext(Struct::VkPhysicalDeviceInvocationMaskFeaturesHUAWEI); - if (!IsExtEnabled(device_extensions.vk_huawei_invocation_mask)) { - skip |= LogError(pnext_vuid, instance, pNext_loc, - "includes a pointer to a VkPhysicalDeviceInvocationMaskFeaturesHUAWEI, but when creating " - "VkDevice, the parent extension " - "(VK_HUAWEI_invocation_mask) was not included in ppEnabledExtensionNames."); - } - VkPhysicalDeviceInvocationMaskFeaturesHUAWEI* structure = (VkPhysicalDeviceInvocationMaskFeaturesHUAWEI*)header; - skip |= ValidateBool32(pNext_loc.dot(Field::invocationMask), structure->invocationMask); - } - } break; - - // Validation code for VkPhysicalDeviceExternalMemoryRDMAFeaturesNV structure members - case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTERNAL_MEMORY_RDMA_FEATURES_NV: { // Covers - // VUID-VkPhysicalDeviceExternalMemoryRDMAFeaturesNV-sType-sType - if (is_const_param) { - [[maybe_unused]] const Location pNext_loc = loc.pNext(Struct::VkPhysicalDeviceExternalMemoryRDMAFeaturesNV); - if (!IsExtEnabled(device_extensions.vk_nv_external_memory_rdma)) { - skip |= LogError(pnext_vuid, instance, pNext_loc, - "includes a pointer to a VkPhysicalDeviceExternalMemoryRDMAFeaturesNV, but when creating " - "VkDevice, the parent extension " - "(VK_NV_external_memory_rdma) was not included in ppEnabledExtensionNames."); - } - VkPhysicalDeviceExternalMemoryRDMAFeaturesNV* structure = (VkPhysicalDeviceExternalMemoryRDMAFeaturesNV*)header; - skip |= ValidateBool32(pNext_loc.dot(Field::externalMemoryRDMA), structure->externalMemoryRDMA); - } - } break; - - // Validation code for VkPhysicalDevicePipelinePropertiesFeaturesEXT structure members - case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PIPELINE_PROPERTIES_FEATURES_EXT: { // Covers - // VUID-VkPhysicalDevicePipelinePropertiesFeaturesEXT-sType-sType - if (is_const_param) { - [[maybe_unused]] const Location pNext_loc = loc.pNext(Struct::VkPhysicalDevicePipelinePropertiesFeaturesEXT); - if (!IsExtEnabled(device_extensions.vk_ext_pipeline_properties)) { - skip |= LogError(pnext_vuid, instance, pNext_loc, - "includes a pointer to a VkPhysicalDevicePipelinePropertiesFeaturesEXT, but when creating " - "VkDevice, the parent extension " - "(VK_EXT_pipeline_properties) was not included in ppEnabledExtensionNames."); - } - VkPhysicalDevicePipelinePropertiesFeaturesEXT* structure = (VkPhysicalDevicePipelinePropertiesFeaturesEXT*)header; - skip |= ValidateBool32(pNext_loc.dot(Field::pipelinePropertiesIdentifier), structure->pipelinePropertiesIdentifier); - } - } break; - - // Validation code for VkPhysicalDeviceFrameBoundaryFeaturesEXT structure members - case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAME_BOUNDARY_FEATURES_EXT: { // Covers - // VUID-VkPhysicalDeviceFrameBoundaryFeaturesEXT-sType-sType - if (is_const_param) { - [[maybe_unused]] const Location pNext_loc = loc.pNext(Struct::VkPhysicalDeviceFrameBoundaryFeaturesEXT); - if (!IsExtEnabled(device_extensions.vk_ext_frame_boundary)) { - skip |= LogError(pnext_vuid, instance, pNext_loc, - "includes a pointer to a VkPhysicalDeviceFrameBoundaryFeaturesEXT, but when creating " - "VkDevice, the parent extension " - "(VK_EXT_frame_boundary) was not included in ppEnabledExtensionNames."); - } - VkPhysicalDeviceFrameBoundaryFeaturesEXT* structure = (VkPhysicalDeviceFrameBoundaryFeaturesEXT*)header; - skip |= ValidateBool32(pNext_loc.dot(Field::frameBoundary), structure->frameBoundary); - } - } break; - // Validation code for VkFrameBoundaryEXT structure members case VK_STRUCTURE_TYPE_FRAME_BOUNDARY_EXT: { // Covers VUID-VkFrameBoundaryEXT-sType-sType if (is_const_param) { @@ -7506,25 +8811,6 @@ } } break; - // Validation code for VkPhysicalDeviceMultisampledRenderToSingleSampledFeaturesEXT structure members - case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MULTISAMPLED_RENDER_TO_SINGLE_SAMPLED_FEATURES_EXT: { // Covers - // VUID-VkPhysicalDeviceMultisampledRenderToSingleSampledFeaturesEXT-sType-sType - if (is_const_param) { - [[maybe_unused]] const Location pNext_loc = - loc.pNext(Struct::VkPhysicalDeviceMultisampledRenderToSingleSampledFeaturesEXT); - if (!IsExtEnabled(device_extensions.vk_ext_multisampled_render_to_single_sampled)) { - skip |= LogError(pnext_vuid, instance, pNext_loc, - "includes a pointer to a VkPhysicalDeviceMultisampledRenderToSingleSampledFeaturesEXT, but " - "when creating VkDevice, the parent extension " - "(VK_EXT_multisampled_render_to_single_sampled) was not included in ppEnabledExtensionNames."); - } - VkPhysicalDeviceMultisampledRenderToSingleSampledFeaturesEXT* structure = - (VkPhysicalDeviceMultisampledRenderToSingleSampledFeaturesEXT*)header; - skip |= ValidateBool32(pNext_loc.dot(Field::multisampledRenderToSingleSampled), - structure->multisampledRenderToSingleSampled); - } - } break; - // No Validation code for VkSubpassResolvePerformanceQueryEXT structure members -- Covers // VUID-VkSubpassResolvePerformanceQueryEXT-sType-sType @@ -7548,44 +8834,6 @@ } } break; - // Validation code for VkPhysicalDeviceExtendedDynamicState2FeaturesEXT structure members - case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTENDED_DYNAMIC_STATE_2_FEATURES_EXT: { // Covers - // VUID-VkPhysicalDeviceExtendedDynamicState2FeaturesEXT-sType-sType - if (is_const_param) { - [[maybe_unused]] const Location pNext_loc = loc.pNext(Struct::VkPhysicalDeviceExtendedDynamicState2FeaturesEXT); - if (!IsExtEnabled(device_extensions.vk_ext_extended_dynamic_state2)) { - skip |= LogError(pnext_vuid, instance, pNext_loc, - "includes a pointer to a VkPhysicalDeviceExtendedDynamicState2FeaturesEXT, but when creating " - "VkDevice, the parent extension " - "(VK_EXT_extended_dynamic_state2) was not included in ppEnabledExtensionNames."); - } - VkPhysicalDeviceExtendedDynamicState2FeaturesEXT* structure = - (VkPhysicalDeviceExtendedDynamicState2FeaturesEXT*)header; - skip |= ValidateBool32(pNext_loc.dot(Field::extendedDynamicState2), structure->extendedDynamicState2); - - skip |= ValidateBool32(pNext_loc.dot(Field::extendedDynamicState2LogicOp), structure->extendedDynamicState2LogicOp); - - skip |= ValidateBool32(pNext_loc.dot(Field::extendedDynamicState2PatchControlPoints), - structure->extendedDynamicState2PatchControlPoints); - } - } break; - - // Validation code for VkPhysicalDeviceColorWriteEnableFeaturesEXT structure members - case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COLOR_WRITE_ENABLE_FEATURES_EXT: { // Covers - // VUID-VkPhysicalDeviceColorWriteEnableFeaturesEXT-sType-sType - if (is_const_param) { - [[maybe_unused]] const Location pNext_loc = loc.pNext(Struct::VkPhysicalDeviceColorWriteEnableFeaturesEXT); - if (!IsExtEnabled(device_extensions.vk_ext_color_write_enable)) { - skip |= LogError(pnext_vuid, instance, pNext_loc, - "includes a pointer to a VkPhysicalDeviceColorWriteEnableFeaturesEXT, but when creating " - "VkDevice, the parent extension " - "(VK_EXT_color_write_enable) was not included in ppEnabledExtensionNames."); - } - VkPhysicalDeviceColorWriteEnableFeaturesEXT* structure = (VkPhysicalDeviceColorWriteEnableFeaturesEXT*)header; - skip |= ValidateBool32(pNext_loc.dot(Field::colorWriteEnable), structure->colorWriteEnable); - } - } break; - // Validation code for VkPipelineColorWriteCreateInfoEXT structure members case VK_STRUCTURE_TYPE_PIPELINE_COLOR_WRITE_CREATE_INFO_EXT: { // Covers VUID-VkPipelineColorWriteCreateInfoEXT-sType-sType if (is_const_param) { @@ -7601,134 +8849,9 @@ } } break; - // Validation code for VkPhysicalDevicePrimitivesGeneratedQueryFeaturesEXT structure members - case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PRIMITIVES_GENERATED_QUERY_FEATURES_EXT: { // Covers - // VUID-VkPhysicalDevicePrimitivesGeneratedQueryFeaturesEXT-sType-sType - if (is_const_param) { - [[maybe_unused]] const Location pNext_loc = loc.pNext(Struct::VkPhysicalDevicePrimitivesGeneratedQueryFeaturesEXT); - if (!IsExtEnabled(device_extensions.vk_ext_primitives_generated_query)) { - skip |= LogError(pnext_vuid, instance, pNext_loc, - "includes a pointer to a VkPhysicalDevicePrimitivesGeneratedQueryFeaturesEXT, but when " - "creating VkDevice, the parent extension " - "(VK_EXT_primitives_generated_query) was not included in ppEnabledExtensionNames."); - } - VkPhysicalDevicePrimitivesGeneratedQueryFeaturesEXT* structure = - (VkPhysicalDevicePrimitivesGeneratedQueryFeaturesEXT*)header; - skip |= ValidateBool32(pNext_loc.dot(Field::primitivesGeneratedQuery), structure->primitivesGeneratedQuery); - - skip |= ValidateBool32(pNext_loc.dot(Field::primitivesGeneratedQueryWithRasterizerDiscard), - structure->primitivesGeneratedQueryWithRasterizerDiscard); - - skip |= ValidateBool32(pNext_loc.dot(Field::primitivesGeneratedQueryWithNonZeroStreams), - structure->primitivesGeneratedQueryWithNonZeroStreams); - } - } break; - - // Validation code for VkPhysicalDeviceImageViewMinLodFeaturesEXT structure members - case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_VIEW_MIN_LOD_FEATURES_EXT: { // Covers - // VUID-VkPhysicalDeviceImageViewMinLodFeaturesEXT-sType-sType - if (is_const_param) { - [[maybe_unused]] const Location pNext_loc = loc.pNext(Struct::VkPhysicalDeviceImageViewMinLodFeaturesEXT); - if (!IsExtEnabled(device_extensions.vk_ext_image_view_min_lod)) { - skip |= LogError(pnext_vuid, instance, pNext_loc, - "includes a pointer to a VkPhysicalDeviceImageViewMinLodFeaturesEXT, but when creating " - "VkDevice, the parent extension " - "(VK_EXT_image_view_min_lod) was not included in ppEnabledExtensionNames."); - } - VkPhysicalDeviceImageViewMinLodFeaturesEXT* structure = (VkPhysicalDeviceImageViewMinLodFeaturesEXT*)header; - skip |= ValidateBool32(pNext_loc.dot(Field::minLod), structure->minLod); - } - } break; - // No Validation code for VkImageViewMinLodCreateInfoEXT structure members -- Covers // VUID-VkImageViewMinLodCreateInfoEXT-sType-sType - // Validation code for VkPhysicalDeviceMultiDrawFeaturesEXT structure members - case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MULTI_DRAW_FEATURES_EXT: { // Covers - // VUID-VkPhysicalDeviceMultiDrawFeaturesEXT-sType-sType - if (is_const_param) { - [[maybe_unused]] const Location pNext_loc = loc.pNext(Struct::VkPhysicalDeviceMultiDrawFeaturesEXT); - if (!IsExtEnabled(device_extensions.vk_ext_multi_draw)) { - skip |= LogError(pnext_vuid, instance, pNext_loc, - "includes a pointer to a VkPhysicalDeviceMultiDrawFeaturesEXT, but when creating VkDevice, " - "the parent extension " - "(VK_EXT_multi_draw) was not included in ppEnabledExtensionNames."); - } - VkPhysicalDeviceMultiDrawFeaturesEXT* structure = (VkPhysicalDeviceMultiDrawFeaturesEXT*)header; - skip |= ValidateBool32(pNext_loc.dot(Field::multiDraw), structure->multiDraw); - } - } break; - - // No Validation code for VkPhysicalDeviceMultiDrawPropertiesEXT structure members -- Covers - // VUID-VkPhysicalDeviceMultiDrawPropertiesEXT-sType-sType - - // Validation code for VkPhysicalDeviceImage2DViewOf3DFeaturesEXT structure members - case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_2D_VIEW_OF_3D_FEATURES_EXT: { // Covers - // VUID-VkPhysicalDeviceImage2DViewOf3DFeaturesEXT-sType-sType - if (is_const_param) { - [[maybe_unused]] const Location pNext_loc = loc.pNext(Struct::VkPhysicalDeviceImage2DViewOf3DFeaturesEXT); - if (!IsExtEnabled(device_extensions.vk_ext_image_2d_view_of_3d)) { - skip |= LogError(pnext_vuid, instance, pNext_loc, - "includes a pointer to a VkPhysicalDeviceImage2DViewOf3DFeaturesEXT, but when creating " - "VkDevice, the parent extension " - "(VK_EXT_image_2d_view_of_3d) was not included in ppEnabledExtensionNames."); - } - VkPhysicalDeviceImage2DViewOf3DFeaturesEXT* structure = (VkPhysicalDeviceImage2DViewOf3DFeaturesEXT*)header; - skip |= ValidateBool32(pNext_loc.dot(Field::image2DViewOf3D), structure->image2DViewOf3D); - - skip |= ValidateBool32(pNext_loc.dot(Field::sampler2DViewOf3D), structure->sampler2DViewOf3D); - } - } break; - - // Validation code for VkPhysicalDeviceShaderTileImageFeaturesEXT structure members - case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_TILE_IMAGE_FEATURES_EXT: { // Covers - // VUID-VkPhysicalDeviceShaderTileImageFeaturesEXT-sType-sType - if (is_const_param) { - [[maybe_unused]] const Location pNext_loc = loc.pNext(Struct::VkPhysicalDeviceShaderTileImageFeaturesEXT); - if (!IsExtEnabled(device_extensions.vk_ext_shader_tile_image)) { - skip |= LogError(pnext_vuid, instance, pNext_loc, - "includes a pointer to a VkPhysicalDeviceShaderTileImageFeaturesEXT, but when creating " - "VkDevice, the parent extension " - "(VK_EXT_shader_tile_image) was not included in ppEnabledExtensionNames."); - } - VkPhysicalDeviceShaderTileImageFeaturesEXT* structure = (VkPhysicalDeviceShaderTileImageFeaturesEXT*)header; - skip |= - ValidateBool32(pNext_loc.dot(Field::shaderTileImageColorReadAccess), structure->shaderTileImageColorReadAccess); - - skip |= - ValidateBool32(pNext_loc.dot(Field::shaderTileImageDepthReadAccess), structure->shaderTileImageDepthReadAccess); - - skip |= ValidateBool32(pNext_loc.dot(Field::shaderTileImageStencilReadAccess), - structure->shaderTileImageStencilReadAccess); - } - } break; - - // No Validation code for VkPhysicalDeviceShaderTileImagePropertiesEXT structure members -- Covers - // VUID-VkPhysicalDeviceShaderTileImagePropertiesEXT-sType-sType - - // Validation code for VkPhysicalDeviceOpacityMicromapFeaturesEXT structure members - case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_OPACITY_MICROMAP_FEATURES_EXT: { // Covers - // VUID-VkPhysicalDeviceOpacityMicromapFeaturesEXT-sType-sType - if (is_const_param) { - [[maybe_unused]] const Location pNext_loc = loc.pNext(Struct::VkPhysicalDeviceOpacityMicromapFeaturesEXT); - if (!IsExtEnabled(device_extensions.vk_ext_opacity_micromap)) { - skip |= LogError(pnext_vuid, instance, pNext_loc, - "includes a pointer to a VkPhysicalDeviceOpacityMicromapFeaturesEXT, but when creating " - "VkDevice, the parent extension " - "(VK_EXT_opacity_micromap) was not included in ppEnabledExtensionNames."); - } - VkPhysicalDeviceOpacityMicromapFeaturesEXT* structure = (VkPhysicalDeviceOpacityMicromapFeaturesEXT*)header; - skip |= ValidateBool32(pNext_loc.dot(Field::micromap), structure->micromap); - - skip |= ValidateBool32(pNext_loc.dot(Field::micromapCaptureReplay), structure->micromapCaptureReplay); - - skip |= ValidateBool32(pNext_loc.dot(Field::micromapHostCommands), structure->micromapHostCommands); - } - } break; - - // No Validation code for VkPhysicalDeviceOpacityMicromapPropertiesEXT structure members -- Covers - // VUID-VkPhysicalDeviceOpacityMicromapPropertiesEXT-sType-sType - // Validation code for VkAccelerationStructureTrianglesOpacityMicromapEXT structure members case VK_STRUCTURE_TYPE_ACCELERATION_STRUCTURE_TRIANGLES_OPACITY_MICROMAP_EXT: { // Covers // VUID-VkAccelerationStructureTrianglesOpacityMicromapEXT-sType-sType @@ -7758,25 +8881,6 @@ } break; #ifdef VK_ENABLE_BETA_EXTENSIONS - // Validation code for VkPhysicalDeviceDisplacementMicromapFeaturesNV structure members - case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DISPLACEMENT_MICROMAP_FEATURES_NV: { // Covers - // VUID-VkPhysicalDeviceDisplacementMicromapFeaturesNV-sType-sType - if (is_const_param) { - [[maybe_unused]] const Location pNext_loc = loc.pNext(Struct::VkPhysicalDeviceDisplacementMicromapFeaturesNV); - if (!IsExtEnabled(device_extensions.vk_nv_displacement_micromap)) { - skip |= LogError(pnext_vuid, instance, pNext_loc, - "includes a pointer to a VkPhysicalDeviceDisplacementMicromapFeaturesNV, but when creating " - "VkDevice, the parent extension " - "(VK_NV_displacement_micromap) was not included in ppEnabledExtensionNames."); - } - VkPhysicalDeviceDisplacementMicromapFeaturesNV* structure = (VkPhysicalDeviceDisplacementMicromapFeaturesNV*)header; - skip |= ValidateBool32(pNext_loc.dot(Field::displacementMicromap), structure->displacementMicromap); - } - } break; - - // No Validation code for VkPhysicalDeviceDisplacementMicromapPropertiesNV structure members -- Covers - // VUID-VkPhysicalDeviceDisplacementMicromapPropertiesNV-sType-sType - // Validation code for VkAccelerationStructureTrianglesDisplacementMicromapNV structure members case VK_STRUCTURE_TYPE_ACCELERATION_STRUCTURE_TRIANGLES_DISPLACEMENT_MICROMAP_NV: { // Covers // VUID-VkAccelerationStructureTrianglesDisplacementMicromapNV-sType-sType @@ -7816,29 +8920,6 @@ } break; #endif // VK_ENABLE_BETA_EXTENSIONS - // Validation code for VkPhysicalDeviceClusterCullingShaderFeaturesHUAWEI structure members - case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_CLUSTER_CULLING_SHADER_FEATURES_HUAWEI: { // Covers - // VUID-VkPhysicalDeviceClusterCullingShaderFeaturesHUAWEI-sType-sType - if (is_const_param) { - [[maybe_unused]] const Location pNext_loc = loc.pNext(Struct::VkPhysicalDeviceClusterCullingShaderFeaturesHUAWEI); - if (!IsExtEnabled(device_extensions.vk_huawei_cluster_culling_shader)) { - skip |= LogError(pnext_vuid, instance, pNext_loc, - "includes a pointer to a VkPhysicalDeviceClusterCullingShaderFeaturesHUAWEI, but when " - "creating VkDevice, the parent extension " - "(VK_HUAWEI_cluster_culling_shader) was not included in ppEnabledExtensionNames."); - } - VkPhysicalDeviceClusterCullingShaderFeaturesHUAWEI* structure = - (VkPhysicalDeviceClusterCullingShaderFeaturesHUAWEI*)header; - skip |= ValidateBool32(pNext_loc.dot(Field::clustercullingShader), structure->clustercullingShader); - - skip |= - ValidateBool32(pNext_loc.dot(Field::multiviewClusterCullingShader), structure->multiviewClusterCullingShader); - } - } break; - - // No Validation code for VkPhysicalDeviceClusterCullingShaderPropertiesHUAWEI structure members -- Covers - // VUID-VkPhysicalDeviceClusterCullingShaderPropertiesHUAWEI-sType-sType - // Validation code for VkPhysicalDeviceClusterCullingShaderVrsFeaturesHUAWEI structure members case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_CLUSTER_CULLING_SHADER_VRS_FEATURES_HUAWEI: { // Covers // VUID-VkPhysicalDeviceClusterCullingShaderVrsFeaturesHUAWEI-sType-sType @@ -7855,24 +8936,6 @@ } } break; - // Validation code for VkPhysicalDeviceBorderColorSwizzleFeaturesEXT structure members - case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_BORDER_COLOR_SWIZZLE_FEATURES_EXT: { // Covers - // VUID-VkPhysicalDeviceBorderColorSwizzleFeaturesEXT-sType-sType - if (is_const_param) { - [[maybe_unused]] const Location pNext_loc = loc.pNext(Struct::VkPhysicalDeviceBorderColorSwizzleFeaturesEXT); - if (!IsExtEnabled(device_extensions.vk_ext_border_color_swizzle)) { - skip |= LogError(pnext_vuid, instance, pNext_loc, - "includes a pointer to a VkPhysicalDeviceBorderColorSwizzleFeaturesEXT, but when creating " - "VkDevice, the parent extension " - "(VK_EXT_border_color_swizzle) was not included in ppEnabledExtensionNames."); - } - VkPhysicalDeviceBorderColorSwizzleFeaturesEXT* structure = (VkPhysicalDeviceBorderColorSwizzleFeaturesEXT*)header; - skip |= ValidateBool32(pNext_loc.dot(Field::borderColorSwizzle), structure->borderColorSwizzle); - - skip |= ValidateBool32(pNext_loc.dot(Field::borderColorSwizzleFromImage), structure->borderColorSwizzleFromImage); - } - } break; - // Validation code for VkSamplerBorderColorComponentMappingCreateInfoEXT structure members case VK_STRUCTURE_TYPE_SAMPLER_BORDER_COLOR_COMPONENT_MAPPING_CREATE_INFO_EXT: { // Covers // VUID-VkSamplerBorderColorComponentMappingCreateInfoEXT-sType-sType @@ -7900,152 +8963,12 @@ } } break; - // Validation code for VkPhysicalDevicePageableDeviceLocalMemoryFeaturesEXT structure members - case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PAGEABLE_DEVICE_LOCAL_MEMORY_FEATURES_EXT: { // Covers - // VUID-VkPhysicalDevicePageableDeviceLocalMemoryFeaturesEXT-sType-sType - if (is_const_param) { - [[maybe_unused]] const Location pNext_loc = loc.pNext(Struct::VkPhysicalDevicePageableDeviceLocalMemoryFeaturesEXT); - if (!IsExtEnabled(device_extensions.vk_ext_pageable_device_local_memory)) { - skip |= LogError(pnext_vuid, instance, pNext_loc, - "includes a pointer to a VkPhysicalDevicePageableDeviceLocalMemoryFeaturesEXT, but when " - "creating VkDevice, the parent extension " - "(VK_EXT_pageable_device_local_memory) was not included in ppEnabledExtensionNames."); - } - VkPhysicalDevicePageableDeviceLocalMemoryFeaturesEXT* structure = - (VkPhysicalDevicePageableDeviceLocalMemoryFeaturesEXT*)header; - skip |= ValidateBool32(pNext_loc.dot(Field::pageableDeviceLocalMemory), structure->pageableDeviceLocalMemory); - } - } break; - - // No Validation code for VkPhysicalDeviceShaderCorePropertiesARM structure members -- Covers - // VUID-VkPhysicalDeviceShaderCorePropertiesARM-sType-sType - // No Validation code for VkDeviceQueueShaderCoreControlCreateInfoARM structure members -- Covers // VUID-VkDeviceQueueShaderCoreControlCreateInfoARM-sType-sType - // Validation code for VkPhysicalDeviceSchedulingControlsFeaturesARM structure members - case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SCHEDULING_CONTROLS_FEATURES_ARM: { // Covers - // VUID-VkPhysicalDeviceSchedulingControlsFeaturesARM-sType-sType - if (is_const_param) { - [[maybe_unused]] const Location pNext_loc = loc.pNext(Struct::VkPhysicalDeviceSchedulingControlsFeaturesARM); - if (!IsExtEnabled(device_extensions.vk_arm_scheduling_controls)) { - skip |= LogError(pnext_vuid, instance, pNext_loc, - "includes a pointer to a VkPhysicalDeviceSchedulingControlsFeaturesARM, but when creating " - "VkDevice, the parent extension " - "(VK_ARM_scheduling_controls) was not included in ppEnabledExtensionNames."); - } - VkPhysicalDeviceSchedulingControlsFeaturesARM* structure = (VkPhysicalDeviceSchedulingControlsFeaturesARM*)header; - skip |= ValidateBool32(pNext_loc.dot(Field::schedulingControls), structure->schedulingControls); - } - } break; - - // Validation code for VkPhysicalDeviceSchedulingControlsPropertiesARM structure members - case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SCHEDULING_CONTROLS_PROPERTIES_ARM: { // Covers - // VUID-VkPhysicalDeviceSchedulingControlsPropertiesARM-sType-sType - if (is_const_param) { - [[maybe_unused]] const Location pNext_loc = loc.pNext(Struct::VkPhysicalDeviceSchedulingControlsPropertiesARM); - if (!IsExtEnabled(device_extensions.vk_arm_scheduling_controls)) { - skip |= LogError(pnext_vuid, instance, pNext_loc, - "extended struct requires the extensions VK_ARM_scheduling_controls"); - } - VkPhysicalDeviceSchedulingControlsPropertiesARM* structure = - (VkPhysicalDeviceSchedulingControlsPropertiesARM*)header; - skip |= ValidateFlags( - pNext_loc.dot(Field::schedulingControlsFlags), vvl::FlagBitmask::VkPhysicalDeviceSchedulingControlsFlagBitsARM, - AllVkPhysicalDeviceSchedulingControlsFlagBitsARM, structure->schedulingControlsFlags, kRequiredFlags, - "VUID-VkPhysicalDeviceSchedulingControlsPropertiesARM-schedulingControlsFlags-parameter", - "VUID-VkPhysicalDeviceSchedulingControlsPropertiesARM-schedulingControlsFlags-requiredbitmask"); - } - } break; - - // Validation code for VkPhysicalDeviceImageSlicedViewOf3DFeaturesEXT structure members - case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_SLICED_VIEW_OF_3D_FEATURES_EXT: { // Covers - // VUID-VkPhysicalDeviceImageSlicedViewOf3DFeaturesEXT-sType-sType - if (is_const_param) { - [[maybe_unused]] const Location pNext_loc = loc.pNext(Struct::VkPhysicalDeviceImageSlicedViewOf3DFeaturesEXT); - if (!IsExtEnabled(device_extensions.vk_ext_image_sliced_view_of_3d)) { - skip |= LogError(pnext_vuid, instance, pNext_loc, - "includes a pointer to a VkPhysicalDeviceImageSlicedViewOf3DFeaturesEXT, but when creating " - "VkDevice, the parent extension " - "(VK_EXT_image_sliced_view_of_3d) was not included in ppEnabledExtensionNames."); - } - VkPhysicalDeviceImageSlicedViewOf3DFeaturesEXT* structure = (VkPhysicalDeviceImageSlicedViewOf3DFeaturesEXT*)header; - skip |= ValidateBool32(pNext_loc.dot(Field::imageSlicedViewOf3D), structure->imageSlicedViewOf3D); - } - } break; - // No Validation code for VkImageViewSlicedCreateInfoEXT structure members -- Covers // VUID-VkImageViewSlicedCreateInfoEXT-sType-sType - // Validation code for VkPhysicalDeviceDescriptorSetHostMappingFeaturesVALVE structure members - case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DESCRIPTOR_SET_HOST_MAPPING_FEATURES_VALVE: { // Covers - // VUID-VkPhysicalDeviceDescriptorSetHostMappingFeaturesVALVE-sType-sType - if (is_const_param) { - [[maybe_unused]] const Location pNext_loc = - loc.pNext(Struct::VkPhysicalDeviceDescriptorSetHostMappingFeaturesVALVE); - if (!IsExtEnabled(device_extensions.vk_valve_descriptor_set_host_mapping)) { - skip |= LogError(pnext_vuid, instance, pNext_loc, - "includes a pointer to a VkPhysicalDeviceDescriptorSetHostMappingFeaturesVALVE, but when " - "creating VkDevice, the parent extension " - "(VK_VALVE_descriptor_set_host_mapping) was not included in ppEnabledExtensionNames."); - } - VkPhysicalDeviceDescriptorSetHostMappingFeaturesVALVE* structure = - (VkPhysicalDeviceDescriptorSetHostMappingFeaturesVALVE*)header; - skip |= ValidateBool32(pNext_loc.dot(Field::descriptorSetHostMapping), structure->descriptorSetHostMapping); - } - } break; - - // Validation code for VkPhysicalDeviceDepthClampZeroOneFeaturesEXT structure members - case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DEPTH_CLAMP_ZERO_ONE_FEATURES_EXT: { // Covers - // VUID-VkPhysicalDeviceDepthClampZeroOneFeaturesEXT-sType-sType - if (is_const_param) { - [[maybe_unused]] const Location pNext_loc = loc.pNext(Struct::VkPhysicalDeviceDepthClampZeroOneFeaturesEXT); - if (!IsExtEnabled(device_extensions.vk_ext_depth_clamp_zero_one)) { - skip |= LogError(pnext_vuid, instance, pNext_loc, - "includes a pointer to a VkPhysicalDeviceDepthClampZeroOneFeaturesEXT, but when creating " - "VkDevice, the parent extension " - "(VK_EXT_depth_clamp_zero_one) was not included in ppEnabledExtensionNames."); - } - VkPhysicalDeviceDepthClampZeroOneFeaturesEXT* structure = (VkPhysicalDeviceDepthClampZeroOneFeaturesEXT*)header; - skip |= ValidateBool32(pNext_loc.dot(Field::depthClampZeroOne), structure->depthClampZeroOne); - } - } break; - - // Validation code for VkPhysicalDeviceNonSeamlessCubeMapFeaturesEXT structure members - case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_NON_SEAMLESS_CUBE_MAP_FEATURES_EXT: { // Covers - // VUID-VkPhysicalDeviceNonSeamlessCubeMapFeaturesEXT-sType-sType - if (is_const_param) { - [[maybe_unused]] const Location pNext_loc = loc.pNext(Struct::VkPhysicalDeviceNonSeamlessCubeMapFeaturesEXT); - if (!IsExtEnabled(device_extensions.vk_ext_non_seamless_cube_map)) { - skip |= LogError(pnext_vuid, instance, pNext_loc, - "includes a pointer to a VkPhysicalDeviceNonSeamlessCubeMapFeaturesEXT, but when creating " - "VkDevice, the parent extension " - "(VK_EXT_non_seamless_cube_map) was not included in ppEnabledExtensionNames."); - } - VkPhysicalDeviceNonSeamlessCubeMapFeaturesEXT* structure = (VkPhysicalDeviceNonSeamlessCubeMapFeaturesEXT*)header; - skip |= ValidateBool32(pNext_loc.dot(Field::nonSeamlessCubeMap), structure->nonSeamlessCubeMap); - } - } break; - - // Validation code for VkPhysicalDeviceRenderPassStripedFeaturesARM structure members - case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RENDER_PASS_STRIPED_FEATURES_ARM: { // Covers - // VUID-VkPhysicalDeviceRenderPassStripedFeaturesARM-sType-sType - if (is_const_param) { - [[maybe_unused]] const Location pNext_loc = loc.pNext(Struct::VkPhysicalDeviceRenderPassStripedFeaturesARM); - if (!IsExtEnabled(device_extensions.vk_arm_render_pass_striped)) { - skip |= LogError(pnext_vuid, instance, pNext_loc, - "includes a pointer to a VkPhysicalDeviceRenderPassStripedFeaturesARM, but when creating " - "VkDevice, the parent extension " - "(VK_ARM_render_pass_striped) was not included in ppEnabledExtensionNames."); - } - VkPhysicalDeviceRenderPassStripedFeaturesARM* structure = (VkPhysicalDeviceRenderPassStripedFeaturesARM*)header; - skip |= ValidateBool32(pNext_loc.dot(Field::renderPassStriped), structure->renderPassStriped); - } - } break; - - // No Validation code for VkPhysicalDeviceRenderPassStripedPropertiesARM structure members -- Covers - // VUID-VkPhysicalDeviceRenderPassStripedPropertiesARM-sType-sType - // Validation code for VkRenderPassStripeBeginInfoARM structure members case VK_STRUCTURE_TYPE_RENDER_PASS_STRIPE_BEGIN_INFO_ARM: { // Covers VUID-VkRenderPassStripeBeginInfoARM-sType-sType if (is_const_param) { @@ -8104,26 +9027,6 @@ } } break; - // Validation code for VkPhysicalDeviceFragmentDensityMapOffsetFeaturesQCOM structure members - case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_DENSITY_MAP_OFFSET_FEATURES_QCOM: { // Covers - // VUID-VkPhysicalDeviceFragmentDensityMapOffsetFeaturesQCOM-sType-sType - if (is_const_param) { - [[maybe_unused]] const Location pNext_loc = loc.pNext(Struct::VkPhysicalDeviceFragmentDensityMapOffsetFeaturesQCOM); - if (!IsExtEnabled(device_extensions.vk_qcom_fragment_density_map_offset)) { - skip |= LogError(pnext_vuid, instance, pNext_loc, - "includes a pointer to a VkPhysicalDeviceFragmentDensityMapOffsetFeaturesQCOM, but when " - "creating VkDevice, the parent extension " - "(VK_QCOM_fragment_density_map_offset) was not included in ppEnabledExtensionNames."); - } - VkPhysicalDeviceFragmentDensityMapOffsetFeaturesQCOM* structure = - (VkPhysicalDeviceFragmentDensityMapOffsetFeaturesQCOM*)header; - skip |= ValidateBool32(pNext_loc.dot(Field::fragmentDensityMapOffset), structure->fragmentDensityMapOffset); - } - } break; - - // No Validation code for VkPhysicalDeviceFragmentDensityMapOffsetPropertiesQCOM structure members -- Covers - // VUID-VkPhysicalDeviceFragmentDensityMapOffsetPropertiesQCOM-sType-sType - // Validation code for VkSubpassFragmentDensityMapOffsetEndInfoQCOM structure members case VK_STRUCTURE_TYPE_SUBPASS_FRAGMENT_DENSITY_MAP_OFFSET_END_INFO_QCOM: { // Covers // VUID-VkSubpassFragmentDensityMapOffsetEndInfoQCOM-sType-sType @@ -8149,157 +9052,12 @@ } } break; - // Validation code for VkPhysicalDeviceCopyMemoryIndirectFeaturesNV structure members - case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COPY_MEMORY_INDIRECT_FEATURES_NV: { // Covers - // VUID-VkPhysicalDeviceCopyMemoryIndirectFeaturesNV-sType-sType - if (is_const_param) { - [[maybe_unused]] const Location pNext_loc = loc.pNext(Struct::VkPhysicalDeviceCopyMemoryIndirectFeaturesNV); - if (!IsExtEnabled(device_extensions.vk_nv_copy_memory_indirect)) { - skip |= LogError(pnext_vuid, instance, pNext_loc, - "includes a pointer to a VkPhysicalDeviceCopyMemoryIndirectFeaturesNV, but when creating " - "VkDevice, the parent extension " - "(VK_NV_copy_memory_indirect) was not included in ppEnabledExtensionNames."); - } - VkPhysicalDeviceCopyMemoryIndirectFeaturesNV* structure = (VkPhysicalDeviceCopyMemoryIndirectFeaturesNV*)header; - skip |= ValidateBool32(pNext_loc.dot(Field::indirectCopy), structure->indirectCopy); - } - } break; - - // No Validation code for VkPhysicalDeviceCopyMemoryIndirectPropertiesNV structure members -- Covers - // VUID-VkPhysicalDeviceCopyMemoryIndirectPropertiesNV-sType-sType - - // Validation code for VkPhysicalDeviceMemoryDecompressionFeaturesNV structure members - case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MEMORY_DECOMPRESSION_FEATURES_NV: { // Covers - // VUID-VkPhysicalDeviceMemoryDecompressionFeaturesNV-sType-sType - if (is_const_param) { - [[maybe_unused]] const Location pNext_loc = loc.pNext(Struct::VkPhysicalDeviceMemoryDecompressionFeaturesNV); - if (!IsExtEnabled(device_extensions.vk_nv_memory_decompression)) { - skip |= LogError(pnext_vuid, instance, pNext_loc, - "includes a pointer to a VkPhysicalDeviceMemoryDecompressionFeaturesNV, but when creating " - "VkDevice, the parent extension " - "(VK_NV_memory_decompression) was not included in ppEnabledExtensionNames."); - } - VkPhysicalDeviceMemoryDecompressionFeaturesNV* structure = (VkPhysicalDeviceMemoryDecompressionFeaturesNV*)header; - skip |= ValidateBool32(pNext_loc.dot(Field::memoryDecompression), structure->memoryDecompression); - } - } break; - - // No Validation code for VkPhysicalDeviceMemoryDecompressionPropertiesNV structure members -- Covers - // VUID-VkPhysicalDeviceMemoryDecompressionPropertiesNV-sType-sType - - // Validation code for VkPhysicalDeviceDeviceGeneratedCommandsComputeFeaturesNV structure members - case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DEVICE_GENERATED_COMMANDS_COMPUTE_FEATURES_NV: { // Covers - // VUID-VkPhysicalDeviceDeviceGeneratedCommandsComputeFeaturesNV-sType-sType - if (is_const_param) { - [[maybe_unused]] const Location pNext_loc = - loc.pNext(Struct::VkPhysicalDeviceDeviceGeneratedCommandsComputeFeaturesNV); - if (!IsExtEnabled(device_extensions.vk_nv_device_generated_commands_compute)) { - skip |= LogError(pnext_vuid, instance, pNext_loc, - "includes a pointer to a VkPhysicalDeviceDeviceGeneratedCommandsComputeFeaturesNV, but when " - "creating VkDevice, the parent extension " - "(VK_NV_device_generated_commands_compute) was not included in ppEnabledExtensionNames."); - } - VkPhysicalDeviceDeviceGeneratedCommandsComputeFeaturesNV* structure = - (VkPhysicalDeviceDeviceGeneratedCommandsComputeFeaturesNV*)header; - skip |= ValidateBool32(pNext_loc.dot(Field::deviceGeneratedCompute), structure->deviceGeneratedCompute); - - skip |= ValidateBool32(pNext_loc.dot(Field::deviceGeneratedComputePipelines), - structure->deviceGeneratedComputePipelines); - - skip |= ValidateBool32(pNext_loc.dot(Field::deviceGeneratedComputeCaptureReplay), - structure->deviceGeneratedComputeCaptureReplay); - } - } break; - // No Validation code for VkComputePipelineIndirectBufferInfoNV structure members -- Covers // VUID-VkComputePipelineIndirectBufferInfoNV-sType-sType - // Validation code for VkPhysicalDeviceLinearColorAttachmentFeaturesNV structure members - case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_LINEAR_COLOR_ATTACHMENT_FEATURES_NV: { // Covers - // VUID-VkPhysicalDeviceLinearColorAttachmentFeaturesNV-sType-sType - if (is_const_param) { - [[maybe_unused]] const Location pNext_loc = loc.pNext(Struct::VkPhysicalDeviceLinearColorAttachmentFeaturesNV); - if (!IsExtEnabled(device_extensions.vk_nv_linear_color_attachment)) { - skip |= LogError(pnext_vuid, instance, pNext_loc, - "includes a pointer to a VkPhysicalDeviceLinearColorAttachmentFeaturesNV, but when creating " - "VkDevice, the parent extension " - "(VK_NV_linear_color_attachment) was not included in ppEnabledExtensionNames."); - } - VkPhysicalDeviceLinearColorAttachmentFeaturesNV* structure = - (VkPhysicalDeviceLinearColorAttachmentFeaturesNV*)header; - skip |= ValidateBool32(pNext_loc.dot(Field::linearColorAttachment), structure->linearColorAttachment); - } - } break; - - // Validation code for VkPhysicalDeviceImageCompressionControlSwapchainFeaturesEXT structure members - case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_COMPRESSION_CONTROL_SWAPCHAIN_FEATURES_EXT: { // Covers - // VUID-VkPhysicalDeviceImageCompressionControlSwapchainFeaturesEXT-sType-sType - if (is_const_param) { - [[maybe_unused]] const Location pNext_loc = - loc.pNext(Struct::VkPhysicalDeviceImageCompressionControlSwapchainFeaturesEXT); - if (!IsExtEnabled(device_extensions.vk_ext_image_compression_control_swapchain)) { - skip |= LogError(pnext_vuid, instance, pNext_loc, - "includes a pointer to a VkPhysicalDeviceImageCompressionControlSwapchainFeaturesEXT, but " - "when creating VkDevice, the parent extension " - "(VK_EXT_image_compression_control_swapchain) was not included in ppEnabledExtensionNames."); - } - VkPhysicalDeviceImageCompressionControlSwapchainFeaturesEXT* structure = - (VkPhysicalDeviceImageCompressionControlSwapchainFeaturesEXT*)header; - skip |= ValidateBool32(pNext_loc.dot(Field::imageCompressionControlSwapchain), - structure->imageCompressionControlSwapchain); - } - } break; - // No Validation code for VkImageViewSampleWeightCreateInfoQCOM structure members -- Covers // VUID-VkImageViewSampleWeightCreateInfoQCOM-sType-sType - // Validation code for VkPhysicalDeviceImageProcessingFeaturesQCOM structure members - case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_PROCESSING_FEATURES_QCOM: { // Covers - // VUID-VkPhysicalDeviceImageProcessingFeaturesQCOM-sType-sType - if (is_const_param) { - [[maybe_unused]] const Location pNext_loc = loc.pNext(Struct::VkPhysicalDeviceImageProcessingFeaturesQCOM); - if (!IsExtEnabled(device_extensions.vk_qcom_image_processing)) { - skip |= LogError(pnext_vuid, instance, pNext_loc, - "includes a pointer to a VkPhysicalDeviceImageProcessingFeaturesQCOM, but when creating " - "VkDevice, the parent extension " - "(VK_QCOM_image_processing) was not included in ppEnabledExtensionNames."); - } - VkPhysicalDeviceImageProcessingFeaturesQCOM* structure = (VkPhysicalDeviceImageProcessingFeaturesQCOM*)header; - skip |= ValidateBool32(pNext_loc.dot(Field::textureSampleWeighted), structure->textureSampleWeighted); - - skip |= ValidateBool32(pNext_loc.dot(Field::textureBoxFilter), structure->textureBoxFilter); - - skip |= ValidateBool32(pNext_loc.dot(Field::textureBlockMatch), structure->textureBlockMatch); - } - } break; - - // No Validation code for VkPhysicalDeviceImageProcessingPropertiesQCOM structure members -- Covers - // VUID-VkPhysicalDeviceImageProcessingPropertiesQCOM-sType-sType - - // Validation code for VkPhysicalDeviceNestedCommandBufferFeaturesEXT structure members - case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_NESTED_COMMAND_BUFFER_FEATURES_EXT: { // Covers - // VUID-VkPhysicalDeviceNestedCommandBufferFeaturesEXT-sType-sType - if (is_const_param) { - [[maybe_unused]] const Location pNext_loc = loc.pNext(Struct::VkPhysicalDeviceNestedCommandBufferFeaturesEXT); - if (!IsExtEnabled(device_extensions.vk_ext_nested_command_buffer)) { - skip |= LogError(pnext_vuid, instance, pNext_loc, - "includes a pointer to a VkPhysicalDeviceNestedCommandBufferFeaturesEXT, but when creating " - "VkDevice, the parent extension " - "(VK_EXT_nested_command_buffer) was not included in ppEnabledExtensionNames."); - } - VkPhysicalDeviceNestedCommandBufferFeaturesEXT* structure = (VkPhysicalDeviceNestedCommandBufferFeaturesEXT*)header; - skip |= ValidateBool32(pNext_loc.dot(Field::nestedCommandBuffer), structure->nestedCommandBuffer); - - skip |= ValidateBool32(pNext_loc.dot(Field::nestedCommandBufferRendering), structure->nestedCommandBufferRendering); - - skip |= ValidateBool32(pNext_loc.dot(Field::nestedCommandBufferSimultaneousUse), - structure->nestedCommandBufferSimultaneousUse); - } - } break; - - // No Validation code for VkPhysicalDeviceNestedCommandBufferPropertiesEXT structure members -- Covers - // VUID-VkPhysicalDeviceNestedCommandBufferPropertiesEXT-sType-sType - // Validation code for VkExternalMemoryAcquireUnmodifiedEXT structure members case VK_STRUCTURE_TYPE_EXTERNAL_MEMORY_ACQUIRE_UNMODIFIED_EXT: { // Covers // VUID-VkExternalMemoryAcquireUnmodifiedEXT-sType-sType @@ -8314,147 +9072,6 @@ } } break; - // Validation code for VkPhysicalDeviceExtendedDynamicState3FeaturesEXT structure members - case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTENDED_DYNAMIC_STATE_3_FEATURES_EXT: { // Covers - // VUID-VkPhysicalDeviceExtendedDynamicState3FeaturesEXT-sType-sType - if (is_const_param) { - [[maybe_unused]] const Location pNext_loc = loc.pNext(Struct::VkPhysicalDeviceExtendedDynamicState3FeaturesEXT); - if (!IsExtEnabled(device_extensions.vk_ext_extended_dynamic_state3)) { - skip |= LogError(pnext_vuid, instance, pNext_loc, - "includes a pointer to a VkPhysicalDeviceExtendedDynamicState3FeaturesEXT, but when creating " - "VkDevice, the parent extension " - "(VK_EXT_extended_dynamic_state3) was not included in ppEnabledExtensionNames."); - } - VkPhysicalDeviceExtendedDynamicState3FeaturesEXT* structure = - (VkPhysicalDeviceExtendedDynamicState3FeaturesEXT*)header; - skip |= ValidateBool32(pNext_loc.dot(Field::extendedDynamicState3TessellationDomainOrigin), - structure->extendedDynamicState3TessellationDomainOrigin); - - skip |= ValidateBool32(pNext_loc.dot(Field::extendedDynamicState3DepthClampEnable), - structure->extendedDynamicState3DepthClampEnable); - - skip |= ValidateBool32(pNext_loc.dot(Field::extendedDynamicState3PolygonMode), - structure->extendedDynamicState3PolygonMode); - - skip |= ValidateBool32(pNext_loc.dot(Field::extendedDynamicState3RasterizationSamples), - structure->extendedDynamicState3RasterizationSamples); - - skip |= ValidateBool32(pNext_loc.dot(Field::extendedDynamicState3SampleMask), - structure->extendedDynamicState3SampleMask); - - skip |= ValidateBool32(pNext_loc.dot(Field::extendedDynamicState3AlphaToCoverageEnable), - structure->extendedDynamicState3AlphaToCoverageEnable); - - skip |= ValidateBool32(pNext_loc.dot(Field::extendedDynamicState3AlphaToOneEnable), - structure->extendedDynamicState3AlphaToOneEnable); - - skip |= ValidateBool32(pNext_loc.dot(Field::extendedDynamicState3LogicOpEnable), - structure->extendedDynamicState3LogicOpEnable); - - skip |= ValidateBool32(pNext_loc.dot(Field::extendedDynamicState3ColorBlendEnable), - structure->extendedDynamicState3ColorBlendEnable); - - skip |= ValidateBool32(pNext_loc.dot(Field::extendedDynamicState3ColorBlendEquation), - structure->extendedDynamicState3ColorBlendEquation); - - skip |= ValidateBool32(pNext_loc.dot(Field::extendedDynamicState3ColorWriteMask), - structure->extendedDynamicState3ColorWriteMask); - - skip |= ValidateBool32(pNext_loc.dot(Field::extendedDynamicState3RasterizationStream), - structure->extendedDynamicState3RasterizationStream); - - skip |= ValidateBool32(pNext_loc.dot(Field::extendedDynamicState3ConservativeRasterizationMode), - structure->extendedDynamicState3ConservativeRasterizationMode); - - skip |= ValidateBool32(pNext_loc.dot(Field::extendedDynamicState3ExtraPrimitiveOverestimationSize), - structure->extendedDynamicState3ExtraPrimitiveOverestimationSize); - - skip |= ValidateBool32(pNext_loc.dot(Field::extendedDynamicState3DepthClipEnable), - structure->extendedDynamicState3DepthClipEnable); - - skip |= ValidateBool32(pNext_loc.dot(Field::extendedDynamicState3SampleLocationsEnable), - structure->extendedDynamicState3SampleLocationsEnable); - - skip |= ValidateBool32(pNext_loc.dot(Field::extendedDynamicState3ColorBlendAdvanced), - structure->extendedDynamicState3ColorBlendAdvanced); - - skip |= ValidateBool32(pNext_loc.dot(Field::extendedDynamicState3ProvokingVertexMode), - structure->extendedDynamicState3ProvokingVertexMode); - - skip |= ValidateBool32(pNext_loc.dot(Field::extendedDynamicState3LineRasterizationMode), - structure->extendedDynamicState3LineRasterizationMode); - - skip |= ValidateBool32(pNext_loc.dot(Field::extendedDynamicState3LineStippleEnable), - structure->extendedDynamicState3LineStippleEnable); - - skip |= ValidateBool32(pNext_loc.dot(Field::extendedDynamicState3DepthClipNegativeOneToOne), - structure->extendedDynamicState3DepthClipNegativeOneToOne); - - skip |= ValidateBool32(pNext_loc.dot(Field::extendedDynamicState3ViewportWScalingEnable), - structure->extendedDynamicState3ViewportWScalingEnable); - - skip |= ValidateBool32(pNext_loc.dot(Field::extendedDynamicState3ViewportSwizzle), - structure->extendedDynamicState3ViewportSwizzle); - - skip |= ValidateBool32(pNext_loc.dot(Field::extendedDynamicState3CoverageToColorEnable), - structure->extendedDynamicState3CoverageToColorEnable); - - skip |= ValidateBool32(pNext_loc.dot(Field::extendedDynamicState3CoverageToColorLocation), - structure->extendedDynamicState3CoverageToColorLocation); - - skip |= ValidateBool32(pNext_loc.dot(Field::extendedDynamicState3CoverageModulationMode), - structure->extendedDynamicState3CoverageModulationMode); - - skip |= ValidateBool32(pNext_loc.dot(Field::extendedDynamicState3CoverageModulationTableEnable), - structure->extendedDynamicState3CoverageModulationTableEnable); - - skip |= ValidateBool32(pNext_loc.dot(Field::extendedDynamicState3CoverageModulationTable), - structure->extendedDynamicState3CoverageModulationTable); - - skip |= ValidateBool32(pNext_loc.dot(Field::extendedDynamicState3CoverageReductionMode), - structure->extendedDynamicState3CoverageReductionMode); - - skip |= ValidateBool32(pNext_loc.dot(Field::extendedDynamicState3RepresentativeFragmentTestEnable), - structure->extendedDynamicState3RepresentativeFragmentTestEnable); - - skip |= ValidateBool32(pNext_loc.dot(Field::extendedDynamicState3ShadingRateImageEnable), - structure->extendedDynamicState3ShadingRateImageEnable); - } - } break; - - // Validation code for VkPhysicalDeviceExtendedDynamicState3PropertiesEXT structure members - case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTENDED_DYNAMIC_STATE_3_PROPERTIES_EXT: { // Covers - // VUID-VkPhysicalDeviceExtendedDynamicState3PropertiesEXT-sType-sType - if (is_const_param) { - [[maybe_unused]] const Location pNext_loc = loc.pNext(Struct::VkPhysicalDeviceExtendedDynamicState3PropertiesEXT); - if (!IsExtEnabled(device_extensions.vk_ext_extended_dynamic_state3)) { - skip |= LogError(pnext_vuid, instance, pNext_loc, - "extended struct requires the extensions VK_EXT_extended_dynamic_state3"); - } - VkPhysicalDeviceExtendedDynamicState3PropertiesEXT* structure = - (VkPhysicalDeviceExtendedDynamicState3PropertiesEXT*)header; - skip |= ValidateBool32(pNext_loc.dot(Field::dynamicPrimitiveTopologyUnrestricted), - structure->dynamicPrimitiveTopologyUnrestricted); - } - } break; - - // Validation code for VkPhysicalDeviceSubpassMergeFeedbackFeaturesEXT structure members - case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SUBPASS_MERGE_FEEDBACK_FEATURES_EXT: { // Covers - // VUID-VkPhysicalDeviceSubpassMergeFeedbackFeaturesEXT-sType-sType - if (is_const_param) { - [[maybe_unused]] const Location pNext_loc = loc.pNext(Struct::VkPhysicalDeviceSubpassMergeFeedbackFeaturesEXT); - if (!IsExtEnabled(device_extensions.vk_ext_subpass_merge_feedback)) { - skip |= LogError(pnext_vuid, instance, pNext_loc, - "includes a pointer to a VkPhysicalDeviceSubpassMergeFeedbackFeaturesEXT, but when creating " - "VkDevice, the parent extension " - "(VK_EXT_subpass_merge_feedback) was not included in ppEnabledExtensionNames."); - } - VkPhysicalDeviceSubpassMergeFeedbackFeaturesEXT* structure = - (VkPhysicalDeviceSubpassMergeFeedbackFeaturesEXT*)header; - skip |= ValidateBool32(pNext_loc.dot(Field::subpassMergeFeedback), structure->subpassMergeFeedback); - } - } break; - // Validation code for VkRenderPassCreationControlEXT structure members case VK_STRUCTURE_TYPE_RENDER_PASS_CREATION_CONTROL_EXT: { // Covers VUID-VkRenderPassCreationControlEXT-sType-sType if (is_const_param) { @@ -8531,26 +9148,6 @@ } } break; - // Validation code for VkPhysicalDeviceShaderModuleIdentifierFeaturesEXT structure members - case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_MODULE_IDENTIFIER_FEATURES_EXT: { // Covers - // VUID-VkPhysicalDeviceShaderModuleIdentifierFeaturesEXT-sType-sType - if (is_const_param) { - [[maybe_unused]] const Location pNext_loc = loc.pNext(Struct::VkPhysicalDeviceShaderModuleIdentifierFeaturesEXT); - if (!IsExtEnabled(device_extensions.vk_ext_shader_module_identifier)) { - skip |= LogError(pnext_vuid, instance, pNext_loc, - "includes a pointer to a VkPhysicalDeviceShaderModuleIdentifierFeaturesEXT, but when creating " - "VkDevice, the parent extension " - "(VK_EXT_shader_module_identifier) was not included in ppEnabledExtensionNames."); - } - VkPhysicalDeviceShaderModuleIdentifierFeaturesEXT* structure = - (VkPhysicalDeviceShaderModuleIdentifierFeaturesEXT*)header; - skip |= ValidateBool32(pNext_loc.dot(Field::shaderModuleIdentifier), structure->shaderModuleIdentifier); - } - } break; - - // No Validation code for VkPhysicalDeviceShaderModuleIdentifierPropertiesEXT structure members -- Covers - // VUID-VkPhysicalDeviceShaderModuleIdentifierPropertiesEXT-sType-sType - // Validation code for VkPipelineShaderStageModuleIdentifierCreateInfoEXT structure members case VK_STRUCTURE_TYPE_PIPELINE_SHADER_STAGE_MODULE_IDENTIFIER_CREATE_INFO_EXT: { // Covers // VUID-VkPipelineShaderStageModuleIdentifierCreateInfoEXT-sType-sType @@ -8568,25 +9165,6 @@ } } break; - // Validation code for VkPhysicalDeviceOpticalFlowFeaturesNV structure members - case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_OPTICAL_FLOW_FEATURES_NV: { // Covers - // VUID-VkPhysicalDeviceOpticalFlowFeaturesNV-sType-sType - if (is_const_param) { - [[maybe_unused]] const Location pNext_loc = loc.pNext(Struct::VkPhysicalDeviceOpticalFlowFeaturesNV); - if (!IsExtEnabled(device_extensions.vk_nv_optical_flow)) { - skip |= LogError(pnext_vuid, instance, pNext_loc, - "includes a pointer to a VkPhysicalDeviceOpticalFlowFeaturesNV, but when creating VkDevice, " - "the parent extension " - "(VK_NV_optical_flow) was not included in ppEnabledExtensionNames."); - } - VkPhysicalDeviceOpticalFlowFeaturesNV* structure = (VkPhysicalDeviceOpticalFlowFeaturesNV*)header; - skip |= ValidateBool32(pNext_loc.dot(Field::opticalFlow), structure->opticalFlow); - } - } break; - - // No Validation code for VkPhysicalDeviceOpticalFlowPropertiesNV structure members -- Covers - // VUID-VkPhysicalDeviceOpticalFlowPropertiesNV-sType-sType - // Validation code for VkOpticalFlowImageFormatInfoNV structure members case VK_STRUCTURE_TYPE_OPTICAL_FLOW_IMAGE_FORMAT_INFO_NV: { // Covers VUID-VkOpticalFlowImageFormatInfoNV-sType-sType if (is_const_param) { @@ -8615,178 +9193,15 @@ "VUID-VkOpticalFlowSessionCreatePrivateDataInfoNV-pPrivateData-parameter"); } } break; - - // Validation code for VkPhysicalDeviceLegacyDitheringFeaturesEXT structure members - case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_LEGACY_DITHERING_FEATURES_EXT: { // Covers - // VUID-VkPhysicalDeviceLegacyDitheringFeaturesEXT-sType-sType - if (is_const_param) { - [[maybe_unused]] const Location pNext_loc = loc.pNext(Struct::VkPhysicalDeviceLegacyDitheringFeaturesEXT); - if (!IsExtEnabled(device_extensions.vk_ext_legacy_dithering)) { - skip |= LogError(pnext_vuid, instance, pNext_loc, - "includes a pointer to a VkPhysicalDeviceLegacyDitheringFeaturesEXT, but when creating " - "VkDevice, the parent extension " - "(VK_EXT_legacy_dithering) was not included in ppEnabledExtensionNames."); - } - VkPhysicalDeviceLegacyDitheringFeaturesEXT* structure = (VkPhysicalDeviceLegacyDitheringFeaturesEXT*)header; - skip |= ValidateBool32(pNext_loc.dot(Field::legacyDithering), structure->legacyDithering); - } - } break; - - // Validation code for VkPhysicalDevicePipelineProtectedAccessFeaturesEXT structure members - case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PIPELINE_PROTECTED_ACCESS_FEATURES_EXT: { // Covers - // VUID-VkPhysicalDevicePipelineProtectedAccessFeaturesEXT-sType-sType - if (is_const_param) { - [[maybe_unused]] const Location pNext_loc = loc.pNext(Struct::VkPhysicalDevicePipelineProtectedAccessFeaturesEXT); - if (!IsExtEnabled(device_extensions.vk_ext_pipeline_protected_access)) { - skip |= LogError(pnext_vuid, instance, pNext_loc, - "includes a pointer to a VkPhysicalDevicePipelineProtectedAccessFeaturesEXT, but when " - "creating VkDevice, the parent extension " - "(VK_EXT_pipeline_protected_access) was not included in ppEnabledExtensionNames."); - } - VkPhysicalDevicePipelineProtectedAccessFeaturesEXT* structure = - (VkPhysicalDevicePipelineProtectedAccessFeaturesEXT*)header; - skip |= ValidateBool32(pNext_loc.dot(Field::pipelineProtectedAccess), structure->pipelineProtectedAccess); - } - } break; #ifdef VK_USE_PLATFORM_ANDROID_KHR - // Validation code for VkPhysicalDeviceExternalFormatResolveFeaturesANDROID structure members - case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTERNAL_FORMAT_RESOLVE_FEATURES_ANDROID: { // Covers - // VUID-VkPhysicalDeviceExternalFormatResolveFeaturesANDROID-sType-sType - if (is_const_param) { - [[maybe_unused]] const Location pNext_loc = loc.pNext(Struct::VkPhysicalDeviceExternalFormatResolveFeaturesANDROID); - if (!IsExtEnabled(device_extensions.vk_android_external_format_resolve)) { - skip |= LogError(pnext_vuid, instance, pNext_loc, - "includes a pointer to a VkPhysicalDeviceExternalFormatResolveFeaturesANDROID, but when " - "creating VkDevice, the parent extension " - "(VK_ANDROID_external_format_resolve) was not included in ppEnabledExtensionNames."); - } - VkPhysicalDeviceExternalFormatResolveFeaturesANDROID* structure = - (VkPhysicalDeviceExternalFormatResolveFeaturesANDROID*)header; - skip |= ValidateBool32(pNext_loc.dot(Field::externalFormatResolve), structure->externalFormatResolve); - } - } break; - - // No Validation code for VkPhysicalDeviceExternalFormatResolvePropertiesANDROID structure members -- Covers - // VUID-VkPhysicalDeviceExternalFormatResolvePropertiesANDROID-sType-sType - // No Validation code for VkAndroidHardwareBufferFormatResolvePropertiesANDROID structure members -- Covers // VUID-VkAndroidHardwareBufferFormatResolvePropertiesANDROID-sType-sType #endif // VK_USE_PLATFORM_ANDROID_KHR - // Validation code for VkPhysicalDeviceShaderObjectFeaturesEXT structure members - case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_OBJECT_FEATURES_EXT: { // Covers - // VUID-VkPhysicalDeviceShaderObjectFeaturesEXT-sType-sType - if (is_const_param) { - [[maybe_unused]] const Location pNext_loc = loc.pNext(Struct::VkPhysicalDeviceShaderObjectFeaturesEXT); - if (!IsExtEnabled(device_extensions.vk_ext_shader_object)) { - skip |= LogError(pnext_vuid, instance, pNext_loc, - "includes a pointer to a VkPhysicalDeviceShaderObjectFeaturesEXT, but when creating VkDevice, " - "the parent extension " - "(VK_EXT_shader_object) was not included in ppEnabledExtensionNames."); - } - VkPhysicalDeviceShaderObjectFeaturesEXT* structure = (VkPhysicalDeviceShaderObjectFeaturesEXT*)header; - skip |= ValidateBool32(pNext_loc.dot(Field::shaderObject), structure->shaderObject); - } - } break; - - // No Validation code for VkPhysicalDeviceShaderObjectPropertiesEXT structure members -- Covers - // VUID-VkPhysicalDeviceShaderObjectPropertiesEXT-sType-sType - - // Validation code for VkPhysicalDeviceTilePropertiesFeaturesQCOM structure members - case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TILE_PROPERTIES_FEATURES_QCOM: { // Covers - // VUID-VkPhysicalDeviceTilePropertiesFeaturesQCOM-sType-sType - if (is_const_param) { - [[maybe_unused]] const Location pNext_loc = loc.pNext(Struct::VkPhysicalDeviceTilePropertiesFeaturesQCOM); - if (!IsExtEnabled(device_extensions.vk_qcom_tile_properties)) { - skip |= LogError(pnext_vuid, instance, pNext_loc, - "includes a pointer to a VkPhysicalDeviceTilePropertiesFeaturesQCOM, but when creating " - "VkDevice, the parent extension " - "(VK_QCOM_tile_properties) was not included in ppEnabledExtensionNames."); - } - VkPhysicalDeviceTilePropertiesFeaturesQCOM* structure = (VkPhysicalDeviceTilePropertiesFeaturesQCOM*)header; - skip |= ValidateBool32(pNext_loc.dot(Field::tileProperties), structure->tileProperties); - } - } break; - - // Validation code for VkPhysicalDeviceAmigoProfilingFeaturesSEC structure members - case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_AMIGO_PROFILING_FEATURES_SEC: { // Covers - // VUID-VkPhysicalDeviceAmigoProfilingFeaturesSEC-sType-sType - if (is_const_param) { - [[maybe_unused]] const Location pNext_loc = loc.pNext(Struct::VkPhysicalDeviceAmigoProfilingFeaturesSEC); - if (!IsExtEnabled(device_extensions.vk_sec_amigo_profiling)) { - skip |= LogError(pnext_vuid, instance, pNext_loc, - "includes a pointer to a VkPhysicalDeviceAmigoProfilingFeaturesSEC, but when creating " - "VkDevice, the parent extension " - "(VK_SEC_amigo_profiling) was not included in ppEnabledExtensionNames."); - } - VkPhysicalDeviceAmigoProfilingFeaturesSEC* structure = (VkPhysicalDeviceAmigoProfilingFeaturesSEC*)header; - skip |= ValidateBool32(pNext_loc.dot(Field::amigoProfiling), structure->amigoProfiling); - } - } break; - // No Validation code for VkAmigoProfilingSubmitInfoSEC structure members -- Covers // VUID-VkAmigoProfilingSubmitInfoSEC-sType-sType - // Validation code for VkPhysicalDeviceMultiviewPerViewViewportsFeaturesQCOM structure members - case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MULTIVIEW_PER_VIEW_VIEWPORTS_FEATURES_QCOM: { // Covers - // VUID-VkPhysicalDeviceMultiviewPerViewViewportsFeaturesQCOM-sType-sType - if (is_const_param) { - [[maybe_unused]] const Location pNext_loc = - loc.pNext(Struct::VkPhysicalDeviceMultiviewPerViewViewportsFeaturesQCOM); - if (!IsExtEnabled(device_extensions.vk_qcom_multiview_per_view_viewports)) { - skip |= LogError(pnext_vuid, instance, pNext_loc, - "includes a pointer to a VkPhysicalDeviceMultiviewPerViewViewportsFeaturesQCOM, but when " - "creating VkDevice, the parent extension " - "(VK_QCOM_multiview_per_view_viewports) was not included in ppEnabledExtensionNames."); - } - VkPhysicalDeviceMultiviewPerViewViewportsFeaturesQCOM* structure = - (VkPhysicalDeviceMultiviewPerViewViewportsFeaturesQCOM*)header; - skip |= ValidateBool32(pNext_loc.dot(Field::multiviewPerViewViewports), structure->multiviewPerViewViewports); - } - } break; - - // No Validation code for VkPhysicalDeviceRayTracingInvocationReorderPropertiesNV structure members -- Covers - // VUID-VkPhysicalDeviceRayTracingInvocationReorderPropertiesNV-sType-sType - - // Validation code for VkPhysicalDeviceRayTracingInvocationReorderFeaturesNV structure members - case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RAY_TRACING_INVOCATION_REORDER_FEATURES_NV: { // Covers - // VUID-VkPhysicalDeviceRayTracingInvocationReorderFeaturesNV-sType-sType - if (is_const_param) { - [[maybe_unused]] const Location pNext_loc = - loc.pNext(Struct::VkPhysicalDeviceRayTracingInvocationReorderFeaturesNV); - if (!IsExtEnabled(device_extensions.vk_nv_ray_tracing_invocation_reorder)) { - skip |= LogError(pnext_vuid, instance, pNext_loc, - "includes a pointer to a VkPhysicalDeviceRayTracingInvocationReorderFeaturesNV, but when " - "creating VkDevice, the parent extension " - "(VK_NV_ray_tracing_invocation_reorder) was not included in ppEnabledExtensionNames."); - } - VkPhysicalDeviceRayTracingInvocationReorderFeaturesNV* structure = - (VkPhysicalDeviceRayTracingInvocationReorderFeaturesNV*)header; - skip |= ValidateBool32(pNext_loc.dot(Field::rayTracingInvocationReorder), structure->rayTracingInvocationReorder); - } - } break; - - // Validation code for VkPhysicalDeviceExtendedSparseAddressSpaceFeaturesNV structure members - case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTENDED_SPARSE_ADDRESS_SPACE_FEATURES_NV: { // Covers - // VUID-VkPhysicalDeviceExtendedSparseAddressSpaceFeaturesNV-sType-sType - if (is_const_param) { - [[maybe_unused]] const Location pNext_loc = loc.pNext(Struct::VkPhysicalDeviceExtendedSparseAddressSpaceFeaturesNV); - if (!IsExtEnabled(device_extensions.vk_nv_extended_sparse_address_space)) { - skip |= LogError(pnext_vuid, instance, pNext_loc, - "includes a pointer to a VkPhysicalDeviceExtendedSparseAddressSpaceFeaturesNV, but when " - "creating VkDevice, the parent extension " - "(VK_NV_extended_sparse_address_space) was not included in ppEnabledExtensionNames."); - } - VkPhysicalDeviceExtendedSparseAddressSpaceFeaturesNV* structure = - (VkPhysicalDeviceExtendedSparseAddressSpaceFeaturesNV*)header; - skip |= ValidateBool32(pNext_loc.dot(Field::extendedSparseAddressSpace), structure->extendedSparseAddressSpace); - } - } break; - - // No Validation code for VkPhysicalDeviceExtendedSparseAddressSpacePropertiesNV structure members -- Covers - // VUID-VkPhysicalDeviceExtendedSparseAddressSpacePropertiesNV-sType-sType - // Validation code for VkLayerSettingsCreateInfoEXT structure members case VK_STRUCTURE_TYPE_LAYER_SETTINGS_CREATE_INFO_EXT: { // Covers VUID-VkLayerSettingsCreateInfoEXT-sType-sType if (is_const_param) { @@ -8820,62 +9235,6 @@ } } break; - // Validation code for VkPhysicalDeviceShaderCoreBuiltinsFeaturesARM structure members - case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_CORE_BUILTINS_FEATURES_ARM: { // Covers - // VUID-VkPhysicalDeviceShaderCoreBuiltinsFeaturesARM-sType-sType - if (is_const_param) { - [[maybe_unused]] const Location pNext_loc = loc.pNext(Struct::VkPhysicalDeviceShaderCoreBuiltinsFeaturesARM); - if (!IsExtEnabled(device_extensions.vk_arm_shader_core_builtins)) { - skip |= LogError(pnext_vuid, instance, pNext_loc, - "includes a pointer to a VkPhysicalDeviceShaderCoreBuiltinsFeaturesARM, but when creating " - "VkDevice, the parent extension " - "(VK_ARM_shader_core_builtins) was not included in ppEnabledExtensionNames."); - } - VkPhysicalDeviceShaderCoreBuiltinsFeaturesARM* structure = (VkPhysicalDeviceShaderCoreBuiltinsFeaturesARM*)header; - skip |= ValidateBool32(pNext_loc.dot(Field::shaderCoreBuiltins), structure->shaderCoreBuiltins); - } - } break; - - // No Validation code for VkPhysicalDeviceShaderCoreBuiltinsPropertiesARM structure members -- Covers - // VUID-VkPhysicalDeviceShaderCoreBuiltinsPropertiesARM-sType-sType - - // Validation code for VkPhysicalDevicePipelineLibraryGroupHandlesFeaturesEXT structure members - case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PIPELINE_LIBRARY_GROUP_HANDLES_FEATURES_EXT: { // Covers - // VUID-VkPhysicalDevicePipelineLibraryGroupHandlesFeaturesEXT-sType-sType - if (is_const_param) { - [[maybe_unused]] const Location pNext_loc = - loc.pNext(Struct::VkPhysicalDevicePipelineLibraryGroupHandlesFeaturesEXT); - if (!IsExtEnabled(device_extensions.vk_ext_pipeline_library_group_handles)) { - skip |= LogError(pnext_vuid, instance, pNext_loc, - "includes a pointer to a VkPhysicalDevicePipelineLibraryGroupHandlesFeaturesEXT, but when " - "creating VkDevice, the parent extension " - "(VK_EXT_pipeline_library_group_handles) was not included in ppEnabledExtensionNames."); - } - VkPhysicalDevicePipelineLibraryGroupHandlesFeaturesEXT* structure = - (VkPhysicalDevicePipelineLibraryGroupHandlesFeaturesEXT*)header; - skip |= ValidateBool32(pNext_loc.dot(Field::pipelineLibraryGroupHandles), structure->pipelineLibraryGroupHandles); - } - } break; - - // Validation code for VkPhysicalDeviceDynamicRenderingUnusedAttachmentsFeaturesEXT structure members - case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DYNAMIC_RENDERING_UNUSED_ATTACHMENTS_FEATURES_EXT: { // Covers - // VUID-VkPhysicalDeviceDynamicRenderingUnusedAttachmentsFeaturesEXT-sType-sType - if (is_const_param) { - [[maybe_unused]] const Location pNext_loc = - loc.pNext(Struct::VkPhysicalDeviceDynamicRenderingUnusedAttachmentsFeaturesEXT); - if (!IsExtEnabled(device_extensions.vk_ext_dynamic_rendering_unused_attachments)) { - skip |= LogError(pnext_vuid, instance, pNext_loc, - "includes a pointer to a VkPhysicalDeviceDynamicRenderingUnusedAttachmentsFeaturesEXT, but " - "when creating VkDevice, the parent extension " - "(VK_EXT_dynamic_rendering_unused_attachments) was not included in ppEnabledExtensionNames."); - } - VkPhysicalDeviceDynamicRenderingUnusedAttachmentsFeaturesEXT* structure = - (VkPhysicalDeviceDynamicRenderingUnusedAttachmentsFeaturesEXT*)header; - skip |= ValidateBool32(pNext_loc.dot(Field::dynamicRenderingUnusedAttachments), - structure->dynamicRenderingUnusedAttachments); - } - } break; - // No Validation code for VkLatencySubmissionPresentIdNV structure members -- Covers // VUID-VkLatencySubmissionPresentIdNV-sType-sType @@ -8894,24 +9253,6 @@ // No Validation code for VkLatencySurfaceCapabilitiesNV structure members -- Covers // VUID-VkLatencySurfaceCapabilitiesNV-sType-sType - // Validation code for VkPhysicalDeviceMultiviewPerViewRenderAreasFeaturesQCOM structure members - case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MULTIVIEW_PER_VIEW_RENDER_AREAS_FEATURES_QCOM: { // Covers - // VUID-VkPhysicalDeviceMultiviewPerViewRenderAreasFeaturesQCOM-sType-sType - if (is_const_param) { - [[maybe_unused]] const Location pNext_loc = - loc.pNext(Struct::VkPhysicalDeviceMultiviewPerViewRenderAreasFeaturesQCOM); - if (!IsExtEnabled(device_extensions.vk_qcom_multiview_per_view_render_areas)) { - skip |= LogError(pnext_vuid, instance, pNext_loc, - "includes a pointer to a VkPhysicalDeviceMultiviewPerViewRenderAreasFeaturesQCOM, but when " - "creating VkDevice, the parent extension " - "(VK_QCOM_multiview_per_view_render_areas) was not included in ppEnabledExtensionNames."); - } - VkPhysicalDeviceMultiviewPerViewRenderAreasFeaturesQCOM* structure = - (VkPhysicalDeviceMultiviewPerViewRenderAreasFeaturesQCOM*)header; - skip |= ValidateBool32(pNext_loc.dot(Field::multiviewPerViewRenderAreas), structure->multiviewPerViewRenderAreas); - } - } break; - // Validation code for VkMultiviewPerViewRenderAreasRenderPassBeginInfoQCOM structure members case VK_STRUCTURE_TYPE_MULTIVIEW_PER_VIEW_RENDER_AREAS_RENDER_PASS_BEGIN_INFO_QCOM: { // Covers // VUID-VkMultiviewPerViewRenderAreasRenderPassBeginInfoQCOM-sType-sType @@ -8938,44 +9279,6 @@ } } break; - // Validation code for VkPhysicalDevicePerStageDescriptorSetFeaturesNV structure members - case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PER_STAGE_DESCRIPTOR_SET_FEATURES_NV: { // Covers - // VUID-VkPhysicalDevicePerStageDescriptorSetFeaturesNV-sType-sType - if (is_const_param) { - [[maybe_unused]] const Location pNext_loc = loc.pNext(Struct::VkPhysicalDevicePerStageDescriptorSetFeaturesNV); - if (!IsExtEnabled(device_extensions.vk_nv_per_stage_descriptor_set)) { - skip |= LogError(pnext_vuid, instance, pNext_loc, - "includes a pointer to a VkPhysicalDevicePerStageDescriptorSetFeaturesNV, but when creating " - "VkDevice, the parent extension " - "(VK_NV_per_stage_descriptor_set) was not included in ppEnabledExtensionNames."); - } - VkPhysicalDevicePerStageDescriptorSetFeaturesNV* structure = - (VkPhysicalDevicePerStageDescriptorSetFeaturesNV*)header; - skip |= ValidateBool32(pNext_loc.dot(Field::perStageDescriptorSet), structure->perStageDescriptorSet); - - skip |= ValidateBool32(pNext_loc.dot(Field::dynamicPipelineLayout), structure->dynamicPipelineLayout); - } - } break; - - // Validation code for VkPhysicalDeviceImageProcessing2FeaturesQCOM structure members - case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_PROCESSING_2_FEATURES_QCOM: { // Covers - // VUID-VkPhysicalDeviceImageProcessing2FeaturesQCOM-sType-sType - if (is_const_param) { - [[maybe_unused]] const Location pNext_loc = loc.pNext(Struct::VkPhysicalDeviceImageProcessing2FeaturesQCOM); - if (!IsExtEnabled(device_extensions.vk_qcom_image_processing2)) { - skip |= LogError(pnext_vuid, instance, pNext_loc, - "includes a pointer to a VkPhysicalDeviceImageProcessing2FeaturesQCOM, but when creating " - "VkDevice, the parent extension " - "(VK_QCOM_image_processing2) was not included in ppEnabledExtensionNames."); - } - VkPhysicalDeviceImageProcessing2FeaturesQCOM* structure = (VkPhysicalDeviceImageProcessing2FeaturesQCOM*)header; - skip |= ValidateBool32(pNext_loc.dot(Field::textureBlockMatch2), structure->textureBlockMatch2); - } - } break; - - // No Validation code for VkPhysicalDeviceImageProcessing2PropertiesQCOM structure members -- Covers - // VUID-VkPhysicalDeviceImageProcessing2PropertiesQCOM-sType-sType - // Validation code for VkSamplerBlockMatchWindowCreateInfoQCOM structure members case VK_STRUCTURE_TYPE_SAMPLER_BLOCK_MATCH_WINDOW_CREATE_INFO_QCOM: { // Covers // VUID-VkSamplerBlockMatchWindowCreateInfoQCOM-sType-sType @@ -8992,22 +9295,6 @@ } } break; - // Validation code for VkPhysicalDeviceCubicWeightsFeaturesQCOM structure members - case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_CUBIC_WEIGHTS_FEATURES_QCOM: { // Covers - // VUID-VkPhysicalDeviceCubicWeightsFeaturesQCOM-sType-sType - if (is_const_param) { - [[maybe_unused]] const Location pNext_loc = loc.pNext(Struct::VkPhysicalDeviceCubicWeightsFeaturesQCOM); - if (!IsExtEnabled(device_extensions.vk_qcom_filter_cubic_weights)) { - skip |= LogError(pnext_vuid, instance, pNext_loc, - "includes a pointer to a VkPhysicalDeviceCubicWeightsFeaturesQCOM, but when creating " - "VkDevice, the parent extension " - "(VK_QCOM_filter_cubic_weights) was not included in ppEnabledExtensionNames."); - } - VkPhysicalDeviceCubicWeightsFeaturesQCOM* structure = (VkPhysicalDeviceCubicWeightsFeaturesQCOM*)header; - skip |= ValidateBool32(pNext_loc.dot(Field::selectableCubicWeights), structure->selectableCubicWeights); - } - } break; - // Validation code for VkSamplerCubicWeightsCreateInfoQCOM structure members case VK_STRUCTURE_TYPE_SAMPLER_CUBIC_WEIGHTS_CREATE_INFO_QCOM: { // Covers // VUID-VkSamplerCubicWeightsCreateInfoQCOM-sType-sType @@ -9038,22 +9325,6 @@ } } break; - // Validation code for VkPhysicalDeviceYcbcrDegammaFeaturesQCOM structure members - case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_YCBCR_DEGAMMA_FEATURES_QCOM: { // Covers - // VUID-VkPhysicalDeviceYcbcrDegammaFeaturesQCOM-sType-sType - if (is_const_param) { - [[maybe_unused]] const Location pNext_loc = loc.pNext(Struct::VkPhysicalDeviceYcbcrDegammaFeaturesQCOM); - if (!IsExtEnabled(device_extensions.vk_qcom_ycbcr_degamma)) { - skip |= LogError(pnext_vuid, instance, pNext_loc, - "includes a pointer to a VkPhysicalDeviceYcbcrDegammaFeaturesQCOM, but when creating " - "VkDevice, the parent extension " - "(VK_QCOM_ycbcr_degamma) was not included in ppEnabledExtensionNames."); - } - VkPhysicalDeviceYcbcrDegammaFeaturesQCOM* structure = (VkPhysicalDeviceYcbcrDegammaFeaturesQCOM*)header; - skip |= ValidateBool32(pNext_loc.dot(Field::ycbcrDegamma), structure->ycbcrDegamma); - } - } break; - // Validation code for VkSamplerYcbcrConversionYcbcrDegammaCreateInfoQCOM structure members case VK_STRUCTURE_TYPE_SAMPLER_YCBCR_CONVERSION_YCBCR_DEGAMMA_CREATE_INFO_QCOM: { // Covers // VUID-VkSamplerYcbcrConversionYcbcrDegammaCreateInfoQCOM-sType-sType @@ -9070,42 +9341,6 @@ skip |= ValidateBool32(pNext_loc.dot(Field::enableCbCrDegamma), structure->enableCbCrDegamma); } } break; - - // Validation code for VkPhysicalDeviceCubicClampFeaturesQCOM structure members - case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_CUBIC_CLAMP_FEATURES_QCOM: { // Covers - // VUID-VkPhysicalDeviceCubicClampFeaturesQCOM-sType-sType - if (is_const_param) { - [[maybe_unused]] const Location pNext_loc = loc.pNext(Struct::VkPhysicalDeviceCubicClampFeaturesQCOM); - if (!IsExtEnabled(device_extensions.vk_qcom_filter_cubic_clamp)) { - skip |= LogError(pnext_vuid, instance, pNext_loc, - "includes a pointer to a VkPhysicalDeviceCubicClampFeaturesQCOM, but when creating VkDevice, " - "the parent extension " - "(VK_QCOM_filter_cubic_clamp) was not included in ppEnabledExtensionNames."); - } - VkPhysicalDeviceCubicClampFeaturesQCOM* structure = (VkPhysicalDeviceCubicClampFeaturesQCOM*)header; - skip |= ValidateBool32(pNext_loc.dot(Field::cubicRangeClamp), structure->cubicRangeClamp); - } - } break; - - // Validation code for VkPhysicalDeviceAttachmentFeedbackLoopDynamicStateFeaturesEXT structure members - case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ATTACHMENT_FEEDBACK_LOOP_DYNAMIC_STATE_FEATURES_EXT: { // Covers - // VUID-VkPhysicalDeviceAttachmentFeedbackLoopDynamicStateFeaturesEXT-sType-sType - if (is_const_param) { - [[maybe_unused]] const Location pNext_loc = - loc.pNext(Struct::VkPhysicalDeviceAttachmentFeedbackLoopDynamicStateFeaturesEXT); - if (!IsExtEnabled(device_extensions.vk_ext_attachment_feedback_loop_dynamic_state)) { - skip |= - LogError(pnext_vuid, instance, pNext_loc, - "includes a pointer to a VkPhysicalDeviceAttachmentFeedbackLoopDynamicStateFeaturesEXT, but when " - "creating VkDevice, the parent extension " - "(VK_EXT_attachment_feedback_loop_dynamic_state) was not included in ppEnabledExtensionNames."); - } - VkPhysicalDeviceAttachmentFeedbackLoopDynamicStateFeaturesEXT* structure = - (VkPhysicalDeviceAttachmentFeedbackLoopDynamicStateFeaturesEXT*)header; - skip |= ValidateBool32(pNext_loc.dot(Field::attachmentFeedbackLoopDynamicState), - structure->attachmentFeedbackLoopDynamicState); - } - } break; #ifdef VK_USE_PLATFORM_SCREEN_QNX // No Validation code for VkScreenBufferFormatPropertiesQNX structure members -- Covers @@ -9115,96 +9350,8 @@ // VUID-VkImportScreenBufferInfoQNX-sType-sType // No Validation code for VkExternalFormatQNX structure members -- Covers VUID-VkExternalFormatQNX-sType-sType - - // Validation code for VkPhysicalDeviceExternalMemoryScreenBufferFeaturesQNX structure members - case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTERNAL_MEMORY_SCREEN_BUFFER_FEATURES_QNX: { // Covers - // VUID-VkPhysicalDeviceExternalMemoryScreenBufferFeaturesQNX-sType-sType - if (is_const_param) { - [[maybe_unused]] const Location pNext_loc = - loc.pNext(Struct::VkPhysicalDeviceExternalMemoryScreenBufferFeaturesQNX); - if (!IsExtEnabled(device_extensions.vk_qnx_external_memory_screen_buffer)) { - skip |= LogError(pnext_vuid, instance, pNext_loc, - "includes a pointer to a VkPhysicalDeviceExternalMemoryScreenBufferFeaturesQNX, but when " - "creating VkDevice, the parent extension " - "(VK_QNX_external_memory_screen_buffer) was not included in ppEnabledExtensionNames."); - } - VkPhysicalDeviceExternalMemoryScreenBufferFeaturesQNX* structure = - (VkPhysicalDeviceExternalMemoryScreenBufferFeaturesQNX*)header; - skip |= ValidateBool32(pNext_loc.dot(Field::screenBufferImport), structure->screenBufferImport); - } - } break; #endif // VK_USE_PLATFORM_SCREEN_QNX - // No Validation code for VkPhysicalDeviceLayeredDriverPropertiesMSFT structure members -- Covers - // VUID-VkPhysicalDeviceLayeredDriverPropertiesMSFT-sType-sType - - // Validation code for VkPhysicalDeviceDescriptorPoolOverallocationFeaturesNV structure members - case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DESCRIPTOR_POOL_OVERALLOCATION_FEATURES_NV: { // Covers - // VUID-VkPhysicalDeviceDescriptorPoolOverallocationFeaturesNV-sType-sType - if (is_const_param) { - [[maybe_unused]] const Location pNext_loc = - loc.pNext(Struct::VkPhysicalDeviceDescriptorPoolOverallocationFeaturesNV); - if (!IsExtEnabled(device_extensions.vk_nv_descriptor_pool_overallocation)) { - skip |= LogError(pnext_vuid, instance, pNext_loc, - "includes a pointer to a VkPhysicalDeviceDescriptorPoolOverallocationFeaturesNV, but when " - "creating VkDevice, the parent extension " - "(VK_NV_descriptor_pool_overallocation) was not included in ppEnabledExtensionNames."); - } - VkPhysicalDeviceDescriptorPoolOverallocationFeaturesNV* structure = - (VkPhysicalDeviceDescriptorPoolOverallocationFeaturesNV*)header; - skip |= ValidateBool32(pNext_loc.dot(Field::descriptorPoolOverallocation), structure->descriptorPoolOverallocation); - } - } break; - - // Validation code for VkPhysicalDeviceRawAccessChainsFeaturesNV structure members - case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RAW_ACCESS_CHAINS_FEATURES_NV: { // Covers - // VUID-VkPhysicalDeviceRawAccessChainsFeaturesNV-sType-sType - if (is_const_param) { - [[maybe_unused]] const Location pNext_loc = loc.pNext(Struct::VkPhysicalDeviceRawAccessChainsFeaturesNV); - if (!IsExtEnabled(device_extensions.vk_nv_raw_access_chains)) { - skip |= LogError(pnext_vuid, instance, pNext_loc, - "includes a pointer to a VkPhysicalDeviceRawAccessChainsFeaturesNV, but when creating " - "VkDevice, the parent extension " - "(VK_NV_raw_access_chains) was not included in ppEnabledExtensionNames."); - } - VkPhysicalDeviceRawAccessChainsFeaturesNV* structure = (VkPhysicalDeviceRawAccessChainsFeaturesNV*)header; - skip |= ValidateBool32(pNext_loc.dot(Field::shaderRawAccessChains), structure->shaderRawAccessChains); - } - } break; - - // Validation code for VkPhysicalDeviceShaderAtomicFloat16VectorFeaturesNV structure members - case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_ATOMIC_FLOAT16_VECTOR_FEATURES_NV: { // Covers - // VUID-VkPhysicalDeviceShaderAtomicFloat16VectorFeaturesNV-sType-sType - if (is_const_param) { - [[maybe_unused]] const Location pNext_loc = loc.pNext(Struct::VkPhysicalDeviceShaderAtomicFloat16VectorFeaturesNV); - if (!IsExtEnabled(device_extensions.vk_nv_shader_atomic_float16_vector)) { - skip |= LogError(pnext_vuid, instance, pNext_loc, - "includes a pointer to a VkPhysicalDeviceShaderAtomicFloat16VectorFeaturesNV, but when " - "creating VkDevice, the parent extension " - "(VK_NV_shader_atomic_float16_vector) was not included in ppEnabledExtensionNames."); - } - VkPhysicalDeviceShaderAtomicFloat16VectorFeaturesNV* structure = - (VkPhysicalDeviceShaderAtomicFloat16VectorFeaturesNV*)header; - skip |= ValidateBool32(pNext_loc.dot(Field::shaderFloat16VectorAtomics), structure->shaderFloat16VectorAtomics); - } - } break; - - // Validation code for VkPhysicalDeviceRayTracingValidationFeaturesNV structure members - case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RAY_TRACING_VALIDATION_FEATURES_NV: { // Covers - // VUID-VkPhysicalDeviceRayTracingValidationFeaturesNV-sType-sType - if (is_const_param) { - [[maybe_unused]] const Location pNext_loc = loc.pNext(Struct::VkPhysicalDeviceRayTracingValidationFeaturesNV); - if (!IsExtEnabled(device_extensions.vk_nv_ray_tracing_validation)) { - skip |= LogError(pnext_vuid, instance, pNext_loc, - "includes a pointer to a VkPhysicalDeviceRayTracingValidationFeaturesNV, but when creating " - "VkDevice, the parent extension " - "(VK_NV_ray_tracing_validation) was not included in ppEnabledExtensionNames."); - } - VkPhysicalDeviceRayTracingValidationFeaturesNV* structure = (VkPhysicalDeviceRayTracingValidationFeaturesNV*)header; - skip |= ValidateBool32(pNext_loc.dot(Field::rayTracingValidation), structure->rayTracingValidation); - } - } break; - // Validation code for VkWriteDescriptorSetAccelerationStructureKHR structure members case VK_STRUCTURE_TYPE_WRITE_DESCRIPTOR_SET_ACCELERATION_STRUCTURE_KHR: { // Covers // VUID-VkWriteDescriptorSetAccelerationStructureKHR-sType-sType @@ -9223,112 +9370,6 @@ } } break; - // Validation code for VkPhysicalDeviceAccelerationStructureFeaturesKHR structure members - case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ACCELERATION_STRUCTURE_FEATURES_KHR: { // Covers - // VUID-VkPhysicalDeviceAccelerationStructureFeaturesKHR-sType-sType - if (is_const_param) { - [[maybe_unused]] const Location pNext_loc = loc.pNext(Struct::VkPhysicalDeviceAccelerationStructureFeaturesKHR); - if (!IsExtEnabled(device_extensions.vk_khr_acceleration_structure)) { - skip |= LogError(pnext_vuid, instance, pNext_loc, - "includes a pointer to a VkPhysicalDeviceAccelerationStructureFeaturesKHR, but when creating " - "VkDevice, the parent extension " - "(VK_KHR_acceleration_structure) was not included in ppEnabledExtensionNames."); - } - VkPhysicalDeviceAccelerationStructureFeaturesKHR* structure = - (VkPhysicalDeviceAccelerationStructureFeaturesKHR*)header; - skip |= ValidateBool32(pNext_loc.dot(Field::accelerationStructure), structure->accelerationStructure); - - skip |= ValidateBool32(pNext_loc.dot(Field::accelerationStructureCaptureReplay), - structure->accelerationStructureCaptureReplay); - - skip |= ValidateBool32(pNext_loc.dot(Field::accelerationStructureIndirectBuild), - structure->accelerationStructureIndirectBuild); - - skip |= ValidateBool32(pNext_loc.dot(Field::accelerationStructureHostCommands), - structure->accelerationStructureHostCommands); - - skip |= ValidateBool32(pNext_loc.dot(Field::descriptorBindingAccelerationStructureUpdateAfterBind), - structure->descriptorBindingAccelerationStructureUpdateAfterBind); - } - } break; - - // No Validation code for VkPhysicalDeviceAccelerationStructurePropertiesKHR structure members -- Covers - // VUID-VkPhysicalDeviceAccelerationStructurePropertiesKHR-sType-sType - - // Validation code for VkPhysicalDeviceRayTracingPipelineFeaturesKHR structure members - case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RAY_TRACING_PIPELINE_FEATURES_KHR: { // Covers - // VUID-VkPhysicalDeviceRayTracingPipelineFeaturesKHR-sType-sType - if (is_const_param) { - [[maybe_unused]] const Location pNext_loc = loc.pNext(Struct::VkPhysicalDeviceRayTracingPipelineFeaturesKHR); - if (!IsExtEnabled(device_extensions.vk_khr_ray_tracing_pipeline)) { - skip |= LogError(pnext_vuid, instance, pNext_loc, - "includes a pointer to a VkPhysicalDeviceRayTracingPipelineFeaturesKHR, but when creating " - "VkDevice, the parent extension " - "(VK_KHR_ray_tracing_pipeline) was not included in ppEnabledExtensionNames."); - } - VkPhysicalDeviceRayTracingPipelineFeaturesKHR* structure = (VkPhysicalDeviceRayTracingPipelineFeaturesKHR*)header; - skip |= ValidateBool32(pNext_loc.dot(Field::rayTracingPipeline), structure->rayTracingPipeline); - - skip |= ValidateBool32(pNext_loc.dot(Field::rayTracingPipelineShaderGroupHandleCaptureReplay), - structure->rayTracingPipelineShaderGroupHandleCaptureReplay); - - skip |= ValidateBool32(pNext_loc.dot(Field::rayTracingPipelineShaderGroupHandleCaptureReplayMixed), - structure->rayTracingPipelineShaderGroupHandleCaptureReplayMixed); - - skip |= ValidateBool32(pNext_loc.dot(Field::rayTracingPipelineTraceRaysIndirect), - structure->rayTracingPipelineTraceRaysIndirect); - - skip |= ValidateBool32(pNext_loc.dot(Field::rayTraversalPrimitiveCulling), structure->rayTraversalPrimitiveCulling); - } - } break; - - // No Validation code for VkPhysicalDeviceRayTracingPipelinePropertiesKHR structure members -- Covers - // VUID-VkPhysicalDeviceRayTracingPipelinePropertiesKHR-sType-sType - - // Validation code for VkPhysicalDeviceRayQueryFeaturesKHR structure members - case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RAY_QUERY_FEATURES_KHR: { // Covers - // VUID-VkPhysicalDeviceRayQueryFeaturesKHR-sType-sType - if (is_const_param) { - [[maybe_unused]] const Location pNext_loc = loc.pNext(Struct::VkPhysicalDeviceRayQueryFeaturesKHR); - if (!IsExtEnabled(device_extensions.vk_khr_ray_query)) { - skip |= LogError(pnext_vuid, instance, pNext_loc, - "includes a pointer to a VkPhysicalDeviceRayQueryFeaturesKHR, but when creating VkDevice, the " - "parent extension " - "(VK_KHR_ray_query) was not included in ppEnabledExtensionNames."); - } - VkPhysicalDeviceRayQueryFeaturesKHR* structure = (VkPhysicalDeviceRayQueryFeaturesKHR*)header; - skip |= ValidateBool32(pNext_loc.dot(Field::rayQuery), structure->rayQuery); - } - } break; - - // Validation code for VkPhysicalDeviceMeshShaderFeaturesEXT structure members - case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MESH_SHADER_FEATURES_EXT: { // Covers - // VUID-VkPhysicalDeviceMeshShaderFeaturesEXT-sType-sType - if (is_const_param) { - [[maybe_unused]] const Location pNext_loc = loc.pNext(Struct::VkPhysicalDeviceMeshShaderFeaturesEXT); - if (!IsExtEnabled(device_extensions.vk_ext_mesh_shader)) { - skip |= LogError(pnext_vuid, instance, pNext_loc, - "includes a pointer to a VkPhysicalDeviceMeshShaderFeaturesEXT, but when creating VkDevice, " - "the parent extension " - "(VK_EXT_mesh_shader) was not included in ppEnabledExtensionNames."); - } - VkPhysicalDeviceMeshShaderFeaturesEXT* structure = (VkPhysicalDeviceMeshShaderFeaturesEXT*)header; - skip |= ValidateBool32(pNext_loc.dot(Field::taskShader), structure->taskShader); - - skip |= ValidateBool32(pNext_loc.dot(Field::meshShader), structure->meshShader); - - skip |= ValidateBool32(pNext_loc.dot(Field::multiviewMeshShader), structure->multiviewMeshShader); - - skip |= ValidateBool32(pNext_loc.dot(Field::primitiveFragmentShadingRateMeshShader), - structure->primitiveFragmentShadingRateMeshShader); - - skip |= ValidateBool32(pNext_loc.dot(Field::meshShaderQueries), structure->meshShaderQueries); - } - } break; - - // No Validation code for VkPhysicalDeviceMeshShaderPropertiesEXT structure members -- Covers - // VUID-VkPhysicalDeviceMeshShaderPropertiesEXT-sType-sType - default: skip = false; }
diff --git a/scripts/generators/stateless_validation_helper_generator.py b/scripts/generators/stateless_validation_helper_generator.py index cf04fce..410938c 100644 --- a/scripts/generators/stateless_validation_helper_generator.py +++ b/scripts/generators/stateless_validation_helper_generator.py
@@ -21,7 +21,7 @@ import os import re from generators.generator_utils import buildListVUID, PlatformGuardHelper -from generators.vulkan_object import Member +from generators.vulkan_object import Member, Struct from generators.base_generator import BaseGenerator # This class is a container for any source code, data, or other behavior that is necessary to @@ -234,6 +234,8 @@ # Map of flag bits typename to list of values self.flagBits = dict() + self.stype_version_dict = dict() + def generate(self): self.write(f'''// *** THIS FILE IS GENERATED - DO NOT EDIT *** // See {os.path.basename(__file__)} for modifications @@ -324,7 +326,6 @@ # VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_4444_FORMATS_FEATURES_EXT # VK_STRUCTURE_TYPE_RENDERING_FRAGMENT_DENSITY_MAP_ATTACHMENT_INFO_EXT root = self.registry.reg - stype_version_dict = dict() for extensions in root.findall('extensions'): for extension in extensions.findall('extension'): extensionName = extension.get('name') @@ -336,23 +337,7 @@ if (entry.get('comment') is None or 'typo' not in entry.get('comment')): alias = entry.get('alias') if (alias is not None and promotedToCore): - stype_version_dict[alias] = extensionName - out = [] - - out.append(''' - #include "chassis.h" - - #include "stateless/stateless_validation.h" - #include "generated/enum_flag_bits.h" - #include "generated/layer_chassis_dispatch.h" - - bool StatelessValidation::ValidatePnextStructContents(const Location& loc, - const VkBaseOutStructure* header, const char *pnext_vuid, - VkPhysicalDevice caller_physical_device, bool is_const_param) const { - bool skip = false; - const bool is_physdev_api = caller_physical_device != VK_NULL_HANDLE; - switch(header->sType) { - ''') + self.stype_version_dict[alias] = extensionName # Generate the struct member checking code from the captured data for struct in self.vk.structs.values(): @@ -361,99 +346,79 @@ if lines: self.validatedStructs[struct.name] = lines + out = [] + out.append(''' + #include "chassis.h" + + #include "stateless/stateless_validation.h" + #include "generated/enum_flag_bits.h" + #include "generated/layer_chassis_dispatch.h" + ''') + + # The reason we split this up into Feature and Properties struct is before be had a 450 case, 10k line function that broke MSVC + # reference: https://www.asawicki.info/news_1617_how_code_refactoring_can_fix_stack_overflow_error + extended_structs = [x for x in self.vk.structs.values() if x.extends] + feature_structs = [x for x in extended_structs if x.extends == ["VkPhysicalDeviceFeatures2", "VkDeviceCreateInfo"]] + property_structs = [x for x in extended_structs if x.extends == ["VkPhysicalDeviceProperties2"]] + other_structs = [x for x in extended_structs if x not in feature_structs and x not in property_structs] + + out.append(''' + bool StatelessValidation::ValidatePnextFeatureStructContents(const Location& loc, + const VkBaseOutStructure* header, const char *pnext_vuid, + VkPhysicalDevice caller_physical_device, bool is_const_param) const { + bool skip = false; + const bool is_physdev_api = caller_physical_device != VK_NULL_HANDLE; + switch(header->sType) { + ''') guard_helper = PlatformGuardHelper() - # Do some processing here to extract data from validatedstructs... - for struct in [x for x in self.vk.structs.values() if x.extends]: + for struct in feature_structs: out.extend(guard_helper.add_guard(struct.protect)) + out.extend(self.genStructBody(struct)) + out.extend(guard_helper.add_guard(None)) + out.append(''' + default: + skip = false; + } + return skip; + } - pnext_case = '\n' - pnext_check = '' + ''') - pnext_case += f' // Validation code for {struct.name} structure members\n' - pnext_case += f' case {struct.sType}: {{ // Covers VUID-{struct.name}-sType-sType\n' + out.append(''' + bool StatelessValidation::ValidatePnextPropertyStructContents(const Location& loc, + const VkBaseOutStructure* header, const char *pnext_vuid, + VkPhysicalDevice caller_physical_device, bool is_const_param) const { + bool skip = false; + const bool is_physdev_api = caller_physical_device != VK_NULL_HANDLE; + switch(header->sType) { + ''') + guard_helper = PlatformGuardHelper() + for struct in property_structs: + out.extend(guard_helper.add_guard(struct.protect)) + out.extend(self.genStructBody(struct)) + out.extend(guard_helper.add_guard(None)) + out.append(''' + default: + skip = false; + } + return skip; + } - if struct.sType and struct.version and all(not x.promotedTo for x in struct.extensions): - pnext_check += f''' - if (is_physdev_api) {{ - VkPhysicalDeviceProperties device_properties = {{}}; - DispatchGetPhysicalDeviceProperties(caller_physical_device, &device_properties); - if (device_properties.apiVersion < {struct.version.nameApi}) {{ - skip |= LogError( - pnext_vuid, instance, loc.dot(Field::pNext), - "includes a pointer to a VkStructureType ({struct.sType}) which was added in {struct.version.nameApi} but the " - "current effective API version is %s.", StringAPIVersion(api_version).c_str()); - }} - }} - ''' + ''') - elif struct.sType in stype_version_dict.keys(): - ext_name = stype_version_dict[struct.sType] - - # Skip extensions that are not in the target API - # This check is needed because parts of the base generator code bypass the - # dependency resolution logic in the registry tooling and thus the generator - # may attempt to generate code for extensions which are not supported in the - # target API variant, thus this check needs to happen even if any specific - # target API variant may not specifically need it - if ext_name not in self.vk.extensions: - continue - - # Dependent on enabled extension - extension = self.vk.extensions[ext_name] - extension_check = '' - if extension.device: - extension_check = f'if ((is_physdev_api && !SupportedByPdev(physical_device, vvl::Extension::_{extension.name})) || (!is_physdev_api && !IsExtEnabled(device_extensions.{extension.name.lower()}))) {{' - else: - extension_check = f'if (!IsExtEnabled(instance_extensions.{extension.name.lower()})) {{' - pnext_check += f''' - {extension_check} - skip |= LogError( - pnext_vuid, instance, loc.dot(Field::pNext), - "includes a pointer to a VkStructureType ({struct.sType}), but its parent extension " - "{extension.name} has not been enabled."); - }} - ''' - - expr = self.expandStructCode(struct.name, struct.name, 'pNext_loc', 'structure->', '', []) - struct_validation_source = self.ScrubStructCode(expr) - if struct_validation_source != '': - # Only reasonable to validate content of structs if const as otherwise the date inside has not been writen to yet - # https://github.com/KhronosGroup/Vulkan-ValidationLayers/issues/3122 - pnext_check += 'if (is_const_param) {\n' - pnext_check += f'[[maybe_unused]] const Location pNext_loc = loc.pNext(Struct::{struct.name});\n' - - # We do the extension checking here at the pNext chaining because if the struct is only used in a new extended command, - # using that command will always trigger a "missing extension" VU - checkExpression = [] - resultExpression = [] - for extension in [x.name for x in struct.extensions if x.device]: - checkExpression.append(f'!IsExtEnabled(device_extensions.{extension.lower()})') - resultExpression.append(extension) - # TODO - Video session creation checks will fail tests if no extensions are found (need to fix test logic) - if len(checkExpression) > 0 and 'Video' not in struct.name: - # Special message for device features - if 'VkPhysicalDeviceFeatures2' in struct.extends and 'VkDeviceCreateInfo' in struct.extends: - pnext_check += f'''if ({" && ".join(checkExpression)}){{ - skip |= LogError(pnext_vuid, instance, pNext_loc, - "includes a pointer to a {struct.name}, but when creating VkDevice, the parent extension " - "({" or ".join(resultExpression)}) was not included in ppEnabledExtensionNames."); - }} - ''' - else: - pnext_check += f'''if ({" && ".join(checkExpression)}){{ - skip |= LogError(pnext_vuid, instance, pNext_loc, "extended struct requires the extensions {" or ".join(resultExpression)}"); - }} - ''' - - struct_validation_source = f'{struct.name} *structure = ({struct.name} *) header;\n{struct_validation_source}' - struct_validation_source += '}\n' - pnext_case += f'{pnext_check}{struct_validation_source}' - pnext_case += '} break;\n' - # Skip functions containing no validation - if struct_validation_source or pnext_check != '': - out.append(pnext_case) - else: - out.append(f'\n // No Validation code for {struct.name} structure members -- Covers VUID-{struct.name}-sType-sType\n') + out.append(''' + // All structs that are not a Feature or Property struct + bool StatelessValidation::ValidatePnextStructContents(const Location& loc, + const VkBaseOutStructure* header, const char *pnext_vuid, + VkPhysicalDevice caller_physical_device, bool is_const_param) const { + bool skip = false; + const bool is_physdev_api = caller_physical_device != VK_NULL_HANDLE; + switch(header->sType) { + ''') + guard_helper = PlatformGuardHelper() + for struct in other_structs: + out.extend(guard_helper.add_guard(struct.protect)) + out.extend(self.genStructBody(struct)) out.extend(guard_helper.add_guard(None)) out.append(''' default: @@ -1006,6 +971,96 @@ lines.append('// No xml-driven validation\n') return lines + # This logic was broken into its own function because we need to fill multiple functions with these structs + def genStructBody(self, struct: Struct): + pnext_case = '\n' + pnext_check = '' + + pnext_case += f' // Validation code for {struct.name} structure members\n' + pnext_case += f' case {struct.sType}: {{ // Covers VUID-{struct.name}-sType-sType\n' + + if struct.sType and struct.version and all(not x.promotedTo for x in struct.extensions): + pnext_check += f''' + if (is_physdev_api) {{ + VkPhysicalDeviceProperties device_properties = {{}}; + DispatchGetPhysicalDeviceProperties(caller_physical_device, &device_properties); + if (device_properties.apiVersion < {struct.version.nameApi}) {{ + skip |= LogError( + pnext_vuid, instance, loc.dot(Field::pNext), + "includes a pointer to a VkStructureType ({struct.sType}) which was added in {struct.version.nameApi} but the " + "current effective API version is %s.", StringAPIVersion(api_version).c_str()); + }} + }} + ''' + + elif struct.sType in self.stype_version_dict.keys(): + ext_name = self.stype_version_dict[struct.sType] + + # Skip extensions that are not in the target API + # This check is needed because parts of the base generator code bypass the + # dependency resolution logic in the registry tooling and thus the generator + # may attempt to generate code for extensions which are not supported in the + # target API variant, thus this check needs to happen even if any specific + # target API variant may not specifically need it + if ext_name not in self.vk.extensions: + return "" + + # Dependent on enabled extension + extension = self.vk.extensions[ext_name] + extension_check = '' + if extension.device: + extension_check = f'if ((is_physdev_api && !SupportedByPdev(physical_device, vvl::Extension::_{extension.name})) || (!is_physdev_api && !IsExtEnabled(device_extensions.{extension.name.lower()}))) {{' + else: + extension_check = f'if (!IsExtEnabled(instance_extensions.{extension.name.lower()})) {{' + pnext_check += f''' + {extension_check} + skip |= LogError( + pnext_vuid, instance, loc.dot(Field::pNext), + "includes a pointer to a VkStructureType ({struct.sType}), but its parent extension " + "{extension.name} has not been enabled."); + }} + ''' + + expr = self.expandStructCode(struct.name, struct.name, 'pNext_loc', 'structure->', '', []) + struct_validation_source = self.ScrubStructCode(expr) + if struct_validation_source != '': + # Only reasonable to validate content of structs if const as otherwise the date inside has not been writen to yet + # https://github.com/KhronosGroup/Vulkan-ValidationLayers/issues/3122 + pnext_check += 'if (is_const_param) {\n' + pnext_check += f'[[maybe_unused]] const Location pNext_loc = loc.pNext(Struct::{struct.name});\n' + + # We do the extension checking here at the pNext chaining because if the struct is only used in a new extended command, + # using that command will always trigger a "missing extension" VU + checkExpression = [] + resultExpression = [] + for extension in [x.name for x in struct.extensions if x.device]: + checkExpression.append(f'!IsExtEnabled(device_extensions.{extension.lower()})') + resultExpression.append(extension) + # TODO - Video session creation checks will fail tests if no extensions are found (need to fix test logic) + if len(checkExpression) > 0 and 'Video' not in struct.name: + # Special message for device features + if 'VkPhysicalDeviceFeatures2' in struct.extends and 'VkDeviceCreateInfo' in struct.extends: + pnext_check += f'''if ({" && ".join(checkExpression)}){{ + skip |= LogError(pnext_vuid, instance, pNext_loc, + "includes a pointer to a {struct.name}, but when creating VkDevice, the parent extension " + "({" or ".join(resultExpression)}) was not included in ppEnabledExtensionNames."); + }} + ''' + else: + pnext_check += f'''if ({" && ".join(checkExpression)}){{ + skip |= LogError(pnext_vuid, instance, pNext_loc, "extended struct requires the extensions {" or ".join(resultExpression)}"); + }} + ''' + + struct_validation_source = f'{struct.name} *structure = ({struct.name} *) header;\n{struct_validation_source}' + struct_validation_source += '}\n' + pnext_case += f'{pnext_check}{struct_validation_source}' + pnext_case += '} break;\n' + # Skip functions containing no validation + if struct_validation_source or pnext_check != '': + return pnext_case + else: + return f'\n // No Validation code for {struct.name} structure members -- Covers VUID-{struct.name}-sType-sType\n' # Helper for iterating over a list where each element is possibly a single element or another 1-dimensional list # Generates (setter, deleter, element) for each element where: