// *** THIS FILE IS GENERATED - DO NOT EDIT ***
// See feature_not_present.py for modifications

/***************************************************************************
 *
 * Copyright (c) 2025-2026 Valve Corporation
 * Copyright (c) 2025-2026 LunarG, Inc.
 *
 * Licensed under the Apache License, Version 2.0 (the "License");
 * you may not use this file except in compliance with the License.
 * You may obtain a copy of the License at
 *
 *     http://www.apache.org/licenses/LICENSE-2.0
 *
 * Unless required by applicable law or agreed to in writing, software
 * distributed under the License is distributed on an "AS IS" BASIS,
 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 * See the License for the specific language governing permissions and
 * limitations under the License.
 ****************************************************************************/

#include "chassis/dispatch_object.h"
#include "generated/dispatch_functions.h"
#include "error_message/error_location.h"

namespace vvl {

void DispatchInstance::ReportErrorFeatureNotPresent(VkPhysicalDevice gpu, const VkDeviceCreateInfo& create_info) {
    std::ostringstream ss;
    ss << "returned VK_ERROR_FEATURE_NOT_PRESENT because the following features were not supported on this physical device:\n";

    // First do 1.0 VkPhysicalDeviceFeatures
    const auto* features2_in = vku::FindStructInPNextChain<VkPhysicalDeviceFeatures2>(create_info.pNext);
    if (create_info.pEnabledFeatures || features2_in) {
        const VkPhysicalDeviceFeatures& enabling =
            create_info.pEnabledFeatures ? *create_info.pEnabledFeatures : features2_in->features;

        VkPhysicalDeviceFeatures supported = {};
        DispatchGetPhysicalDeviceFeatures(gpu, &supported);
        if (enabling.robustBufferAccess && !supported.robustBufferAccess) {
            ss << "VkPhysicalDeviceFeatures::robustBufferAccess is not supported\n";
        }
        if (enabling.fullDrawIndexUint32 && !supported.fullDrawIndexUint32) {
            ss << "VkPhysicalDeviceFeatures::fullDrawIndexUint32 is not supported\n";
        }
        if (enabling.imageCubeArray && !supported.imageCubeArray) {
            ss << "VkPhysicalDeviceFeatures::imageCubeArray is not supported\n";
        }
        if (enabling.independentBlend && !supported.independentBlend) {
            ss << "VkPhysicalDeviceFeatures::independentBlend is not supported\n";
        }
        if (enabling.geometryShader && !supported.geometryShader) {
            ss << "VkPhysicalDeviceFeatures::geometryShader is not supported\n";
        }
        if (enabling.tessellationShader && !supported.tessellationShader) {
            ss << "VkPhysicalDeviceFeatures::tessellationShader is not supported\n";
        }
        if (enabling.sampleRateShading && !supported.sampleRateShading) {
            ss << "VkPhysicalDeviceFeatures::sampleRateShading is not supported\n";
        }
        if (enabling.dualSrcBlend && !supported.dualSrcBlend) {
            ss << "VkPhysicalDeviceFeatures::dualSrcBlend is not supported\n";
        }
        if (enabling.logicOp && !supported.logicOp) {
            ss << "VkPhysicalDeviceFeatures::logicOp is not supported\n";
        }
        if (enabling.multiDrawIndirect && !supported.multiDrawIndirect) {
            ss << "VkPhysicalDeviceFeatures::multiDrawIndirect is not supported\n";
        }
        if (enabling.drawIndirectFirstInstance && !supported.drawIndirectFirstInstance) {
            ss << "VkPhysicalDeviceFeatures::drawIndirectFirstInstance is not supported\n";
        }
        if (enabling.depthClamp && !supported.depthClamp) {
            ss << "VkPhysicalDeviceFeatures::depthClamp is not supported\n";
        }
        if (enabling.depthBiasClamp && !supported.depthBiasClamp) {
            ss << "VkPhysicalDeviceFeatures::depthBiasClamp is not supported\n";
        }
        if (enabling.fillModeNonSolid && !supported.fillModeNonSolid) {
            ss << "VkPhysicalDeviceFeatures::fillModeNonSolid is not supported\n";
        }
        if (enabling.depthBounds && !supported.depthBounds) {
            ss << "VkPhysicalDeviceFeatures::depthBounds is not supported\n";
        }
        if (enabling.wideLines && !supported.wideLines) {
            ss << "VkPhysicalDeviceFeatures::wideLines is not supported\n";
        }
        if (enabling.largePoints && !supported.largePoints) {
            ss << "VkPhysicalDeviceFeatures::largePoints is not supported\n";
        }
        if (enabling.alphaToOne && !supported.alphaToOne) {
            ss << "VkPhysicalDeviceFeatures::alphaToOne is not supported\n";
        }
        if (enabling.multiViewport && !supported.multiViewport) {
            ss << "VkPhysicalDeviceFeatures::multiViewport is not supported\n";
        }
        if (enabling.samplerAnisotropy && !supported.samplerAnisotropy) {
            ss << "VkPhysicalDeviceFeatures::samplerAnisotropy is not supported\n";
        }
        if (enabling.textureCompressionETC2 && !supported.textureCompressionETC2) {
            ss << "VkPhysicalDeviceFeatures::textureCompressionETC2 is not supported\n";
        }
        if (enabling.textureCompressionASTC_LDR && !supported.textureCompressionASTC_LDR) {
            ss << "VkPhysicalDeviceFeatures::textureCompressionASTC_LDR is not supported\n";
        }
        if (enabling.textureCompressionBC && !supported.textureCompressionBC) {
            ss << "VkPhysicalDeviceFeatures::textureCompressionBC is not supported\n";
        }
        if (enabling.occlusionQueryPrecise && !supported.occlusionQueryPrecise) {
            ss << "VkPhysicalDeviceFeatures::occlusionQueryPrecise is not supported\n";
        }
        if (enabling.pipelineStatisticsQuery && !supported.pipelineStatisticsQuery) {
            ss << "VkPhysicalDeviceFeatures::pipelineStatisticsQuery is not supported\n";
        }
        if (enabling.vertexPipelineStoresAndAtomics && !supported.vertexPipelineStoresAndAtomics) {
            ss << "VkPhysicalDeviceFeatures::vertexPipelineStoresAndAtomics is not supported\n";
        }
        if (enabling.fragmentStoresAndAtomics && !supported.fragmentStoresAndAtomics) {
            ss << "VkPhysicalDeviceFeatures::fragmentStoresAndAtomics is not supported\n";
        }
        if (enabling.shaderTessellationAndGeometryPointSize && !supported.shaderTessellationAndGeometryPointSize) {
            ss << "VkPhysicalDeviceFeatures::shaderTessellationAndGeometryPointSize is not supported\n";
        }
        if (enabling.shaderImageGatherExtended && !supported.shaderImageGatherExtended) {
            ss << "VkPhysicalDeviceFeatures::shaderImageGatherExtended is not supported\n";
        }
        if (enabling.shaderStorageImageExtendedFormats && !supported.shaderStorageImageExtendedFormats) {
            ss << "VkPhysicalDeviceFeatures::shaderStorageImageExtendedFormats is not supported\n";
        }
        if (enabling.shaderStorageImageMultisample && !supported.shaderStorageImageMultisample) {
            ss << "VkPhysicalDeviceFeatures::shaderStorageImageMultisample is not supported\n";
        }
        if (enabling.shaderStorageImageReadWithoutFormat && !supported.shaderStorageImageReadWithoutFormat) {
            ss << "VkPhysicalDeviceFeatures::shaderStorageImageReadWithoutFormat is not supported\n";
        }
        if (enabling.shaderStorageImageWriteWithoutFormat && !supported.shaderStorageImageWriteWithoutFormat) {
            ss << "VkPhysicalDeviceFeatures::shaderStorageImageWriteWithoutFormat is not supported\n";
        }
        if (enabling.shaderUniformBufferArrayDynamicIndexing && !supported.shaderUniformBufferArrayDynamicIndexing) {
            ss << "VkPhysicalDeviceFeatures::shaderUniformBufferArrayDynamicIndexing is not supported\n";
        }
        if (enabling.shaderSampledImageArrayDynamicIndexing && !supported.shaderSampledImageArrayDynamicIndexing) {
            ss << "VkPhysicalDeviceFeatures::shaderSampledImageArrayDynamicIndexing is not supported\n";
        }
        if (enabling.shaderStorageBufferArrayDynamicIndexing && !supported.shaderStorageBufferArrayDynamicIndexing) {
            ss << "VkPhysicalDeviceFeatures::shaderStorageBufferArrayDynamicIndexing is not supported\n";
        }
        if (enabling.shaderStorageImageArrayDynamicIndexing && !supported.shaderStorageImageArrayDynamicIndexing) {
            ss << "VkPhysicalDeviceFeatures::shaderStorageImageArrayDynamicIndexing is not supported\n";
        }
        if (enabling.shaderClipDistance && !supported.shaderClipDistance) {
            ss << "VkPhysicalDeviceFeatures::shaderClipDistance is not supported\n";
        }
        if (enabling.shaderCullDistance && !supported.shaderCullDistance) {
            ss << "VkPhysicalDeviceFeatures::shaderCullDistance is not supported\n";
        }
        if (enabling.shaderFloat64 && !supported.shaderFloat64) {
            ss << "VkPhysicalDeviceFeatures::shaderFloat64 is not supported\n";
        }
        if (enabling.shaderInt64 && !supported.shaderInt64) {
            ss << "VkPhysicalDeviceFeatures::shaderInt64 is not supported\n";
        }
        if (enabling.shaderInt16 && !supported.shaderInt16) {
            ss << "VkPhysicalDeviceFeatures::shaderInt16 is not supported\n";
        }
        if (enabling.shaderResourceResidency && !supported.shaderResourceResidency) {
            ss << "VkPhysicalDeviceFeatures::shaderResourceResidency is not supported\n";
        }
        if (enabling.shaderResourceMinLod && !supported.shaderResourceMinLod) {
            ss << "VkPhysicalDeviceFeatures::shaderResourceMinLod is not supported\n";
        }
        if (enabling.sparseBinding && !supported.sparseBinding) {
            ss << "VkPhysicalDeviceFeatures::sparseBinding is not supported\n";
        }
        if (enabling.sparseResidencyBuffer && !supported.sparseResidencyBuffer) {
            ss << "VkPhysicalDeviceFeatures::sparseResidencyBuffer is not supported\n";
        }
        if (enabling.sparseResidencyImage2D && !supported.sparseResidencyImage2D) {
            ss << "VkPhysicalDeviceFeatures::sparseResidencyImage2D is not supported\n";
        }
        if (enabling.sparseResidencyImage3D && !supported.sparseResidencyImage3D) {
            ss << "VkPhysicalDeviceFeatures::sparseResidencyImage3D is not supported\n";
        }
        if (enabling.sparseResidency2Samples && !supported.sparseResidency2Samples) {
            ss << "VkPhysicalDeviceFeatures::sparseResidency2Samples is not supported\n";
        }
        if (enabling.sparseResidency4Samples && !supported.sparseResidency4Samples) {
            ss << "VkPhysicalDeviceFeatures::sparseResidency4Samples is not supported\n";
        }
        if (enabling.sparseResidency8Samples && !supported.sparseResidency8Samples) {
            ss << "VkPhysicalDeviceFeatures::sparseResidency8Samples is not supported\n";
        }
        if (enabling.sparseResidency16Samples && !supported.sparseResidency16Samples) {
            ss << "VkPhysicalDeviceFeatures::sparseResidency16Samples is not supported\n";
        }
        if (enabling.sparseResidencyAliased && !supported.sparseResidencyAliased) {
            ss << "VkPhysicalDeviceFeatures::sparseResidencyAliased is not supported\n";
        }
        if (enabling.variableMultisampleRate && !supported.variableMultisampleRate) {
            ss << "VkPhysicalDeviceFeatures::variableMultisampleRate is not supported\n";
        }
        if (enabling.inheritedQueries && !supported.inheritedQueries) {
            ss << "VkPhysicalDeviceFeatures::inheritedQueries is not supported\n";
        }
    }
    VkPhysicalDeviceFeatures2 features_2 = vku::InitStructHelper();
    for (const VkBaseInStructure* current = static_cast<const VkBaseInStructure*>(create_info.pNext); current != nullptr;
         current = current->pNext) {
        switch (current->sType) {
            case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_16BIT_STORAGE_FEATURES: {
                VkPhysicalDevice16BitStorageFeatures supported = vku::InitStructHelper();
                features_2.pNext = &supported;
                DispatchGetPhysicalDeviceFeatures2(gpu, &features_2);
                const VkPhysicalDevice16BitStorageFeatures* enabling =
                    reinterpret_cast<const VkPhysicalDevice16BitStorageFeatures*>(current);
                if (enabling->storageBuffer16BitAccess && !supported.storageBuffer16BitAccess) {
                    ss << "VkPhysicalDevice16BitStorageFeatures::storageBuffer16BitAccess is not supported\n";
                }
                if (enabling->uniformAndStorageBuffer16BitAccess && !supported.uniformAndStorageBuffer16BitAccess) {
                    ss << "VkPhysicalDevice16BitStorageFeatures::uniformAndStorageBuffer16BitAccess is not supported\n";
                }
                if (enabling->storagePushConstant16 && !supported.storagePushConstant16) {
                    ss << "VkPhysicalDevice16BitStorageFeatures::storagePushConstant16 is not supported\n";
                }
                if (enabling->storageInputOutput16 && !supported.storageInputOutput16) {
                    ss << "VkPhysicalDevice16BitStorageFeatures::storageInputOutput16 is not supported\n";
                }
                break;
            }
            case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_4444_FORMATS_FEATURES_EXT: {
                VkPhysicalDevice4444FormatsFeaturesEXT supported = vku::InitStructHelper();
                features_2.pNext = &supported;
                DispatchGetPhysicalDeviceFeatures2(gpu, &features_2);
                const VkPhysicalDevice4444FormatsFeaturesEXT* enabling =
                    reinterpret_cast<const VkPhysicalDevice4444FormatsFeaturesEXT*>(current);
                if (enabling->formatA4R4G4B4 && !supported.formatA4R4G4B4) {
                    ss << "VkPhysicalDevice4444FormatsFeaturesEXT::formatA4R4G4B4 is not supported\n";
                }
                if (enabling->formatA4B4G4R4 && !supported.formatA4B4G4R4) {
                    ss << "VkPhysicalDevice4444FormatsFeaturesEXT::formatA4B4G4R4 is not supported\n";
                }
                break;
            }
            case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_8BIT_STORAGE_FEATURES: {
                VkPhysicalDevice8BitStorageFeatures supported = vku::InitStructHelper();
                features_2.pNext = &supported;
                DispatchGetPhysicalDeviceFeatures2(gpu, &features_2);
                const VkPhysicalDevice8BitStorageFeatures* enabling =
                    reinterpret_cast<const VkPhysicalDevice8BitStorageFeatures*>(current);
                if (enabling->storageBuffer8BitAccess && !supported.storageBuffer8BitAccess) {
                    ss << "VkPhysicalDevice8BitStorageFeatures::storageBuffer8BitAccess is not supported\n";
                }
                if (enabling->uniformAndStorageBuffer8BitAccess && !supported.uniformAndStorageBuffer8BitAccess) {
                    ss << "VkPhysicalDevice8BitStorageFeatures::uniformAndStorageBuffer8BitAccess is not supported\n";
                }
                if (enabling->storagePushConstant8 && !supported.storagePushConstant8) {
                    ss << "VkPhysicalDevice8BitStorageFeatures::storagePushConstant8 is not supported\n";
                }
                break;
            }
            case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ASTC_DECODE_FEATURES_EXT: {
                VkPhysicalDeviceASTCDecodeFeaturesEXT supported = vku::InitStructHelper();
                features_2.pNext = &supported;
                DispatchGetPhysicalDeviceFeatures2(gpu, &features_2);
                const VkPhysicalDeviceASTCDecodeFeaturesEXT* enabling =
                    reinterpret_cast<const VkPhysicalDeviceASTCDecodeFeaturesEXT*>(current);
                if (enabling->decodeModeSharedExponent && !supported.decodeModeSharedExponent) {
                    ss << "VkPhysicalDeviceASTCDecodeFeaturesEXT::decodeModeSharedExponent is not supported\n";
                }
                break;
            }
            case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ACCELERATION_STRUCTURE_FEATURES_KHR: {
                VkPhysicalDeviceAccelerationStructureFeaturesKHR supported = vku::InitStructHelper();
                features_2.pNext = &supported;
                DispatchGetPhysicalDeviceFeatures2(gpu, &features_2);
                const VkPhysicalDeviceAccelerationStructureFeaturesKHR* enabling =
                    reinterpret_cast<const VkPhysicalDeviceAccelerationStructureFeaturesKHR*>(current);
                if (enabling->accelerationStructure && !supported.accelerationStructure) {
                    ss << "VkPhysicalDeviceAccelerationStructureFeaturesKHR::accelerationStructure is not supported\n";
                }
                if (enabling->accelerationStructureCaptureReplay && !supported.accelerationStructureCaptureReplay) {
                    ss << "VkPhysicalDeviceAccelerationStructureFeaturesKHR::accelerationStructureCaptureReplay is not supported\n";
                }
                if (enabling->accelerationStructureIndirectBuild && !supported.accelerationStructureIndirectBuild) {
                    ss << "VkPhysicalDeviceAccelerationStructureFeaturesKHR::accelerationStructureIndirectBuild is not supported\n";
                }
                if (enabling->accelerationStructureHostCommands && !supported.accelerationStructureHostCommands) {
                    ss << "VkPhysicalDeviceAccelerationStructureFeaturesKHR::accelerationStructureHostCommands is not supported\n";
                }
                if (enabling->descriptorBindingAccelerationStructureUpdateAfterBind &&
                    !supported.descriptorBindingAccelerationStructureUpdateAfterBind) {
                    ss << "VkPhysicalDeviceAccelerationStructureFeaturesKHR::descriptorBindingAccelerationStructureUpdateAfterBind "
                          "is not supported\n";
                }
                break;
            }
            case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ADDRESS_BINDING_REPORT_FEATURES_EXT: {
                VkPhysicalDeviceAddressBindingReportFeaturesEXT supported = vku::InitStructHelper();
                features_2.pNext = &supported;
                DispatchGetPhysicalDeviceFeatures2(gpu, &features_2);
                const VkPhysicalDeviceAddressBindingReportFeaturesEXT* enabling =
                    reinterpret_cast<const VkPhysicalDeviceAddressBindingReportFeaturesEXT*>(current);
                if (enabling->reportAddressBinding && !supported.reportAddressBinding) {
                    ss << "VkPhysicalDeviceAddressBindingReportFeaturesEXT::reportAddressBinding is not supported\n";
                }
                break;
            }
            case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_AMIGO_PROFILING_FEATURES_SEC: {
                VkPhysicalDeviceAmigoProfilingFeaturesSEC supported = vku::InitStructHelper();
                features_2.pNext = &supported;
                DispatchGetPhysicalDeviceFeatures2(gpu, &features_2);
                const VkPhysicalDeviceAmigoProfilingFeaturesSEC* enabling =
                    reinterpret_cast<const VkPhysicalDeviceAmigoProfilingFeaturesSEC*>(current);
                if (enabling->amigoProfiling && !supported.amigoProfiling) {
                    ss << "VkPhysicalDeviceAmigoProfilingFeaturesSEC::amigoProfiling is not supported\n";
                }
                break;
            }
            case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ANTI_LAG_FEATURES_AMD: {
                VkPhysicalDeviceAntiLagFeaturesAMD supported = vku::InitStructHelper();
                features_2.pNext = &supported;
                DispatchGetPhysicalDeviceFeatures2(gpu, &features_2);
                const VkPhysicalDeviceAntiLagFeaturesAMD* enabling =
                    reinterpret_cast<const VkPhysicalDeviceAntiLagFeaturesAMD*>(current);
                if (enabling->antiLag && !supported.antiLag) {
                    ss << "VkPhysicalDeviceAntiLagFeaturesAMD::antiLag is not supported\n";
                }
                break;
            }
            case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ATTACHMENT_FEEDBACK_LOOP_DYNAMIC_STATE_FEATURES_EXT: {
                VkPhysicalDeviceAttachmentFeedbackLoopDynamicStateFeaturesEXT supported = vku::InitStructHelper();
                features_2.pNext = &supported;
                DispatchGetPhysicalDeviceFeatures2(gpu, &features_2);
                const VkPhysicalDeviceAttachmentFeedbackLoopDynamicStateFeaturesEXT* enabling =
                    reinterpret_cast<const VkPhysicalDeviceAttachmentFeedbackLoopDynamicStateFeaturesEXT*>(current);
                if (enabling->attachmentFeedbackLoopDynamicState && !supported.attachmentFeedbackLoopDynamicState) {
                    ss << "VkPhysicalDeviceAttachmentFeedbackLoopDynamicStateFeaturesEXT::attachmentFeedbackLoopDynamicState is "
                          "not supported\n";
                }
                break;
            }
            case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ATTACHMENT_FEEDBACK_LOOP_LAYOUT_FEATURES_EXT: {
                VkPhysicalDeviceAttachmentFeedbackLoopLayoutFeaturesEXT supported = vku::InitStructHelper();
                features_2.pNext = &supported;
                DispatchGetPhysicalDeviceFeatures2(gpu, &features_2);
                const VkPhysicalDeviceAttachmentFeedbackLoopLayoutFeaturesEXT* enabling =
                    reinterpret_cast<const VkPhysicalDeviceAttachmentFeedbackLoopLayoutFeaturesEXT*>(current);
                if (enabling->attachmentFeedbackLoopLayout && !supported.attachmentFeedbackLoopLayout) {
                    ss << "VkPhysicalDeviceAttachmentFeedbackLoopLayoutFeaturesEXT::attachmentFeedbackLoopLayout is not "
                          "supported\n";
                }
                break;
            }
            case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_BLEND_OPERATION_ADVANCED_FEATURES_EXT: {
                VkPhysicalDeviceBlendOperationAdvancedFeaturesEXT supported = vku::InitStructHelper();
                features_2.pNext = &supported;
                DispatchGetPhysicalDeviceFeatures2(gpu, &features_2);
                const VkPhysicalDeviceBlendOperationAdvancedFeaturesEXT* enabling =
                    reinterpret_cast<const VkPhysicalDeviceBlendOperationAdvancedFeaturesEXT*>(current);
                if (enabling->advancedBlendCoherentOperations && !supported.advancedBlendCoherentOperations) {
                    ss << "VkPhysicalDeviceBlendOperationAdvancedFeaturesEXT::advancedBlendCoherentOperations is not supported\n";
                }
                break;
            }
            case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_BORDER_COLOR_SWIZZLE_FEATURES_EXT: {
                VkPhysicalDeviceBorderColorSwizzleFeaturesEXT supported = vku::InitStructHelper();
                features_2.pNext = &supported;
                DispatchGetPhysicalDeviceFeatures2(gpu, &features_2);
                const VkPhysicalDeviceBorderColorSwizzleFeaturesEXT* enabling =
                    reinterpret_cast<const VkPhysicalDeviceBorderColorSwizzleFeaturesEXT*>(current);
                if (enabling->borderColorSwizzle && !supported.borderColorSwizzle) {
                    ss << "VkPhysicalDeviceBorderColorSwizzleFeaturesEXT::borderColorSwizzle is not supported\n";
                }
                if (enabling->borderColorSwizzleFromImage && !supported.borderColorSwizzleFromImage) {
                    ss << "VkPhysicalDeviceBorderColorSwizzleFeaturesEXT::borderColorSwizzleFromImage is not supported\n";
                }
                break;
            }
            case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_BUFFER_DEVICE_ADDRESS_FEATURES: {
                VkPhysicalDeviceBufferDeviceAddressFeatures supported = vku::InitStructHelper();
                features_2.pNext = &supported;
                DispatchGetPhysicalDeviceFeatures2(gpu, &features_2);
                const VkPhysicalDeviceBufferDeviceAddressFeatures* enabling =
                    reinterpret_cast<const VkPhysicalDeviceBufferDeviceAddressFeatures*>(current);
                if (enabling->bufferDeviceAddress && !supported.bufferDeviceAddress) {
                    ss << "VkPhysicalDeviceBufferDeviceAddressFeatures::bufferDeviceAddress is not supported\n";
                }
                if (enabling->bufferDeviceAddressCaptureReplay && !supported.bufferDeviceAddressCaptureReplay) {
                    ss << "VkPhysicalDeviceBufferDeviceAddressFeatures::bufferDeviceAddressCaptureReplay is not supported\n";
                }
                if (enabling->bufferDeviceAddressMultiDevice && !supported.bufferDeviceAddressMultiDevice) {
                    ss << "VkPhysicalDeviceBufferDeviceAddressFeatures::bufferDeviceAddressMultiDevice is not supported\n";
                }
                break;
            }
            case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_BUFFER_DEVICE_ADDRESS_FEATURES_EXT: {
                VkPhysicalDeviceBufferDeviceAddressFeaturesEXT supported = vku::InitStructHelper();
                features_2.pNext = &supported;
                DispatchGetPhysicalDeviceFeatures2(gpu, &features_2);
                const VkPhysicalDeviceBufferDeviceAddressFeaturesEXT* enabling =
                    reinterpret_cast<const VkPhysicalDeviceBufferDeviceAddressFeaturesEXT*>(current);
                if (enabling->bufferDeviceAddress && !supported.bufferDeviceAddress) {
                    ss << "VkPhysicalDeviceBufferDeviceAddressFeaturesEXT::bufferDeviceAddress is not supported\n";
                }
                if (enabling->bufferDeviceAddressCaptureReplay && !supported.bufferDeviceAddressCaptureReplay) {
                    ss << "VkPhysicalDeviceBufferDeviceAddressFeaturesEXT::bufferDeviceAddressCaptureReplay is not supported\n";
                }
                if (enabling->bufferDeviceAddressMultiDevice && !supported.bufferDeviceAddressMultiDevice) {
                    ss << "VkPhysicalDeviceBufferDeviceAddressFeaturesEXT::bufferDeviceAddressMultiDevice is not supported\n";
                }
                break;
            }
            case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_CLUSTER_ACCELERATION_STRUCTURE_FEATURES_NV: {
                VkPhysicalDeviceClusterAccelerationStructureFeaturesNV supported = vku::InitStructHelper();
                features_2.pNext = &supported;
                DispatchGetPhysicalDeviceFeatures2(gpu, &features_2);
                const VkPhysicalDeviceClusterAccelerationStructureFeaturesNV* enabling =
                    reinterpret_cast<const VkPhysicalDeviceClusterAccelerationStructureFeaturesNV*>(current);
                if (enabling->clusterAccelerationStructure && !supported.clusterAccelerationStructure) {
                    ss << "VkPhysicalDeviceClusterAccelerationStructureFeaturesNV::clusterAccelerationStructure is not supported\n";
                }
                break;
            }
            case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_CLUSTER_CULLING_SHADER_FEATURES_HUAWEI: {
                VkPhysicalDeviceClusterCullingShaderFeaturesHUAWEI supported = vku::InitStructHelper();
                features_2.pNext = &supported;
                DispatchGetPhysicalDeviceFeatures2(gpu, &features_2);
                const VkPhysicalDeviceClusterCullingShaderFeaturesHUAWEI* enabling =
                    reinterpret_cast<const VkPhysicalDeviceClusterCullingShaderFeaturesHUAWEI*>(current);
                if (enabling->clustercullingShader && !supported.clustercullingShader) {
                    ss << "VkPhysicalDeviceClusterCullingShaderFeaturesHUAWEI::clustercullingShader is not supported\n";
                }
                if (enabling->multiviewClusterCullingShader && !supported.multiviewClusterCullingShader) {
                    ss << "VkPhysicalDeviceClusterCullingShaderFeaturesHUAWEI::multiviewClusterCullingShader is not supported\n";
                }
                break;
            }
            case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COHERENT_MEMORY_FEATURES_AMD: {
                VkPhysicalDeviceCoherentMemoryFeaturesAMD supported = vku::InitStructHelper();
                features_2.pNext = &supported;
                DispatchGetPhysicalDeviceFeatures2(gpu, &features_2);
                const VkPhysicalDeviceCoherentMemoryFeaturesAMD* enabling =
                    reinterpret_cast<const VkPhysicalDeviceCoherentMemoryFeaturesAMD*>(current);
                if (enabling->deviceCoherentMemory && !supported.deviceCoherentMemory) {
                    ss << "VkPhysicalDeviceCoherentMemoryFeaturesAMD::deviceCoherentMemory is not supported\n";
                }
                break;
            }
            case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COLOR_WRITE_ENABLE_FEATURES_EXT: {
                VkPhysicalDeviceColorWriteEnableFeaturesEXT supported = vku::InitStructHelper();
                features_2.pNext = &supported;
                DispatchGetPhysicalDeviceFeatures2(gpu, &features_2);
                const VkPhysicalDeviceColorWriteEnableFeaturesEXT* enabling =
                    reinterpret_cast<const VkPhysicalDeviceColorWriteEnableFeaturesEXT*>(current);
                if (enabling->colorWriteEnable && !supported.colorWriteEnable) {
                    ss << "VkPhysicalDeviceColorWriteEnableFeaturesEXT::colorWriteEnable is not supported\n";
                }
                break;
            }
            case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COMMAND_BUFFER_INHERITANCE_FEATURES_NV: {
                VkPhysicalDeviceCommandBufferInheritanceFeaturesNV supported = vku::InitStructHelper();
                features_2.pNext = &supported;
                DispatchGetPhysicalDeviceFeatures2(gpu, &features_2);
                const VkPhysicalDeviceCommandBufferInheritanceFeaturesNV* enabling =
                    reinterpret_cast<const VkPhysicalDeviceCommandBufferInheritanceFeaturesNV*>(current);
                if (enabling->commandBufferInheritance && !supported.commandBufferInheritance) {
                    ss << "VkPhysicalDeviceCommandBufferInheritanceFeaturesNV::commandBufferInheritance is not supported\n";
                }
                break;
            }
            case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COMPUTE_OCCUPANCY_PRIORITY_FEATURES_NV: {
                VkPhysicalDeviceComputeOccupancyPriorityFeaturesNV supported = vku::InitStructHelper();
                features_2.pNext = &supported;
                DispatchGetPhysicalDeviceFeatures2(gpu, &features_2);
                const VkPhysicalDeviceComputeOccupancyPriorityFeaturesNV* enabling =
                    reinterpret_cast<const VkPhysicalDeviceComputeOccupancyPriorityFeaturesNV*>(current);
                if (enabling->computeOccupancyPriority && !supported.computeOccupancyPriority) {
                    ss << "VkPhysicalDeviceComputeOccupancyPriorityFeaturesNV::computeOccupancyPriority is not supported\n";
                }
                break;
            }
            case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COMPUTE_SHADER_DERIVATIVES_FEATURES_KHR: {
                VkPhysicalDeviceComputeShaderDerivativesFeaturesKHR supported = vku::InitStructHelper();
                features_2.pNext = &supported;
                DispatchGetPhysicalDeviceFeatures2(gpu, &features_2);
                const VkPhysicalDeviceComputeShaderDerivativesFeaturesKHR* enabling =
                    reinterpret_cast<const VkPhysicalDeviceComputeShaderDerivativesFeaturesKHR*>(current);
                if (enabling->computeDerivativeGroupQuads && !supported.computeDerivativeGroupQuads) {
                    ss << "VkPhysicalDeviceComputeShaderDerivativesFeaturesKHR::computeDerivativeGroupQuads is not supported\n";
                }
                if (enabling->computeDerivativeGroupLinear && !supported.computeDerivativeGroupLinear) {
                    ss << "VkPhysicalDeviceComputeShaderDerivativesFeaturesKHR::computeDerivativeGroupLinear is not supported\n";
                }
                break;
            }
            case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_CONDITIONAL_RENDERING_FEATURES_EXT: {
                VkPhysicalDeviceConditionalRenderingFeaturesEXT supported = vku::InitStructHelper();
                features_2.pNext = &supported;
                DispatchGetPhysicalDeviceFeatures2(gpu, &features_2);
                const VkPhysicalDeviceConditionalRenderingFeaturesEXT* enabling =
                    reinterpret_cast<const VkPhysicalDeviceConditionalRenderingFeaturesEXT*>(current);
                if (enabling->conditionalRendering && !supported.conditionalRendering) {
                    ss << "VkPhysicalDeviceConditionalRenderingFeaturesEXT::conditionalRendering is not supported\n";
                }
                if (enabling->inheritedConditionalRendering && !supported.inheritedConditionalRendering) {
                    ss << "VkPhysicalDeviceConditionalRenderingFeaturesEXT::inheritedConditionalRendering is not supported\n";
                }
                break;
            }
            case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COOPERATIVE_MATRIX_2_FEATURES_NV: {
                VkPhysicalDeviceCooperativeMatrix2FeaturesNV supported = vku::InitStructHelper();
                features_2.pNext = &supported;
                DispatchGetPhysicalDeviceFeatures2(gpu, &features_2);
                const VkPhysicalDeviceCooperativeMatrix2FeaturesNV* enabling =
                    reinterpret_cast<const VkPhysicalDeviceCooperativeMatrix2FeaturesNV*>(current);
                if (enabling->cooperativeMatrixWorkgroupScope && !supported.cooperativeMatrixWorkgroupScope) {
                    ss << "VkPhysicalDeviceCooperativeMatrix2FeaturesNV::cooperativeMatrixWorkgroupScope is not supported\n";
                }
                if (enabling->cooperativeMatrixFlexibleDimensions && !supported.cooperativeMatrixFlexibleDimensions) {
                    ss << "VkPhysicalDeviceCooperativeMatrix2FeaturesNV::cooperativeMatrixFlexibleDimensions is not supported\n";
                }
                if (enabling->cooperativeMatrixReductions && !supported.cooperativeMatrixReductions) {
                    ss << "VkPhysicalDeviceCooperativeMatrix2FeaturesNV::cooperativeMatrixReductions is not supported\n";
                }
                if (enabling->cooperativeMatrixConversions && !supported.cooperativeMatrixConversions) {
                    ss << "VkPhysicalDeviceCooperativeMatrix2FeaturesNV::cooperativeMatrixConversions is not supported\n";
                }
                if (enabling->cooperativeMatrixPerElementOperations && !supported.cooperativeMatrixPerElementOperations) {
                    ss << "VkPhysicalDeviceCooperativeMatrix2FeaturesNV::cooperativeMatrixPerElementOperations is not supported\n";
                }
                if (enabling->cooperativeMatrixTensorAddressing && !supported.cooperativeMatrixTensorAddressing) {
                    ss << "VkPhysicalDeviceCooperativeMatrix2FeaturesNV::cooperativeMatrixTensorAddressing is not supported\n";
                }
                if (enabling->cooperativeMatrixBlockLoads && !supported.cooperativeMatrixBlockLoads) {
                    ss << "VkPhysicalDeviceCooperativeMatrix2FeaturesNV::cooperativeMatrixBlockLoads is not supported\n";
                }
                break;
            }
            case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COOPERATIVE_MATRIX_CONVERSION_FEATURES_QCOM: {
                VkPhysicalDeviceCooperativeMatrixConversionFeaturesQCOM supported = vku::InitStructHelper();
                features_2.pNext = &supported;
                DispatchGetPhysicalDeviceFeatures2(gpu, &features_2);
                const VkPhysicalDeviceCooperativeMatrixConversionFeaturesQCOM* enabling =
                    reinterpret_cast<const VkPhysicalDeviceCooperativeMatrixConversionFeaturesQCOM*>(current);
                if (enabling->cooperativeMatrixConversion && !supported.cooperativeMatrixConversion) {
                    ss << "VkPhysicalDeviceCooperativeMatrixConversionFeaturesQCOM::cooperativeMatrixConversion is not supported\n";
                }
                break;
            }
            case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COOPERATIVE_MATRIX_FEATURES_KHR: {
                VkPhysicalDeviceCooperativeMatrixFeaturesKHR supported = vku::InitStructHelper();
                features_2.pNext = &supported;
                DispatchGetPhysicalDeviceFeatures2(gpu, &features_2);
                const VkPhysicalDeviceCooperativeMatrixFeaturesKHR* enabling =
                    reinterpret_cast<const VkPhysicalDeviceCooperativeMatrixFeaturesKHR*>(current);
                if (enabling->cooperativeMatrix && !supported.cooperativeMatrix) {
                    ss << "VkPhysicalDeviceCooperativeMatrixFeaturesKHR::cooperativeMatrix is not supported\n";
                }
                if (enabling->cooperativeMatrixRobustBufferAccess && !supported.cooperativeMatrixRobustBufferAccess) {
                    ss << "VkPhysicalDeviceCooperativeMatrixFeaturesKHR::cooperativeMatrixRobustBufferAccess is not supported\n";
                }
                break;
            }
            case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COOPERATIVE_MATRIX_FEATURES_NV: {
                VkPhysicalDeviceCooperativeMatrixFeaturesNV supported = vku::InitStructHelper();
                features_2.pNext = &supported;
                DispatchGetPhysicalDeviceFeatures2(gpu, &features_2);
                const VkPhysicalDeviceCooperativeMatrixFeaturesNV* enabling =
                    reinterpret_cast<const VkPhysicalDeviceCooperativeMatrixFeaturesNV*>(current);
                if (enabling->cooperativeMatrix && !supported.cooperativeMatrix) {
                    ss << "VkPhysicalDeviceCooperativeMatrixFeaturesNV::cooperativeMatrix is not supported\n";
                }
                if (enabling->cooperativeMatrixRobustBufferAccess && !supported.cooperativeMatrixRobustBufferAccess) {
                    ss << "VkPhysicalDeviceCooperativeMatrixFeaturesNV::cooperativeMatrixRobustBufferAccess is not supported\n";
                }
                break;
            }
            case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COOPERATIVE_VECTOR_FEATURES_NV: {
                VkPhysicalDeviceCooperativeVectorFeaturesNV supported = vku::InitStructHelper();
                features_2.pNext = &supported;
                DispatchGetPhysicalDeviceFeatures2(gpu, &features_2);
                const VkPhysicalDeviceCooperativeVectorFeaturesNV* enabling =
                    reinterpret_cast<const VkPhysicalDeviceCooperativeVectorFeaturesNV*>(current);
                if (enabling->cooperativeVector && !supported.cooperativeVector) {
                    ss << "VkPhysicalDeviceCooperativeVectorFeaturesNV::cooperativeVector is not supported\n";
                }
                if (enabling->cooperativeVectorTraining && !supported.cooperativeVectorTraining) {
                    ss << "VkPhysicalDeviceCooperativeVectorFeaturesNV::cooperativeVectorTraining is not supported\n";
                }
                break;
            }
            case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COPY_MEMORY_INDIRECT_FEATURES_KHR: {
                VkPhysicalDeviceCopyMemoryIndirectFeaturesKHR supported = vku::InitStructHelper();
                features_2.pNext = &supported;
                DispatchGetPhysicalDeviceFeatures2(gpu, &features_2);
                const VkPhysicalDeviceCopyMemoryIndirectFeaturesKHR* enabling =
                    reinterpret_cast<const VkPhysicalDeviceCopyMemoryIndirectFeaturesKHR*>(current);
                if (enabling->indirectMemoryCopy && !supported.indirectMemoryCopy) {
                    ss << "VkPhysicalDeviceCopyMemoryIndirectFeaturesKHR::indirectMemoryCopy is not supported\n";
                }
                if (enabling->indirectMemoryToImageCopy && !supported.indirectMemoryToImageCopy) {
                    ss << "VkPhysicalDeviceCopyMemoryIndirectFeaturesKHR::indirectMemoryToImageCopy is not supported\n";
                }
                break;
            }
            case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COPY_MEMORY_INDIRECT_FEATURES_NV: {
                VkPhysicalDeviceCopyMemoryIndirectFeaturesNV supported = vku::InitStructHelper();
                features_2.pNext = &supported;
                DispatchGetPhysicalDeviceFeatures2(gpu, &features_2);
                const VkPhysicalDeviceCopyMemoryIndirectFeaturesNV* enabling =
                    reinterpret_cast<const VkPhysicalDeviceCopyMemoryIndirectFeaturesNV*>(current);
                if (enabling->indirectCopy && !supported.indirectCopy) {
                    ss << "VkPhysicalDeviceCopyMemoryIndirectFeaturesNV::indirectCopy is not supported\n";
                }
                break;
            }
            case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_CORNER_SAMPLED_IMAGE_FEATURES_NV: {
                VkPhysicalDeviceCornerSampledImageFeaturesNV supported = vku::InitStructHelper();
                features_2.pNext = &supported;
                DispatchGetPhysicalDeviceFeatures2(gpu, &features_2);
                const VkPhysicalDeviceCornerSampledImageFeaturesNV* enabling =
                    reinterpret_cast<const VkPhysicalDeviceCornerSampledImageFeaturesNV*>(current);
                if (enabling->cornerSampledImage && !supported.cornerSampledImage) {
                    ss << "VkPhysicalDeviceCornerSampledImageFeaturesNV::cornerSampledImage is not supported\n";
                }
                break;
            }
            case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COVERAGE_REDUCTION_MODE_FEATURES_NV: {
                VkPhysicalDeviceCoverageReductionModeFeaturesNV supported = vku::InitStructHelper();
                features_2.pNext = &supported;
                DispatchGetPhysicalDeviceFeatures2(gpu, &features_2);
                const VkPhysicalDeviceCoverageReductionModeFeaturesNV* enabling =
                    reinterpret_cast<const VkPhysicalDeviceCoverageReductionModeFeaturesNV*>(current);
                if (enabling->coverageReductionMode && !supported.coverageReductionMode) {
                    ss << "VkPhysicalDeviceCoverageReductionModeFeaturesNV::coverageReductionMode is not supported\n";
                }
                break;
            }
            case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_CUBIC_CLAMP_FEATURES_QCOM: {
                VkPhysicalDeviceCubicClampFeaturesQCOM supported = vku::InitStructHelper();
                features_2.pNext = &supported;
                DispatchGetPhysicalDeviceFeatures2(gpu, &features_2);
                const VkPhysicalDeviceCubicClampFeaturesQCOM* enabling =
                    reinterpret_cast<const VkPhysicalDeviceCubicClampFeaturesQCOM*>(current);
                if (enabling->cubicRangeClamp && !supported.cubicRangeClamp) {
                    ss << "VkPhysicalDeviceCubicClampFeaturesQCOM::cubicRangeClamp is not supported\n";
                }
                break;
            }
            case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_CUBIC_WEIGHTS_FEATURES_QCOM: {
                VkPhysicalDeviceCubicWeightsFeaturesQCOM supported = vku::InitStructHelper();
                features_2.pNext = &supported;
                DispatchGetPhysicalDeviceFeatures2(gpu, &features_2);
                const VkPhysicalDeviceCubicWeightsFeaturesQCOM* enabling =
                    reinterpret_cast<const VkPhysicalDeviceCubicWeightsFeaturesQCOM*>(current);
                if (enabling->selectableCubicWeights && !supported.selectableCubicWeights) {
                    ss << "VkPhysicalDeviceCubicWeightsFeaturesQCOM::selectableCubicWeights is not supported\n";
                }
                break;
            }
#ifdef VK_ENABLE_BETA_EXTENSIONS
            case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_CUDA_KERNEL_LAUNCH_FEATURES_NV: {
                VkPhysicalDeviceCudaKernelLaunchFeaturesNV supported = vku::InitStructHelper();
                features_2.pNext = &supported;
                DispatchGetPhysicalDeviceFeatures2(gpu, &features_2);
                const VkPhysicalDeviceCudaKernelLaunchFeaturesNV* enabling =
                    reinterpret_cast<const VkPhysicalDeviceCudaKernelLaunchFeaturesNV*>(current);
                if (enabling->cudaKernelLaunchFeatures && !supported.cudaKernelLaunchFeatures) {
                    ss << "VkPhysicalDeviceCudaKernelLaunchFeaturesNV::cudaKernelLaunchFeatures is not supported\n";
                }
                break;
            }
#endif  // VK_ENABLE_BETA_EXTENSIONS
            case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_CUSTOM_BORDER_COLOR_FEATURES_EXT: {
                VkPhysicalDeviceCustomBorderColorFeaturesEXT supported = vku::InitStructHelper();
                features_2.pNext = &supported;
                DispatchGetPhysicalDeviceFeatures2(gpu, &features_2);
                const VkPhysicalDeviceCustomBorderColorFeaturesEXT* enabling =
                    reinterpret_cast<const VkPhysicalDeviceCustomBorderColorFeaturesEXT*>(current);
                if (enabling->customBorderColors && !supported.customBorderColors) {
                    ss << "VkPhysicalDeviceCustomBorderColorFeaturesEXT::customBorderColors is not supported\n";
                }
                if (enabling->customBorderColorWithoutFormat && !supported.customBorderColorWithoutFormat) {
                    ss << "VkPhysicalDeviceCustomBorderColorFeaturesEXT::customBorderColorWithoutFormat is not supported\n";
                }
                break;
            }
            case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_CUSTOM_RESOLVE_FEATURES_EXT: {
                VkPhysicalDeviceCustomResolveFeaturesEXT supported = vku::InitStructHelper();
                features_2.pNext = &supported;
                DispatchGetPhysicalDeviceFeatures2(gpu, &features_2);
                const VkPhysicalDeviceCustomResolveFeaturesEXT* enabling =
                    reinterpret_cast<const VkPhysicalDeviceCustomResolveFeaturesEXT*>(current);
                if (enabling->customResolve && !supported.customResolve) {
                    ss << "VkPhysicalDeviceCustomResolveFeaturesEXT::customResolve is not supported\n";
                }
                break;
            }
            case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DATA_GRAPH_FEATURES_ARM: {
                VkPhysicalDeviceDataGraphFeaturesARM supported = vku::InitStructHelper();
                features_2.pNext = &supported;
                DispatchGetPhysicalDeviceFeatures2(gpu, &features_2);
                const VkPhysicalDeviceDataGraphFeaturesARM* enabling =
                    reinterpret_cast<const VkPhysicalDeviceDataGraphFeaturesARM*>(current);
                if (enabling->dataGraph && !supported.dataGraph) {
                    ss << "VkPhysicalDeviceDataGraphFeaturesARM::dataGraph is not supported\n";
                }
                if (enabling->dataGraphUpdateAfterBind && !supported.dataGraphUpdateAfterBind) {
                    ss << "VkPhysicalDeviceDataGraphFeaturesARM::dataGraphUpdateAfterBind is not supported\n";
                }
                if (enabling->dataGraphSpecializationConstants && !supported.dataGraphSpecializationConstants) {
                    ss << "VkPhysicalDeviceDataGraphFeaturesARM::dataGraphSpecializationConstants is not supported\n";
                }
                if (enabling->dataGraphDescriptorBuffer && !supported.dataGraphDescriptorBuffer) {
                    ss << "VkPhysicalDeviceDataGraphFeaturesARM::dataGraphDescriptorBuffer is not supported\n";
                }
                if (enabling->dataGraphShaderModule && !supported.dataGraphShaderModule) {
                    ss << "VkPhysicalDeviceDataGraphFeaturesARM::dataGraphShaderModule is not supported\n";
                }
                break;
            }
            case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DATA_GRAPH_MODEL_FEATURES_QCOM: {
                VkPhysicalDeviceDataGraphModelFeaturesQCOM supported = vku::InitStructHelper();
                features_2.pNext = &supported;
                DispatchGetPhysicalDeviceFeatures2(gpu, &features_2);
                const VkPhysicalDeviceDataGraphModelFeaturesQCOM* enabling =
                    reinterpret_cast<const VkPhysicalDeviceDataGraphModelFeaturesQCOM*>(current);
                if (enabling->dataGraphModel && !supported.dataGraphModel) {
                    ss << "VkPhysicalDeviceDataGraphModelFeaturesQCOM::dataGraphModel is not supported\n";
                }
                break;
            }
            case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DATA_GRAPH_NEURAL_ACCELERATOR_STATISTICS_FEATURES_ARM: {
                VkPhysicalDeviceDataGraphNeuralAcceleratorStatisticsFeaturesARM supported = vku::InitStructHelper();
                features_2.pNext = &supported;
                DispatchGetPhysicalDeviceFeatures2(gpu, &features_2);
                const VkPhysicalDeviceDataGraphNeuralAcceleratorStatisticsFeaturesARM* enabling =
                    reinterpret_cast<const VkPhysicalDeviceDataGraphNeuralAcceleratorStatisticsFeaturesARM*>(current);
                if (enabling->dataGraphNeuralAcceleratorStatistics && !supported.dataGraphNeuralAcceleratorStatistics) {
                    ss << "VkPhysicalDeviceDataGraphNeuralAcceleratorStatisticsFeaturesARM::dataGraphNeuralAcceleratorStatistics "
                          "is not supported\n";
                }
                break;
            }
            case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DATA_GRAPH_OPTICAL_FLOW_FEATURES_ARM: {
                VkPhysicalDeviceDataGraphOpticalFlowFeaturesARM supported = vku::InitStructHelper();
                features_2.pNext = &supported;
                DispatchGetPhysicalDeviceFeatures2(gpu, &features_2);
                const VkPhysicalDeviceDataGraphOpticalFlowFeaturesARM* enabling =
                    reinterpret_cast<const VkPhysicalDeviceDataGraphOpticalFlowFeaturesARM*>(current);
                if (enabling->dataGraphOpticalFlow && !supported.dataGraphOpticalFlow) {
                    ss << "VkPhysicalDeviceDataGraphOpticalFlowFeaturesARM::dataGraphOpticalFlow is not supported\n";
                }
                break;
            }
            case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DEDICATED_ALLOCATION_IMAGE_ALIASING_FEATURES_NV: {
                VkPhysicalDeviceDedicatedAllocationImageAliasingFeaturesNV supported = vku::InitStructHelper();
                features_2.pNext = &supported;
                DispatchGetPhysicalDeviceFeatures2(gpu, &features_2);
                const VkPhysicalDeviceDedicatedAllocationImageAliasingFeaturesNV* enabling =
                    reinterpret_cast<const VkPhysicalDeviceDedicatedAllocationImageAliasingFeaturesNV*>(current);
                if (enabling->dedicatedAllocationImageAliasing && !supported.dedicatedAllocationImageAliasing) {
                    ss << "VkPhysicalDeviceDedicatedAllocationImageAliasingFeaturesNV::dedicatedAllocationImageAliasing is not "
                          "supported\n";
                }
                break;
            }
#ifdef VK_ENABLE_BETA_EXTENSIONS
            case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DENSE_GEOMETRY_FORMAT_FEATURES_AMDX: {
                VkPhysicalDeviceDenseGeometryFormatFeaturesAMDX supported = vku::InitStructHelper();
                features_2.pNext = &supported;
                DispatchGetPhysicalDeviceFeatures2(gpu, &features_2);
                const VkPhysicalDeviceDenseGeometryFormatFeaturesAMDX* enabling =
                    reinterpret_cast<const VkPhysicalDeviceDenseGeometryFormatFeaturesAMDX*>(current);
                if (enabling->denseGeometryFormat && !supported.denseGeometryFormat) {
                    ss << "VkPhysicalDeviceDenseGeometryFormatFeaturesAMDX::denseGeometryFormat is not supported\n";
                }
                break;
            }
#endif  // VK_ENABLE_BETA_EXTENSIONS
            case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DEPTH_BIAS_CONTROL_FEATURES_EXT: {
                VkPhysicalDeviceDepthBiasControlFeaturesEXT supported = vku::InitStructHelper();
                features_2.pNext = &supported;
                DispatchGetPhysicalDeviceFeatures2(gpu, &features_2);
                const VkPhysicalDeviceDepthBiasControlFeaturesEXT* enabling =
                    reinterpret_cast<const VkPhysicalDeviceDepthBiasControlFeaturesEXT*>(current);
                if (enabling->depthBiasControl && !supported.depthBiasControl) {
                    ss << "VkPhysicalDeviceDepthBiasControlFeaturesEXT::depthBiasControl is not supported\n";
                }
                if (enabling->leastRepresentableValueForceUnormRepresentation &&
                    !supported.leastRepresentableValueForceUnormRepresentation) {
                    ss << "VkPhysicalDeviceDepthBiasControlFeaturesEXT::leastRepresentableValueForceUnormRepresentation is not "
                          "supported\n";
                }
                if (enabling->floatRepresentation && !supported.floatRepresentation) {
                    ss << "VkPhysicalDeviceDepthBiasControlFeaturesEXT::floatRepresentation is not supported\n";
                }
                if (enabling->depthBiasExact && !supported.depthBiasExact) {
                    ss << "VkPhysicalDeviceDepthBiasControlFeaturesEXT::depthBiasExact is not supported\n";
                }
                break;
            }
            case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DEPTH_CLAMP_CONTROL_FEATURES_EXT: {
                VkPhysicalDeviceDepthClampControlFeaturesEXT supported = vku::InitStructHelper();
                features_2.pNext = &supported;
                DispatchGetPhysicalDeviceFeatures2(gpu, &features_2);
                const VkPhysicalDeviceDepthClampControlFeaturesEXT* enabling =
                    reinterpret_cast<const VkPhysicalDeviceDepthClampControlFeaturesEXT*>(current);
                if (enabling->depthClampControl && !supported.depthClampControl) {
                    ss << "VkPhysicalDeviceDepthClampControlFeaturesEXT::depthClampControl is not supported\n";
                }
                break;
            }
            case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DEPTH_CLAMP_ZERO_ONE_FEATURES_KHR: {
                VkPhysicalDeviceDepthClampZeroOneFeaturesKHR supported = vku::InitStructHelper();
                features_2.pNext = &supported;
                DispatchGetPhysicalDeviceFeatures2(gpu, &features_2);
                const VkPhysicalDeviceDepthClampZeroOneFeaturesKHR* enabling =
                    reinterpret_cast<const VkPhysicalDeviceDepthClampZeroOneFeaturesKHR*>(current);
                if (enabling->depthClampZeroOne && !supported.depthClampZeroOne) {
                    ss << "VkPhysicalDeviceDepthClampZeroOneFeaturesKHR::depthClampZeroOne is not supported\n";
                }
                break;
            }
            case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DEPTH_CLIP_CONTROL_FEATURES_EXT: {
                VkPhysicalDeviceDepthClipControlFeaturesEXT supported = vku::InitStructHelper();
                features_2.pNext = &supported;
                DispatchGetPhysicalDeviceFeatures2(gpu, &features_2);
                const VkPhysicalDeviceDepthClipControlFeaturesEXT* enabling =
                    reinterpret_cast<const VkPhysicalDeviceDepthClipControlFeaturesEXT*>(current);
                if (enabling->depthClipControl && !supported.depthClipControl) {
                    ss << "VkPhysicalDeviceDepthClipControlFeaturesEXT::depthClipControl is not supported\n";
                }
                break;
            }
            case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DEPTH_CLIP_ENABLE_FEATURES_EXT: {
                VkPhysicalDeviceDepthClipEnableFeaturesEXT supported = vku::InitStructHelper();
                features_2.pNext = &supported;
                DispatchGetPhysicalDeviceFeatures2(gpu, &features_2);
                const VkPhysicalDeviceDepthClipEnableFeaturesEXT* enabling =
                    reinterpret_cast<const VkPhysicalDeviceDepthClipEnableFeaturesEXT*>(current);
                if (enabling->depthClipEnable && !supported.depthClipEnable) {
                    ss << "VkPhysicalDeviceDepthClipEnableFeaturesEXT::depthClipEnable is not supported\n";
                }
                break;
            }
            case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DESCRIPTOR_BUFFER_FEATURES_EXT: {
                VkPhysicalDeviceDescriptorBufferFeaturesEXT supported = vku::InitStructHelper();
                features_2.pNext = &supported;
                DispatchGetPhysicalDeviceFeatures2(gpu, &features_2);
                const VkPhysicalDeviceDescriptorBufferFeaturesEXT* enabling =
                    reinterpret_cast<const VkPhysicalDeviceDescriptorBufferFeaturesEXT*>(current);
                if (enabling->descriptorBuffer && !supported.descriptorBuffer) {
                    ss << "VkPhysicalDeviceDescriptorBufferFeaturesEXT::descriptorBuffer is not supported\n";
                }
                if (enabling->descriptorBufferCaptureReplay && !supported.descriptorBufferCaptureReplay) {
                    ss << "VkPhysicalDeviceDescriptorBufferFeaturesEXT::descriptorBufferCaptureReplay is not supported\n";
                }
                if (enabling->descriptorBufferImageLayoutIgnored && !supported.descriptorBufferImageLayoutIgnored) {
                    ss << "VkPhysicalDeviceDescriptorBufferFeaturesEXT::descriptorBufferImageLayoutIgnored is not supported\n";
                }
                if (enabling->descriptorBufferPushDescriptors && !supported.descriptorBufferPushDescriptors) {
                    ss << "VkPhysicalDeviceDescriptorBufferFeaturesEXT::descriptorBufferPushDescriptors is not supported\n";
                }
                break;
            }
            case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DESCRIPTOR_BUFFER_TENSOR_FEATURES_ARM: {
                VkPhysicalDeviceDescriptorBufferTensorFeaturesARM supported = vku::InitStructHelper();
                features_2.pNext = &supported;
                DispatchGetPhysicalDeviceFeatures2(gpu, &features_2);
                const VkPhysicalDeviceDescriptorBufferTensorFeaturesARM* enabling =
                    reinterpret_cast<const VkPhysicalDeviceDescriptorBufferTensorFeaturesARM*>(current);
                if (enabling->descriptorBufferTensorDescriptors && !supported.descriptorBufferTensorDescriptors) {
                    ss << "VkPhysicalDeviceDescriptorBufferTensorFeaturesARM::descriptorBufferTensorDescriptors is not supported\n";
                }
                break;
            }
            case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DESCRIPTOR_HEAP_FEATURES_EXT: {
                VkPhysicalDeviceDescriptorHeapFeaturesEXT supported = vku::InitStructHelper();
                features_2.pNext = &supported;
                DispatchGetPhysicalDeviceFeatures2(gpu, &features_2);
                const VkPhysicalDeviceDescriptorHeapFeaturesEXT* enabling =
                    reinterpret_cast<const VkPhysicalDeviceDescriptorHeapFeaturesEXT*>(current);
                if (enabling->descriptorHeap && !supported.descriptorHeap) {
                    ss << "VkPhysicalDeviceDescriptorHeapFeaturesEXT::descriptorHeap is not supported\n";
                }
                if (enabling->descriptorHeapCaptureReplay && !supported.descriptorHeapCaptureReplay) {
                    ss << "VkPhysicalDeviceDescriptorHeapFeaturesEXT::descriptorHeapCaptureReplay is not supported\n";
                }
                break;
            }
            case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DESCRIPTOR_INDEXING_FEATURES: {
                VkPhysicalDeviceDescriptorIndexingFeatures supported = vku::InitStructHelper();
                features_2.pNext = &supported;
                DispatchGetPhysicalDeviceFeatures2(gpu, &features_2);
                const VkPhysicalDeviceDescriptorIndexingFeatures* enabling =
                    reinterpret_cast<const VkPhysicalDeviceDescriptorIndexingFeatures*>(current);
                if (enabling->shaderInputAttachmentArrayDynamicIndexing && !supported.shaderInputAttachmentArrayDynamicIndexing) {
                    ss << "VkPhysicalDeviceDescriptorIndexingFeatures::shaderInputAttachmentArrayDynamicIndexing is not "
                          "supported\n";
                }
                if (enabling->shaderUniformTexelBufferArrayDynamicIndexing &&
                    !supported.shaderUniformTexelBufferArrayDynamicIndexing) {
                    ss << "VkPhysicalDeviceDescriptorIndexingFeatures::shaderUniformTexelBufferArrayDynamicIndexing is not "
                          "supported\n";
                }
                if (enabling->shaderStorageTexelBufferArrayDynamicIndexing &&
                    !supported.shaderStorageTexelBufferArrayDynamicIndexing) {
                    ss << "VkPhysicalDeviceDescriptorIndexingFeatures::shaderStorageTexelBufferArrayDynamicIndexing is not "
                          "supported\n";
                }
                if (enabling->shaderUniformBufferArrayNonUniformIndexing && !supported.shaderUniformBufferArrayNonUniformIndexing) {
                    ss << "VkPhysicalDeviceDescriptorIndexingFeatures::shaderUniformBufferArrayNonUniformIndexing is not "
                          "supported\n";
                }
                if (enabling->shaderSampledImageArrayNonUniformIndexing && !supported.shaderSampledImageArrayNonUniformIndexing) {
                    ss << "VkPhysicalDeviceDescriptorIndexingFeatures::shaderSampledImageArrayNonUniformIndexing is not "
                          "supported\n";
                }
                if (enabling->shaderStorageBufferArrayNonUniformIndexing && !supported.shaderStorageBufferArrayNonUniformIndexing) {
                    ss << "VkPhysicalDeviceDescriptorIndexingFeatures::shaderStorageBufferArrayNonUniformIndexing is not "
                          "supported\n";
                }
                if (enabling->shaderStorageImageArrayNonUniformIndexing && !supported.shaderStorageImageArrayNonUniformIndexing) {
                    ss << "VkPhysicalDeviceDescriptorIndexingFeatures::shaderStorageImageArrayNonUniformIndexing is not "
                          "supported\n";
                }
                if (enabling->shaderInputAttachmentArrayNonUniformIndexing &&
                    !supported.shaderInputAttachmentArrayNonUniformIndexing) {
                    ss << "VkPhysicalDeviceDescriptorIndexingFeatures::shaderInputAttachmentArrayNonUniformIndexing is not "
                          "supported\n";
                }
                if (enabling->shaderUniformTexelBufferArrayNonUniformIndexing &&
                    !supported.shaderUniformTexelBufferArrayNonUniformIndexing) {
                    ss << "VkPhysicalDeviceDescriptorIndexingFeatures::shaderUniformTexelBufferArrayNonUniformIndexing is not "
                          "supported\n";
                }
                if (enabling->shaderStorageTexelBufferArrayNonUniformIndexing &&
                    !supported.shaderStorageTexelBufferArrayNonUniformIndexing) {
                    ss << "VkPhysicalDeviceDescriptorIndexingFeatures::shaderStorageTexelBufferArrayNonUniformIndexing is not "
                          "supported\n";
                }
                if (enabling->descriptorBindingUniformBufferUpdateAfterBind &&
                    !supported.descriptorBindingUniformBufferUpdateAfterBind) {
                    ss << "VkPhysicalDeviceDescriptorIndexingFeatures::descriptorBindingUniformBufferUpdateAfterBind is not "
                          "supported\n";
                }
                if (enabling->descriptorBindingSampledImageUpdateAfterBind &&
                    !supported.descriptorBindingSampledImageUpdateAfterBind) {
                    ss << "VkPhysicalDeviceDescriptorIndexingFeatures::descriptorBindingSampledImageUpdateAfterBind is not "
                          "supported\n";
                }
                if (enabling->descriptorBindingStorageImageUpdateAfterBind &&
                    !supported.descriptorBindingStorageImageUpdateAfterBind) {
                    ss << "VkPhysicalDeviceDescriptorIndexingFeatures::descriptorBindingStorageImageUpdateAfterBind is not "
                          "supported\n";
                }
                if (enabling->descriptorBindingStorageBufferUpdateAfterBind &&
                    !supported.descriptorBindingStorageBufferUpdateAfterBind) {
                    ss << "VkPhysicalDeviceDescriptorIndexingFeatures::descriptorBindingStorageBufferUpdateAfterBind is not "
                          "supported\n";
                }
                if (enabling->descriptorBindingUniformTexelBufferUpdateAfterBind &&
                    !supported.descriptorBindingUniformTexelBufferUpdateAfterBind) {
                    ss << "VkPhysicalDeviceDescriptorIndexingFeatures::descriptorBindingUniformTexelBufferUpdateAfterBind is not "
                          "supported\n";
                }
                if (enabling->descriptorBindingStorageTexelBufferUpdateAfterBind &&
                    !supported.descriptorBindingStorageTexelBufferUpdateAfterBind) {
                    ss << "VkPhysicalDeviceDescriptorIndexingFeatures::descriptorBindingStorageTexelBufferUpdateAfterBind is not "
                          "supported\n";
                }
                if (enabling->descriptorBindingUpdateUnusedWhilePending && !supported.descriptorBindingUpdateUnusedWhilePending) {
                    ss << "VkPhysicalDeviceDescriptorIndexingFeatures::descriptorBindingUpdateUnusedWhilePending is not "
                          "supported\n";
                }
                if (enabling->descriptorBindingPartiallyBound && !supported.descriptorBindingPartiallyBound) {
                    ss << "VkPhysicalDeviceDescriptorIndexingFeatures::descriptorBindingPartiallyBound is not supported\n";
                }
                if (enabling->descriptorBindingVariableDescriptorCount && !supported.descriptorBindingVariableDescriptorCount) {
                    ss << "VkPhysicalDeviceDescriptorIndexingFeatures::descriptorBindingVariableDescriptorCount is not supported\n";
                }
                if (enabling->runtimeDescriptorArray && !supported.runtimeDescriptorArray) {
                    ss << "VkPhysicalDeviceDescriptorIndexingFeatures::runtimeDescriptorArray is not supported\n";
                }
                break;
            }
            case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DESCRIPTOR_POOL_OVERALLOCATION_FEATURES_NV: {
                VkPhysicalDeviceDescriptorPoolOverallocationFeaturesNV supported = vku::InitStructHelper();
                features_2.pNext = &supported;
                DispatchGetPhysicalDeviceFeatures2(gpu, &features_2);
                const VkPhysicalDeviceDescriptorPoolOverallocationFeaturesNV* enabling =
                    reinterpret_cast<const VkPhysicalDeviceDescriptorPoolOverallocationFeaturesNV*>(current);
                if (enabling->descriptorPoolOverallocation && !supported.descriptorPoolOverallocation) {
                    ss << "VkPhysicalDeviceDescriptorPoolOverallocationFeaturesNV::descriptorPoolOverallocation is not supported\n";
                }
                break;
            }
            case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DESCRIPTOR_SET_HOST_MAPPING_FEATURES_VALVE: {
                VkPhysicalDeviceDescriptorSetHostMappingFeaturesVALVE supported = vku::InitStructHelper();
                features_2.pNext = &supported;
                DispatchGetPhysicalDeviceFeatures2(gpu, &features_2);
                const VkPhysicalDeviceDescriptorSetHostMappingFeaturesVALVE* enabling =
                    reinterpret_cast<const VkPhysicalDeviceDescriptorSetHostMappingFeaturesVALVE*>(current);
                if (enabling->descriptorSetHostMapping && !supported.descriptorSetHostMapping) {
                    ss << "VkPhysicalDeviceDescriptorSetHostMappingFeaturesVALVE::descriptorSetHostMapping is not supported\n";
                }
                break;
            }
            case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DEVICE_ADDRESS_COMMANDS_FEATURES_KHR: {
                VkPhysicalDeviceDeviceAddressCommandsFeaturesKHR supported = vku::InitStructHelper();
                features_2.pNext = &supported;
                DispatchGetPhysicalDeviceFeatures2(gpu, &features_2);
                const VkPhysicalDeviceDeviceAddressCommandsFeaturesKHR* enabling =
                    reinterpret_cast<const VkPhysicalDeviceDeviceAddressCommandsFeaturesKHR*>(current);
                if (enabling->deviceAddressCommands && !supported.deviceAddressCommands) {
                    ss << "VkPhysicalDeviceDeviceAddressCommandsFeaturesKHR::deviceAddressCommands is not supported\n";
                }
                break;
            }
            case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DEVICE_GENERATED_COMMANDS_COMPUTE_FEATURES_NV: {
                VkPhysicalDeviceDeviceGeneratedCommandsComputeFeaturesNV supported = vku::InitStructHelper();
                features_2.pNext = &supported;
                DispatchGetPhysicalDeviceFeatures2(gpu, &features_2);
                const VkPhysicalDeviceDeviceGeneratedCommandsComputeFeaturesNV* enabling =
                    reinterpret_cast<const VkPhysicalDeviceDeviceGeneratedCommandsComputeFeaturesNV*>(current);
                if (enabling->deviceGeneratedCompute && !supported.deviceGeneratedCompute) {
                    ss << "VkPhysicalDeviceDeviceGeneratedCommandsComputeFeaturesNV::deviceGeneratedCompute is not supported\n";
                }
                if (enabling->deviceGeneratedComputePipelines && !supported.deviceGeneratedComputePipelines) {
                    ss << "VkPhysicalDeviceDeviceGeneratedCommandsComputeFeaturesNV::deviceGeneratedComputePipelines is not "
                          "supported\n";
                }
                if (enabling->deviceGeneratedComputeCaptureReplay && !supported.deviceGeneratedComputeCaptureReplay) {
                    ss << "VkPhysicalDeviceDeviceGeneratedCommandsComputeFeaturesNV::deviceGeneratedComputeCaptureReplay is not "
                          "supported\n";
                }
                break;
            }
            case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DEVICE_GENERATED_COMMANDS_FEATURES_EXT: {
                VkPhysicalDeviceDeviceGeneratedCommandsFeaturesEXT supported = vku::InitStructHelper();
                features_2.pNext = &supported;
                DispatchGetPhysicalDeviceFeatures2(gpu, &features_2);
                const VkPhysicalDeviceDeviceGeneratedCommandsFeaturesEXT* enabling =
                    reinterpret_cast<const VkPhysicalDeviceDeviceGeneratedCommandsFeaturesEXT*>(current);
                if (enabling->deviceGeneratedCommands && !supported.deviceGeneratedCommands) {
                    ss << "VkPhysicalDeviceDeviceGeneratedCommandsFeaturesEXT::deviceGeneratedCommands is not supported\n";
                }
                if (enabling->dynamicGeneratedPipelineLayout && !supported.dynamicGeneratedPipelineLayout) {
                    ss << "VkPhysicalDeviceDeviceGeneratedCommandsFeaturesEXT::dynamicGeneratedPipelineLayout is not supported\n";
                }
                break;
            }
            case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DEVICE_GENERATED_COMMANDS_FEATURES_NV: {
                VkPhysicalDeviceDeviceGeneratedCommandsFeaturesNV supported = vku::InitStructHelper();
                features_2.pNext = &supported;
                DispatchGetPhysicalDeviceFeatures2(gpu, &features_2);
                const VkPhysicalDeviceDeviceGeneratedCommandsFeaturesNV* enabling =
                    reinterpret_cast<const VkPhysicalDeviceDeviceGeneratedCommandsFeaturesNV*>(current);
                if (enabling->deviceGeneratedCommands && !supported.deviceGeneratedCommands) {
                    ss << "VkPhysicalDeviceDeviceGeneratedCommandsFeaturesNV::deviceGeneratedCommands is not supported\n";
                }
                break;
            }
            case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DEVICE_MEMORY_REPORT_FEATURES_EXT: {
                VkPhysicalDeviceDeviceMemoryReportFeaturesEXT supported = vku::InitStructHelper();
                features_2.pNext = &supported;
                DispatchGetPhysicalDeviceFeatures2(gpu, &features_2);
                const VkPhysicalDeviceDeviceMemoryReportFeaturesEXT* enabling =
                    reinterpret_cast<const VkPhysicalDeviceDeviceMemoryReportFeaturesEXT*>(current);
                if (enabling->deviceMemoryReport && !supported.deviceMemoryReport) {
                    ss << "VkPhysicalDeviceDeviceMemoryReportFeaturesEXT::deviceMemoryReport is not supported\n";
                }
                break;
            }
            case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DIAGNOSTICS_CONFIG_FEATURES_NV: {
                VkPhysicalDeviceDiagnosticsConfigFeaturesNV supported = vku::InitStructHelper();
                features_2.pNext = &supported;
                DispatchGetPhysicalDeviceFeatures2(gpu, &features_2);
                const VkPhysicalDeviceDiagnosticsConfigFeaturesNV* enabling =
                    reinterpret_cast<const VkPhysicalDeviceDiagnosticsConfigFeaturesNV*>(current);
                if (enabling->diagnosticsConfig && !supported.diagnosticsConfig) {
                    ss << "VkPhysicalDeviceDiagnosticsConfigFeaturesNV::diagnosticsConfig is not supported\n";
                }
                break;
            }
#ifdef VK_ENABLE_BETA_EXTENSIONS
            case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DISPLACEMENT_MICROMAP_FEATURES_NV: {
                VkPhysicalDeviceDisplacementMicromapFeaturesNV supported = vku::InitStructHelper();
                features_2.pNext = &supported;
                DispatchGetPhysicalDeviceFeatures2(gpu, &features_2);
                const VkPhysicalDeviceDisplacementMicromapFeaturesNV* enabling =
                    reinterpret_cast<const VkPhysicalDeviceDisplacementMicromapFeaturesNV*>(current);
                if (enabling->displacementMicromap && !supported.displacementMicromap) {
                    ss << "VkPhysicalDeviceDisplacementMicromapFeaturesNV::displacementMicromap is not supported\n";
                }
                break;
            }
#endif  // VK_ENABLE_BETA_EXTENSIONS
            case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DYNAMIC_RENDERING_FEATURES: {
                VkPhysicalDeviceDynamicRenderingFeatures supported = vku::InitStructHelper();
                features_2.pNext = &supported;
                DispatchGetPhysicalDeviceFeatures2(gpu, &features_2);
                const VkPhysicalDeviceDynamicRenderingFeatures* enabling =
                    reinterpret_cast<const VkPhysicalDeviceDynamicRenderingFeatures*>(current);
                if (enabling->dynamicRendering && !supported.dynamicRendering) {
                    ss << "VkPhysicalDeviceDynamicRenderingFeatures::dynamicRendering is not supported\n";
                }
                break;
            }
            case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DYNAMIC_RENDERING_LOCAL_READ_FEATURES: {
                VkPhysicalDeviceDynamicRenderingLocalReadFeatures supported = vku::InitStructHelper();
                features_2.pNext = &supported;
                DispatchGetPhysicalDeviceFeatures2(gpu, &features_2);
                const VkPhysicalDeviceDynamicRenderingLocalReadFeatures* enabling =
                    reinterpret_cast<const VkPhysicalDeviceDynamicRenderingLocalReadFeatures*>(current);
                if (enabling->dynamicRenderingLocalRead && !supported.dynamicRenderingLocalRead) {
                    ss << "VkPhysicalDeviceDynamicRenderingLocalReadFeatures::dynamicRenderingLocalRead is not supported\n";
                }
                break;
            }
            case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DYNAMIC_RENDERING_UNUSED_ATTACHMENTS_FEATURES_EXT: {
                VkPhysicalDeviceDynamicRenderingUnusedAttachmentsFeaturesEXT supported = vku::InitStructHelper();
                features_2.pNext = &supported;
                DispatchGetPhysicalDeviceFeatures2(gpu, &features_2);
                const VkPhysicalDeviceDynamicRenderingUnusedAttachmentsFeaturesEXT* enabling =
                    reinterpret_cast<const VkPhysicalDeviceDynamicRenderingUnusedAttachmentsFeaturesEXT*>(current);
                if (enabling->dynamicRenderingUnusedAttachments && !supported.dynamicRenderingUnusedAttachments) {
                    ss << "VkPhysicalDeviceDynamicRenderingUnusedAttachmentsFeaturesEXT::dynamicRenderingUnusedAttachments is not "
                          "supported\n";
                }
                break;
            }
            case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXCLUSIVE_SCISSOR_FEATURES_NV: {
                VkPhysicalDeviceExclusiveScissorFeaturesNV supported = vku::InitStructHelper();
                features_2.pNext = &supported;
                DispatchGetPhysicalDeviceFeatures2(gpu, &features_2);
                const VkPhysicalDeviceExclusiveScissorFeaturesNV* enabling =
                    reinterpret_cast<const VkPhysicalDeviceExclusiveScissorFeaturesNV*>(current);
                if (enabling->exclusiveScissor && !supported.exclusiveScissor) {
                    ss << "VkPhysicalDeviceExclusiveScissorFeaturesNV::exclusiveScissor is not supported\n";
                }
                break;
            }
            case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTENDED_DYNAMIC_STATE_2_FEATURES_EXT: {
                VkPhysicalDeviceExtendedDynamicState2FeaturesEXT supported = vku::InitStructHelper();
                features_2.pNext = &supported;
                DispatchGetPhysicalDeviceFeatures2(gpu, &features_2);
                const VkPhysicalDeviceExtendedDynamicState2FeaturesEXT* enabling =
                    reinterpret_cast<const VkPhysicalDeviceExtendedDynamicState2FeaturesEXT*>(current);
                if (enabling->extendedDynamicState2 && !supported.extendedDynamicState2) {
                    ss << "VkPhysicalDeviceExtendedDynamicState2FeaturesEXT::extendedDynamicState2 is not supported\n";
                }
                if (enabling->extendedDynamicState2LogicOp && !supported.extendedDynamicState2LogicOp) {
                    ss << "VkPhysicalDeviceExtendedDynamicState2FeaturesEXT::extendedDynamicState2LogicOp is not supported\n";
                }
                if (enabling->extendedDynamicState2PatchControlPoints && !supported.extendedDynamicState2PatchControlPoints) {
                    ss << "VkPhysicalDeviceExtendedDynamicState2FeaturesEXT::extendedDynamicState2PatchControlPoints is not "
                          "supported\n";
                }
                break;
            }
            case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTENDED_DYNAMIC_STATE_3_FEATURES_EXT: {
                VkPhysicalDeviceExtendedDynamicState3FeaturesEXT supported = vku::InitStructHelper();
                features_2.pNext = &supported;
                DispatchGetPhysicalDeviceFeatures2(gpu, &features_2);
                const VkPhysicalDeviceExtendedDynamicState3FeaturesEXT* enabling =
                    reinterpret_cast<const VkPhysicalDeviceExtendedDynamicState3FeaturesEXT*>(current);
                if (enabling->extendedDynamicState3TessellationDomainOrigin &&
                    !supported.extendedDynamicState3TessellationDomainOrigin) {
                    ss << "VkPhysicalDeviceExtendedDynamicState3FeaturesEXT::extendedDynamicState3TessellationDomainOrigin is not "
                          "supported\n";
                }
                if (enabling->extendedDynamicState3DepthClampEnable && !supported.extendedDynamicState3DepthClampEnable) {
                    ss << "VkPhysicalDeviceExtendedDynamicState3FeaturesEXT::extendedDynamicState3DepthClampEnable is not "
                          "supported\n";
                }
                if (enabling->extendedDynamicState3PolygonMode && !supported.extendedDynamicState3PolygonMode) {
                    ss << "VkPhysicalDeviceExtendedDynamicState3FeaturesEXT::extendedDynamicState3PolygonMode is not supported\n";
                }
                if (enabling->extendedDynamicState3RasterizationSamples && !supported.extendedDynamicState3RasterizationSamples) {
                    ss << "VkPhysicalDeviceExtendedDynamicState3FeaturesEXT::extendedDynamicState3RasterizationSamples is not "
                          "supported\n";
                }
                if (enabling->extendedDynamicState3SampleMask && !supported.extendedDynamicState3SampleMask) {
                    ss << "VkPhysicalDeviceExtendedDynamicState3FeaturesEXT::extendedDynamicState3SampleMask is not supported\n";
                }
                if (enabling->extendedDynamicState3AlphaToCoverageEnable && !supported.extendedDynamicState3AlphaToCoverageEnable) {
                    ss << "VkPhysicalDeviceExtendedDynamicState3FeaturesEXT::extendedDynamicState3AlphaToCoverageEnable is not "
                          "supported\n";
                }
                if (enabling->extendedDynamicState3AlphaToOneEnable && !supported.extendedDynamicState3AlphaToOneEnable) {
                    ss << "VkPhysicalDeviceExtendedDynamicState3FeaturesEXT::extendedDynamicState3AlphaToOneEnable is not "
                          "supported\n";
                }
                if (enabling->extendedDynamicState3LogicOpEnable && !supported.extendedDynamicState3LogicOpEnable) {
                    ss << "VkPhysicalDeviceExtendedDynamicState3FeaturesEXT::extendedDynamicState3LogicOpEnable is not supported\n";
                }
                if (enabling->extendedDynamicState3ColorBlendEnable && !supported.extendedDynamicState3ColorBlendEnable) {
                    ss << "VkPhysicalDeviceExtendedDynamicState3FeaturesEXT::extendedDynamicState3ColorBlendEnable is not "
                          "supported\n";
                }
                if (enabling->extendedDynamicState3ColorBlendEquation && !supported.extendedDynamicState3ColorBlendEquation) {
                    ss << "VkPhysicalDeviceExtendedDynamicState3FeaturesEXT::extendedDynamicState3ColorBlendEquation is not "
                          "supported\n";
                }
                if (enabling->extendedDynamicState3ColorWriteMask && !supported.extendedDynamicState3ColorWriteMask) {
                    ss << "VkPhysicalDeviceExtendedDynamicState3FeaturesEXT::extendedDynamicState3ColorWriteMask is not "
                          "supported\n";
                }
                if (enabling->extendedDynamicState3RasterizationStream && !supported.extendedDynamicState3RasterizationStream) {
                    ss << "VkPhysicalDeviceExtendedDynamicState3FeaturesEXT::extendedDynamicState3RasterizationStream is not "
                          "supported\n";
                }
                if (enabling->extendedDynamicState3ConservativeRasterizationMode &&
                    !supported.extendedDynamicState3ConservativeRasterizationMode) {
                    ss << "VkPhysicalDeviceExtendedDynamicState3FeaturesEXT::extendedDynamicState3ConservativeRasterizationMode is "
                          "not supported\n";
                }
                if (enabling->extendedDynamicState3ExtraPrimitiveOverestimationSize &&
                    !supported.extendedDynamicState3ExtraPrimitiveOverestimationSize) {
                    ss << "VkPhysicalDeviceExtendedDynamicState3FeaturesEXT::extendedDynamicState3ExtraPrimitiveOverestimationSize "
                          "is not supported\n";
                }
                if (enabling->extendedDynamicState3DepthClipEnable && !supported.extendedDynamicState3DepthClipEnable) {
                    ss << "VkPhysicalDeviceExtendedDynamicState3FeaturesEXT::extendedDynamicState3DepthClipEnable is not "
                          "supported\n";
                }
                if (enabling->extendedDynamicState3SampleLocationsEnable && !supported.extendedDynamicState3SampleLocationsEnable) {
                    ss << "VkPhysicalDeviceExtendedDynamicState3FeaturesEXT::extendedDynamicState3SampleLocationsEnable is not "
                          "supported\n";
                }
                if (enabling->extendedDynamicState3ColorBlendAdvanced && !supported.extendedDynamicState3ColorBlendAdvanced) {
                    ss << "VkPhysicalDeviceExtendedDynamicState3FeaturesEXT::extendedDynamicState3ColorBlendAdvanced is not "
                          "supported\n";
                }
                if (enabling->extendedDynamicState3ProvokingVertexMode && !supported.extendedDynamicState3ProvokingVertexMode) {
                    ss << "VkPhysicalDeviceExtendedDynamicState3FeaturesEXT::extendedDynamicState3ProvokingVertexMode is not "
                          "supported\n";
                }
                if (enabling->extendedDynamicState3LineRasterizationMode && !supported.extendedDynamicState3LineRasterizationMode) {
                    ss << "VkPhysicalDeviceExtendedDynamicState3FeaturesEXT::extendedDynamicState3LineRasterizationMode is not "
                          "supported\n";
                }
                if (enabling->extendedDynamicState3LineStippleEnable && !supported.extendedDynamicState3LineStippleEnable) {
                    ss << "VkPhysicalDeviceExtendedDynamicState3FeaturesEXT::extendedDynamicState3LineStippleEnable is not "
                          "supported\n";
                }
                if (enabling->extendedDynamicState3DepthClipNegativeOneToOne &&
                    !supported.extendedDynamicState3DepthClipNegativeOneToOne) {
                    ss << "VkPhysicalDeviceExtendedDynamicState3FeaturesEXT::extendedDynamicState3DepthClipNegativeOneToOne is not "
                          "supported\n";
                }
                if (enabling->extendedDynamicState3ViewportWScalingEnable &&
                    !supported.extendedDynamicState3ViewportWScalingEnable) {
                    ss << "VkPhysicalDeviceExtendedDynamicState3FeaturesEXT::extendedDynamicState3ViewportWScalingEnable is not "
                          "supported\n";
                }
                if (enabling->extendedDynamicState3ViewportSwizzle && !supported.extendedDynamicState3ViewportSwizzle) {
                    ss << "VkPhysicalDeviceExtendedDynamicState3FeaturesEXT::extendedDynamicState3ViewportSwizzle is not "
                          "supported\n";
                }
                if (enabling->extendedDynamicState3CoverageToColorEnable && !supported.extendedDynamicState3CoverageToColorEnable) {
                    ss << "VkPhysicalDeviceExtendedDynamicState3FeaturesEXT::extendedDynamicState3CoverageToColorEnable is not "
                          "supported\n";
                }
                if (enabling->extendedDynamicState3CoverageToColorLocation &&
                    !supported.extendedDynamicState3CoverageToColorLocation) {
                    ss << "VkPhysicalDeviceExtendedDynamicState3FeaturesEXT::extendedDynamicState3CoverageToColorLocation is not "
                          "supported\n";
                }
                if (enabling->extendedDynamicState3CoverageModulationMode &&
                    !supported.extendedDynamicState3CoverageModulationMode) {
                    ss << "VkPhysicalDeviceExtendedDynamicState3FeaturesEXT::extendedDynamicState3CoverageModulationMode is not "
                          "supported\n";
                }
                if (enabling->extendedDynamicState3CoverageModulationTableEnable &&
                    !supported.extendedDynamicState3CoverageModulationTableEnable) {
                    ss << "VkPhysicalDeviceExtendedDynamicState3FeaturesEXT::extendedDynamicState3CoverageModulationTableEnable is "
                          "not supported\n";
                }
                if (enabling->extendedDynamicState3CoverageModulationTable &&
                    !supported.extendedDynamicState3CoverageModulationTable) {
                    ss << "VkPhysicalDeviceExtendedDynamicState3FeaturesEXT::extendedDynamicState3CoverageModulationTable is not "
                          "supported\n";
                }
                if (enabling->extendedDynamicState3CoverageReductionMode && !supported.extendedDynamicState3CoverageReductionMode) {
                    ss << "VkPhysicalDeviceExtendedDynamicState3FeaturesEXT::extendedDynamicState3CoverageReductionMode is not "
                          "supported\n";
                }
                if (enabling->extendedDynamicState3RepresentativeFragmentTestEnable &&
                    !supported.extendedDynamicState3RepresentativeFragmentTestEnable) {
                    ss << "VkPhysicalDeviceExtendedDynamicState3FeaturesEXT::extendedDynamicState3RepresentativeFragmentTestEnable "
                          "is not supported\n";
                }
                if (enabling->extendedDynamicState3ShadingRateImageEnable &&
                    !supported.extendedDynamicState3ShadingRateImageEnable) {
                    ss << "VkPhysicalDeviceExtendedDynamicState3FeaturesEXT::extendedDynamicState3ShadingRateImageEnable is not "
                          "supported\n";
                }
                break;
            }
            case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTENDED_DYNAMIC_STATE_FEATURES_EXT: {
                VkPhysicalDeviceExtendedDynamicStateFeaturesEXT supported = vku::InitStructHelper();
                features_2.pNext = &supported;
                DispatchGetPhysicalDeviceFeatures2(gpu, &features_2);
                const VkPhysicalDeviceExtendedDynamicStateFeaturesEXT* enabling =
                    reinterpret_cast<const VkPhysicalDeviceExtendedDynamicStateFeaturesEXT*>(current);
                if (enabling->extendedDynamicState && !supported.extendedDynamicState) {
                    ss << "VkPhysicalDeviceExtendedDynamicStateFeaturesEXT::extendedDynamicState is not supported\n";
                }
                break;
            }
            case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTENDED_SPARSE_ADDRESS_SPACE_FEATURES_NV: {
                VkPhysicalDeviceExtendedSparseAddressSpaceFeaturesNV supported = vku::InitStructHelper();
                features_2.pNext = &supported;
                DispatchGetPhysicalDeviceFeatures2(gpu, &features_2);
                const VkPhysicalDeviceExtendedSparseAddressSpaceFeaturesNV* enabling =
                    reinterpret_cast<const VkPhysicalDeviceExtendedSparseAddressSpaceFeaturesNV*>(current);
                if (enabling->extendedSparseAddressSpace && !supported.extendedSparseAddressSpace) {
                    ss << "VkPhysicalDeviceExtendedSparseAddressSpaceFeaturesNV::extendedSparseAddressSpace is not supported\n";
                }
                break;
            }
#ifdef VK_USE_PLATFORM_ANDROID_KHR
            case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTERNAL_FORMAT_RESOLVE_FEATURES_ANDROID: {
                VkPhysicalDeviceExternalFormatResolveFeaturesANDROID supported = vku::InitStructHelper();
                features_2.pNext = &supported;
                DispatchGetPhysicalDeviceFeatures2(gpu, &features_2);
                const VkPhysicalDeviceExternalFormatResolveFeaturesANDROID* enabling =
                    reinterpret_cast<const VkPhysicalDeviceExternalFormatResolveFeaturesANDROID*>(current);
                if (enabling->externalFormatResolve && !supported.externalFormatResolve) {
                    ss << "VkPhysicalDeviceExternalFormatResolveFeaturesANDROID::externalFormatResolve is not supported\n";
                }
                break;
            }
#endif  // VK_USE_PLATFORM_ANDROID_KHR
            case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTERNAL_MEMORY_RDMA_FEATURES_NV: {
                VkPhysicalDeviceExternalMemoryRDMAFeaturesNV supported = vku::InitStructHelper();
                features_2.pNext = &supported;
                DispatchGetPhysicalDeviceFeatures2(gpu, &features_2);
                const VkPhysicalDeviceExternalMemoryRDMAFeaturesNV* enabling =
                    reinterpret_cast<const VkPhysicalDeviceExternalMemoryRDMAFeaturesNV*>(current);
                if (enabling->externalMemoryRDMA && !supported.externalMemoryRDMA) {
                    ss << "VkPhysicalDeviceExternalMemoryRDMAFeaturesNV::externalMemoryRDMA is not supported\n";
                }
                break;
            }
#ifdef VK_USE_PLATFORM_SCREEN_QNX
            case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTERNAL_MEMORY_SCREEN_BUFFER_FEATURES_QNX: {
                VkPhysicalDeviceExternalMemoryScreenBufferFeaturesQNX supported = vku::InitStructHelper();
                features_2.pNext = &supported;
                DispatchGetPhysicalDeviceFeatures2(gpu, &features_2);
                const VkPhysicalDeviceExternalMemoryScreenBufferFeaturesQNX* enabling =
                    reinterpret_cast<const VkPhysicalDeviceExternalMemoryScreenBufferFeaturesQNX*>(current);
                if (enabling->screenBufferImport && !supported.screenBufferImport) {
                    ss << "VkPhysicalDeviceExternalMemoryScreenBufferFeaturesQNX::screenBufferImport is not supported\n";
                }
                break;
            }
#endif  // VK_USE_PLATFORM_SCREEN_QNX
            case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FAULT_FEATURES_EXT: {
                VkPhysicalDeviceFaultFeaturesEXT supported = vku::InitStructHelper();
                features_2.pNext = &supported;
                DispatchGetPhysicalDeviceFeatures2(gpu, &features_2);
                const VkPhysicalDeviceFaultFeaturesEXT* enabling =
                    reinterpret_cast<const VkPhysicalDeviceFaultFeaturesEXT*>(current);
                if (enabling->deviceFault && !supported.deviceFault) {
                    ss << "VkPhysicalDeviceFaultFeaturesEXT::deviceFault is not supported\n";
                }
                if (enabling->deviceFaultVendorBinary && !supported.deviceFaultVendorBinary) {
                    ss << "VkPhysicalDeviceFaultFeaturesEXT::deviceFaultVendorBinary is not supported\n";
                }
                break;
            }
            case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FAULT_FEATURES_KHR: {
                VkPhysicalDeviceFaultFeaturesKHR supported = vku::InitStructHelper();
                features_2.pNext = &supported;
                DispatchGetPhysicalDeviceFeatures2(gpu, &features_2);
                const VkPhysicalDeviceFaultFeaturesKHR* enabling =
                    reinterpret_cast<const VkPhysicalDeviceFaultFeaturesKHR*>(current);
                if (enabling->deviceFault && !supported.deviceFault) {
                    ss << "VkPhysicalDeviceFaultFeaturesKHR::deviceFault is not supported\n";
                }
                if (enabling->deviceFaultVendorBinary && !supported.deviceFaultVendorBinary) {
                    ss << "VkPhysicalDeviceFaultFeaturesKHR::deviceFaultVendorBinary is not supported\n";
                }
                if (enabling->deviceFaultReportMasked && !supported.deviceFaultReportMasked) {
                    ss << "VkPhysicalDeviceFaultFeaturesKHR::deviceFaultReportMasked is not supported\n";
                }
                if (enabling->deviceFaultDeviceLostOnMasked && !supported.deviceFaultDeviceLostOnMasked) {
                    ss << "VkPhysicalDeviceFaultFeaturesKHR::deviceFaultDeviceLostOnMasked is not supported\n";
                }
                break;
            }
            case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FORMAT_PACK_FEATURES_ARM: {
                VkPhysicalDeviceFormatPackFeaturesARM supported = vku::InitStructHelper();
                features_2.pNext = &supported;
                DispatchGetPhysicalDeviceFeatures2(gpu, &features_2);
                const VkPhysicalDeviceFormatPackFeaturesARM* enabling =
                    reinterpret_cast<const VkPhysicalDeviceFormatPackFeaturesARM*>(current);
                if (enabling->formatPack && !supported.formatPack) {
                    ss << "VkPhysicalDeviceFormatPackFeaturesARM::formatPack is not supported\n";
                }
                break;
            }
            case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_DENSITY_MAP_2_FEATURES_EXT: {
                VkPhysicalDeviceFragmentDensityMap2FeaturesEXT supported = vku::InitStructHelper();
                features_2.pNext = &supported;
                DispatchGetPhysicalDeviceFeatures2(gpu, &features_2);
                const VkPhysicalDeviceFragmentDensityMap2FeaturesEXT* enabling =
                    reinterpret_cast<const VkPhysicalDeviceFragmentDensityMap2FeaturesEXT*>(current);
                if (enabling->fragmentDensityMapDeferred && !supported.fragmentDensityMapDeferred) {
                    ss << "VkPhysicalDeviceFragmentDensityMap2FeaturesEXT::fragmentDensityMapDeferred is not supported\n";
                }
                break;
            }
            case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_DENSITY_MAP_FEATURES_EXT: {
                VkPhysicalDeviceFragmentDensityMapFeaturesEXT supported = vku::InitStructHelper();
                features_2.pNext = &supported;
                DispatchGetPhysicalDeviceFeatures2(gpu, &features_2);
                const VkPhysicalDeviceFragmentDensityMapFeaturesEXT* enabling =
                    reinterpret_cast<const VkPhysicalDeviceFragmentDensityMapFeaturesEXT*>(current);
                if (enabling->fragmentDensityMap && !supported.fragmentDensityMap) {
                    ss << "VkPhysicalDeviceFragmentDensityMapFeaturesEXT::fragmentDensityMap is not supported\n";
                }
                if (enabling->fragmentDensityMapDynamic && !supported.fragmentDensityMapDynamic) {
                    ss << "VkPhysicalDeviceFragmentDensityMapFeaturesEXT::fragmentDensityMapDynamic is not supported\n";
                }
                if (enabling->fragmentDensityMapNonSubsampledImages && !supported.fragmentDensityMapNonSubsampledImages) {
                    ss << "VkPhysicalDeviceFragmentDensityMapFeaturesEXT::fragmentDensityMapNonSubsampledImages is not supported\n";
                }
                break;
            }
            case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_DENSITY_MAP_LAYERED_FEATURES_VALVE: {
                VkPhysicalDeviceFragmentDensityMapLayeredFeaturesVALVE supported = vku::InitStructHelper();
                features_2.pNext = &supported;
                DispatchGetPhysicalDeviceFeatures2(gpu, &features_2);
                const VkPhysicalDeviceFragmentDensityMapLayeredFeaturesVALVE* enabling =
                    reinterpret_cast<const VkPhysicalDeviceFragmentDensityMapLayeredFeaturesVALVE*>(current);
                if (enabling->fragmentDensityMapLayered && !supported.fragmentDensityMapLayered) {
                    ss << "VkPhysicalDeviceFragmentDensityMapLayeredFeaturesVALVE::fragmentDensityMapLayered is not supported\n";
                }
                break;
            }
            case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_DENSITY_MAP_OFFSET_FEATURES_EXT: {
                VkPhysicalDeviceFragmentDensityMapOffsetFeaturesEXT supported = vku::InitStructHelper();
                features_2.pNext = &supported;
                DispatchGetPhysicalDeviceFeatures2(gpu, &features_2);
                const VkPhysicalDeviceFragmentDensityMapOffsetFeaturesEXT* enabling =
                    reinterpret_cast<const VkPhysicalDeviceFragmentDensityMapOffsetFeaturesEXT*>(current);
                if (enabling->fragmentDensityMapOffset && !supported.fragmentDensityMapOffset) {
                    ss << "VkPhysicalDeviceFragmentDensityMapOffsetFeaturesEXT::fragmentDensityMapOffset is not supported\n";
                }
                break;
            }
            case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_SHADER_BARYCENTRIC_FEATURES_KHR: {
                VkPhysicalDeviceFragmentShaderBarycentricFeaturesKHR supported = vku::InitStructHelper();
                features_2.pNext = &supported;
                DispatchGetPhysicalDeviceFeatures2(gpu, &features_2);
                const VkPhysicalDeviceFragmentShaderBarycentricFeaturesKHR* enabling =
                    reinterpret_cast<const VkPhysicalDeviceFragmentShaderBarycentricFeaturesKHR*>(current);
                if (enabling->fragmentShaderBarycentric && !supported.fragmentShaderBarycentric) {
                    ss << "VkPhysicalDeviceFragmentShaderBarycentricFeaturesKHR::fragmentShaderBarycentric is not supported\n";
                }
                break;
            }
            case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_SHADER_INTERLOCK_FEATURES_EXT: {
                VkPhysicalDeviceFragmentShaderInterlockFeaturesEXT supported = vku::InitStructHelper();
                features_2.pNext = &supported;
                DispatchGetPhysicalDeviceFeatures2(gpu, &features_2);
                const VkPhysicalDeviceFragmentShaderInterlockFeaturesEXT* enabling =
                    reinterpret_cast<const VkPhysicalDeviceFragmentShaderInterlockFeaturesEXT*>(current);
                if (enabling->fragmentShaderSampleInterlock && !supported.fragmentShaderSampleInterlock) {
                    ss << "VkPhysicalDeviceFragmentShaderInterlockFeaturesEXT::fragmentShaderSampleInterlock is not supported\n";
                }
                if (enabling->fragmentShaderPixelInterlock && !supported.fragmentShaderPixelInterlock) {
                    ss << "VkPhysicalDeviceFragmentShaderInterlockFeaturesEXT::fragmentShaderPixelInterlock is not supported\n";
                }
                if (enabling->fragmentShaderShadingRateInterlock && !supported.fragmentShaderShadingRateInterlock) {
                    ss << "VkPhysicalDeviceFragmentShaderInterlockFeaturesEXT::fragmentShaderShadingRateInterlock is not "
                          "supported\n";
                }
                break;
            }
            case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_SHADING_RATE_ENUMS_FEATURES_NV: {
                VkPhysicalDeviceFragmentShadingRateEnumsFeaturesNV supported = vku::InitStructHelper();
                features_2.pNext = &supported;
                DispatchGetPhysicalDeviceFeatures2(gpu, &features_2);
                const VkPhysicalDeviceFragmentShadingRateEnumsFeaturesNV* enabling =
                    reinterpret_cast<const VkPhysicalDeviceFragmentShadingRateEnumsFeaturesNV*>(current);
                if (enabling->fragmentShadingRateEnums && !supported.fragmentShadingRateEnums) {
                    ss << "VkPhysicalDeviceFragmentShadingRateEnumsFeaturesNV::fragmentShadingRateEnums is not supported\n";
                }
                if (enabling->supersampleFragmentShadingRates && !supported.supersampleFragmentShadingRates) {
                    ss << "VkPhysicalDeviceFragmentShadingRateEnumsFeaturesNV::supersampleFragmentShadingRates is not supported\n";
                }
                if (enabling->noInvocationFragmentShadingRates && !supported.noInvocationFragmentShadingRates) {
                    ss << "VkPhysicalDeviceFragmentShadingRateEnumsFeaturesNV::noInvocationFragmentShadingRates is not supported\n";
                }
                break;
            }
            case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_SHADING_RATE_FEATURES_KHR: {
                VkPhysicalDeviceFragmentShadingRateFeaturesKHR supported = vku::InitStructHelper();
                features_2.pNext = &supported;
                DispatchGetPhysicalDeviceFeatures2(gpu, &features_2);
                const VkPhysicalDeviceFragmentShadingRateFeaturesKHR* enabling =
                    reinterpret_cast<const VkPhysicalDeviceFragmentShadingRateFeaturesKHR*>(current);
                if (enabling->pipelineFragmentShadingRate && !supported.pipelineFragmentShadingRate) {
                    ss << "VkPhysicalDeviceFragmentShadingRateFeaturesKHR::pipelineFragmentShadingRate is not supported\n";
                }
                if (enabling->primitiveFragmentShadingRate && !supported.primitiveFragmentShadingRate) {
                    ss << "VkPhysicalDeviceFragmentShadingRateFeaturesKHR::primitiveFragmentShadingRate is not supported\n";
                }
                if (enabling->attachmentFragmentShadingRate && !supported.attachmentFragmentShadingRate) {
                    ss << "VkPhysicalDeviceFragmentShadingRateFeaturesKHR::attachmentFragmentShadingRate is not supported\n";
                }
                break;
            }
            case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAME_BOUNDARY_FEATURES_EXT: {
                VkPhysicalDeviceFrameBoundaryFeaturesEXT supported = vku::InitStructHelper();
                features_2.pNext = &supported;
                DispatchGetPhysicalDeviceFeatures2(gpu, &features_2);
                const VkPhysicalDeviceFrameBoundaryFeaturesEXT* enabling =
                    reinterpret_cast<const VkPhysicalDeviceFrameBoundaryFeaturesEXT*>(current);
                if (enabling->frameBoundary && !supported.frameBoundary) {
                    ss << "VkPhysicalDeviceFrameBoundaryFeaturesEXT::frameBoundary is not supported\n";
                }
                break;
            }
            case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_GLOBAL_PRIORITY_QUERY_FEATURES: {
                VkPhysicalDeviceGlobalPriorityQueryFeatures supported = vku::InitStructHelper();
                features_2.pNext = &supported;
                DispatchGetPhysicalDeviceFeatures2(gpu, &features_2);
                const VkPhysicalDeviceGlobalPriorityQueryFeatures* enabling =
                    reinterpret_cast<const VkPhysicalDeviceGlobalPriorityQueryFeatures*>(current);
                if (enabling->globalPriorityQuery && !supported.globalPriorityQuery) {
                    ss << "VkPhysicalDeviceGlobalPriorityQueryFeatures::globalPriorityQuery is not supported\n";
                }
                break;
            }
            case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_GRAPHICS_PIPELINE_LIBRARY_FEATURES_EXT: {
                VkPhysicalDeviceGraphicsPipelineLibraryFeaturesEXT supported = vku::InitStructHelper();
                features_2.pNext = &supported;
                DispatchGetPhysicalDeviceFeatures2(gpu, &features_2);
                const VkPhysicalDeviceGraphicsPipelineLibraryFeaturesEXT* enabling =
                    reinterpret_cast<const VkPhysicalDeviceGraphicsPipelineLibraryFeaturesEXT*>(current);
                if (enabling->graphicsPipelineLibrary && !supported.graphicsPipelineLibrary) {
                    ss << "VkPhysicalDeviceGraphicsPipelineLibraryFeaturesEXT::graphicsPipelineLibrary is not supported\n";
                }
                break;
            }
            case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_HDR_VIVID_FEATURES_HUAWEI: {
                VkPhysicalDeviceHdrVividFeaturesHUAWEI supported = vku::InitStructHelper();
                features_2.pNext = &supported;
                DispatchGetPhysicalDeviceFeatures2(gpu, &features_2);
                const VkPhysicalDeviceHdrVividFeaturesHUAWEI* enabling =
                    reinterpret_cast<const VkPhysicalDeviceHdrVividFeaturesHUAWEI*>(current);
                if (enabling->hdrVivid && !supported.hdrVivid) {
                    ss << "VkPhysicalDeviceHdrVividFeaturesHUAWEI::hdrVivid is not supported\n";
                }
                break;
            }
            case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_HOST_IMAGE_COPY_FEATURES: {
                VkPhysicalDeviceHostImageCopyFeatures supported = vku::InitStructHelper();
                features_2.pNext = &supported;
                DispatchGetPhysicalDeviceFeatures2(gpu, &features_2);
                const VkPhysicalDeviceHostImageCopyFeatures* enabling =
                    reinterpret_cast<const VkPhysicalDeviceHostImageCopyFeatures*>(current);
                if (enabling->hostImageCopy && !supported.hostImageCopy) {
                    ss << "VkPhysicalDeviceHostImageCopyFeatures::hostImageCopy is not supported\n";
                }
                break;
            }
            case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_HOST_QUERY_RESET_FEATURES: {
                VkPhysicalDeviceHostQueryResetFeatures supported = vku::InitStructHelper();
                features_2.pNext = &supported;
                DispatchGetPhysicalDeviceFeatures2(gpu, &features_2);
                const VkPhysicalDeviceHostQueryResetFeatures* enabling =
                    reinterpret_cast<const VkPhysicalDeviceHostQueryResetFeatures*>(current);
                if (enabling->hostQueryReset && !supported.hostQueryReset) {
                    ss << "VkPhysicalDeviceHostQueryResetFeatures::hostQueryReset is not supported\n";
                }
                break;
            }
            case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_2D_VIEW_OF_3D_FEATURES_EXT: {
                VkPhysicalDeviceImage2DViewOf3DFeaturesEXT supported = vku::InitStructHelper();
                features_2.pNext = &supported;
                DispatchGetPhysicalDeviceFeatures2(gpu, &features_2);
                const VkPhysicalDeviceImage2DViewOf3DFeaturesEXT* enabling =
                    reinterpret_cast<const VkPhysicalDeviceImage2DViewOf3DFeaturesEXT*>(current);
                if (enabling->image2DViewOf3D && !supported.image2DViewOf3D) {
                    ss << "VkPhysicalDeviceImage2DViewOf3DFeaturesEXT::image2DViewOf3D is not supported\n";
                }
                if (enabling->sampler2DViewOf3D && !supported.sampler2DViewOf3D) {
                    ss << "VkPhysicalDeviceImage2DViewOf3DFeaturesEXT::sampler2DViewOf3D is not supported\n";
                }
                break;
            }
            case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_ALIGNMENT_CONTROL_FEATURES_MESA: {
                VkPhysicalDeviceImageAlignmentControlFeaturesMESA supported = vku::InitStructHelper();
                features_2.pNext = &supported;
                DispatchGetPhysicalDeviceFeatures2(gpu, &features_2);
                const VkPhysicalDeviceImageAlignmentControlFeaturesMESA* enabling =
                    reinterpret_cast<const VkPhysicalDeviceImageAlignmentControlFeaturesMESA*>(current);
                if (enabling->imageAlignmentControl && !supported.imageAlignmentControl) {
                    ss << "VkPhysicalDeviceImageAlignmentControlFeaturesMESA::imageAlignmentControl is not supported\n";
                }
                break;
            }
            case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_COMPRESSION_CONTROL_FEATURES_EXT: {
                VkPhysicalDeviceImageCompressionControlFeaturesEXT supported = vku::InitStructHelper();
                features_2.pNext = &supported;
                DispatchGetPhysicalDeviceFeatures2(gpu, &features_2);
                const VkPhysicalDeviceImageCompressionControlFeaturesEXT* enabling =
                    reinterpret_cast<const VkPhysicalDeviceImageCompressionControlFeaturesEXT*>(current);
                if (enabling->imageCompressionControl && !supported.imageCompressionControl) {
                    ss << "VkPhysicalDeviceImageCompressionControlFeaturesEXT::imageCompressionControl is not supported\n";
                }
                break;
            }
            case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_COMPRESSION_CONTROL_SWAPCHAIN_FEATURES_EXT: {
                VkPhysicalDeviceImageCompressionControlSwapchainFeaturesEXT supported = vku::InitStructHelper();
                features_2.pNext = &supported;
                DispatchGetPhysicalDeviceFeatures2(gpu, &features_2);
                const VkPhysicalDeviceImageCompressionControlSwapchainFeaturesEXT* enabling =
                    reinterpret_cast<const VkPhysicalDeviceImageCompressionControlSwapchainFeaturesEXT*>(current);
                if (enabling->imageCompressionControlSwapchain && !supported.imageCompressionControlSwapchain) {
                    ss << "VkPhysicalDeviceImageCompressionControlSwapchainFeaturesEXT::imageCompressionControlSwapchain is not "
                          "supported\n";
                }
                break;
            }
            case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_PROCESSING_2_FEATURES_QCOM: {
                VkPhysicalDeviceImageProcessing2FeaturesQCOM supported = vku::InitStructHelper();
                features_2.pNext = &supported;
                DispatchGetPhysicalDeviceFeatures2(gpu, &features_2);
                const VkPhysicalDeviceImageProcessing2FeaturesQCOM* enabling =
                    reinterpret_cast<const VkPhysicalDeviceImageProcessing2FeaturesQCOM*>(current);
                if (enabling->textureBlockMatch2 && !supported.textureBlockMatch2) {
                    ss << "VkPhysicalDeviceImageProcessing2FeaturesQCOM::textureBlockMatch2 is not supported\n";
                }
                break;
            }
            case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_PROCESSING_FEATURES_QCOM: {
                VkPhysicalDeviceImageProcessingFeaturesQCOM supported = vku::InitStructHelper();
                features_2.pNext = &supported;
                DispatchGetPhysicalDeviceFeatures2(gpu, &features_2);
                const VkPhysicalDeviceImageProcessingFeaturesQCOM* enabling =
                    reinterpret_cast<const VkPhysicalDeviceImageProcessingFeaturesQCOM*>(current);
                if (enabling->textureSampleWeighted && !supported.textureSampleWeighted) {
                    ss << "VkPhysicalDeviceImageProcessingFeaturesQCOM::textureSampleWeighted is not supported\n";
                }
                if (enabling->textureBoxFilter && !supported.textureBoxFilter) {
                    ss << "VkPhysicalDeviceImageProcessingFeaturesQCOM::textureBoxFilter is not supported\n";
                }
                if (enabling->textureBlockMatch && !supported.textureBlockMatch) {
                    ss << "VkPhysicalDeviceImageProcessingFeaturesQCOM::textureBlockMatch is not supported\n";
                }
                break;
            }
            case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_ROBUSTNESS_FEATURES: {
                VkPhysicalDeviceImageRobustnessFeatures supported = vku::InitStructHelper();
                features_2.pNext = &supported;
                DispatchGetPhysicalDeviceFeatures2(gpu, &features_2);
                const VkPhysicalDeviceImageRobustnessFeatures* enabling =
                    reinterpret_cast<const VkPhysicalDeviceImageRobustnessFeatures*>(current);
                if (enabling->robustImageAccess && !supported.robustImageAccess) {
                    ss << "VkPhysicalDeviceImageRobustnessFeatures::robustImageAccess is not supported\n";
                }
                break;
            }
            case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_SLICED_VIEW_OF_3D_FEATURES_EXT: {
                VkPhysicalDeviceImageSlicedViewOf3DFeaturesEXT supported = vku::InitStructHelper();
                features_2.pNext = &supported;
                DispatchGetPhysicalDeviceFeatures2(gpu, &features_2);
                const VkPhysicalDeviceImageSlicedViewOf3DFeaturesEXT* enabling =
                    reinterpret_cast<const VkPhysicalDeviceImageSlicedViewOf3DFeaturesEXT*>(current);
                if (enabling->imageSlicedViewOf3D && !supported.imageSlicedViewOf3D) {
                    ss << "VkPhysicalDeviceImageSlicedViewOf3DFeaturesEXT::imageSlicedViewOf3D is not supported\n";
                }
                break;
            }
            case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_VIEW_MIN_LOD_FEATURES_EXT: {
                VkPhysicalDeviceImageViewMinLodFeaturesEXT supported = vku::InitStructHelper();
                features_2.pNext = &supported;
                DispatchGetPhysicalDeviceFeatures2(gpu, &features_2);
                const VkPhysicalDeviceImageViewMinLodFeaturesEXT* enabling =
                    reinterpret_cast<const VkPhysicalDeviceImageViewMinLodFeaturesEXT*>(current);
                if (enabling->minLod && !supported.minLod) {
                    ss << "VkPhysicalDeviceImageViewMinLodFeaturesEXT::minLod is not supported\n";
                }
                break;
            }
            case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGELESS_FRAMEBUFFER_FEATURES: {
                VkPhysicalDeviceImagelessFramebufferFeatures supported = vku::InitStructHelper();
                features_2.pNext = &supported;
                DispatchGetPhysicalDeviceFeatures2(gpu, &features_2);
                const VkPhysicalDeviceImagelessFramebufferFeatures* enabling =
                    reinterpret_cast<const VkPhysicalDeviceImagelessFramebufferFeatures*>(current);
                if (enabling->imagelessFramebuffer && !supported.imagelessFramebuffer) {
                    ss << "VkPhysicalDeviceImagelessFramebufferFeatures::imagelessFramebuffer is not supported\n";
                }
                break;
            }
            case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_INDEX_TYPE_UINT8_FEATURES: {
                VkPhysicalDeviceIndexTypeUint8Features supported = vku::InitStructHelper();
                features_2.pNext = &supported;
                DispatchGetPhysicalDeviceFeatures2(gpu, &features_2);
                const VkPhysicalDeviceIndexTypeUint8Features* enabling =
                    reinterpret_cast<const VkPhysicalDeviceIndexTypeUint8Features*>(current);
                if (enabling->indexTypeUint8 && !supported.indexTypeUint8) {
                    ss << "VkPhysicalDeviceIndexTypeUint8Features::indexTypeUint8 is not supported\n";
                }
                break;
            }
            case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_INHERITED_VIEWPORT_SCISSOR_FEATURES_NV: {
                VkPhysicalDeviceInheritedViewportScissorFeaturesNV supported = vku::InitStructHelper();
                features_2.pNext = &supported;
                DispatchGetPhysicalDeviceFeatures2(gpu, &features_2);
                const VkPhysicalDeviceInheritedViewportScissorFeaturesNV* enabling =
                    reinterpret_cast<const VkPhysicalDeviceInheritedViewportScissorFeaturesNV*>(current);
                if (enabling->inheritedViewportScissor2D && !supported.inheritedViewportScissor2D) {
                    ss << "VkPhysicalDeviceInheritedViewportScissorFeaturesNV::inheritedViewportScissor2D is not supported\n";
                }
                break;
            }
            case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_INLINE_UNIFORM_BLOCK_FEATURES: {
                VkPhysicalDeviceInlineUniformBlockFeatures supported = vku::InitStructHelper();
                features_2.pNext = &supported;
                DispatchGetPhysicalDeviceFeatures2(gpu, &features_2);
                const VkPhysicalDeviceInlineUniformBlockFeatures* enabling =
                    reinterpret_cast<const VkPhysicalDeviceInlineUniformBlockFeatures*>(current);
                if (enabling->inlineUniformBlock && !supported.inlineUniformBlock) {
                    ss << "VkPhysicalDeviceInlineUniformBlockFeatures::inlineUniformBlock is not supported\n";
                }
                if (enabling->descriptorBindingInlineUniformBlockUpdateAfterBind &&
                    !supported.descriptorBindingInlineUniformBlockUpdateAfterBind) {
                    ss << "VkPhysicalDeviceInlineUniformBlockFeatures::descriptorBindingInlineUniformBlockUpdateAfterBind is not "
                          "supported\n";
                }
                break;
            }
            case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_INTERNALLY_SYNCHRONIZED_QUEUES_FEATURES_KHR: {
                VkPhysicalDeviceInternallySynchronizedQueuesFeaturesKHR supported = vku::InitStructHelper();
                features_2.pNext = &supported;
                DispatchGetPhysicalDeviceFeatures2(gpu, &features_2);
                const VkPhysicalDeviceInternallySynchronizedQueuesFeaturesKHR* enabling =
                    reinterpret_cast<const VkPhysicalDeviceInternallySynchronizedQueuesFeaturesKHR*>(current);
                if (enabling->internallySynchronizedQueues && !supported.internallySynchronizedQueues) {
                    ss << "VkPhysicalDeviceInternallySynchronizedQueuesFeaturesKHR::internallySynchronizedQueues is not "
                          "supported\n";
                }
                break;
            }
            case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_INVOCATION_MASK_FEATURES_HUAWEI: {
                VkPhysicalDeviceInvocationMaskFeaturesHUAWEI supported = vku::InitStructHelper();
                features_2.pNext = &supported;
                DispatchGetPhysicalDeviceFeatures2(gpu, &features_2);
                const VkPhysicalDeviceInvocationMaskFeaturesHUAWEI* enabling =
                    reinterpret_cast<const VkPhysicalDeviceInvocationMaskFeaturesHUAWEI*>(current);
                if (enabling->invocationMask && !supported.invocationMask) {
                    ss << "VkPhysicalDeviceInvocationMaskFeaturesHUAWEI::invocationMask is not supported\n";
                }
                break;
            }
            case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_LEGACY_DITHERING_FEATURES_EXT: {
                VkPhysicalDeviceLegacyDitheringFeaturesEXT supported = vku::InitStructHelper();
                features_2.pNext = &supported;
                DispatchGetPhysicalDeviceFeatures2(gpu, &features_2);
                const VkPhysicalDeviceLegacyDitheringFeaturesEXT* enabling =
                    reinterpret_cast<const VkPhysicalDeviceLegacyDitheringFeaturesEXT*>(current);
                if (enabling->legacyDithering && !supported.legacyDithering) {
                    ss << "VkPhysicalDeviceLegacyDitheringFeaturesEXT::legacyDithering is not supported\n";
                }
                break;
            }
            case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_LEGACY_VERTEX_ATTRIBUTES_FEATURES_EXT: {
                VkPhysicalDeviceLegacyVertexAttributesFeaturesEXT supported = vku::InitStructHelper();
                features_2.pNext = &supported;
                DispatchGetPhysicalDeviceFeatures2(gpu, &features_2);
                const VkPhysicalDeviceLegacyVertexAttributesFeaturesEXT* enabling =
                    reinterpret_cast<const VkPhysicalDeviceLegacyVertexAttributesFeaturesEXT*>(current);
                if (enabling->legacyVertexAttributes && !supported.legacyVertexAttributes) {
                    ss << "VkPhysicalDeviceLegacyVertexAttributesFeaturesEXT::legacyVertexAttributes is not supported\n";
                }
                break;
            }
            case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_LINE_RASTERIZATION_FEATURES: {
                VkPhysicalDeviceLineRasterizationFeatures supported = vku::InitStructHelper();
                features_2.pNext = &supported;
                DispatchGetPhysicalDeviceFeatures2(gpu, &features_2);
                const VkPhysicalDeviceLineRasterizationFeatures* enabling =
                    reinterpret_cast<const VkPhysicalDeviceLineRasterizationFeatures*>(current);
                if (enabling->rectangularLines && !supported.rectangularLines) {
                    ss << "VkPhysicalDeviceLineRasterizationFeatures::rectangularLines is not supported\n";
                }
                if (enabling->bresenhamLines && !supported.bresenhamLines) {
                    ss << "VkPhysicalDeviceLineRasterizationFeatures::bresenhamLines is not supported\n";
                }
                if (enabling->smoothLines && !supported.smoothLines) {
                    ss << "VkPhysicalDeviceLineRasterizationFeatures::smoothLines is not supported\n";
                }
                if (enabling->stippledRectangularLines && !supported.stippledRectangularLines) {
                    ss << "VkPhysicalDeviceLineRasterizationFeatures::stippledRectangularLines is not supported\n";
                }
                if (enabling->stippledBresenhamLines && !supported.stippledBresenhamLines) {
                    ss << "VkPhysicalDeviceLineRasterizationFeatures::stippledBresenhamLines is not supported\n";
                }
                if (enabling->stippledSmoothLines && !supported.stippledSmoothLines) {
                    ss << "VkPhysicalDeviceLineRasterizationFeatures::stippledSmoothLines is not supported\n";
                }
                break;
            }
            case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_LINEAR_COLOR_ATTACHMENT_FEATURES_NV: {
                VkPhysicalDeviceLinearColorAttachmentFeaturesNV supported = vku::InitStructHelper();
                features_2.pNext = &supported;
                DispatchGetPhysicalDeviceFeatures2(gpu, &features_2);
                const VkPhysicalDeviceLinearColorAttachmentFeaturesNV* enabling =
                    reinterpret_cast<const VkPhysicalDeviceLinearColorAttachmentFeaturesNV*>(current);
                if (enabling->linearColorAttachment && !supported.linearColorAttachment) {
                    ss << "VkPhysicalDeviceLinearColorAttachmentFeaturesNV::linearColorAttachment is not supported\n";
                }
                break;
            }
            case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MAINTENANCE_10_FEATURES_KHR: {
                VkPhysicalDeviceMaintenance10FeaturesKHR supported = vku::InitStructHelper();
                features_2.pNext = &supported;
                DispatchGetPhysicalDeviceFeatures2(gpu, &features_2);
                const VkPhysicalDeviceMaintenance10FeaturesKHR* enabling =
                    reinterpret_cast<const VkPhysicalDeviceMaintenance10FeaturesKHR*>(current);
                if (enabling->maintenance10 && !supported.maintenance10) {
                    ss << "VkPhysicalDeviceMaintenance10FeaturesKHR::maintenance10 is not supported\n";
                }
                break;
            }
            case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MAINTENANCE_11_FEATURES_KHR: {
                VkPhysicalDeviceMaintenance11FeaturesKHR supported = vku::InitStructHelper();
                features_2.pNext = &supported;
                DispatchGetPhysicalDeviceFeatures2(gpu, &features_2);
                const VkPhysicalDeviceMaintenance11FeaturesKHR* enabling =
                    reinterpret_cast<const VkPhysicalDeviceMaintenance11FeaturesKHR*>(current);
                if (enabling->maintenance11 && !supported.maintenance11) {
                    ss << "VkPhysicalDeviceMaintenance11FeaturesKHR::maintenance11 is not supported\n";
                }
                break;
            }
            case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MAINTENANCE_4_FEATURES: {
                VkPhysicalDeviceMaintenance4Features supported = vku::InitStructHelper();
                features_2.pNext = &supported;
                DispatchGetPhysicalDeviceFeatures2(gpu, &features_2);
                const VkPhysicalDeviceMaintenance4Features* enabling =
                    reinterpret_cast<const VkPhysicalDeviceMaintenance4Features*>(current);
                if (enabling->maintenance4 && !supported.maintenance4) {
                    ss << "VkPhysicalDeviceMaintenance4Features::maintenance4 is not supported\n";
                }
                break;
            }
            case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MAINTENANCE_5_FEATURES: {
                VkPhysicalDeviceMaintenance5Features supported = vku::InitStructHelper();
                features_2.pNext = &supported;
                DispatchGetPhysicalDeviceFeatures2(gpu, &features_2);
                const VkPhysicalDeviceMaintenance5Features* enabling =
                    reinterpret_cast<const VkPhysicalDeviceMaintenance5Features*>(current);
                if (enabling->maintenance5 && !supported.maintenance5) {
                    ss << "VkPhysicalDeviceMaintenance5Features::maintenance5 is not supported\n";
                }
                break;
            }
            case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MAINTENANCE_6_FEATURES: {
                VkPhysicalDeviceMaintenance6Features supported = vku::InitStructHelper();
                features_2.pNext = &supported;
                DispatchGetPhysicalDeviceFeatures2(gpu, &features_2);
                const VkPhysicalDeviceMaintenance6Features* enabling =
                    reinterpret_cast<const VkPhysicalDeviceMaintenance6Features*>(current);
                if (enabling->maintenance6 && !supported.maintenance6) {
                    ss << "VkPhysicalDeviceMaintenance6Features::maintenance6 is not supported\n";
                }
                break;
            }
            case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MAINTENANCE_7_FEATURES_KHR: {
                VkPhysicalDeviceMaintenance7FeaturesKHR supported = vku::InitStructHelper();
                features_2.pNext = &supported;
                DispatchGetPhysicalDeviceFeatures2(gpu, &features_2);
                const VkPhysicalDeviceMaintenance7FeaturesKHR* enabling =
                    reinterpret_cast<const VkPhysicalDeviceMaintenance7FeaturesKHR*>(current);
                if (enabling->maintenance7 && !supported.maintenance7) {
                    ss << "VkPhysicalDeviceMaintenance7FeaturesKHR::maintenance7 is not supported\n";
                }
                break;
            }
            case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MAINTENANCE_8_FEATURES_KHR: {
                VkPhysicalDeviceMaintenance8FeaturesKHR supported = vku::InitStructHelper();
                features_2.pNext = &supported;
                DispatchGetPhysicalDeviceFeatures2(gpu, &features_2);
                const VkPhysicalDeviceMaintenance8FeaturesKHR* enabling =
                    reinterpret_cast<const VkPhysicalDeviceMaintenance8FeaturesKHR*>(current);
                if (enabling->maintenance8 && !supported.maintenance8) {
                    ss << "VkPhysicalDeviceMaintenance8FeaturesKHR::maintenance8 is not supported\n";
                }
                break;
            }
            case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MAINTENANCE_9_FEATURES_KHR: {
                VkPhysicalDeviceMaintenance9FeaturesKHR supported = vku::InitStructHelper();
                features_2.pNext = &supported;
                DispatchGetPhysicalDeviceFeatures2(gpu, &features_2);
                const VkPhysicalDeviceMaintenance9FeaturesKHR* enabling =
                    reinterpret_cast<const VkPhysicalDeviceMaintenance9FeaturesKHR*>(current);
                if (enabling->maintenance9 && !supported.maintenance9) {
                    ss << "VkPhysicalDeviceMaintenance9FeaturesKHR::maintenance9 is not supported\n";
                }
                break;
            }
            case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MAP_MEMORY_PLACED_FEATURES_EXT: {
                VkPhysicalDeviceMapMemoryPlacedFeaturesEXT supported = vku::InitStructHelper();
                features_2.pNext = &supported;
                DispatchGetPhysicalDeviceFeatures2(gpu, &features_2);
                const VkPhysicalDeviceMapMemoryPlacedFeaturesEXT* enabling =
                    reinterpret_cast<const VkPhysicalDeviceMapMemoryPlacedFeaturesEXT*>(current);
                if (enabling->memoryMapPlaced && !supported.memoryMapPlaced) {
                    ss << "VkPhysicalDeviceMapMemoryPlacedFeaturesEXT::memoryMapPlaced is not supported\n";
                }
                if (enabling->memoryMapRangePlaced && !supported.memoryMapRangePlaced) {
                    ss << "VkPhysicalDeviceMapMemoryPlacedFeaturesEXT::memoryMapRangePlaced is not supported\n";
                }
                if (enabling->memoryUnmapReserve && !supported.memoryUnmapReserve) {
                    ss << "VkPhysicalDeviceMapMemoryPlacedFeaturesEXT::memoryUnmapReserve is not supported\n";
                }
                break;
            }
            case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MEMORY_DECOMPRESSION_FEATURES_EXT: {
                VkPhysicalDeviceMemoryDecompressionFeaturesEXT supported = vku::InitStructHelper();
                features_2.pNext = &supported;
                DispatchGetPhysicalDeviceFeatures2(gpu, &features_2);
                const VkPhysicalDeviceMemoryDecompressionFeaturesEXT* enabling =
                    reinterpret_cast<const VkPhysicalDeviceMemoryDecompressionFeaturesEXT*>(current);
                if (enabling->memoryDecompression && !supported.memoryDecompression) {
                    ss << "VkPhysicalDeviceMemoryDecompressionFeaturesEXT::memoryDecompression is not supported\n";
                }
                break;
            }
            case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MEMORY_PRIORITY_FEATURES_EXT: {
                VkPhysicalDeviceMemoryPriorityFeaturesEXT supported = vku::InitStructHelper();
                features_2.pNext = &supported;
                DispatchGetPhysicalDeviceFeatures2(gpu, &features_2);
                const VkPhysicalDeviceMemoryPriorityFeaturesEXT* enabling =
                    reinterpret_cast<const VkPhysicalDeviceMemoryPriorityFeaturesEXT*>(current);
                if (enabling->memoryPriority && !supported.memoryPriority) {
                    ss << "VkPhysicalDeviceMemoryPriorityFeaturesEXT::memoryPriority is not supported\n";
                }
                break;
            }
            case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MESH_SHADER_FEATURES_EXT: {
                VkPhysicalDeviceMeshShaderFeaturesEXT supported = vku::InitStructHelper();
                features_2.pNext = &supported;
                DispatchGetPhysicalDeviceFeatures2(gpu, &features_2);
                const VkPhysicalDeviceMeshShaderFeaturesEXT* enabling =
                    reinterpret_cast<const VkPhysicalDeviceMeshShaderFeaturesEXT*>(current);
                if (enabling->taskShader && !supported.taskShader) {
                    ss << "VkPhysicalDeviceMeshShaderFeaturesEXT::taskShader is not supported\n";
                }
                if (enabling->meshShader && !supported.meshShader) {
                    ss << "VkPhysicalDeviceMeshShaderFeaturesEXT::meshShader is not supported\n";
                }
                if (enabling->multiviewMeshShader && !supported.multiviewMeshShader) {
                    ss << "VkPhysicalDeviceMeshShaderFeaturesEXT::multiviewMeshShader is not supported\n";
                }
                if (enabling->primitiveFragmentShadingRateMeshShader && !supported.primitiveFragmentShadingRateMeshShader) {
                    ss << "VkPhysicalDeviceMeshShaderFeaturesEXT::primitiveFragmentShadingRateMeshShader is not supported\n";
                }
                if (enabling->meshShaderQueries && !supported.meshShaderQueries) {
                    ss << "VkPhysicalDeviceMeshShaderFeaturesEXT::meshShaderQueries is not supported\n";
                }
                break;
            }
            case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MESH_SHADER_FEATURES_NV: {
                VkPhysicalDeviceMeshShaderFeaturesNV supported = vku::InitStructHelper();
                features_2.pNext = &supported;
                DispatchGetPhysicalDeviceFeatures2(gpu, &features_2);
                const VkPhysicalDeviceMeshShaderFeaturesNV* enabling =
                    reinterpret_cast<const VkPhysicalDeviceMeshShaderFeaturesNV*>(current);
                if (enabling->taskShader && !supported.taskShader) {
                    ss << "VkPhysicalDeviceMeshShaderFeaturesNV::taskShader is not supported\n";
                }
                if (enabling->meshShader && !supported.meshShader) {
                    ss << "VkPhysicalDeviceMeshShaderFeaturesNV::meshShader is not supported\n";
                }
                break;
            }
            case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MULTI_DRAW_FEATURES_EXT: {
                VkPhysicalDeviceMultiDrawFeaturesEXT supported = vku::InitStructHelper();
                features_2.pNext = &supported;
                DispatchGetPhysicalDeviceFeatures2(gpu, &features_2);
                const VkPhysicalDeviceMultiDrawFeaturesEXT* enabling =
                    reinterpret_cast<const VkPhysicalDeviceMultiDrawFeaturesEXT*>(current);
                if (enabling->multiDraw && !supported.multiDraw) {
                    ss << "VkPhysicalDeviceMultiDrawFeaturesEXT::multiDraw is not supported\n";
                }
                break;
            }
            case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MULTISAMPLED_RENDER_TO_SINGLE_SAMPLED_FEATURES_EXT: {
                VkPhysicalDeviceMultisampledRenderToSingleSampledFeaturesEXT supported = vku::InitStructHelper();
                features_2.pNext = &supported;
                DispatchGetPhysicalDeviceFeatures2(gpu, &features_2);
                const VkPhysicalDeviceMultisampledRenderToSingleSampledFeaturesEXT* enabling =
                    reinterpret_cast<const VkPhysicalDeviceMultisampledRenderToSingleSampledFeaturesEXT*>(current);
                if (enabling->multisampledRenderToSingleSampled && !supported.multisampledRenderToSingleSampled) {
                    ss << "VkPhysicalDeviceMultisampledRenderToSingleSampledFeaturesEXT::multisampledRenderToSingleSampled is not "
                          "supported\n";
                }
                break;
            }
            case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MULTIVIEW_FEATURES: {
                VkPhysicalDeviceMultiviewFeatures supported = vku::InitStructHelper();
                features_2.pNext = &supported;
                DispatchGetPhysicalDeviceFeatures2(gpu, &features_2);
                const VkPhysicalDeviceMultiviewFeatures* enabling =
                    reinterpret_cast<const VkPhysicalDeviceMultiviewFeatures*>(current);
                if (enabling->multiview && !supported.multiview) {
                    ss << "VkPhysicalDeviceMultiviewFeatures::multiview is not supported\n";
                }
                if (enabling->multiviewGeometryShader && !supported.multiviewGeometryShader) {
                    ss << "VkPhysicalDeviceMultiviewFeatures::multiviewGeometryShader is not supported\n";
                }
                if (enabling->multiviewTessellationShader && !supported.multiviewTessellationShader) {
                    ss << "VkPhysicalDeviceMultiviewFeatures::multiviewTessellationShader is not supported\n";
                }
                break;
            }
            case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MULTIVIEW_PER_VIEW_RENDER_AREAS_FEATURES_QCOM: {
                VkPhysicalDeviceMultiviewPerViewRenderAreasFeaturesQCOM supported = vku::InitStructHelper();
                features_2.pNext = &supported;
                DispatchGetPhysicalDeviceFeatures2(gpu, &features_2);
                const VkPhysicalDeviceMultiviewPerViewRenderAreasFeaturesQCOM* enabling =
                    reinterpret_cast<const VkPhysicalDeviceMultiviewPerViewRenderAreasFeaturesQCOM*>(current);
                if (enabling->multiviewPerViewRenderAreas && !supported.multiviewPerViewRenderAreas) {
                    ss << "VkPhysicalDeviceMultiviewPerViewRenderAreasFeaturesQCOM::multiviewPerViewRenderAreas is not supported\n";
                }
                break;
            }
            case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MULTIVIEW_PER_VIEW_VIEWPORTS_FEATURES_QCOM: {
                VkPhysicalDeviceMultiviewPerViewViewportsFeaturesQCOM supported = vku::InitStructHelper();
                features_2.pNext = &supported;
                DispatchGetPhysicalDeviceFeatures2(gpu, &features_2);
                const VkPhysicalDeviceMultiviewPerViewViewportsFeaturesQCOM* enabling =
                    reinterpret_cast<const VkPhysicalDeviceMultiviewPerViewViewportsFeaturesQCOM*>(current);
                if (enabling->multiviewPerViewViewports && !supported.multiviewPerViewViewports) {
                    ss << "VkPhysicalDeviceMultiviewPerViewViewportsFeaturesQCOM::multiviewPerViewViewports is not supported\n";
                }
                break;
            }
            case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MUTABLE_DESCRIPTOR_TYPE_FEATURES_EXT: {
                VkPhysicalDeviceMutableDescriptorTypeFeaturesEXT supported = vku::InitStructHelper();
                features_2.pNext = &supported;
                DispatchGetPhysicalDeviceFeatures2(gpu, &features_2);
                const VkPhysicalDeviceMutableDescriptorTypeFeaturesEXT* enabling =
                    reinterpret_cast<const VkPhysicalDeviceMutableDescriptorTypeFeaturesEXT*>(current);
                if (enabling->mutableDescriptorType && !supported.mutableDescriptorType) {
                    ss << "VkPhysicalDeviceMutableDescriptorTypeFeaturesEXT::mutableDescriptorType is not supported\n";
                }
                break;
            }
            case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_NESTED_COMMAND_BUFFER_FEATURES_EXT: {
                VkPhysicalDeviceNestedCommandBufferFeaturesEXT supported = vku::InitStructHelper();
                features_2.pNext = &supported;
                DispatchGetPhysicalDeviceFeatures2(gpu, &features_2);
                const VkPhysicalDeviceNestedCommandBufferFeaturesEXT* enabling =
                    reinterpret_cast<const VkPhysicalDeviceNestedCommandBufferFeaturesEXT*>(current);
                if (enabling->nestedCommandBuffer && !supported.nestedCommandBuffer) {
                    ss << "VkPhysicalDeviceNestedCommandBufferFeaturesEXT::nestedCommandBuffer is not supported\n";
                }
                if (enabling->nestedCommandBufferRendering && !supported.nestedCommandBufferRendering) {
                    ss << "VkPhysicalDeviceNestedCommandBufferFeaturesEXT::nestedCommandBufferRendering is not supported\n";
                }
                if (enabling->nestedCommandBufferSimultaneousUse && !supported.nestedCommandBufferSimultaneousUse) {
                    ss << "VkPhysicalDeviceNestedCommandBufferFeaturesEXT::nestedCommandBufferSimultaneousUse is not supported\n";
                }
                break;
            }
            case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_NON_SEAMLESS_CUBE_MAP_FEATURES_EXT: {
                VkPhysicalDeviceNonSeamlessCubeMapFeaturesEXT supported = vku::InitStructHelper();
                features_2.pNext = &supported;
                DispatchGetPhysicalDeviceFeatures2(gpu, &features_2);
                const VkPhysicalDeviceNonSeamlessCubeMapFeaturesEXT* enabling =
                    reinterpret_cast<const VkPhysicalDeviceNonSeamlessCubeMapFeaturesEXT*>(current);
                if (enabling->nonSeamlessCubeMap && !supported.nonSeamlessCubeMap) {
                    ss << "VkPhysicalDeviceNonSeamlessCubeMapFeaturesEXT::nonSeamlessCubeMap is not supported\n";
                }
                break;
            }
            case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_OPACITY_MICROMAP_FEATURES_EXT: {
                VkPhysicalDeviceOpacityMicromapFeaturesEXT supported = vku::InitStructHelper();
                features_2.pNext = &supported;
                DispatchGetPhysicalDeviceFeatures2(gpu, &features_2);
                const VkPhysicalDeviceOpacityMicromapFeaturesEXT* enabling =
                    reinterpret_cast<const VkPhysicalDeviceOpacityMicromapFeaturesEXT*>(current);
                if (enabling->micromap && !supported.micromap) {
                    ss << "VkPhysicalDeviceOpacityMicromapFeaturesEXT::micromap is not supported\n";
                }
                if (enabling->micromapCaptureReplay && !supported.micromapCaptureReplay) {
                    ss << "VkPhysicalDeviceOpacityMicromapFeaturesEXT::micromapCaptureReplay is not supported\n";
                }
                if (enabling->micromapHostCommands && !supported.micromapHostCommands) {
                    ss << "VkPhysicalDeviceOpacityMicromapFeaturesEXT::micromapHostCommands is not supported\n";
                }
                break;
            }
            case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_OPTICAL_FLOW_FEATURES_NV: {
                VkPhysicalDeviceOpticalFlowFeaturesNV supported = vku::InitStructHelper();
                features_2.pNext = &supported;
                DispatchGetPhysicalDeviceFeatures2(gpu, &features_2);
                const VkPhysicalDeviceOpticalFlowFeaturesNV* enabling =
                    reinterpret_cast<const VkPhysicalDeviceOpticalFlowFeaturesNV*>(current);
                if (enabling->opticalFlow && !supported.opticalFlow) {
                    ss << "VkPhysicalDeviceOpticalFlowFeaturesNV::opticalFlow is not supported\n";
                }
                break;
            }
            case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PAGEABLE_DEVICE_LOCAL_MEMORY_FEATURES_EXT: {
                VkPhysicalDevicePageableDeviceLocalMemoryFeaturesEXT supported = vku::InitStructHelper();
                features_2.pNext = &supported;
                DispatchGetPhysicalDeviceFeatures2(gpu, &features_2);
                const VkPhysicalDevicePageableDeviceLocalMemoryFeaturesEXT* enabling =
                    reinterpret_cast<const VkPhysicalDevicePageableDeviceLocalMemoryFeaturesEXT*>(current);
                if (enabling->pageableDeviceLocalMemory && !supported.pageableDeviceLocalMemory) {
                    ss << "VkPhysicalDevicePageableDeviceLocalMemoryFeaturesEXT::pageableDeviceLocalMemory is not supported\n";
                }
                break;
            }
            case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PARTITIONED_ACCELERATION_STRUCTURE_FEATURES_NV: {
                VkPhysicalDevicePartitionedAccelerationStructureFeaturesNV supported = vku::InitStructHelper();
                features_2.pNext = &supported;
                DispatchGetPhysicalDeviceFeatures2(gpu, &features_2);
                const VkPhysicalDevicePartitionedAccelerationStructureFeaturesNV* enabling =
                    reinterpret_cast<const VkPhysicalDevicePartitionedAccelerationStructureFeaturesNV*>(current);
                if (enabling->partitionedAccelerationStructure && !supported.partitionedAccelerationStructure) {
                    ss << "VkPhysicalDevicePartitionedAccelerationStructureFeaturesNV::partitionedAccelerationStructure is not "
                          "supported\n";
                }
                break;
            }
            case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PER_STAGE_DESCRIPTOR_SET_FEATURES_NV: {
                VkPhysicalDevicePerStageDescriptorSetFeaturesNV supported = vku::InitStructHelper();
                features_2.pNext = &supported;
                DispatchGetPhysicalDeviceFeatures2(gpu, &features_2);
                const VkPhysicalDevicePerStageDescriptorSetFeaturesNV* enabling =
                    reinterpret_cast<const VkPhysicalDevicePerStageDescriptorSetFeaturesNV*>(current);
                if (enabling->perStageDescriptorSet && !supported.perStageDescriptorSet) {
                    ss << "VkPhysicalDevicePerStageDescriptorSetFeaturesNV::perStageDescriptorSet is not supported\n";
                }
                if (enabling->dynamicPipelineLayout && !supported.dynamicPipelineLayout) {
                    ss << "VkPhysicalDevicePerStageDescriptorSetFeaturesNV::dynamicPipelineLayout is not supported\n";
                }
                break;
            }
            case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PERFORMANCE_COUNTERS_BY_REGION_FEATURES_ARM: {
                VkPhysicalDevicePerformanceCountersByRegionFeaturesARM supported = vku::InitStructHelper();
                features_2.pNext = &supported;
                DispatchGetPhysicalDeviceFeatures2(gpu, &features_2);
                const VkPhysicalDevicePerformanceCountersByRegionFeaturesARM* enabling =
                    reinterpret_cast<const VkPhysicalDevicePerformanceCountersByRegionFeaturesARM*>(current);
                if (enabling->performanceCountersByRegion && !supported.performanceCountersByRegion) {
                    ss << "VkPhysicalDevicePerformanceCountersByRegionFeaturesARM::performanceCountersByRegion is not supported\n";
                }
                break;
            }
            case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PERFORMANCE_QUERY_FEATURES_KHR: {
                VkPhysicalDevicePerformanceQueryFeaturesKHR supported = vku::InitStructHelper();
                features_2.pNext = &supported;
                DispatchGetPhysicalDeviceFeatures2(gpu, &features_2);
                const VkPhysicalDevicePerformanceQueryFeaturesKHR* enabling =
                    reinterpret_cast<const VkPhysicalDevicePerformanceQueryFeaturesKHR*>(current);
                if (enabling->performanceCounterQueryPools && !supported.performanceCounterQueryPools) {
                    ss << "VkPhysicalDevicePerformanceQueryFeaturesKHR::performanceCounterQueryPools is not supported\n";
                }
                if (enabling->performanceCounterMultipleQueryPools && !supported.performanceCounterMultipleQueryPools) {
                    ss << "VkPhysicalDevicePerformanceQueryFeaturesKHR::performanceCounterMultipleQueryPools is not supported\n";
                }
                break;
            }
            case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PIPELINE_BINARY_FEATURES_KHR: {
                VkPhysicalDevicePipelineBinaryFeaturesKHR supported = vku::InitStructHelper();
                features_2.pNext = &supported;
                DispatchGetPhysicalDeviceFeatures2(gpu, &features_2);
                const VkPhysicalDevicePipelineBinaryFeaturesKHR* enabling =
                    reinterpret_cast<const VkPhysicalDevicePipelineBinaryFeaturesKHR*>(current);
                if (enabling->pipelineBinaries && !supported.pipelineBinaries) {
                    ss << "VkPhysicalDevicePipelineBinaryFeaturesKHR::pipelineBinaries is not supported\n";
                }
                break;
            }
            case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PIPELINE_CACHE_INCREMENTAL_MODE_FEATURES_SEC: {
                VkPhysicalDevicePipelineCacheIncrementalModeFeaturesSEC supported = vku::InitStructHelper();
                features_2.pNext = &supported;
                DispatchGetPhysicalDeviceFeatures2(gpu, &features_2);
                const VkPhysicalDevicePipelineCacheIncrementalModeFeaturesSEC* enabling =
                    reinterpret_cast<const VkPhysicalDevicePipelineCacheIncrementalModeFeaturesSEC*>(current);
                if (enabling->pipelineCacheIncrementalMode && !supported.pipelineCacheIncrementalMode) {
                    ss << "VkPhysicalDevicePipelineCacheIncrementalModeFeaturesSEC::pipelineCacheIncrementalMode is not "
                          "supported\n";
                }
                break;
            }
            case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PIPELINE_CREATION_CACHE_CONTROL_FEATURES: {
                VkPhysicalDevicePipelineCreationCacheControlFeatures supported = vku::InitStructHelper();
                features_2.pNext = &supported;
                DispatchGetPhysicalDeviceFeatures2(gpu, &features_2);
                const VkPhysicalDevicePipelineCreationCacheControlFeatures* enabling =
                    reinterpret_cast<const VkPhysicalDevicePipelineCreationCacheControlFeatures*>(current);
                if (enabling->pipelineCreationCacheControl && !supported.pipelineCreationCacheControl) {
                    ss << "VkPhysicalDevicePipelineCreationCacheControlFeatures::pipelineCreationCacheControl is not supported\n";
                }
                break;
            }
            case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PIPELINE_EXECUTABLE_PROPERTIES_FEATURES_KHR: {
                VkPhysicalDevicePipelineExecutablePropertiesFeaturesKHR supported = vku::InitStructHelper();
                features_2.pNext = &supported;
                DispatchGetPhysicalDeviceFeatures2(gpu, &features_2);
                const VkPhysicalDevicePipelineExecutablePropertiesFeaturesKHR* enabling =
                    reinterpret_cast<const VkPhysicalDevicePipelineExecutablePropertiesFeaturesKHR*>(current);
                if (enabling->pipelineExecutableInfo && !supported.pipelineExecutableInfo) {
                    ss << "VkPhysicalDevicePipelineExecutablePropertiesFeaturesKHR::pipelineExecutableInfo is not supported\n";
                }
                break;
            }
            case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PIPELINE_LIBRARY_GROUP_HANDLES_FEATURES_EXT: {
                VkPhysicalDevicePipelineLibraryGroupHandlesFeaturesEXT supported = vku::InitStructHelper();
                features_2.pNext = &supported;
                DispatchGetPhysicalDeviceFeatures2(gpu, &features_2);
                const VkPhysicalDevicePipelineLibraryGroupHandlesFeaturesEXT* enabling =
                    reinterpret_cast<const VkPhysicalDevicePipelineLibraryGroupHandlesFeaturesEXT*>(current);
                if (enabling->pipelineLibraryGroupHandles && !supported.pipelineLibraryGroupHandles) {
                    ss << "VkPhysicalDevicePipelineLibraryGroupHandlesFeaturesEXT::pipelineLibraryGroupHandles is not supported\n";
                }
                break;
            }
            case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PIPELINE_OPACITY_MICROMAP_FEATURES_ARM: {
                VkPhysicalDevicePipelineOpacityMicromapFeaturesARM supported = vku::InitStructHelper();
                features_2.pNext = &supported;
                DispatchGetPhysicalDeviceFeatures2(gpu, &features_2);
                const VkPhysicalDevicePipelineOpacityMicromapFeaturesARM* enabling =
                    reinterpret_cast<const VkPhysicalDevicePipelineOpacityMicromapFeaturesARM*>(current);
                if (enabling->pipelineOpacityMicromap && !supported.pipelineOpacityMicromap) {
                    ss << "VkPhysicalDevicePipelineOpacityMicromapFeaturesARM::pipelineOpacityMicromap is not supported\n";
                }
                break;
            }
            case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PIPELINE_PROPERTIES_FEATURES_EXT: {
                VkPhysicalDevicePipelinePropertiesFeaturesEXT supported = vku::InitStructHelper();
                features_2.pNext = &supported;
                DispatchGetPhysicalDeviceFeatures2(gpu, &features_2);
                const VkPhysicalDevicePipelinePropertiesFeaturesEXT* enabling =
                    reinterpret_cast<const VkPhysicalDevicePipelinePropertiesFeaturesEXT*>(current);
                if (enabling->pipelinePropertiesIdentifier && !supported.pipelinePropertiesIdentifier) {
                    ss << "VkPhysicalDevicePipelinePropertiesFeaturesEXT::pipelinePropertiesIdentifier is not supported\n";
                }
                break;
            }
            case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PIPELINE_PROTECTED_ACCESS_FEATURES: {
                VkPhysicalDevicePipelineProtectedAccessFeatures supported = vku::InitStructHelper();
                features_2.pNext = &supported;
                DispatchGetPhysicalDeviceFeatures2(gpu, &features_2);
                const VkPhysicalDevicePipelineProtectedAccessFeatures* enabling =
                    reinterpret_cast<const VkPhysicalDevicePipelineProtectedAccessFeatures*>(current);
                if (enabling->pipelineProtectedAccess && !supported.pipelineProtectedAccess) {
                    ss << "VkPhysicalDevicePipelineProtectedAccessFeatures::pipelineProtectedAccess is not supported\n";
                }
                break;
            }
            case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PIPELINE_ROBUSTNESS_FEATURES: {
                VkPhysicalDevicePipelineRobustnessFeatures supported = vku::InitStructHelper();
                features_2.pNext = &supported;
                DispatchGetPhysicalDeviceFeatures2(gpu, &features_2);
                const VkPhysicalDevicePipelineRobustnessFeatures* enabling =
                    reinterpret_cast<const VkPhysicalDevicePipelineRobustnessFeatures*>(current);
                if (enabling->pipelineRobustness && !supported.pipelineRobustness) {
                    ss << "VkPhysicalDevicePipelineRobustnessFeatures::pipelineRobustness is not supported\n";
                }
                break;
            }
#ifdef VK_ENABLE_BETA_EXTENSIONS
            case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PORTABILITY_SUBSET_FEATURES_KHR: {
                VkPhysicalDevicePortabilitySubsetFeaturesKHR supported = vku::InitStructHelper();
                features_2.pNext = &supported;
                DispatchGetPhysicalDeviceFeatures2(gpu, &features_2);
                const VkPhysicalDevicePortabilitySubsetFeaturesKHR* enabling =
                    reinterpret_cast<const VkPhysicalDevicePortabilitySubsetFeaturesKHR*>(current);
                if (enabling->constantAlphaColorBlendFactors && !supported.constantAlphaColorBlendFactors) {
                    ss << "VkPhysicalDevicePortabilitySubsetFeaturesKHR::constantAlphaColorBlendFactors is not supported\n";
                }
                if (enabling->events && !supported.events) {
                    ss << "VkPhysicalDevicePortabilitySubsetFeaturesKHR::events is not supported\n";
                }
                if (enabling->imageViewFormatReinterpretation && !supported.imageViewFormatReinterpretation) {
                    ss << "VkPhysicalDevicePortabilitySubsetFeaturesKHR::imageViewFormatReinterpretation is not supported\n";
                }
                if (enabling->imageViewFormatSwizzle && !supported.imageViewFormatSwizzle) {
                    ss << "VkPhysicalDevicePortabilitySubsetFeaturesKHR::imageViewFormatSwizzle is not supported\n";
                }
                if (enabling->imageView2DOn3DImage && !supported.imageView2DOn3DImage) {
                    ss << "VkPhysicalDevicePortabilitySubsetFeaturesKHR::imageView2DOn3DImage is not supported\n";
                }
                if (enabling->multisampleArrayImage && !supported.multisampleArrayImage) {
                    ss << "VkPhysicalDevicePortabilitySubsetFeaturesKHR::multisampleArrayImage is not supported\n";
                }
                if (enabling->mutableComparisonSamplers && !supported.mutableComparisonSamplers) {
                    ss << "VkPhysicalDevicePortabilitySubsetFeaturesKHR::mutableComparisonSamplers is not supported\n";
                }
                if (enabling->pointPolygons && !supported.pointPolygons) {
                    ss << "VkPhysicalDevicePortabilitySubsetFeaturesKHR::pointPolygons is not supported\n";
                }
                if (enabling->samplerMipLodBias && !supported.samplerMipLodBias) {
                    ss << "VkPhysicalDevicePortabilitySubsetFeaturesKHR::samplerMipLodBias is not supported\n";
                }
                if (enabling->separateStencilMaskRef && !supported.separateStencilMaskRef) {
                    ss << "VkPhysicalDevicePortabilitySubsetFeaturesKHR::separateStencilMaskRef is not supported\n";
                }
                if (enabling->shaderSampleRateInterpolationFunctions && !supported.shaderSampleRateInterpolationFunctions) {
                    ss << "VkPhysicalDevicePortabilitySubsetFeaturesKHR::shaderSampleRateInterpolationFunctions is not supported\n";
                }
                if (enabling->tessellationIsolines && !supported.tessellationIsolines) {
                    ss << "VkPhysicalDevicePortabilitySubsetFeaturesKHR::tessellationIsolines is not supported\n";
                }
                if (enabling->tessellationPointMode && !supported.tessellationPointMode) {
                    ss << "VkPhysicalDevicePortabilitySubsetFeaturesKHR::tessellationPointMode is not supported\n";
                }
                if (enabling->triangleFans && !supported.triangleFans) {
                    ss << "VkPhysicalDevicePortabilitySubsetFeaturesKHR::triangleFans is not supported\n";
                }
                if (enabling->vertexAttributeAccessBeyondStride && !supported.vertexAttributeAccessBeyondStride) {
                    ss << "VkPhysicalDevicePortabilitySubsetFeaturesKHR::vertexAttributeAccessBeyondStride is not supported\n";
                }
                break;
            }
#endif  // VK_ENABLE_BETA_EXTENSIONS
            case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PRESENT_BARRIER_FEATURES_NV: {
                VkPhysicalDevicePresentBarrierFeaturesNV supported = vku::InitStructHelper();
                features_2.pNext = &supported;
                DispatchGetPhysicalDeviceFeatures2(gpu, &features_2);
                const VkPhysicalDevicePresentBarrierFeaturesNV* enabling =
                    reinterpret_cast<const VkPhysicalDevicePresentBarrierFeaturesNV*>(current);
                if (enabling->presentBarrier && !supported.presentBarrier) {
                    ss << "VkPhysicalDevicePresentBarrierFeaturesNV::presentBarrier is not supported\n";
                }
                break;
            }
            case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PRESENT_ID_2_FEATURES_KHR: {
                VkPhysicalDevicePresentId2FeaturesKHR supported = vku::InitStructHelper();
                features_2.pNext = &supported;
                DispatchGetPhysicalDeviceFeatures2(gpu, &features_2);
                const VkPhysicalDevicePresentId2FeaturesKHR* enabling =
                    reinterpret_cast<const VkPhysicalDevicePresentId2FeaturesKHR*>(current);
                if (enabling->presentId2 && !supported.presentId2) {
                    ss << "VkPhysicalDevicePresentId2FeaturesKHR::presentId2 is not supported\n";
                }
                break;
            }
            case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PRESENT_ID_FEATURES_KHR: {
                VkPhysicalDevicePresentIdFeaturesKHR supported = vku::InitStructHelper();
                features_2.pNext = &supported;
                DispatchGetPhysicalDeviceFeatures2(gpu, &features_2);
                const VkPhysicalDevicePresentIdFeaturesKHR* enabling =
                    reinterpret_cast<const VkPhysicalDevicePresentIdFeaturesKHR*>(current);
                if (enabling->presentId && !supported.presentId) {
                    ss << "VkPhysicalDevicePresentIdFeaturesKHR::presentId is not supported\n";
                }
                break;
            }
            case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PRESENT_METERING_FEATURES_NV: {
                VkPhysicalDevicePresentMeteringFeaturesNV supported = vku::InitStructHelper();
                features_2.pNext = &supported;
                DispatchGetPhysicalDeviceFeatures2(gpu, &features_2);
                const VkPhysicalDevicePresentMeteringFeaturesNV* enabling =
                    reinterpret_cast<const VkPhysicalDevicePresentMeteringFeaturesNV*>(current);
                if (enabling->presentMetering && !supported.presentMetering) {
                    ss << "VkPhysicalDevicePresentMeteringFeaturesNV::presentMetering is not supported\n";
                }
                break;
            }
            case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PRESENT_MODE_FIFO_LATEST_READY_FEATURES_KHR: {
                VkPhysicalDevicePresentModeFifoLatestReadyFeaturesKHR supported = vku::InitStructHelper();
                features_2.pNext = &supported;
                DispatchGetPhysicalDeviceFeatures2(gpu, &features_2);
                const VkPhysicalDevicePresentModeFifoLatestReadyFeaturesKHR* enabling =
                    reinterpret_cast<const VkPhysicalDevicePresentModeFifoLatestReadyFeaturesKHR*>(current);
                if (enabling->presentModeFifoLatestReady && !supported.presentModeFifoLatestReady) {
                    ss << "VkPhysicalDevicePresentModeFifoLatestReadyFeaturesKHR::presentModeFifoLatestReady is not supported\n";
                }
                break;
            }
            case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PRESENT_TIMING_FEATURES_EXT: {
                VkPhysicalDevicePresentTimingFeaturesEXT supported = vku::InitStructHelper();
                features_2.pNext = &supported;
                DispatchGetPhysicalDeviceFeatures2(gpu, &features_2);
                const VkPhysicalDevicePresentTimingFeaturesEXT* enabling =
                    reinterpret_cast<const VkPhysicalDevicePresentTimingFeaturesEXT*>(current);
                if (enabling->presentTiming && !supported.presentTiming) {
                    ss << "VkPhysicalDevicePresentTimingFeaturesEXT::presentTiming is not supported\n";
                }
                if (enabling->presentAtAbsoluteTime && !supported.presentAtAbsoluteTime) {
                    ss << "VkPhysicalDevicePresentTimingFeaturesEXT::presentAtAbsoluteTime is not supported\n";
                }
                if (enabling->presentAtRelativeTime && !supported.presentAtRelativeTime) {
                    ss << "VkPhysicalDevicePresentTimingFeaturesEXT::presentAtRelativeTime is not supported\n";
                }
                break;
            }
            case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PRESENT_WAIT_2_FEATURES_KHR: {
                VkPhysicalDevicePresentWait2FeaturesKHR supported = vku::InitStructHelper();
                features_2.pNext = &supported;
                DispatchGetPhysicalDeviceFeatures2(gpu, &features_2);
                const VkPhysicalDevicePresentWait2FeaturesKHR* enabling =
                    reinterpret_cast<const VkPhysicalDevicePresentWait2FeaturesKHR*>(current);
                if (enabling->presentWait2 && !supported.presentWait2) {
                    ss << "VkPhysicalDevicePresentWait2FeaturesKHR::presentWait2 is not supported\n";
                }
                break;
            }
            case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PRESENT_WAIT_FEATURES_KHR: {
                VkPhysicalDevicePresentWaitFeaturesKHR supported = vku::InitStructHelper();
                features_2.pNext = &supported;
                DispatchGetPhysicalDeviceFeatures2(gpu, &features_2);
                const VkPhysicalDevicePresentWaitFeaturesKHR* enabling =
                    reinterpret_cast<const VkPhysicalDevicePresentWaitFeaturesKHR*>(current);
                if (enabling->presentWait && !supported.presentWait) {
                    ss << "VkPhysicalDevicePresentWaitFeaturesKHR::presentWait is not supported\n";
                }
                break;
            }
            case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PRIMITIVE_RESTART_INDEX_FEATURES_EXT: {
                VkPhysicalDevicePrimitiveRestartIndexFeaturesEXT supported = vku::InitStructHelper();
                features_2.pNext = &supported;
                DispatchGetPhysicalDeviceFeatures2(gpu, &features_2);
                const VkPhysicalDevicePrimitiveRestartIndexFeaturesEXT* enabling =
                    reinterpret_cast<const VkPhysicalDevicePrimitiveRestartIndexFeaturesEXT*>(current);
                if (enabling->primitiveRestartIndex && !supported.primitiveRestartIndex) {
                    ss << "VkPhysicalDevicePrimitiveRestartIndexFeaturesEXT::primitiveRestartIndex is not supported\n";
                }
                break;
            }
            case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PRIMITIVE_TOPOLOGY_LIST_RESTART_FEATURES_EXT: {
                VkPhysicalDevicePrimitiveTopologyListRestartFeaturesEXT supported = vku::InitStructHelper();
                features_2.pNext = &supported;
                DispatchGetPhysicalDeviceFeatures2(gpu, &features_2);
                const VkPhysicalDevicePrimitiveTopologyListRestartFeaturesEXT* enabling =
                    reinterpret_cast<const VkPhysicalDevicePrimitiveTopologyListRestartFeaturesEXT*>(current);
                if (enabling->primitiveTopologyListRestart && !supported.primitiveTopologyListRestart) {
                    ss << "VkPhysicalDevicePrimitiveTopologyListRestartFeaturesEXT::primitiveTopologyListRestart is not "
                          "supported\n";
                }
                if (enabling->primitiveTopologyPatchListRestart && !supported.primitiveTopologyPatchListRestart) {
                    ss << "VkPhysicalDevicePrimitiveTopologyListRestartFeaturesEXT::primitiveTopologyPatchListRestart is not "
                          "supported\n";
                }
                break;
            }
            case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PRIMITIVES_GENERATED_QUERY_FEATURES_EXT: {
                VkPhysicalDevicePrimitivesGeneratedQueryFeaturesEXT supported = vku::InitStructHelper();
                features_2.pNext = &supported;
                DispatchGetPhysicalDeviceFeatures2(gpu, &features_2);
                const VkPhysicalDevicePrimitivesGeneratedQueryFeaturesEXT* enabling =
                    reinterpret_cast<const VkPhysicalDevicePrimitivesGeneratedQueryFeaturesEXT*>(current);
                if (enabling->primitivesGeneratedQuery && !supported.primitivesGeneratedQuery) {
                    ss << "VkPhysicalDevicePrimitivesGeneratedQueryFeaturesEXT::primitivesGeneratedQuery is not supported\n";
                }
                if (enabling->primitivesGeneratedQueryWithRasterizerDiscard &&
                    !supported.primitivesGeneratedQueryWithRasterizerDiscard) {
                    ss << "VkPhysicalDevicePrimitivesGeneratedQueryFeaturesEXT::primitivesGeneratedQueryWithRasterizerDiscard is "
                          "not supported\n";
                }
                if (enabling->primitivesGeneratedQueryWithNonZeroStreams && !supported.primitivesGeneratedQueryWithNonZeroStreams) {
                    ss << "VkPhysicalDevicePrimitivesGeneratedQueryFeaturesEXT::primitivesGeneratedQueryWithNonZeroStreams is not "
                          "supported\n";
                }
                break;
            }
            case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PRIVATE_DATA_FEATURES: {
                VkPhysicalDevicePrivateDataFeatures supported = vku::InitStructHelper();
                features_2.pNext = &supported;
                DispatchGetPhysicalDeviceFeatures2(gpu, &features_2);
                const VkPhysicalDevicePrivateDataFeatures* enabling =
                    reinterpret_cast<const VkPhysicalDevicePrivateDataFeatures*>(current);
                if (enabling->privateData && !supported.privateData) {
                    ss << "VkPhysicalDevicePrivateDataFeatures::privateData is not supported\n";
                }
                break;
            }
            case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PROTECTED_MEMORY_FEATURES: {
                VkPhysicalDeviceProtectedMemoryFeatures supported = vku::InitStructHelper();
                features_2.pNext = &supported;
                DispatchGetPhysicalDeviceFeatures2(gpu, &features_2);
                const VkPhysicalDeviceProtectedMemoryFeatures* enabling =
                    reinterpret_cast<const VkPhysicalDeviceProtectedMemoryFeatures*>(current);
                if (enabling->protectedMemory && !supported.protectedMemory) {
                    ss << "VkPhysicalDeviceProtectedMemoryFeatures::protectedMemory is not supported\n";
                }
                break;
            }
            case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PROVOKING_VERTEX_FEATURES_EXT: {
                VkPhysicalDeviceProvokingVertexFeaturesEXT supported = vku::InitStructHelper();
                features_2.pNext = &supported;
                DispatchGetPhysicalDeviceFeatures2(gpu, &features_2);
                const VkPhysicalDeviceProvokingVertexFeaturesEXT* enabling =
                    reinterpret_cast<const VkPhysicalDeviceProvokingVertexFeaturesEXT*>(current);
                if (enabling->provokingVertexLast && !supported.provokingVertexLast) {
                    ss << "VkPhysicalDeviceProvokingVertexFeaturesEXT::provokingVertexLast is not supported\n";
                }
                if (enabling->transformFeedbackPreservesProvokingVertex && !supported.transformFeedbackPreservesProvokingVertex) {
                    ss << "VkPhysicalDeviceProvokingVertexFeaturesEXT::transformFeedbackPreservesProvokingVertex is not "
                          "supported\n";
                }
                break;
            }
            case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PUSH_CONSTANT_BANK_FEATURES_NV: {
                VkPhysicalDevicePushConstantBankFeaturesNV supported = vku::InitStructHelper();
                features_2.pNext = &supported;
                DispatchGetPhysicalDeviceFeatures2(gpu, &features_2);
                const VkPhysicalDevicePushConstantBankFeaturesNV* enabling =
                    reinterpret_cast<const VkPhysicalDevicePushConstantBankFeaturesNV*>(current);
                if (enabling->pushConstantBank && !supported.pushConstantBank) {
                    ss << "VkPhysicalDevicePushConstantBankFeaturesNV::pushConstantBank is not supported\n";
                }
                break;
            }
            case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_QUEUE_PERF_HINT_FEATURES_QCOM: {
                VkPhysicalDeviceQueuePerfHintFeaturesQCOM supported = vku::InitStructHelper();
                features_2.pNext = &supported;
                DispatchGetPhysicalDeviceFeatures2(gpu, &features_2);
                const VkPhysicalDeviceQueuePerfHintFeaturesQCOM* enabling =
                    reinterpret_cast<const VkPhysicalDeviceQueuePerfHintFeaturesQCOM*>(current);
                if (enabling->queuePerfHint && !supported.queuePerfHint) {
                    ss << "VkPhysicalDeviceQueuePerfHintFeaturesQCOM::queuePerfHint is not supported\n";
                }
                break;
            }
            case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RGBA10X6_FORMATS_FEATURES_EXT: {
                VkPhysicalDeviceRGBA10X6FormatsFeaturesEXT supported = vku::InitStructHelper();
                features_2.pNext = &supported;
                DispatchGetPhysicalDeviceFeatures2(gpu, &features_2);
                const VkPhysicalDeviceRGBA10X6FormatsFeaturesEXT* enabling =
                    reinterpret_cast<const VkPhysicalDeviceRGBA10X6FormatsFeaturesEXT*>(current);
                if (enabling->formatRgba10x6WithoutYCbCrSampler && !supported.formatRgba10x6WithoutYCbCrSampler) {
                    ss << "VkPhysicalDeviceRGBA10X6FormatsFeaturesEXT::formatRgba10x6WithoutYCbCrSampler is not supported\n";
                }
                break;
            }
            case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RASTERIZATION_ORDER_ATTACHMENT_ACCESS_FEATURES_EXT: {
                VkPhysicalDeviceRasterizationOrderAttachmentAccessFeaturesEXT supported = vku::InitStructHelper();
                features_2.pNext = &supported;
                DispatchGetPhysicalDeviceFeatures2(gpu, &features_2);
                const VkPhysicalDeviceRasterizationOrderAttachmentAccessFeaturesEXT* enabling =
                    reinterpret_cast<const VkPhysicalDeviceRasterizationOrderAttachmentAccessFeaturesEXT*>(current);
                if (enabling->rasterizationOrderColorAttachmentAccess && !supported.rasterizationOrderColorAttachmentAccess) {
                    ss << "VkPhysicalDeviceRasterizationOrderAttachmentAccessFeaturesEXT::rasterizationOrderColorAttachmentAccess "
                          "is not supported\n";
                }
                if (enabling->rasterizationOrderDepthAttachmentAccess && !supported.rasterizationOrderDepthAttachmentAccess) {
                    ss << "VkPhysicalDeviceRasterizationOrderAttachmentAccessFeaturesEXT::rasterizationOrderDepthAttachmentAccess "
                          "is not supported\n";
                }
                if (enabling->rasterizationOrderStencilAttachmentAccess && !supported.rasterizationOrderStencilAttachmentAccess) {
                    ss << "VkPhysicalDeviceRasterizationOrderAttachmentAccessFeaturesEXT::"
                          "rasterizationOrderStencilAttachmentAccess is not supported\n";
                }
                break;
            }
            case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RAW_ACCESS_CHAINS_FEATURES_NV: {
                VkPhysicalDeviceRawAccessChainsFeaturesNV supported = vku::InitStructHelper();
                features_2.pNext = &supported;
                DispatchGetPhysicalDeviceFeatures2(gpu, &features_2);
                const VkPhysicalDeviceRawAccessChainsFeaturesNV* enabling =
                    reinterpret_cast<const VkPhysicalDeviceRawAccessChainsFeaturesNV*>(current);
                if (enabling->shaderRawAccessChains && !supported.shaderRawAccessChains) {
                    ss << "VkPhysicalDeviceRawAccessChainsFeaturesNV::shaderRawAccessChains is not supported\n";
                }
                break;
            }
            case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RAY_QUERY_FEATURES_KHR: {
                VkPhysicalDeviceRayQueryFeaturesKHR supported = vku::InitStructHelper();
                features_2.pNext = &supported;
                DispatchGetPhysicalDeviceFeatures2(gpu, &features_2);
                const VkPhysicalDeviceRayQueryFeaturesKHR* enabling =
                    reinterpret_cast<const VkPhysicalDeviceRayQueryFeaturesKHR*>(current);
                if (enabling->rayQuery && !supported.rayQuery) {
                    ss << "VkPhysicalDeviceRayQueryFeaturesKHR::rayQuery is not supported\n";
                }
                break;
            }
            case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RAY_TRACING_INVOCATION_REORDER_FEATURES_EXT: {
                VkPhysicalDeviceRayTracingInvocationReorderFeaturesEXT supported = vku::InitStructHelper();
                features_2.pNext = &supported;
                DispatchGetPhysicalDeviceFeatures2(gpu, &features_2);
                const VkPhysicalDeviceRayTracingInvocationReorderFeaturesEXT* enabling =
                    reinterpret_cast<const VkPhysicalDeviceRayTracingInvocationReorderFeaturesEXT*>(current);
                if (enabling->rayTracingInvocationReorder && !supported.rayTracingInvocationReorder) {
                    ss << "VkPhysicalDeviceRayTracingInvocationReorderFeaturesEXT::rayTracingInvocationReorder is not supported\n";
                }
                break;
            }
            case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RAY_TRACING_INVOCATION_REORDER_FEATURES_NV: {
                VkPhysicalDeviceRayTracingInvocationReorderFeaturesNV supported = vku::InitStructHelper();
                features_2.pNext = &supported;
                DispatchGetPhysicalDeviceFeatures2(gpu, &features_2);
                const VkPhysicalDeviceRayTracingInvocationReorderFeaturesNV* enabling =
                    reinterpret_cast<const VkPhysicalDeviceRayTracingInvocationReorderFeaturesNV*>(current);
                if (enabling->rayTracingInvocationReorder && !supported.rayTracingInvocationReorder) {
                    ss << "VkPhysicalDeviceRayTracingInvocationReorderFeaturesNV::rayTracingInvocationReorder is not supported\n";
                }
                break;
            }
            case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RAY_TRACING_LINEAR_SWEPT_SPHERES_FEATURES_NV: {
                VkPhysicalDeviceRayTracingLinearSweptSpheresFeaturesNV supported = vku::InitStructHelper();
                features_2.pNext = &supported;
                DispatchGetPhysicalDeviceFeatures2(gpu, &features_2);
                const VkPhysicalDeviceRayTracingLinearSweptSpheresFeaturesNV* enabling =
                    reinterpret_cast<const VkPhysicalDeviceRayTracingLinearSweptSpheresFeaturesNV*>(current);
                if (enabling->spheres && !supported.spheres) {
                    ss << "VkPhysicalDeviceRayTracingLinearSweptSpheresFeaturesNV::spheres is not supported\n";
                }
                if (enabling->linearSweptSpheres && !supported.linearSweptSpheres) {
                    ss << "VkPhysicalDeviceRayTracingLinearSweptSpheresFeaturesNV::linearSweptSpheres is not supported\n";
                }
                break;
            }
            case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RAY_TRACING_MAINTENANCE_1_FEATURES_KHR: {
                VkPhysicalDeviceRayTracingMaintenance1FeaturesKHR supported = vku::InitStructHelper();
                features_2.pNext = &supported;
                DispatchGetPhysicalDeviceFeatures2(gpu, &features_2);
                const VkPhysicalDeviceRayTracingMaintenance1FeaturesKHR* enabling =
                    reinterpret_cast<const VkPhysicalDeviceRayTracingMaintenance1FeaturesKHR*>(current);
                if (enabling->rayTracingMaintenance1 && !supported.rayTracingMaintenance1) {
                    ss << "VkPhysicalDeviceRayTracingMaintenance1FeaturesKHR::rayTracingMaintenance1 is not supported\n";
                }
                if (enabling->rayTracingPipelineTraceRaysIndirect2 && !supported.rayTracingPipelineTraceRaysIndirect2) {
                    ss << "VkPhysicalDeviceRayTracingMaintenance1FeaturesKHR::rayTracingPipelineTraceRaysIndirect2 is not "
                          "supported\n";
                }
                break;
            }
            case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RAY_TRACING_MOTION_BLUR_FEATURES_NV: {
                VkPhysicalDeviceRayTracingMotionBlurFeaturesNV supported = vku::InitStructHelper();
                features_2.pNext = &supported;
                DispatchGetPhysicalDeviceFeatures2(gpu, &features_2);
                const VkPhysicalDeviceRayTracingMotionBlurFeaturesNV* enabling =
                    reinterpret_cast<const VkPhysicalDeviceRayTracingMotionBlurFeaturesNV*>(current);
                if (enabling->rayTracingMotionBlur && !supported.rayTracingMotionBlur) {
                    ss << "VkPhysicalDeviceRayTracingMotionBlurFeaturesNV::rayTracingMotionBlur is not supported\n";
                }
                if (enabling->rayTracingMotionBlurPipelineTraceRaysIndirect &&
                    !supported.rayTracingMotionBlurPipelineTraceRaysIndirect) {
                    ss << "VkPhysicalDeviceRayTracingMotionBlurFeaturesNV::rayTracingMotionBlurPipelineTraceRaysIndirect is not "
                          "supported\n";
                }
                break;
            }
            case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RAY_TRACING_PIPELINE_FEATURES_KHR: {
                VkPhysicalDeviceRayTracingPipelineFeaturesKHR supported = vku::InitStructHelper();
                features_2.pNext = &supported;
                DispatchGetPhysicalDeviceFeatures2(gpu, &features_2);
                const VkPhysicalDeviceRayTracingPipelineFeaturesKHR* enabling =
                    reinterpret_cast<const VkPhysicalDeviceRayTracingPipelineFeaturesKHR*>(current);
                if (enabling->rayTracingPipeline && !supported.rayTracingPipeline) {
                    ss << "VkPhysicalDeviceRayTracingPipelineFeaturesKHR::rayTracingPipeline is not supported\n";
                }
                if (enabling->rayTracingPipelineShaderGroupHandleCaptureReplay &&
                    !supported.rayTracingPipelineShaderGroupHandleCaptureReplay) {
                    ss << "VkPhysicalDeviceRayTracingPipelineFeaturesKHR::rayTracingPipelineShaderGroupHandleCaptureReplay is not "
                          "supported\n";
                }
                if (enabling->rayTracingPipelineShaderGroupHandleCaptureReplayMixed &&
                    !supported.rayTracingPipelineShaderGroupHandleCaptureReplayMixed) {
                    ss << "VkPhysicalDeviceRayTracingPipelineFeaturesKHR::rayTracingPipelineShaderGroupHandleCaptureReplayMixed is "
                          "not supported\n";
                }
                if (enabling->rayTracingPipelineTraceRaysIndirect && !supported.rayTracingPipelineTraceRaysIndirect) {
                    ss << "VkPhysicalDeviceRayTracingPipelineFeaturesKHR::rayTracingPipelineTraceRaysIndirect is not supported\n";
                }
                if (enabling->rayTraversalPrimitiveCulling && !supported.rayTraversalPrimitiveCulling) {
                    ss << "VkPhysicalDeviceRayTracingPipelineFeaturesKHR::rayTraversalPrimitiveCulling is not supported\n";
                }
                break;
            }
            case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RAY_TRACING_POSITION_FETCH_FEATURES_KHR: {
                VkPhysicalDeviceRayTracingPositionFetchFeaturesKHR supported = vku::InitStructHelper();
                features_2.pNext = &supported;
                DispatchGetPhysicalDeviceFeatures2(gpu, &features_2);
                const VkPhysicalDeviceRayTracingPositionFetchFeaturesKHR* enabling =
                    reinterpret_cast<const VkPhysicalDeviceRayTracingPositionFetchFeaturesKHR*>(current);
                if (enabling->rayTracingPositionFetch && !supported.rayTracingPositionFetch) {
                    ss << "VkPhysicalDeviceRayTracingPositionFetchFeaturesKHR::rayTracingPositionFetch is not supported\n";
                }
                break;
            }
            case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RAY_TRACING_VALIDATION_FEATURES_NV: {
                VkPhysicalDeviceRayTracingValidationFeaturesNV supported = vku::InitStructHelper();
                features_2.pNext = &supported;
                DispatchGetPhysicalDeviceFeatures2(gpu, &features_2);
                const VkPhysicalDeviceRayTracingValidationFeaturesNV* enabling =
                    reinterpret_cast<const VkPhysicalDeviceRayTracingValidationFeaturesNV*>(current);
                if (enabling->rayTracingValidation && !supported.rayTracingValidation) {
                    ss << "VkPhysicalDeviceRayTracingValidationFeaturesNV::rayTracingValidation is not supported\n";
                }
                break;
            }
            case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RELAXED_LINE_RASTERIZATION_FEATURES_IMG: {
                VkPhysicalDeviceRelaxedLineRasterizationFeaturesIMG supported = vku::InitStructHelper();
                features_2.pNext = &supported;
                DispatchGetPhysicalDeviceFeatures2(gpu, &features_2);
                const VkPhysicalDeviceRelaxedLineRasterizationFeaturesIMG* enabling =
                    reinterpret_cast<const VkPhysicalDeviceRelaxedLineRasterizationFeaturesIMG*>(current);
                if (enabling->relaxedLineRasterization && !supported.relaxedLineRasterization) {
                    ss << "VkPhysicalDeviceRelaxedLineRasterizationFeaturesIMG::relaxedLineRasterization is not supported\n";
                }
                break;
            }
            case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RENDER_PASS_STRIPED_FEATURES_ARM: {
                VkPhysicalDeviceRenderPassStripedFeaturesARM supported = vku::InitStructHelper();
                features_2.pNext = &supported;
                DispatchGetPhysicalDeviceFeatures2(gpu, &features_2);
                const VkPhysicalDeviceRenderPassStripedFeaturesARM* enabling =
                    reinterpret_cast<const VkPhysicalDeviceRenderPassStripedFeaturesARM*>(current);
                if (enabling->renderPassStriped && !supported.renderPassStriped) {
                    ss << "VkPhysicalDeviceRenderPassStripedFeaturesARM::renderPassStriped is not supported\n";
                }
                break;
            }
            case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_REPRESENTATIVE_FRAGMENT_TEST_FEATURES_NV: {
                VkPhysicalDeviceRepresentativeFragmentTestFeaturesNV supported = vku::InitStructHelper();
                features_2.pNext = &supported;
                DispatchGetPhysicalDeviceFeatures2(gpu, &features_2);
                const VkPhysicalDeviceRepresentativeFragmentTestFeaturesNV* enabling =
                    reinterpret_cast<const VkPhysicalDeviceRepresentativeFragmentTestFeaturesNV*>(current);
                if (enabling->representativeFragmentTest && !supported.representativeFragmentTest) {
                    ss << "VkPhysicalDeviceRepresentativeFragmentTestFeaturesNV::representativeFragmentTest is not supported\n";
                }
                break;
            }
            case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ROBUSTNESS_2_FEATURES_KHR: {
                VkPhysicalDeviceRobustness2FeaturesKHR supported = vku::InitStructHelper();
                features_2.pNext = &supported;
                DispatchGetPhysicalDeviceFeatures2(gpu, &features_2);
                const VkPhysicalDeviceRobustness2FeaturesKHR* enabling =
                    reinterpret_cast<const VkPhysicalDeviceRobustness2FeaturesKHR*>(current);
                if (enabling->robustBufferAccess2 && !supported.robustBufferAccess2) {
                    ss << "VkPhysicalDeviceRobustness2FeaturesKHR::robustBufferAccess2 is not supported\n";
                }
                if (enabling->robustImageAccess2 && !supported.robustImageAccess2) {
                    ss << "VkPhysicalDeviceRobustness2FeaturesKHR::robustImageAccess2 is not supported\n";
                }
                if (enabling->nullDescriptor && !supported.nullDescriptor) {
                    ss << "VkPhysicalDeviceRobustness2FeaturesKHR::nullDescriptor is not supported\n";
                }
                break;
            }
            case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SAMPLER_YCBCR_CONVERSION_FEATURES: {
                VkPhysicalDeviceSamplerYcbcrConversionFeatures supported = vku::InitStructHelper();
                features_2.pNext = &supported;
                DispatchGetPhysicalDeviceFeatures2(gpu, &features_2);
                const VkPhysicalDeviceSamplerYcbcrConversionFeatures* enabling =
                    reinterpret_cast<const VkPhysicalDeviceSamplerYcbcrConversionFeatures*>(current);
                if (enabling->samplerYcbcrConversion && !supported.samplerYcbcrConversion) {
                    ss << "VkPhysicalDeviceSamplerYcbcrConversionFeatures::samplerYcbcrConversion is not supported\n";
                }
                break;
            }
            case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SCALAR_BLOCK_LAYOUT_FEATURES: {
                VkPhysicalDeviceScalarBlockLayoutFeatures supported = vku::InitStructHelper();
                features_2.pNext = &supported;
                DispatchGetPhysicalDeviceFeatures2(gpu, &features_2);
                const VkPhysicalDeviceScalarBlockLayoutFeatures* enabling =
                    reinterpret_cast<const VkPhysicalDeviceScalarBlockLayoutFeatures*>(current);
                if (enabling->scalarBlockLayout && !supported.scalarBlockLayout) {
                    ss << "VkPhysicalDeviceScalarBlockLayoutFeatures::scalarBlockLayout is not supported\n";
                }
                break;
            }
            case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SCHEDULING_CONTROLS_FEATURES_ARM: {
                VkPhysicalDeviceSchedulingControlsFeaturesARM supported = vku::InitStructHelper();
                features_2.pNext = &supported;
                DispatchGetPhysicalDeviceFeatures2(gpu, &features_2);
                const VkPhysicalDeviceSchedulingControlsFeaturesARM* enabling =
                    reinterpret_cast<const VkPhysicalDeviceSchedulingControlsFeaturesARM*>(current);
                if (enabling->schedulingControls && !supported.schedulingControls) {
                    ss << "VkPhysicalDeviceSchedulingControlsFeaturesARM::schedulingControls is not supported\n";
                }
                break;
            }
            case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SEPARATE_DEPTH_STENCIL_LAYOUTS_FEATURES: {
                VkPhysicalDeviceSeparateDepthStencilLayoutsFeatures supported = vku::InitStructHelper();
                features_2.pNext = &supported;
                DispatchGetPhysicalDeviceFeatures2(gpu, &features_2);
                const VkPhysicalDeviceSeparateDepthStencilLayoutsFeatures* enabling =
                    reinterpret_cast<const VkPhysicalDeviceSeparateDepthStencilLayoutsFeatures*>(current);
                if (enabling->separateDepthStencilLayouts && !supported.separateDepthStencilLayouts) {
                    ss << "VkPhysicalDeviceSeparateDepthStencilLayoutsFeatures::separateDepthStencilLayouts is not supported\n";
                }
                break;
            }
            case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_64_BIT_INDEXING_FEATURES_EXT: {
                VkPhysicalDeviceShader64BitIndexingFeaturesEXT supported = vku::InitStructHelper();
                features_2.pNext = &supported;
                DispatchGetPhysicalDeviceFeatures2(gpu, &features_2);
                const VkPhysicalDeviceShader64BitIndexingFeaturesEXT* enabling =
                    reinterpret_cast<const VkPhysicalDeviceShader64BitIndexingFeaturesEXT*>(current);
                if (enabling->shader64BitIndexing && !supported.shader64BitIndexing) {
                    ss << "VkPhysicalDeviceShader64BitIndexingFeaturesEXT::shader64BitIndexing is not supported\n";
                }
                break;
            }
            case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_ABORT_FEATURES_KHR: {
                VkPhysicalDeviceShaderAbortFeaturesKHR supported = vku::InitStructHelper();
                features_2.pNext = &supported;
                DispatchGetPhysicalDeviceFeatures2(gpu, &features_2);
                const VkPhysicalDeviceShaderAbortFeaturesKHR* enabling =
                    reinterpret_cast<const VkPhysicalDeviceShaderAbortFeaturesKHR*>(current);
                if (enabling->shaderAbort && !supported.shaderAbort) {
                    ss << "VkPhysicalDeviceShaderAbortFeaturesKHR::shaderAbort is not supported\n";
                }
                break;
            }
            case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_ATOMIC_FLOAT16_VECTOR_FEATURES_NV: {
                VkPhysicalDeviceShaderAtomicFloat16VectorFeaturesNV supported = vku::InitStructHelper();
                features_2.pNext = &supported;
                DispatchGetPhysicalDeviceFeatures2(gpu, &features_2);
                const VkPhysicalDeviceShaderAtomicFloat16VectorFeaturesNV* enabling =
                    reinterpret_cast<const VkPhysicalDeviceShaderAtomicFloat16VectorFeaturesNV*>(current);
                if (enabling->shaderFloat16VectorAtomics && !supported.shaderFloat16VectorAtomics) {
                    ss << "VkPhysicalDeviceShaderAtomicFloat16VectorFeaturesNV::shaderFloat16VectorAtomics is not supported\n";
                }
                break;
            }
            case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_ATOMIC_FLOAT_2_FEATURES_EXT: {
                VkPhysicalDeviceShaderAtomicFloat2FeaturesEXT supported = vku::InitStructHelper();
                features_2.pNext = &supported;
                DispatchGetPhysicalDeviceFeatures2(gpu, &features_2);
                const VkPhysicalDeviceShaderAtomicFloat2FeaturesEXT* enabling =
                    reinterpret_cast<const VkPhysicalDeviceShaderAtomicFloat2FeaturesEXT*>(current);
                if (enabling->shaderBufferFloat16Atomics && !supported.shaderBufferFloat16Atomics) {
                    ss << "VkPhysicalDeviceShaderAtomicFloat2FeaturesEXT::shaderBufferFloat16Atomics is not supported\n";
                }
                if (enabling->shaderBufferFloat16AtomicAdd && !supported.shaderBufferFloat16AtomicAdd) {
                    ss << "VkPhysicalDeviceShaderAtomicFloat2FeaturesEXT::shaderBufferFloat16AtomicAdd is not supported\n";
                }
                if (enabling->shaderBufferFloat16AtomicMinMax && !supported.shaderBufferFloat16AtomicMinMax) {
                    ss << "VkPhysicalDeviceShaderAtomicFloat2FeaturesEXT::shaderBufferFloat16AtomicMinMax is not supported\n";
                }
                if (enabling->shaderBufferFloat32AtomicMinMax && !supported.shaderBufferFloat32AtomicMinMax) {
                    ss << "VkPhysicalDeviceShaderAtomicFloat2FeaturesEXT::shaderBufferFloat32AtomicMinMax is not supported\n";
                }
                if (enabling->shaderBufferFloat64AtomicMinMax && !supported.shaderBufferFloat64AtomicMinMax) {
                    ss << "VkPhysicalDeviceShaderAtomicFloat2FeaturesEXT::shaderBufferFloat64AtomicMinMax is not supported\n";
                }
                if (enabling->shaderSharedFloat16Atomics && !supported.shaderSharedFloat16Atomics) {
                    ss << "VkPhysicalDeviceShaderAtomicFloat2FeaturesEXT::shaderSharedFloat16Atomics is not supported\n";
                }
                if (enabling->shaderSharedFloat16AtomicAdd && !supported.shaderSharedFloat16AtomicAdd) {
                    ss << "VkPhysicalDeviceShaderAtomicFloat2FeaturesEXT::shaderSharedFloat16AtomicAdd is not supported\n";
                }
                if (enabling->shaderSharedFloat16AtomicMinMax && !supported.shaderSharedFloat16AtomicMinMax) {
                    ss << "VkPhysicalDeviceShaderAtomicFloat2FeaturesEXT::shaderSharedFloat16AtomicMinMax is not supported\n";
                }
                if (enabling->shaderSharedFloat32AtomicMinMax && !supported.shaderSharedFloat32AtomicMinMax) {
                    ss << "VkPhysicalDeviceShaderAtomicFloat2FeaturesEXT::shaderSharedFloat32AtomicMinMax is not supported\n";
                }
                if (enabling->shaderSharedFloat64AtomicMinMax && !supported.shaderSharedFloat64AtomicMinMax) {
                    ss << "VkPhysicalDeviceShaderAtomicFloat2FeaturesEXT::shaderSharedFloat64AtomicMinMax is not supported\n";
                }
                if (enabling->shaderImageFloat32AtomicMinMax && !supported.shaderImageFloat32AtomicMinMax) {
                    ss << "VkPhysicalDeviceShaderAtomicFloat2FeaturesEXT::shaderImageFloat32AtomicMinMax is not supported\n";
                }
                if (enabling->sparseImageFloat32AtomicMinMax && !supported.sparseImageFloat32AtomicMinMax) {
                    ss << "VkPhysicalDeviceShaderAtomicFloat2FeaturesEXT::sparseImageFloat32AtomicMinMax is not supported\n";
                }
                break;
            }
            case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_ATOMIC_FLOAT_FEATURES_EXT: {
                VkPhysicalDeviceShaderAtomicFloatFeaturesEXT supported = vku::InitStructHelper();
                features_2.pNext = &supported;
                DispatchGetPhysicalDeviceFeatures2(gpu, &features_2);
                const VkPhysicalDeviceShaderAtomicFloatFeaturesEXT* enabling =
                    reinterpret_cast<const VkPhysicalDeviceShaderAtomicFloatFeaturesEXT*>(current);
                if (enabling->shaderBufferFloat32Atomics && !supported.shaderBufferFloat32Atomics) {
                    ss << "VkPhysicalDeviceShaderAtomicFloatFeaturesEXT::shaderBufferFloat32Atomics is not supported\n";
                }
                if (enabling->shaderBufferFloat32AtomicAdd && !supported.shaderBufferFloat32AtomicAdd) {
                    ss << "VkPhysicalDeviceShaderAtomicFloatFeaturesEXT::shaderBufferFloat32AtomicAdd is not supported\n";
                }
                if (enabling->shaderBufferFloat64Atomics && !supported.shaderBufferFloat64Atomics) {
                    ss << "VkPhysicalDeviceShaderAtomicFloatFeaturesEXT::shaderBufferFloat64Atomics is not supported\n";
                }
                if (enabling->shaderBufferFloat64AtomicAdd && !supported.shaderBufferFloat64AtomicAdd) {
                    ss << "VkPhysicalDeviceShaderAtomicFloatFeaturesEXT::shaderBufferFloat64AtomicAdd is not supported\n";
                }
                if (enabling->shaderSharedFloat32Atomics && !supported.shaderSharedFloat32Atomics) {
                    ss << "VkPhysicalDeviceShaderAtomicFloatFeaturesEXT::shaderSharedFloat32Atomics is not supported\n";
                }
                if (enabling->shaderSharedFloat32AtomicAdd && !supported.shaderSharedFloat32AtomicAdd) {
                    ss << "VkPhysicalDeviceShaderAtomicFloatFeaturesEXT::shaderSharedFloat32AtomicAdd is not supported\n";
                }
                if (enabling->shaderSharedFloat64Atomics && !supported.shaderSharedFloat64Atomics) {
                    ss << "VkPhysicalDeviceShaderAtomicFloatFeaturesEXT::shaderSharedFloat64Atomics is not supported\n";
                }
                if (enabling->shaderSharedFloat64AtomicAdd && !supported.shaderSharedFloat64AtomicAdd) {
                    ss << "VkPhysicalDeviceShaderAtomicFloatFeaturesEXT::shaderSharedFloat64AtomicAdd is not supported\n";
                }
                if (enabling->shaderImageFloat32Atomics && !supported.shaderImageFloat32Atomics) {
                    ss << "VkPhysicalDeviceShaderAtomicFloatFeaturesEXT::shaderImageFloat32Atomics is not supported\n";
                }
                if (enabling->shaderImageFloat32AtomicAdd && !supported.shaderImageFloat32AtomicAdd) {
                    ss << "VkPhysicalDeviceShaderAtomicFloatFeaturesEXT::shaderImageFloat32AtomicAdd is not supported\n";
                }
                if (enabling->sparseImageFloat32Atomics && !supported.sparseImageFloat32Atomics) {
                    ss << "VkPhysicalDeviceShaderAtomicFloatFeaturesEXT::sparseImageFloat32Atomics is not supported\n";
                }
                if (enabling->sparseImageFloat32AtomicAdd && !supported.sparseImageFloat32AtomicAdd) {
                    ss << "VkPhysicalDeviceShaderAtomicFloatFeaturesEXT::sparseImageFloat32AtomicAdd is not supported\n";
                }
                break;
            }
            case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_ATOMIC_INT64_FEATURES: {
                VkPhysicalDeviceShaderAtomicInt64Features supported = vku::InitStructHelper();
                features_2.pNext = &supported;
                DispatchGetPhysicalDeviceFeatures2(gpu, &features_2);
                const VkPhysicalDeviceShaderAtomicInt64Features* enabling =
                    reinterpret_cast<const VkPhysicalDeviceShaderAtomicInt64Features*>(current);
                if (enabling->shaderBufferInt64Atomics && !supported.shaderBufferInt64Atomics) {
                    ss << "VkPhysicalDeviceShaderAtomicInt64Features::shaderBufferInt64Atomics is not supported\n";
                }
                if (enabling->shaderSharedInt64Atomics && !supported.shaderSharedInt64Atomics) {
                    ss << "VkPhysicalDeviceShaderAtomicInt64Features::shaderSharedInt64Atomics is not supported\n";
                }
                break;
            }
            case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_BFLOAT16_FEATURES_KHR: {
                VkPhysicalDeviceShaderBfloat16FeaturesKHR supported = vku::InitStructHelper();
                features_2.pNext = &supported;
                DispatchGetPhysicalDeviceFeatures2(gpu, &features_2);
                const VkPhysicalDeviceShaderBfloat16FeaturesKHR* enabling =
                    reinterpret_cast<const VkPhysicalDeviceShaderBfloat16FeaturesKHR*>(current);
                if (enabling->shaderBFloat16Type && !supported.shaderBFloat16Type) {
                    ss << "VkPhysicalDeviceShaderBfloat16FeaturesKHR::shaderBFloat16Type is not supported\n";
                }
                if (enabling->shaderBFloat16DotProduct && !supported.shaderBFloat16DotProduct) {
                    ss << "VkPhysicalDeviceShaderBfloat16FeaturesKHR::shaderBFloat16DotProduct is not supported\n";
                }
                if (enabling->shaderBFloat16CooperativeMatrix && !supported.shaderBFloat16CooperativeMatrix) {
                    ss << "VkPhysicalDeviceShaderBfloat16FeaturesKHR::shaderBFloat16CooperativeMatrix is not supported\n";
                }
                break;
            }
            case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_CLOCK_FEATURES_KHR: {
                VkPhysicalDeviceShaderClockFeaturesKHR supported = vku::InitStructHelper();
                features_2.pNext = &supported;
                DispatchGetPhysicalDeviceFeatures2(gpu, &features_2);
                const VkPhysicalDeviceShaderClockFeaturesKHR* enabling =
                    reinterpret_cast<const VkPhysicalDeviceShaderClockFeaturesKHR*>(current);
                if (enabling->shaderSubgroupClock && !supported.shaderSubgroupClock) {
                    ss << "VkPhysicalDeviceShaderClockFeaturesKHR::shaderSubgroupClock is not supported\n";
                }
                if (enabling->shaderDeviceClock && !supported.shaderDeviceClock) {
                    ss << "VkPhysicalDeviceShaderClockFeaturesKHR::shaderDeviceClock is not supported\n";
                }
                break;
            }
            case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_CONSTANT_DATA_FEATURES_KHR: {
                VkPhysicalDeviceShaderConstantDataFeaturesKHR supported = vku::InitStructHelper();
                features_2.pNext = &supported;
                DispatchGetPhysicalDeviceFeatures2(gpu, &features_2);
                const VkPhysicalDeviceShaderConstantDataFeaturesKHR* enabling =
                    reinterpret_cast<const VkPhysicalDeviceShaderConstantDataFeaturesKHR*>(current);
                if (enabling->shaderConstantData && !supported.shaderConstantData) {
                    ss << "VkPhysicalDeviceShaderConstantDataFeaturesKHR::shaderConstantData is not supported\n";
                }
                break;
            }
            case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_CORE_BUILTINS_FEATURES_ARM: {
                VkPhysicalDeviceShaderCoreBuiltinsFeaturesARM supported = vku::InitStructHelper();
                features_2.pNext = &supported;
                DispatchGetPhysicalDeviceFeatures2(gpu, &features_2);
                const VkPhysicalDeviceShaderCoreBuiltinsFeaturesARM* enabling =
                    reinterpret_cast<const VkPhysicalDeviceShaderCoreBuiltinsFeaturesARM*>(current);
                if (enabling->shaderCoreBuiltins && !supported.shaderCoreBuiltins) {
                    ss << "VkPhysicalDeviceShaderCoreBuiltinsFeaturesARM::shaderCoreBuiltins is not supported\n";
                }
                break;
            }
            case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_DEMOTE_TO_HELPER_INVOCATION_FEATURES: {
                VkPhysicalDeviceShaderDemoteToHelperInvocationFeatures supported = vku::InitStructHelper();
                features_2.pNext = &supported;
                DispatchGetPhysicalDeviceFeatures2(gpu, &features_2);
                const VkPhysicalDeviceShaderDemoteToHelperInvocationFeatures* enabling =
                    reinterpret_cast<const VkPhysicalDeviceShaderDemoteToHelperInvocationFeatures*>(current);
                if (enabling->shaderDemoteToHelperInvocation && !supported.shaderDemoteToHelperInvocation) {
                    ss << "VkPhysicalDeviceShaderDemoteToHelperInvocationFeatures::shaderDemoteToHelperInvocation is not "
                          "supported\n";
                }
                break;
            }
            case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_DRAW_PARAMETERS_FEATURES: {
                VkPhysicalDeviceShaderDrawParametersFeatures supported = vku::InitStructHelper();
                features_2.pNext = &supported;
                DispatchGetPhysicalDeviceFeatures2(gpu, &features_2);
                const VkPhysicalDeviceShaderDrawParametersFeatures* enabling =
                    reinterpret_cast<const VkPhysicalDeviceShaderDrawParametersFeatures*>(current);
                if (enabling->shaderDrawParameters && !supported.shaderDrawParameters) {
                    ss << "VkPhysicalDeviceShaderDrawParametersFeatures::shaderDrawParameters is not supported\n";
                }
                break;
            }
            case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_EARLY_AND_LATE_FRAGMENT_TESTS_FEATURES_AMD: {
                VkPhysicalDeviceShaderEarlyAndLateFragmentTestsFeaturesAMD supported = vku::InitStructHelper();
                features_2.pNext = &supported;
                DispatchGetPhysicalDeviceFeatures2(gpu, &features_2);
                const VkPhysicalDeviceShaderEarlyAndLateFragmentTestsFeaturesAMD* enabling =
                    reinterpret_cast<const VkPhysicalDeviceShaderEarlyAndLateFragmentTestsFeaturesAMD*>(current);
                if (enabling->shaderEarlyAndLateFragmentTests && !supported.shaderEarlyAndLateFragmentTests) {
                    ss << "VkPhysicalDeviceShaderEarlyAndLateFragmentTestsFeaturesAMD::shaderEarlyAndLateFragmentTests is not "
                          "supported\n";
                }
                break;
            }
#ifdef VK_ENABLE_BETA_EXTENSIONS
            case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_ENQUEUE_FEATURES_AMDX: {
                VkPhysicalDeviceShaderEnqueueFeaturesAMDX supported = vku::InitStructHelper();
                features_2.pNext = &supported;
                DispatchGetPhysicalDeviceFeatures2(gpu, &features_2);
                const VkPhysicalDeviceShaderEnqueueFeaturesAMDX* enabling =
                    reinterpret_cast<const VkPhysicalDeviceShaderEnqueueFeaturesAMDX*>(current);
                if (enabling->shaderEnqueue && !supported.shaderEnqueue) {
                    ss << "VkPhysicalDeviceShaderEnqueueFeaturesAMDX::shaderEnqueue is not supported\n";
                }
                if (enabling->shaderMeshEnqueue && !supported.shaderMeshEnqueue) {
                    ss << "VkPhysicalDeviceShaderEnqueueFeaturesAMDX::shaderMeshEnqueue is not supported\n";
                }
                break;
            }
#endif  // VK_ENABLE_BETA_EXTENSIONS
            case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_EXPECT_ASSUME_FEATURES: {
                VkPhysicalDeviceShaderExpectAssumeFeatures supported = vku::InitStructHelper();
                features_2.pNext = &supported;
                DispatchGetPhysicalDeviceFeatures2(gpu, &features_2);
                const VkPhysicalDeviceShaderExpectAssumeFeatures* enabling =
                    reinterpret_cast<const VkPhysicalDeviceShaderExpectAssumeFeatures*>(current);
                if (enabling->shaderExpectAssume && !supported.shaderExpectAssume) {
                    ss << "VkPhysicalDeviceShaderExpectAssumeFeatures::shaderExpectAssume is not supported\n";
                }
                break;
            }
            case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_FLOAT16_INT8_FEATURES: {
                VkPhysicalDeviceShaderFloat16Int8Features supported = vku::InitStructHelper();
                features_2.pNext = &supported;
                DispatchGetPhysicalDeviceFeatures2(gpu, &features_2);
                const VkPhysicalDeviceShaderFloat16Int8Features* enabling =
                    reinterpret_cast<const VkPhysicalDeviceShaderFloat16Int8Features*>(current);
                if (enabling->shaderFloat16 && !supported.shaderFloat16) {
                    ss << "VkPhysicalDeviceShaderFloat16Int8Features::shaderFloat16 is not supported\n";
                }
                if (enabling->shaderInt8 && !supported.shaderInt8) {
                    ss << "VkPhysicalDeviceShaderFloat16Int8Features::shaderInt8 is not supported\n";
                }
                break;
            }
            case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_FLOAT8_FEATURES_EXT: {
                VkPhysicalDeviceShaderFloat8FeaturesEXT supported = vku::InitStructHelper();
                features_2.pNext = &supported;
                DispatchGetPhysicalDeviceFeatures2(gpu, &features_2);
                const VkPhysicalDeviceShaderFloat8FeaturesEXT* enabling =
                    reinterpret_cast<const VkPhysicalDeviceShaderFloat8FeaturesEXT*>(current);
                if (enabling->shaderFloat8 && !supported.shaderFloat8) {
                    ss << "VkPhysicalDeviceShaderFloat8FeaturesEXT::shaderFloat8 is not supported\n";
                }
                if (enabling->shaderFloat8CooperativeMatrix && !supported.shaderFloat8CooperativeMatrix) {
                    ss << "VkPhysicalDeviceShaderFloat8FeaturesEXT::shaderFloat8CooperativeMatrix is not supported\n";
                }
                break;
            }
            case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_FLOAT_CONTROLS_2_FEATURES: {
                VkPhysicalDeviceShaderFloatControls2Features supported = vku::InitStructHelper();
                features_2.pNext = &supported;
                DispatchGetPhysicalDeviceFeatures2(gpu, &features_2);
                const VkPhysicalDeviceShaderFloatControls2Features* enabling =
                    reinterpret_cast<const VkPhysicalDeviceShaderFloatControls2Features*>(current);
                if (enabling->shaderFloatControls2 && !supported.shaderFloatControls2) {
                    ss << "VkPhysicalDeviceShaderFloatControls2Features::shaderFloatControls2 is not supported\n";
                }
                break;
            }
            case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_FMA_FEATURES_KHR: {
                VkPhysicalDeviceShaderFmaFeaturesKHR supported = vku::InitStructHelper();
                features_2.pNext = &supported;
                DispatchGetPhysicalDeviceFeatures2(gpu, &features_2);
                const VkPhysicalDeviceShaderFmaFeaturesKHR* enabling =
                    reinterpret_cast<const VkPhysicalDeviceShaderFmaFeaturesKHR*>(current);
                if (enabling->shaderFmaFloat16 && !supported.shaderFmaFloat16) {
                    ss << "VkPhysicalDeviceShaderFmaFeaturesKHR::shaderFmaFloat16 is not supported\n";
                }
                if (enabling->shaderFmaFloat32 && !supported.shaderFmaFloat32) {
                    ss << "VkPhysicalDeviceShaderFmaFeaturesKHR::shaderFmaFloat32 is not supported\n";
                }
                if (enabling->shaderFmaFloat64 && !supported.shaderFmaFloat64) {
                    ss << "VkPhysicalDeviceShaderFmaFeaturesKHR::shaderFmaFloat64 is not supported\n";
                }
                break;
            }
            case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_IMAGE_ATOMIC_INT64_FEATURES_EXT: {
                VkPhysicalDeviceShaderImageAtomicInt64FeaturesEXT supported = vku::InitStructHelper();
                features_2.pNext = &supported;
                DispatchGetPhysicalDeviceFeatures2(gpu, &features_2);
                const VkPhysicalDeviceShaderImageAtomicInt64FeaturesEXT* enabling =
                    reinterpret_cast<const VkPhysicalDeviceShaderImageAtomicInt64FeaturesEXT*>(current);
                if (enabling->shaderImageInt64Atomics && !supported.shaderImageInt64Atomics) {
                    ss << "VkPhysicalDeviceShaderImageAtomicInt64FeaturesEXT::shaderImageInt64Atomics is not supported\n";
                }
                if (enabling->sparseImageInt64Atomics && !supported.sparseImageInt64Atomics) {
                    ss << "VkPhysicalDeviceShaderImageAtomicInt64FeaturesEXT::sparseImageInt64Atomics is not supported\n";
                }
                break;
            }
            case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_IMAGE_FOOTPRINT_FEATURES_NV: {
                VkPhysicalDeviceShaderImageFootprintFeaturesNV supported = vku::InitStructHelper();
                features_2.pNext = &supported;
                DispatchGetPhysicalDeviceFeatures2(gpu, &features_2);
                const VkPhysicalDeviceShaderImageFootprintFeaturesNV* enabling =
                    reinterpret_cast<const VkPhysicalDeviceShaderImageFootprintFeaturesNV*>(current);
                if (enabling->imageFootprint && !supported.imageFootprint) {
                    ss << "VkPhysicalDeviceShaderImageFootprintFeaturesNV::imageFootprint is not supported\n";
                }
                break;
            }
            case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_INSTRUMENTATION_FEATURES_ARM: {
                VkPhysicalDeviceShaderInstrumentationFeaturesARM supported = vku::InitStructHelper();
                features_2.pNext = &supported;
                DispatchGetPhysicalDeviceFeatures2(gpu, &features_2);
                const VkPhysicalDeviceShaderInstrumentationFeaturesARM* enabling =
                    reinterpret_cast<const VkPhysicalDeviceShaderInstrumentationFeaturesARM*>(current);
                if (enabling->shaderInstrumentation && !supported.shaderInstrumentation) {
                    ss << "VkPhysicalDeviceShaderInstrumentationFeaturesARM::shaderInstrumentation is not supported\n";
                }
                break;
            }
            case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_INTEGER_DOT_PRODUCT_FEATURES: {
                VkPhysicalDeviceShaderIntegerDotProductFeatures supported = vku::InitStructHelper();
                features_2.pNext = &supported;
                DispatchGetPhysicalDeviceFeatures2(gpu, &features_2);
                const VkPhysicalDeviceShaderIntegerDotProductFeatures* enabling =
                    reinterpret_cast<const VkPhysicalDeviceShaderIntegerDotProductFeatures*>(current);
                if (enabling->shaderIntegerDotProduct && !supported.shaderIntegerDotProduct) {
                    ss << "VkPhysicalDeviceShaderIntegerDotProductFeatures::shaderIntegerDotProduct is not supported\n";
                }
                break;
            }
            case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_INTEGER_FUNCTIONS_2_FEATURES_INTEL: {
                VkPhysicalDeviceShaderIntegerFunctions2FeaturesINTEL supported = vku::InitStructHelper();
                features_2.pNext = &supported;
                DispatchGetPhysicalDeviceFeatures2(gpu, &features_2);
                const VkPhysicalDeviceShaderIntegerFunctions2FeaturesINTEL* enabling =
                    reinterpret_cast<const VkPhysicalDeviceShaderIntegerFunctions2FeaturesINTEL*>(current);
                if (enabling->shaderIntegerFunctions2 && !supported.shaderIntegerFunctions2) {
                    ss << "VkPhysicalDeviceShaderIntegerFunctions2FeaturesINTEL::shaderIntegerFunctions2 is not supported\n";
                }
                break;
            }
            case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_LONG_VECTOR_FEATURES_EXT: {
                VkPhysicalDeviceShaderLongVectorFeaturesEXT supported = vku::InitStructHelper();
                features_2.pNext = &supported;
                DispatchGetPhysicalDeviceFeatures2(gpu, &features_2);
                const VkPhysicalDeviceShaderLongVectorFeaturesEXT* enabling =
                    reinterpret_cast<const VkPhysicalDeviceShaderLongVectorFeaturesEXT*>(current);
                if (enabling->longVector && !supported.longVector) {
                    ss << "VkPhysicalDeviceShaderLongVectorFeaturesEXT::longVector is not supported\n";
                }
                break;
            }
            case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_MAXIMAL_RECONVERGENCE_FEATURES_KHR: {
                VkPhysicalDeviceShaderMaximalReconvergenceFeaturesKHR supported = vku::InitStructHelper();
                features_2.pNext = &supported;
                DispatchGetPhysicalDeviceFeatures2(gpu, &features_2);
                const VkPhysicalDeviceShaderMaximalReconvergenceFeaturesKHR* enabling =
                    reinterpret_cast<const VkPhysicalDeviceShaderMaximalReconvergenceFeaturesKHR*>(current);
                if (enabling->shaderMaximalReconvergence && !supported.shaderMaximalReconvergence) {
                    ss << "VkPhysicalDeviceShaderMaximalReconvergenceFeaturesKHR::shaderMaximalReconvergence is not supported\n";
                }
                break;
            }
            case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_MIXED_FLOAT_DOT_PRODUCT_FEATURES_VALVE: {
                VkPhysicalDeviceShaderMixedFloatDotProductFeaturesVALVE supported = vku::InitStructHelper();
                features_2.pNext = &supported;
                DispatchGetPhysicalDeviceFeatures2(gpu, &features_2);
                const VkPhysicalDeviceShaderMixedFloatDotProductFeaturesVALVE* enabling =
                    reinterpret_cast<const VkPhysicalDeviceShaderMixedFloatDotProductFeaturesVALVE*>(current);
                if (enabling->shaderMixedFloatDotProductFloat16AccFloat32 &&
                    !supported.shaderMixedFloatDotProductFloat16AccFloat32) {
                    ss << "VkPhysicalDeviceShaderMixedFloatDotProductFeaturesVALVE::shaderMixedFloatDotProductFloat16AccFloat32 is "
                          "not supported\n";
                }
                if (enabling->shaderMixedFloatDotProductFloat16AccFloat16 &&
                    !supported.shaderMixedFloatDotProductFloat16AccFloat16) {
                    ss << "VkPhysicalDeviceShaderMixedFloatDotProductFeaturesVALVE::shaderMixedFloatDotProductFloat16AccFloat16 is "
                          "not supported\n";
                }
                if (enabling->shaderMixedFloatDotProductBFloat16Acc && !supported.shaderMixedFloatDotProductBFloat16Acc) {
                    ss << "VkPhysicalDeviceShaderMixedFloatDotProductFeaturesVALVE::shaderMixedFloatDotProductBFloat16Acc is not "
                          "supported\n";
                }
                if (enabling->shaderMixedFloatDotProductFloat8AccFloat32 && !supported.shaderMixedFloatDotProductFloat8AccFloat32) {
                    ss << "VkPhysicalDeviceShaderMixedFloatDotProductFeaturesVALVE::shaderMixedFloatDotProductFloat8AccFloat32 is "
                          "not supported\n";
                }
                break;
            }
            case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_MODULE_IDENTIFIER_FEATURES_EXT: {
                VkPhysicalDeviceShaderModuleIdentifierFeaturesEXT supported = vku::InitStructHelper();
                features_2.pNext = &supported;
                DispatchGetPhysicalDeviceFeatures2(gpu, &features_2);
                const VkPhysicalDeviceShaderModuleIdentifierFeaturesEXT* enabling =
                    reinterpret_cast<const VkPhysicalDeviceShaderModuleIdentifierFeaturesEXT*>(current);
                if (enabling->shaderModuleIdentifier && !supported.shaderModuleIdentifier) {
                    ss << "VkPhysicalDeviceShaderModuleIdentifierFeaturesEXT::shaderModuleIdentifier is not supported\n";
                }
                break;
            }
            case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_OBJECT_FEATURES_EXT: {
                VkPhysicalDeviceShaderObjectFeaturesEXT supported = vku::InitStructHelper();
                features_2.pNext = &supported;
                DispatchGetPhysicalDeviceFeatures2(gpu, &features_2);
                const VkPhysicalDeviceShaderObjectFeaturesEXT* enabling =
                    reinterpret_cast<const VkPhysicalDeviceShaderObjectFeaturesEXT*>(current);
                if (enabling->shaderObject && !supported.shaderObject) {
                    ss << "VkPhysicalDeviceShaderObjectFeaturesEXT::shaderObject is not supported\n";
                }
                break;
            }
            case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_QUAD_CONTROL_FEATURES_KHR: {
                VkPhysicalDeviceShaderQuadControlFeaturesKHR supported = vku::InitStructHelper();
                features_2.pNext = &supported;
                DispatchGetPhysicalDeviceFeatures2(gpu, &features_2);
                const VkPhysicalDeviceShaderQuadControlFeaturesKHR* enabling =
                    reinterpret_cast<const VkPhysicalDeviceShaderQuadControlFeaturesKHR*>(current);
                if (enabling->shaderQuadControl && !supported.shaderQuadControl) {
                    ss << "VkPhysicalDeviceShaderQuadControlFeaturesKHR::shaderQuadControl is not supported\n";
                }
                break;
            }
            case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_RELAXED_EXTENDED_INSTRUCTION_FEATURES_KHR: {
                VkPhysicalDeviceShaderRelaxedExtendedInstructionFeaturesKHR supported = vku::InitStructHelper();
                features_2.pNext = &supported;
                DispatchGetPhysicalDeviceFeatures2(gpu, &features_2);
                const VkPhysicalDeviceShaderRelaxedExtendedInstructionFeaturesKHR* enabling =
                    reinterpret_cast<const VkPhysicalDeviceShaderRelaxedExtendedInstructionFeaturesKHR*>(current);
                if (enabling->shaderRelaxedExtendedInstruction && !supported.shaderRelaxedExtendedInstruction) {
                    ss << "VkPhysicalDeviceShaderRelaxedExtendedInstructionFeaturesKHR::shaderRelaxedExtendedInstruction is not "
                          "supported\n";
                }
                break;
            }
            case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_REPLICATED_COMPOSITES_FEATURES_EXT: {
                VkPhysicalDeviceShaderReplicatedCompositesFeaturesEXT supported = vku::InitStructHelper();
                features_2.pNext = &supported;
                DispatchGetPhysicalDeviceFeatures2(gpu, &features_2);
                const VkPhysicalDeviceShaderReplicatedCompositesFeaturesEXT* enabling =
                    reinterpret_cast<const VkPhysicalDeviceShaderReplicatedCompositesFeaturesEXT*>(current);
                if (enabling->shaderReplicatedComposites && !supported.shaderReplicatedComposites) {
                    ss << "VkPhysicalDeviceShaderReplicatedCompositesFeaturesEXT::shaderReplicatedComposites is not supported\n";
                }
                break;
            }
            case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_SM_BUILTINS_FEATURES_NV: {
                VkPhysicalDeviceShaderSMBuiltinsFeaturesNV supported = vku::InitStructHelper();
                features_2.pNext = &supported;
                DispatchGetPhysicalDeviceFeatures2(gpu, &features_2);
                const VkPhysicalDeviceShaderSMBuiltinsFeaturesNV* enabling =
                    reinterpret_cast<const VkPhysicalDeviceShaderSMBuiltinsFeaturesNV*>(current);
                if (enabling->shaderSMBuiltins && !supported.shaderSMBuiltins) {
                    ss << "VkPhysicalDeviceShaderSMBuiltinsFeaturesNV::shaderSMBuiltins is not supported\n";
                }
                break;
            }
            case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_SUBGROUP_EXTENDED_TYPES_FEATURES: {
                VkPhysicalDeviceShaderSubgroupExtendedTypesFeatures supported = vku::InitStructHelper();
                features_2.pNext = &supported;
                DispatchGetPhysicalDeviceFeatures2(gpu, &features_2);
                const VkPhysicalDeviceShaderSubgroupExtendedTypesFeatures* enabling =
                    reinterpret_cast<const VkPhysicalDeviceShaderSubgroupExtendedTypesFeatures*>(current);
                if (enabling->shaderSubgroupExtendedTypes && !supported.shaderSubgroupExtendedTypes) {
                    ss << "VkPhysicalDeviceShaderSubgroupExtendedTypesFeatures::shaderSubgroupExtendedTypes is not supported\n";
                }
                break;
            }
            case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_SUBGROUP_PARTITIONED_FEATURES_EXT: {
                VkPhysicalDeviceShaderSubgroupPartitionedFeaturesEXT supported = vku::InitStructHelper();
                features_2.pNext = &supported;
                DispatchGetPhysicalDeviceFeatures2(gpu, &features_2);
                const VkPhysicalDeviceShaderSubgroupPartitionedFeaturesEXT* enabling =
                    reinterpret_cast<const VkPhysicalDeviceShaderSubgroupPartitionedFeaturesEXT*>(current);
                if (enabling->shaderSubgroupPartitioned && !supported.shaderSubgroupPartitioned) {
                    ss << "VkPhysicalDeviceShaderSubgroupPartitionedFeaturesEXT::shaderSubgroupPartitioned is not supported\n";
                }
                break;
            }
            case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_SUBGROUP_ROTATE_FEATURES: {
                VkPhysicalDeviceShaderSubgroupRotateFeatures supported = vku::InitStructHelper();
                features_2.pNext = &supported;
                DispatchGetPhysicalDeviceFeatures2(gpu, &features_2);
                const VkPhysicalDeviceShaderSubgroupRotateFeatures* enabling =
                    reinterpret_cast<const VkPhysicalDeviceShaderSubgroupRotateFeatures*>(current);
                if (enabling->shaderSubgroupRotate && !supported.shaderSubgroupRotate) {
                    ss << "VkPhysicalDeviceShaderSubgroupRotateFeatures::shaderSubgroupRotate is not supported\n";
                }
                if (enabling->shaderSubgroupRotateClustered && !supported.shaderSubgroupRotateClustered) {
                    ss << "VkPhysicalDeviceShaderSubgroupRotateFeatures::shaderSubgroupRotateClustered is not supported\n";
                }
                break;
            }
            case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_SUBGROUP_UNIFORM_CONTROL_FLOW_FEATURES_KHR: {
                VkPhysicalDeviceShaderSubgroupUniformControlFlowFeaturesKHR supported = vku::InitStructHelper();
                features_2.pNext = &supported;
                DispatchGetPhysicalDeviceFeatures2(gpu, &features_2);
                const VkPhysicalDeviceShaderSubgroupUniformControlFlowFeaturesKHR* enabling =
                    reinterpret_cast<const VkPhysicalDeviceShaderSubgroupUniformControlFlowFeaturesKHR*>(current);
                if (enabling->shaderSubgroupUniformControlFlow && !supported.shaderSubgroupUniformControlFlow) {
                    ss << "VkPhysicalDeviceShaderSubgroupUniformControlFlowFeaturesKHR::shaderSubgroupUniformControlFlow is not "
                          "supported\n";
                }
                break;
            }
            case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_TERMINATE_INVOCATION_FEATURES: {
                VkPhysicalDeviceShaderTerminateInvocationFeatures supported = vku::InitStructHelper();
                features_2.pNext = &supported;
                DispatchGetPhysicalDeviceFeatures2(gpu, &features_2);
                const VkPhysicalDeviceShaderTerminateInvocationFeatures* enabling =
                    reinterpret_cast<const VkPhysicalDeviceShaderTerminateInvocationFeatures*>(current);
                if (enabling->shaderTerminateInvocation && !supported.shaderTerminateInvocation) {
                    ss << "VkPhysicalDeviceShaderTerminateInvocationFeatures::shaderTerminateInvocation is not supported\n";
                }
                break;
            }
            case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_TILE_IMAGE_FEATURES_EXT: {
                VkPhysicalDeviceShaderTileImageFeaturesEXT supported = vku::InitStructHelper();
                features_2.pNext = &supported;
                DispatchGetPhysicalDeviceFeatures2(gpu, &features_2);
                const VkPhysicalDeviceShaderTileImageFeaturesEXT* enabling =
                    reinterpret_cast<const VkPhysicalDeviceShaderTileImageFeaturesEXT*>(current);
                if (enabling->shaderTileImageColorReadAccess && !supported.shaderTileImageColorReadAccess) {
                    ss << "VkPhysicalDeviceShaderTileImageFeaturesEXT::shaderTileImageColorReadAccess is not supported\n";
                }
                if (enabling->shaderTileImageDepthReadAccess && !supported.shaderTileImageDepthReadAccess) {
                    ss << "VkPhysicalDeviceShaderTileImageFeaturesEXT::shaderTileImageDepthReadAccess is not supported\n";
                }
                if (enabling->shaderTileImageStencilReadAccess && !supported.shaderTileImageStencilReadAccess) {
                    ss << "VkPhysicalDeviceShaderTileImageFeaturesEXT::shaderTileImageStencilReadAccess is not supported\n";
                }
                break;
            }
            case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_UNIFORM_BUFFER_UNSIZED_ARRAY_FEATURES_EXT: {
                VkPhysicalDeviceShaderUniformBufferUnsizedArrayFeaturesEXT supported = vku::InitStructHelper();
                features_2.pNext = &supported;
                DispatchGetPhysicalDeviceFeatures2(gpu, &features_2);
                const VkPhysicalDeviceShaderUniformBufferUnsizedArrayFeaturesEXT* enabling =
                    reinterpret_cast<const VkPhysicalDeviceShaderUniformBufferUnsizedArrayFeaturesEXT*>(current);
                if (enabling->shaderUniformBufferUnsizedArray && !supported.shaderUniformBufferUnsizedArray) {
                    ss << "VkPhysicalDeviceShaderUniformBufferUnsizedArrayFeaturesEXT::shaderUniformBufferUnsizedArray is not "
                          "supported\n";
                }
                break;
            }
            case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_UNTYPED_POINTERS_FEATURES_KHR: {
                VkPhysicalDeviceShaderUntypedPointersFeaturesKHR supported = vku::InitStructHelper();
                features_2.pNext = &supported;
                DispatchGetPhysicalDeviceFeatures2(gpu, &features_2);
                const VkPhysicalDeviceShaderUntypedPointersFeaturesKHR* enabling =
                    reinterpret_cast<const VkPhysicalDeviceShaderUntypedPointersFeaturesKHR*>(current);
                if (enabling->shaderUntypedPointers && !supported.shaderUntypedPointers) {
                    ss << "VkPhysicalDeviceShaderUntypedPointersFeaturesKHR::shaderUntypedPointers is not supported\n";
                }
                break;
            }
            case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADING_RATE_IMAGE_FEATURES_NV: {
                VkPhysicalDeviceShadingRateImageFeaturesNV supported = vku::InitStructHelper();
                features_2.pNext = &supported;
                DispatchGetPhysicalDeviceFeatures2(gpu, &features_2);
                const VkPhysicalDeviceShadingRateImageFeaturesNV* enabling =
                    reinterpret_cast<const VkPhysicalDeviceShadingRateImageFeaturesNV*>(current);
                if (enabling->shadingRateImage && !supported.shadingRateImage) {
                    ss << "VkPhysicalDeviceShadingRateImageFeaturesNV::shadingRateImage is not supported\n";
                }
                if (enabling->shadingRateCoarseSampleOrder && !supported.shadingRateCoarseSampleOrder) {
                    ss << "VkPhysicalDeviceShadingRateImageFeaturesNV::shadingRateCoarseSampleOrder is not supported\n";
                }
                break;
            }
            case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SUBGROUP_SIZE_CONTROL_FEATURES: {
                VkPhysicalDeviceSubgroupSizeControlFeatures supported = vku::InitStructHelper();
                features_2.pNext = &supported;
                DispatchGetPhysicalDeviceFeatures2(gpu, &features_2);
                const VkPhysicalDeviceSubgroupSizeControlFeatures* enabling =
                    reinterpret_cast<const VkPhysicalDeviceSubgroupSizeControlFeatures*>(current);
                if (enabling->subgroupSizeControl && !supported.subgroupSizeControl) {
                    ss << "VkPhysicalDeviceSubgroupSizeControlFeatures::subgroupSizeControl is not supported\n";
                }
                if (enabling->computeFullSubgroups && !supported.computeFullSubgroups) {
                    ss << "VkPhysicalDeviceSubgroupSizeControlFeatures::computeFullSubgroups is not supported\n";
                }
                break;
            }
            case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SUBPASS_MERGE_FEEDBACK_FEATURES_EXT: {
                VkPhysicalDeviceSubpassMergeFeedbackFeaturesEXT supported = vku::InitStructHelper();
                features_2.pNext = &supported;
                DispatchGetPhysicalDeviceFeatures2(gpu, &features_2);
                const VkPhysicalDeviceSubpassMergeFeedbackFeaturesEXT* enabling =
                    reinterpret_cast<const VkPhysicalDeviceSubpassMergeFeedbackFeaturesEXT*>(current);
                if (enabling->subpassMergeFeedback && !supported.subpassMergeFeedback) {
                    ss << "VkPhysicalDeviceSubpassMergeFeedbackFeaturesEXT::subpassMergeFeedback is not supported\n";
                }
                break;
            }
            case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SUBPASS_SHADING_FEATURES_HUAWEI: {
                VkPhysicalDeviceSubpassShadingFeaturesHUAWEI supported = vku::InitStructHelper();
                features_2.pNext = &supported;
                DispatchGetPhysicalDeviceFeatures2(gpu, &features_2);
                const VkPhysicalDeviceSubpassShadingFeaturesHUAWEI* enabling =
                    reinterpret_cast<const VkPhysicalDeviceSubpassShadingFeaturesHUAWEI*>(current);
                if (enabling->subpassShading && !supported.subpassShading) {
                    ss << "VkPhysicalDeviceSubpassShadingFeaturesHUAWEI::subpassShading is not supported\n";
                }
                break;
            }
            case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SWAPCHAIN_MAINTENANCE_1_FEATURES_KHR: {
                VkPhysicalDeviceSwapchainMaintenance1FeaturesKHR supported = vku::InitStructHelper();
                features_2.pNext = &supported;
                DispatchGetPhysicalDeviceFeatures2(gpu, &features_2);
                const VkPhysicalDeviceSwapchainMaintenance1FeaturesKHR* enabling =
                    reinterpret_cast<const VkPhysicalDeviceSwapchainMaintenance1FeaturesKHR*>(current);
                if (enabling->swapchainMaintenance1 && !supported.swapchainMaintenance1) {
                    ss << "VkPhysicalDeviceSwapchainMaintenance1FeaturesKHR::swapchainMaintenance1 is not supported\n";
                }
                break;
            }
            case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SYNCHRONIZATION_2_FEATURES: {
                VkPhysicalDeviceSynchronization2Features supported = vku::InitStructHelper();
                features_2.pNext = &supported;
                DispatchGetPhysicalDeviceFeatures2(gpu, &features_2);
                const VkPhysicalDeviceSynchronization2Features* enabling =
                    reinterpret_cast<const VkPhysicalDeviceSynchronization2Features*>(current);
                if (enabling->synchronization2 && !supported.synchronization2) {
                    ss << "VkPhysicalDeviceSynchronization2Features::synchronization2 is not supported\n";
                }
                break;
            }
            case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TENSOR_FEATURES_ARM: {
                VkPhysicalDeviceTensorFeaturesARM supported = vku::InitStructHelper();
                features_2.pNext = &supported;
                DispatchGetPhysicalDeviceFeatures2(gpu, &features_2);
                const VkPhysicalDeviceTensorFeaturesARM* enabling =
                    reinterpret_cast<const VkPhysicalDeviceTensorFeaturesARM*>(current);
                if (enabling->tensorNonPacked && !supported.tensorNonPacked) {
                    ss << "VkPhysicalDeviceTensorFeaturesARM::tensorNonPacked is not supported\n";
                }
                if (enabling->shaderTensorAccess && !supported.shaderTensorAccess) {
                    ss << "VkPhysicalDeviceTensorFeaturesARM::shaderTensorAccess is not supported\n";
                }
                if (enabling->shaderStorageTensorArrayDynamicIndexing && !supported.shaderStorageTensorArrayDynamicIndexing) {
                    ss << "VkPhysicalDeviceTensorFeaturesARM::shaderStorageTensorArrayDynamicIndexing is not supported\n";
                }
                if (enabling->shaderStorageTensorArrayNonUniformIndexing && !supported.shaderStorageTensorArrayNonUniformIndexing) {
                    ss << "VkPhysicalDeviceTensorFeaturesARM::shaderStorageTensorArrayNonUniformIndexing is not supported\n";
                }
                if (enabling->descriptorBindingStorageTensorUpdateAfterBind &&
                    !supported.descriptorBindingStorageTensorUpdateAfterBind) {
                    ss << "VkPhysicalDeviceTensorFeaturesARM::descriptorBindingStorageTensorUpdateAfterBind is not supported\n";
                }
                if (enabling->tensors && !supported.tensors) {
                    ss << "VkPhysicalDeviceTensorFeaturesARM::tensors is not supported\n";
                }
                break;
            }
            case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TEXEL_BUFFER_ALIGNMENT_FEATURES_EXT: {
                VkPhysicalDeviceTexelBufferAlignmentFeaturesEXT supported = vku::InitStructHelper();
                features_2.pNext = &supported;
                DispatchGetPhysicalDeviceFeatures2(gpu, &features_2);
                const VkPhysicalDeviceTexelBufferAlignmentFeaturesEXT* enabling =
                    reinterpret_cast<const VkPhysicalDeviceTexelBufferAlignmentFeaturesEXT*>(current);
                if (enabling->texelBufferAlignment && !supported.texelBufferAlignment) {
                    ss << "VkPhysicalDeviceTexelBufferAlignmentFeaturesEXT::texelBufferAlignment is not supported\n";
                }
                break;
            }
            case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TEXTURE_COMPRESSION_ASTC_3D_FEATURES_EXT: {
                VkPhysicalDeviceTextureCompressionASTC3DFeaturesEXT supported = vku::InitStructHelper();
                features_2.pNext = &supported;
                DispatchGetPhysicalDeviceFeatures2(gpu, &features_2);
                const VkPhysicalDeviceTextureCompressionASTC3DFeaturesEXT* enabling =
                    reinterpret_cast<const VkPhysicalDeviceTextureCompressionASTC3DFeaturesEXT*>(current);
                if (enabling->textureCompressionASTC_3D && !supported.textureCompressionASTC_3D) {
                    ss << "VkPhysicalDeviceTextureCompressionASTC3DFeaturesEXT::textureCompressionASTC_3D is not supported\n";
                }
                break;
            }
            case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TEXTURE_COMPRESSION_ASTC_HDR_FEATURES: {
                VkPhysicalDeviceTextureCompressionASTCHDRFeatures supported = vku::InitStructHelper();
                features_2.pNext = &supported;
                DispatchGetPhysicalDeviceFeatures2(gpu, &features_2);
                const VkPhysicalDeviceTextureCompressionASTCHDRFeatures* enabling =
                    reinterpret_cast<const VkPhysicalDeviceTextureCompressionASTCHDRFeatures*>(current);
                if (enabling->textureCompressionASTC_HDR && !supported.textureCompressionASTC_HDR) {
                    ss << "VkPhysicalDeviceTextureCompressionASTCHDRFeatures::textureCompressionASTC_HDR is not supported\n";
                }
                break;
            }
            case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_THROTTLE_HINT_FEATURES_SEC: {
                VkPhysicalDeviceThrottleHintFeaturesSEC supported = vku::InitStructHelper();
                features_2.pNext = &supported;
                DispatchGetPhysicalDeviceFeatures2(gpu, &features_2);
                const VkPhysicalDeviceThrottleHintFeaturesSEC* enabling =
                    reinterpret_cast<const VkPhysicalDeviceThrottleHintFeaturesSEC*>(current);
                if (enabling->throttleHint && !supported.throttleHint) {
                    ss << "VkPhysicalDeviceThrottleHintFeaturesSEC::throttleHint is not supported\n";
                }
                break;
            }
            case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TILE_MEMORY_HEAP_FEATURES_QCOM: {
                VkPhysicalDeviceTileMemoryHeapFeaturesQCOM supported = vku::InitStructHelper();
                features_2.pNext = &supported;
                DispatchGetPhysicalDeviceFeatures2(gpu, &features_2);
                const VkPhysicalDeviceTileMemoryHeapFeaturesQCOM* enabling =
                    reinterpret_cast<const VkPhysicalDeviceTileMemoryHeapFeaturesQCOM*>(current);
                if (enabling->tileMemoryHeap && !supported.tileMemoryHeap) {
                    ss << "VkPhysicalDeviceTileMemoryHeapFeaturesQCOM::tileMemoryHeap is not supported\n";
                }
                break;
            }
            case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TILE_PROPERTIES_FEATURES_QCOM: {
                VkPhysicalDeviceTilePropertiesFeaturesQCOM supported = vku::InitStructHelper();
                features_2.pNext = &supported;
                DispatchGetPhysicalDeviceFeatures2(gpu, &features_2);
                const VkPhysicalDeviceTilePropertiesFeaturesQCOM* enabling =
                    reinterpret_cast<const VkPhysicalDeviceTilePropertiesFeaturesQCOM*>(current);
                if (enabling->tileProperties && !supported.tileProperties) {
                    ss << "VkPhysicalDeviceTilePropertiesFeaturesQCOM::tileProperties is not supported\n";
                }
                break;
            }
            case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TILE_SHADING_FEATURES_QCOM: {
                VkPhysicalDeviceTileShadingFeaturesQCOM supported = vku::InitStructHelper();
                features_2.pNext = &supported;
                DispatchGetPhysicalDeviceFeatures2(gpu, &features_2);
                const VkPhysicalDeviceTileShadingFeaturesQCOM* enabling =
                    reinterpret_cast<const VkPhysicalDeviceTileShadingFeaturesQCOM*>(current);
                if (enabling->tileShading && !supported.tileShading) {
                    ss << "VkPhysicalDeviceTileShadingFeaturesQCOM::tileShading is not supported\n";
                }
                if (enabling->tileShadingFragmentStage && !supported.tileShadingFragmentStage) {
                    ss << "VkPhysicalDeviceTileShadingFeaturesQCOM::tileShadingFragmentStage is not supported\n";
                }
                if (enabling->tileShadingColorAttachments && !supported.tileShadingColorAttachments) {
                    ss << "VkPhysicalDeviceTileShadingFeaturesQCOM::tileShadingColorAttachments is not supported\n";
                }
                if (enabling->tileShadingDepthAttachments && !supported.tileShadingDepthAttachments) {
                    ss << "VkPhysicalDeviceTileShadingFeaturesQCOM::tileShadingDepthAttachments is not supported\n";
                }
                if (enabling->tileShadingStencilAttachments && !supported.tileShadingStencilAttachments) {
                    ss << "VkPhysicalDeviceTileShadingFeaturesQCOM::tileShadingStencilAttachments is not supported\n";
                }
                if (enabling->tileShadingInputAttachments && !supported.tileShadingInputAttachments) {
                    ss << "VkPhysicalDeviceTileShadingFeaturesQCOM::tileShadingInputAttachments is not supported\n";
                }
                if (enabling->tileShadingSampledAttachments && !supported.tileShadingSampledAttachments) {
                    ss << "VkPhysicalDeviceTileShadingFeaturesQCOM::tileShadingSampledAttachments is not supported\n";
                }
                if (enabling->tileShadingPerTileDraw && !supported.tileShadingPerTileDraw) {
                    ss << "VkPhysicalDeviceTileShadingFeaturesQCOM::tileShadingPerTileDraw is not supported\n";
                }
                if (enabling->tileShadingPerTileDispatch && !supported.tileShadingPerTileDispatch) {
                    ss << "VkPhysicalDeviceTileShadingFeaturesQCOM::tileShadingPerTileDispatch is not supported\n";
                }
                if (enabling->tileShadingDispatchTile && !supported.tileShadingDispatchTile) {
                    ss << "VkPhysicalDeviceTileShadingFeaturesQCOM::tileShadingDispatchTile is not supported\n";
                }
                if (enabling->tileShadingApron && !supported.tileShadingApron) {
                    ss << "VkPhysicalDeviceTileShadingFeaturesQCOM::tileShadingApron is not supported\n";
                }
                if (enabling->tileShadingAnisotropicApron && !supported.tileShadingAnisotropicApron) {
                    ss << "VkPhysicalDeviceTileShadingFeaturesQCOM::tileShadingAnisotropicApron is not supported\n";
                }
                if (enabling->tileShadingAtomicOps && !supported.tileShadingAtomicOps) {
                    ss << "VkPhysicalDeviceTileShadingFeaturesQCOM::tileShadingAtomicOps is not supported\n";
                }
                if (enabling->tileShadingImageProcessing && !supported.tileShadingImageProcessing) {
                    ss << "VkPhysicalDeviceTileShadingFeaturesQCOM::tileShadingImageProcessing is not supported\n";
                }
                break;
            }
            case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TIMELINE_SEMAPHORE_FEATURES: {
                VkPhysicalDeviceTimelineSemaphoreFeatures supported = vku::InitStructHelper();
                features_2.pNext = &supported;
                DispatchGetPhysicalDeviceFeatures2(gpu, &features_2);
                const VkPhysicalDeviceTimelineSemaphoreFeatures* enabling =
                    reinterpret_cast<const VkPhysicalDeviceTimelineSemaphoreFeatures*>(current);
                if (enabling->timelineSemaphore && !supported.timelineSemaphore) {
                    ss << "VkPhysicalDeviceTimelineSemaphoreFeatures::timelineSemaphore is not supported\n";
                }
                break;
            }
            case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TRANSFORM_FEEDBACK_FEATURES_EXT: {
                VkPhysicalDeviceTransformFeedbackFeaturesEXT supported = vku::InitStructHelper();
                features_2.pNext = &supported;
                DispatchGetPhysicalDeviceFeatures2(gpu, &features_2);
                const VkPhysicalDeviceTransformFeedbackFeaturesEXT* enabling =
                    reinterpret_cast<const VkPhysicalDeviceTransformFeedbackFeaturesEXT*>(current);
                if (enabling->transformFeedback && !supported.transformFeedback) {
                    ss << "VkPhysicalDeviceTransformFeedbackFeaturesEXT::transformFeedback is not supported\n";
                }
                if (enabling->geometryStreams && !supported.geometryStreams) {
                    ss << "VkPhysicalDeviceTransformFeedbackFeaturesEXT::geometryStreams is not supported\n";
                }
                break;
            }
            case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_UNIFIED_IMAGE_LAYOUTS_FEATURES_KHR: {
                VkPhysicalDeviceUnifiedImageLayoutsFeaturesKHR supported = vku::InitStructHelper();
                features_2.pNext = &supported;
                DispatchGetPhysicalDeviceFeatures2(gpu, &features_2);
                const VkPhysicalDeviceUnifiedImageLayoutsFeaturesKHR* enabling =
                    reinterpret_cast<const VkPhysicalDeviceUnifiedImageLayoutsFeaturesKHR*>(current);
                if (enabling->unifiedImageLayouts && !supported.unifiedImageLayouts) {
                    ss << "VkPhysicalDeviceUnifiedImageLayoutsFeaturesKHR::unifiedImageLayouts is not supported\n";
                }
                if (enabling->unifiedImageLayoutsVideo && !supported.unifiedImageLayoutsVideo) {
                    ss << "VkPhysicalDeviceUnifiedImageLayoutsFeaturesKHR::unifiedImageLayoutsVideo is not supported\n";
                }
                break;
            }
            case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_UNIFORM_BUFFER_STANDARD_LAYOUT_FEATURES: {
                VkPhysicalDeviceUniformBufferStandardLayoutFeatures supported = vku::InitStructHelper();
                features_2.pNext = &supported;
                DispatchGetPhysicalDeviceFeatures2(gpu, &features_2);
                const VkPhysicalDeviceUniformBufferStandardLayoutFeatures* enabling =
                    reinterpret_cast<const VkPhysicalDeviceUniformBufferStandardLayoutFeatures*>(current);
                if (enabling->uniformBufferStandardLayout && !supported.uniformBufferStandardLayout) {
                    ss << "VkPhysicalDeviceUniformBufferStandardLayoutFeatures::uniformBufferStandardLayout is not supported\n";
                }
                break;
            }
            case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VARIABLE_POINTERS_FEATURES: {
                VkPhysicalDeviceVariablePointersFeatures supported = vku::InitStructHelper();
                features_2.pNext = &supported;
                DispatchGetPhysicalDeviceFeatures2(gpu, &features_2);
                const VkPhysicalDeviceVariablePointersFeatures* enabling =
                    reinterpret_cast<const VkPhysicalDeviceVariablePointersFeatures*>(current);
                if (enabling->variablePointersStorageBuffer && !supported.variablePointersStorageBuffer) {
                    ss << "VkPhysicalDeviceVariablePointersFeatures::variablePointersStorageBuffer is not supported\n";
                }
                if (enabling->variablePointers && !supported.variablePointers) {
                    ss << "VkPhysicalDeviceVariablePointersFeatures::variablePointers is not supported\n";
                }
                break;
            }
            case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VERTEX_ATTRIBUTE_DIVISOR_FEATURES: {
                VkPhysicalDeviceVertexAttributeDivisorFeatures supported = vku::InitStructHelper();
                features_2.pNext = &supported;
                DispatchGetPhysicalDeviceFeatures2(gpu, &features_2);
                const VkPhysicalDeviceVertexAttributeDivisorFeatures* enabling =
                    reinterpret_cast<const VkPhysicalDeviceVertexAttributeDivisorFeatures*>(current);
                if (enabling->vertexAttributeInstanceRateDivisor && !supported.vertexAttributeInstanceRateDivisor) {
                    ss << "VkPhysicalDeviceVertexAttributeDivisorFeatures::vertexAttributeInstanceRateDivisor is not supported\n";
                }
                if (enabling->vertexAttributeInstanceRateZeroDivisor && !supported.vertexAttributeInstanceRateZeroDivisor) {
                    ss << "VkPhysicalDeviceVertexAttributeDivisorFeatures::vertexAttributeInstanceRateZeroDivisor is not "
                          "supported\n";
                }
                break;
            }
            case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VERTEX_ATTRIBUTE_ROBUSTNESS_FEATURES_EXT: {
                VkPhysicalDeviceVertexAttributeRobustnessFeaturesEXT supported = vku::InitStructHelper();
                features_2.pNext = &supported;
                DispatchGetPhysicalDeviceFeatures2(gpu, &features_2);
                const VkPhysicalDeviceVertexAttributeRobustnessFeaturesEXT* enabling =
                    reinterpret_cast<const VkPhysicalDeviceVertexAttributeRobustnessFeaturesEXT*>(current);
                if (enabling->vertexAttributeRobustness && !supported.vertexAttributeRobustness) {
                    ss << "VkPhysicalDeviceVertexAttributeRobustnessFeaturesEXT::vertexAttributeRobustness is not supported\n";
                }
                break;
            }
            case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VERTEX_INPUT_DYNAMIC_STATE_FEATURES_EXT: {
                VkPhysicalDeviceVertexInputDynamicStateFeaturesEXT supported = vku::InitStructHelper();
                features_2.pNext = &supported;
                DispatchGetPhysicalDeviceFeatures2(gpu, &features_2);
                const VkPhysicalDeviceVertexInputDynamicStateFeaturesEXT* enabling =
                    reinterpret_cast<const VkPhysicalDeviceVertexInputDynamicStateFeaturesEXT*>(current);
                if (enabling->vertexInputDynamicState && !supported.vertexInputDynamicState) {
                    ss << "VkPhysicalDeviceVertexInputDynamicStateFeaturesEXT::vertexInputDynamicState is not supported\n";
                }
                break;
            }
            case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VIDEO_DECODE_VP9_FEATURES_KHR: {
                VkPhysicalDeviceVideoDecodeVP9FeaturesKHR supported = vku::InitStructHelper();
                features_2.pNext = &supported;
                DispatchGetPhysicalDeviceFeatures2(gpu, &features_2);
                const VkPhysicalDeviceVideoDecodeVP9FeaturesKHR* enabling =
                    reinterpret_cast<const VkPhysicalDeviceVideoDecodeVP9FeaturesKHR*>(current);
                if (enabling->videoDecodeVP9 && !supported.videoDecodeVP9) {
                    ss << "VkPhysicalDeviceVideoDecodeVP9FeaturesKHR::videoDecodeVP9 is not supported\n";
                }
                break;
            }
            case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VIDEO_ENCODE_AV1_FEATURES_KHR: {
                VkPhysicalDeviceVideoEncodeAV1FeaturesKHR supported = vku::InitStructHelper();
                features_2.pNext = &supported;
                DispatchGetPhysicalDeviceFeatures2(gpu, &features_2);
                const VkPhysicalDeviceVideoEncodeAV1FeaturesKHR* enabling =
                    reinterpret_cast<const VkPhysicalDeviceVideoEncodeAV1FeaturesKHR*>(current);
                if (enabling->videoEncodeAV1 && !supported.videoEncodeAV1) {
                    ss << "VkPhysicalDeviceVideoEncodeAV1FeaturesKHR::videoEncodeAV1 is not supported\n";
                }
                break;
            }
            case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VIDEO_ENCODE_INTRA_REFRESH_FEATURES_KHR: {
                VkPhysicalDeviceVideoEncodeIntraRefreshFeaturesKHR supported = vku::InitStructHelper();
                features_2.pNext = &supported;
                DispatchGetPhysicalDeviceFeatures2(gpu, &features_2);
                const VkPhysicalDeviceVideoEncodeIntraRefreshFeaturesKHR* enabling =
                    reinterpret_cast<const VkPhysicalDeviceVideoEncodeIntraRefreshFeaturesKHR*>(current);
                if (enabling->videoEncodeIntraRefresh && !supported.videoEncodeIntraRefresh) {
                    ss << "VkPhysicalDeviceVideoEncodeIntraRefreshFeaturesKHR::videoEncodeIntraRefresh is not supported\n";
                }
                break;
            }
            case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VIDEO_ENCODE_QUANTIZATION_MAP_FEATURES_KHR: {
                VkPhysicalDeviceVideoEncodeQuantizationMapFeaturesKHR supported = vku::InitStructHelper();
                features_2.pNext = &supported;
                DispatchGetPhysicalDeviceFeatures2(gpu, &features_2);
                const VkPhysicalDeviceVideoEncodeQuantizationMapFeaturesKHR* enabling =
                    reinterpret_cast<const VkPhysicalDeviceVideoEncodeQuantizationMapFeaturesKHR*>(current);
                if (enabling->videoEncodeQuantizationMap && !supported.videoEncodeQuantizationMap) {
                    ss << "VkPhysicalDeviceVideoEncodeQuantizationMapFeaturesKHR::videoEncodeQuantizationMap is not supported\n";
                }
                break;
            }
            case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VIDEO_ENCODE_RGB_CONVERSION_FEATURES_VALVE: {
                VkPhysicalDeviceVideoEncodeRgbConversionFeaturesVALVE supported = vku::InitStructHelper();
                features_2.pNext = &supported;
                DispatchGetPhysicalDeviceFeatures2(gpu, &features_2);
                const VkPhysicalDeviceVideoEncodeRgbConversionFeaturesVALVE* enabling =
                    reinterpret_cast<const VkPhysicalDeviceVideoEncodeRgbConversionFeaturesVALVE*>(current);
                if (enabling->videoEncodeRgbConversion && !supported.videoEncodeRgbConversion) {
                    ss << "VkPhysicalDeviceVideoEncodeRgbConversionFeaturesVALVE::videoEncodeRgbConversion is not supported\n";
                }
                break;
            }
            case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VIDEO_MAINTENANCE_1_FEATURES_KHR: {
                VkPhysicalDeviceVideoMaintenance1FeaturesKHR supported = vku::InitStructHelper();
                features_2.pNext = &supported;
                DispatchGetPhysicalDeviceFeatures2(gpu, &features_2);
                const VkPhysicalDeviceVideoMaintenance1FeaturesKHR* enabling =
                    reinterpret_cast<const VkPhysicalDeviceVideoMaintenance1FeaturesKHR*>(current);
                if (enabling->videoMaintenance1 && !supported.videoMaintenance1) {
                    ss << "VkPhysicalDeviceVideoMaintenance1FeaturesKHR::videoMaintenance1 is not supported\n";
                }
                break;
            }
            case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VIDEO_MAINTENANCE_2_FEATURES_KHR: {
                VkPhysicalDeviceVideoMaintenance2FeaturesKHR supported = vku::InitStructHelper();
                features_2.pNext = &supported;
                DispatchGetPhysicalDeviceFeatures2(gpu, &features_2);
                const VkPhysicalDeviceVideoMaintenance2FeaturesKHR* enabling =
                    reinterpret_cast<const VkPhysicalDeviceVideoMaintenance2FeaturesKHR*>(current);
                if (enabling->videoMaintenance2 && !supported.videoMaintenance2) {
                    ss << "VkPhysicalDeviceVideoMaintenance2FeaturesKHR::videoMaintenance2 is not supported\n";
                }
                break;
            }
            case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_1_1_FEATURES: {
                VkPhysicalDeviceVulkan11Features supported = vku::InitStructHelper();
                features_2.pNext = &supported;
                DispatchGetPhysicalDeviceFeatures2(gpu, &features_2);
                const VkPhysicalDeviceVulkan11Features* enabling =
                    reinterpret_cast<const VkPhysicalDeviceVulkan11Features*>(current);
                if (enabling->storageBuffer16BitAccess && !supported.storageBuffer16BitAccess) {
                    ss << "VkPhysicalDeviceVulkan11Features::storageBuffer16BitAccess is not supported\n";
                }
                if (enabling->uniformAndStorageBuffer16BitAccess && !supported.uniformAndStorageBuffer16BitAccess) {
                    ss << "VkPhysicalDeviceVulkan11Features::uniformAndStorageBuffer16BitAccess is not supported\n";
                }
                if (enabling->storagePushConstant16 && !supported.storagePushConstant16) {
                    ss << "VkPhysicalDeviceVulkan11Features::storagePushConstant16 is not supported\n";
                }
                if (enabling->storageInputOutput16 && !supported.storageInputOutput16) {
                    ss << "VkPhysicalDeviceVulkan11Features::storageInputOutput16 is not supported\n";
                }
                if (enabling->multiview && !supported.multiview) {
                    ss << "VkPhysicalDeviceVulkan11Features::multiview is not supported\n";
                }
                if (enabling->multiviewGeometryShader && !supported.multiviewGeometryShader) {
                    ss << "VkPhysicalDeviceVulkan11Features::multiviewGeometryShader is not supported\n";
                }
                if (enabling->multiviewTessellationShader && !supported.multiviewTessellationShader) {
                    ss << "VkPhysicalDeviceVulkan11Features::multiviewTessellationShader is not supported\n";
                }
                if (enabling->variablePointersStorageBuffer && !supported.variablePointersStorageBuffer) {
                    ss << "VkPhysicalDeviceVulkan11Features::variablePointersStorageBuffer is not supported\n";
                }
                if (enabling->variablePointers && !supported.variablePointers) {
                    ss << "VkPhysicalDeviceVulkan11Features::variablePointers is not supported\n";
                }
                if (enabling->protectedMemory && !supported.protectedMemory) {
                    ss << "VkPhysicalDeviceVulkan11Features::protectedMemory is not supported\n";
                }
                if (enabling->samplerYcbcrConversion && !supported.samplerYcbcrConversion) {
                    ss << "VkPhysicalDeviceVulkan11Features::samplerYcbcrConversion is not supported\n";
                }
                if (enabling->shaderDrawParameters && !supported.shaderDrawParameters) {
                    ss << "VkPhysicalDeviceVulkan11Features::shaderDrawParameters is not supported\n";
                }
                break;
            }
            case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_1_2_FEATURES: {
                VkPhysicalDeviceVulkan12Features supported = vku::InitStructHelper();
                features_2.pNext = &supported;
                DispatchGetPhysicalDeviceFeatures2(gpu, &features_2);
                const VkPhysicalDeviceVulkan12Features* enabling =
                    reinterpret_cast<const VkPhysicalDeviceVulkan12Features*>(current);
                if (enabling->samplerMirrorClampToEdge && !supported.samplerMirrorClampToEdge) {
                    ss << "VkPhysicalDeviceVulkan12Features::samplerMirrorClampToEdge is not supported\n";
                }
                if (enabling->drawIndirectCount && !supported.drawIndirectCount) {
                    ss << "VkPhysicalDeviceVulkan12Features::drawIndirectCount is not supported\n";
                }
                if (enabling->storageBuffer8BitAccess && !supported.storageBuffer8BitAccess) {
                    ss << "VkPhysicalDeviceVulkan12Features::storageBuffer8BitAccess is not supported\n";
                }
                if (enabling->uniformAndStorageBuffer8BitAccess && !supported.uniformAndStorageBuffer8BitAccess) {
                    ss << "VkPhysicalDeviceVulkan12Features::uniformAndStorageBuffer8BitAccess is not supported\n";
                }
                if (enabling->storagePushConstant8 && !supported.storagePushConstant8) {
                    ss << "VkPhysicalDeviceVulkan12Features::storagePushConstant8 is not supported\n";
                }
                if (enabling->shaderBufferInt64Atomics && !supported.shaderBufferInt64Atomics) {
                    ss << "VkPhysicalDeviceVulkan12Features::shaderBufferInt64Atomics is not supported\n";
                }
                if (enabling->shaderSharedInt64Atomics && !supported.shaderSharedInt64Atomics) {
                    ss << "VkPhysicalDeviceVulkan12Features::shaderSharedInt64Atomics is not supported\n";
                }
                if (enabling->shaderFloat16 && !supported.shaderFloat16) {
                    ss << "VkPhysicalDeviceVulkan12Features::shaderFloat16 is not supported\n";
                }
                if (enabling->shaderInt8 && !supported.shaderInt8) {
                    ss << "VkPhysicalDeviceVulkan12Features::shaderInt8 is not supported\n";
                }
                if (enabling->descriptorIndexing && !supported.descriptorIndexing) {
                    ss << "VkPhysicalDeviceVulkan12Features::descriptorIndexing is not supported\n";
                }
                if (enabling->shaderInputAttachmentArrayDynamicIndexing && !supported.shaderInputAttachmentArrayDynamicIndexing) {
                    ss << "VkPhysicalDeviceVulkan12Features::shaderInputAttachmentArrayDynamicIndexing is not supported\n";
                }
                if (enabling->shaderUniformTexelBufferArrayDynamicIndexing &&
                    !supported.shaderUniformTexelBufferArrayDynamicIndexing) {
                    ss << "VkPhysicalDeviceVulkan12Features::shaderUniformTexelBufferArrayDynamicIndexing is not supported\n";
                }
                if (enabling->shaderStorageTexelBufferArrayDynamicIndexing &&
                    !supported.shaderStorageTexelBufferArrayDynamicIndexing) {
                    ss << "VkPhysicalDeviceVulkan12Features::shaderStorageTexelBufferArrayDynamicIndexing is not supported\n";
                }
                if (enabling->shaderUniformBufferArrayNonUniformIndexing && !supported.shaderUniformBufferArrayNonUniformIndexing) {
                    ss << "VkPhysicalDeviceVulkan12Features::shaderUniformBufferArrayNonUniformIndexing is not supported\n";
                }
                if (enabling->shaderSampledImageArrayNonUniformIndexing && !supported.shaderSampledImageArrayNonUniformIndexing) {
                    ss << "VkPhysicalDeviceVulkan12Features::shaderSampledImageArrayNonUniformIndexing is not supported\n";
                }
                if (enabling->shaderStorageBufferArrayNonUniformIndexing && !supported.shaderStorageBufferArrayNonUniformIndexing) {
                    ss << "VkPhysicalDeviceVulkan12Features::shaderStorageBufferArrayNonUniformIndexing is not supported\n";
                }
                if (enabling->shaderStorageImageArrayNonUniformIndexing && !supported.shaderStorageImageArrayNonUniformIndexing) {
                    ss << "VkPhysicalDeviceVulkan12Features::shaderStorageImageArrayNonUniformIndexing is not supported\n";
                }
                if (enabling->shaderInputAttachmentArrayNonUniformIndexing &&
                    !supported.shaderInputAttachmentArrayNonUniformIndexing) {
                    ss << "VkPhysicalDeviceVulkan12Features::shaderInputAttachmentArrayNonUniformIndexing is not supported\n";
                }
                if (enabling->shaderUniformTexelBufferArrayNonUniformIndexing &&
                    !supported.shaderUniformTexelBufferArrayNonUniformIndexing) {
                    ss << "VkPhysicalDeviceVulkan12Features::shaderUniformTexelBufferArrayNonUniformIndexing is not supported\n";
                }
                if (enabling->shaderStorageTexelBufferArrayNonUniformIndexing &&
                    !supported.shaderStorageTexelBufferArrayNonUniformIndexing) {
                    ss << "VkPhysicalDeviceVulkan12Features::shaderStorageTexelBufferArrayNonUniformIndexing is not supported\n";
                }
                if (enabling->descriptorBindingUniformBufferUpdateAfterBind &&
                    !supported.descriptorBindingUniformBufferUpdateAfterBind) {
                    ss << "VkPhysicalDeviceVulkan12Features::descriptorBindingUniformBufferUpdateAfterBind is not supported\n";
                }
                if (enabling->descriptorBindingSampledImageUpdateAfterBind &&
                    !supported.descriptorBindingSampledImageUpdateAfterBind) {
                    ss << "VkPhysicalDeviceVulkan12Features::descriptorBindingSampledImageUpdateAfterBind is not supported\n";
                }
                if (enabling->descriptorBindingStorageImageUpdateAfterBind &&
                    !supported.descriptorBindingStorageImageUpdateAfterBind) {
                    ss << "VkPhysicalDeviceVulkan12Features::descriptorBindingStorageImageUpdateAfterBind is not supported\n";
                }
                if (enabling->descriptorBindingStorageBufferUpdateAfterBind &&
                    !supported.descriptorBindingStorageBufferUpdateAfterBind) {
                    ss << "VkPhysicalDeviceVulkan12Features::descriptorBindingStorageBufferUpdateAfterBind is not supported\n";
                }
                if (enabling->descriptorBindingUniformTexelBufferUpdateAfterBind &&
                    !supported.descriptorBindingUniformTexelBufferUpdateAfterBind) {
                    ss << "VkPhysicalDeviceVulkan12Features::descriptorBindingUniformTexelBufferUpdateAfterBind is not supported\n";
                }
                if (enabling->descriptorBindingStorageTexelBufferUpdateAfterBind &&
                    !supported.descriptorBindingStorageTexelBufferUpdateAfterBind) {
                    ss << "VkPhysicalDeviceVulkan12Features::descriptorBindingStorageTexelBufferUpdateAfterBind is not supported\n";
                }
                if (enabling->descriptorBindingUpdateUnusedWhilePending && !supported.descriptorBindingUpdateUnusedWhilePending) {
                    ss << "VkPhysicalDeviceVulkan12Features::descriptorBindingUpdateUnusedWhilePending is not supported\n";
                }
                if (enabling->descriptorBindingPartiallyBound && !supported.descriptorBindingPartiallyBound) {
                    ss << "VkPhysicalDeviceVulkan12Features::descriptorBindingPartiallyBound is not supported\n";
                }
                if (enabling->descriptorBindingVariableDescriptorCount && !supported.descriptorBindingVariableDescriptorCount) {
                    ss << "VkPhysicalDeviceVulkan12Features::descriptorBindingVariableDescriptorCount is not supported\n";
                }
                if (enabling->runtimeDescriptorArray && !supported.runtimeDescriptorArray) {
                    ss << "VkPhysicalDeviceVulkan12Features::runtimeDescriptorArray is not supported\n";
                }
                if (enabling->samplerFilterMinmax && !supported.samplerFilterMinmax) {
                    ss << "VkPhysicalDeviceVulkan12Features::samplerFilterMinmax is not supported\n";
                }
                if (enabling->scalarBlockLayout && !supported.scalarBlockLayout) {
                    ss << "VkPhysicalDeviceVulkan12Features::scalarBlockLayout is not supported\n";
                }
                if (enabling->imagelessFramebuffer && !supported.imagelessFramebuffer) {
                    ss << "VkPhysicalDeviceVulkan12Features::imagelessFramebuffer is not supported\n";
                }
                if (enabling->uniformBufferStandardLayout && !supported.uniformBufferStandardLayout) {
                    ss << "VkPhysicalDeviceVulkan12Features::uniformBufferStandardLayout is not supported\n";
                }
                if (enabling->shaderSubgroupExtendedTypes && !supported.shaderSubgroupExtendedTypes) {
                    ss << "VkPhysicalDeviceVulkan12Features::shaderSubgroupExtendedTypes is not supported\n";
                }
                if (enabling->separateDepthStencilLayouts && !supported.separateDepthStencilLayouts) {
                    ss << "VkPhysicalDeviceVulkan12Features::separateDepthStencilLayouts is not supported\n";
                }
                if (enabling->hostQueryReset && !supported.hostQueryReset) {
                    ss << "VkPhysicalDeviceVulkan12Features::hostQueryReset is not supported\n";
                }
                if (enabling->timelineSemaphore && !supported.timelineSemaphore) {
                    ss << "VkPhysicalDeviceVulkan12Features::timelineSemaphore is not supported\n";
                }
                if (enabling->bufferDeviceAddress && !supported.bufferDeviceAddress) {
                    ss << "VkPhysicalDeviceVulkan12Features::bufferDeviceAddress is not supported\n";
                }
                if (enabling->bufferDeviceAddressCaptureReplay && !supported.bufferDeviceAddressCaptureReplay) {
                    ss << "VkPhysicalDeviceVulkan12Features::bufferDeviceAddressCaptureReplay is not supported\n";
                }
                if (enabling->bufferDeviceAddressMultiDevice && !supported.bufferDeviceAddressMultiDevice) {
                    ss << "VkPhysicalDeviceVulkan12Features::bufferDeviceAddressMultiDevice is not supported\n";
                }
                if (enabling->vulkanMemoryModel && !supported.vulkanMemoryModel) {
                    ss << "VkPhysicalDeviceVulkan12Features::vulkanMemoryModel is not supported\n";
                }
                if (enabling->vulkanMemoryModelDeviceScope && !supported.vulkanMemoryModelDeviceScope) {
                    ss << "VkPhysicalDeviceVulkan12Features::vulkanMemoryModelDeviceScope is not supported\n";
                }
                if (enabling->vulkanMemoryModelAvailabilityVisibilityChains &&
                    !supported.vulkanMemoryModelAvailabilityVisibilityChains) {
                    ss << "VkPhysicalDeviceVulkan12Features::vulkanMemoryModelAvailabilityVisibilityChains is not supported\n";
                }
                if (enabling->shaderOutputViewportIndex && !supported.shaderOutputViewportIndex) {
                    ss << "VkPhysicalDeviceVulkan12Features::shaderOutputViewportIndex is not supported\n";
                }
                if (enabling->shaderOutputLayer && !supported.shaderOutputLayer) {
                    ss << "VkPhysicalDeviceVulkan12Features::shaderOutputLayer is not supported\n";
                }
                if (enabling->subgroupBroadcastDynamicId && !supported.subgroupBroadcastDynamicId) {
                    ss << "VkPhysicalDeviceVulkan12Features::subgroupBroadcastDynamicId is not supported\n";
                }
                break;
            }
            case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_1_3_FEATURES: {
                VkPhysicalDeviceVulkan13Features supported = vku::InitStructHelper();
                features_2.pNext = &supported;
                DispatchGetPhysicalDeviceFeatures2(gpu, &features_2);
                const VkPhysicalDeviceVulkan13Features* enabling =
                    reinterpret_cast<const VkPhysicalDeviceVulkan13Features*>(current);
                if (enabling->robustImageAccess && !supported.robustImageAccess) {
                    ss << "VkPhysicalDeviceVulkan13Features::robustImageAccess is not supported\n";
                }
                if (enabling->inlineUniformBlock && !supported.inlineUniformBlock) {
                    ss << "VkPhysicalDeviceVulkan13Features::inlineUniformBlock is not supported\n";
                }
                if (enabling->descriptorBindingInlineUniformBlockUpdateAfterBind &&
                    !supported.descriptorBindingInlineUniformBlockUpdateAfterBind) {
                    ss << "VkPhysicalDeviceVulkan13Features::descriptorBindingInlineUniformBlockUpdateAfterBind is not supported\n";
                }
                if (enabling->pipelineCreationCacheControl && !supported.pipelineCreationCacheControl) {
                    ss << "VkPhysicalDeviceVulkan13Features::pipelineCreationCacheControl is not supported\n";
                }
                if (enabling->privateData && !supported.privateData) {
                    ss << "VkPhysicalDeviceVulkan13Features::privateData is not supported\n";
                }
                if (enabling->shaderDemoteToHelperInvocation && !supported.shaderDemoteToHelperInvocation) {
                    ss << "VkPhysicalDeviceVulkan13Features::shaderDemoteToHelperInvocation is not supported\n";
                }
                if (enabling->shaderTerminateInvocation && !supported.shaderTerminateInvocation) {
                    ss << "VkPhysicalDeviceVulkan13Features::shaderTerminateInvocation is not supported\n";
                }
                if (enabling->subgroupSizeControl && !supported.subgroupSizeControl) {
                    ss << "VkPhysicalDeviceVulkan13Features::subgroupSizeControl is not supported\n";
                }
                if (enabling->computeFullSubgroups && !supported.computeFullSubgroups) {
                    ss << "VkPhysicalDeviceVulkan13Features::computeFullSubgroups is not supported\n";
                }
                if (enabling->synchronization2 && !supported.synchronization2) {
                    ss << "VkPhysicalDeviceVulkan13Features::synchronization2 is not supported\n";
                }
                if (enabling->textureCompressionASTC_HDR && !supported.textureCompressionASTC_HDR) {
                    ss << "VkPhysicalDeviceVulkan13Features::textureCompressionASTC_HDR is not supported\n";
                }
                if (enabling->shaderZeroInitializeWorkgroupMemory && !supported.shaderZeroInitializeWorkgroupMemory) {
                    ss << "VkPhysicalDeviceVulkan13Features::shaderZeroInitializeWorkgroupMemory is not supported\n";
                }
                if (enabling->dynamicRendering && !supported.dynamicRendering) {
                    ss << "VkPhysicalDeviceVulkan13Features::dynamicRendering is not supported\n";
                }
                if (enabling->shaderIntegerDotProduct && !supported.shaderIntegerDotProduct) {
                    ss << "VkPhysicalDeviceVulkan13Features::shaderIntegerDotProduct is not supported\n";
                }
                if (enabling->maintenance4 && !supported.maintenance4) {
                    ss << "VkPhysicalDeviceVulkan13Features::maintenance4 is not supported\n";
                }
                break;
            }
            case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_1_4_FEATURES: {
                VkPhysicalDeviceVulkan14Features supported = vku::InitStructHelper();
                features_2.pNext = &supported;
                DispatchGetPhysicalDeviceFeatures2(gpu, &features_2);
                const VkPhysicalDeviceVulkan14Features* enabling =
                    reinterpret_cast<const VkPhysicalDeviceVulkan14Features*>(current);
                if (enabling->globalPriorityQuery && !supported.globalPriorityQuery) {
                    ss << "VkPhysicalDeviceVulkan14Features::globalPriorityQuery is not supported\n";
                }
                if (enabling->shaderSubgroupRotate && !supported.shaderSubgroupRotate) {
                    ss << "VkPhysicalDeviceVulkan14Features::shaderSubgroupRotate is not supported\n";
                }
                if (enabling->shaderSubgroupRotateClustered && !supported.shaderSubgroupRotateClustered) {
                    ss << "VkPhysicalDeviceVulkan14Features::shaderSubgroupRotateClustered is not supported\n";
                }
                if (enabling->shaderFloatControls2 && !supported.shaderFloatControls2) {
                    ss << "VkPhysicalDeviceVulkan14Features::shaderFloatControls2 is not supported\n";
                }
                if (enabling->shaderExpectAssume && !supported.shaderExpectAssume) {
                    ss << "VkPhysicalDeviceVulkan14Features::shaderExpectAssume is not supported\n";
                }
                if (enabling->rectangularLines && !supported.rectangularLines) {
                    ss << "VkPhysicalDeviceVulkan14Features::rectangularLines is not supported\n";
                }
                if (enabling->bresenhamLines && !supported.bresenhamLines) {
                    ss << "VkPhysicalDeviceVulkan14Features::bresenhamLines is not supported\n";
                }
                if (enabling->smoothLines && !supported.smoothLines) {
                    ss << "VkPhysicalDeviceVulkan14Features::smoothLines is not supported\n";
                }
                if (enabling->stippledRectangularLines && !supported.stippledRectangularLines) {
                    ss << "VkPhysicalDeviceVulkan14Features::stippledRectangularLines is not supported\n";
                }
                if (enabling->stippledBresenhamLines && !supported.stippledBresenhamLines) {
                    ss << "VkPhysicalDeviceVulkan14Features::stippledBresenhamLines is not supported\n";
                }
                if (enabling->stippledSmoothLines && !supported.stippledSmoothLines) {
                    ss << "VkPhysicalDeviceVulkan14Features::stippledSmoothLines is not supported\n";
                }
                if (enabling->vertexAttributeInstanceRateDivisor && !supported.vertexAttributeInstanceRateDivisor) {
                    ss << "VkPhysicalDeviceVulkan14Features::vertexAttributeInstanceRateDivisor is not supported\n";
                }
                if (enabling->vertexAttributeInstanceRateZeroDivisor && !supported.vertexAttributeInstanceRateZeroDivisor) {
                    ss << "VkPhysicalDeviceVulkan14Features::vertexAttributeInstanceRateZeroDivisor is not supported\n";
                }
                if (enabling->indexTypeUint8 && !supported.indexTypeUint8) {
                    ss << "VkPhysicalDeviceVulkan14Features::indexTypeUint8 is not supported\n";
                }
                if (enabling->dynamicRenderingLocalRead && !supported.dynamicRenderingLocalRead) {
                    ss << "VkPhysicalDeviceVulkan14Features::dynamicRenderingLocalRead is not supported\n";
                }
                if (enabling->maintenance5 && !supported.maintenance5) {
                    ss << "VkPhysicalDeviceVulkan14Features::maintenance5 is not supported\n";
                }
                if (enabling->maintenance6 && !supported.maintenance6) {
                    ss << "VkPhysicalDeviceVulkan14Features::maintenance6 is not supported\n";
                }
                if (enabling->pipelineProtectedAccess && !supported.pipelineProtectedAccess) {
                    ss << "VkPhysicalDeviceVulkan14Features::pipelineProtectedAccess is not supported\n";
                }
                if (enabling->pipelineRobustness && !supported.pipelineRobustness) {
                    ss << "VkPhysicalDeviceVulkan14Features::pipelineRobustness is not supported\n";
                }
                if (enabling->hostImageCopy && !supported.hostImageCopy) {
                    ss << "VkPhysicalDeviceVulkan14Features::hostImageCopy is not supported\n";
                }
                if (enabling->pushDescriptor && !supported.pushDescriptor) {
                    ss << "VkPhysicalDeviceVulkan14Features::pushDescriptor is not supported\n";
                }
                break;
            }
            case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_MEMORY_MODEL_FEATURES: {
                VkPhysicalDeviceVulkanMemoryModelFeatures supported = vku::InitStructHelper();
                features_2.pNext = &supported;
                DispatchGetPhysicalDeviceFeatures2(gpu, &features_2);
                const VkPhysicalDeviceVulkanMemoryModelFeatures* enabling =
                    reinterpret_cast<const VkPhysicalDeviceVulkanMemoryModelFeatures*>(current);
                if (enabling->vulkanMemoryModel && !supported.vulkanMemoryModel) {
                    ss << "VkPhysicalDeviceVulkanMemoryModelFeatures::vulkanMemoryModel is not supported\n";
                }
                if (enabling->vulkanMemoryModelDeviceScope && !supported.vulkanMemoryModelDeviceScope) {
                    ss << "VkPhysicalDeviceVulkanMemoryModelFeatures::vulkanMemoryModelDeviceScope is not supported\n";
                }
                if (enabling->vulkanMemoryModelAvailabilityVisibilityChains &&
                    !supported.vulkanMemoryModelAvailabilityVisibilityChains) {
                    ss << "VkPhysicalDeviceVulkanMemoryModelFeatures::vulkanMemoryModelAvailabilityVisibilityChains is not "
                          "supported\n";
                }
                break;
            }
            case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_WORKGROUP_MEMORY_EXPLICIT_LAYOUT_FEATURES_KHR: {
                VkPhysicalDeviceWorkgroupMemoryExplicitLayoutFeaturesKHR supported = vku::InitStructHelper();
                features_2.pNext = &supported;
                DispatchGetPhysicalDeviceFeatures2(gpu, &features_2);
                const VkPhysicalDeviceWorkgroupMemoryExplicitLayoutFeaturesKHR* enabling =
                    reinterpret_cast<const VkPhysicalDeviceWorkgroupMemoryExplicitLayoutFeaturesKHR*>(current);
                if (enabling->workgroupMemoryExplicitLayout && !supported.workgroupMemoryExplicitLayout) {
                    ss << "VkPhysicalDeviceWorkgroupMemoryExplicitLayoutFeaturesKHR::workgroupMemoryExplicitLayout is not "
                          "supported\n";
                }
                if (enabling->workgroupMemoryExplicitLayoutScalarBlockLayout &&
                    !supported.workgroupMemoryExplicitLayoutScalarBlockLayout) {
                    ss << "VkPhysicalDeviceWorkgroupMemoryExplicitLayoutFeaturesKHR::"
                          "workgroupMemoryExplicitLayoutScalarBlockLayout is not supported\n";
                }
                if (enabling->workgroupMemoryExplicitLayout8BitAccess && !supported.workgroupMemoryExplicitLayout8BitAccess) {
                    ss << "VkPhysicalDeviceWorkgroupMemoryExplicitLayoutFeaturesKHR::workgroupMemoryExplicitLayout8BitAccess is "
                          "not supported\n";
                }
                if (enabling->workgroupMemoryExplicitLayout16BitAccess && !supported.workgroupMemoryExplicitLayout16BitAccess) {
                    ss << "VkPhysicalDeviceWorkgroupMemoryExplicitLayoutFeaturesKHR::workgroupMemoryExplicitLayout16BitAccess is "
                          "not supported\n";
                }
                break;
            }
            case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_YCBCR_2_PLANE_444_FORMATS_FEATURES_EXT: {
                VkPhysicalDeviceYcbcr2Plane444FormatsFeaturesEXT supported = vku::InitStructHelper();
                features_2.pNext = &supported;
                DispatchGetPhysicalDeviceFeatures2(gpu, &features_2);
                const VkPhysicalDeviceYcbcr2Plane444FormatsFeaturesEXT* enabling =
                    reinterpret_cast<const VkPhysicalDeviceYcbcr2Plane444FormatsFeaturesEXT*>(current);
                if (enabling->ycbcr2plane444Formats && !supported.ycbcr2plane444Formats) {
                    ss << "VkPhysicalDeviceYcbcr2Plane444FormatsFeaturesEXT::ycbcr2plane444Formats is not supported\n";
                }
                break;
            }
            case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_YCBCR_DEGAMMA_FEATURES_QCOM: {
                VkPhysicalDeviceYcbcrDegammaFeaturesQCOM supported = vku::InitStructHelper();
                features_2.pNext = &supported;
                DispatchGetPhysicalDeviceFeatures2(gpu, &features_2);
                const VkPhysicalDeviceYcbcrDegammaFeaturesQCOM* enabling =
                    reinterpret_cast<const VkPhysicalDeviceYcbcrDegammaFeaturesQCOM*>(current);
                if (enabling->ycbcrDegamma && !supported.ycbcrDegamma) {
                    ss << "VkPhysicalDeviceYcbcrDegammaFeaturesQCOM::ycbcrDegamma is not supported\n";
                }
                break;
            }
            case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_YCBCR_IMAGE_ARRAYS_FEATURES_EXT: {
                VkPhysicalDeviceYcbcrImageArraysFeaturesEXT supported = vku::InitStructHelper();
                features_2.pNext = &supported;
                DispatchGetPhysicalDeviceFeatures2(gpu, &features_2);
                const VkPhysicalDeviceYcbcrImageArraysFeaturesEXT* enabling =
                    reinterpret_cast<const VkPhysicalDeviceYcbcrImageArraysFeaturesEXT*>(current);
                if (enabling->ycbcrImageArrays && !supported.ycbcrImageArrays) {
                    ss << "VkPhysicalDeviceYcbcrImageArraysFeaturesEXT::ycbcrImageArrays is not supported\n";
                }
                break;
            }
            case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ZERO_INITIALIZE_DEVICE_MEMORY_FEATURES_EXT: {
                VkPhysicalDeviceZeroInitializeDeviceMemoryFeaturesEXT supported = vku::InitStructHelper();
                features_2.pNext = &supported;
                DispatchGetPhysicalDeviceFeatures2(gpu, &features_2);
                const VkPhysicalDeviceZeroInitializeDeviceMemoryFeaturesEXT* enabling =
                    reinterpret_cast<const VkPhysicalDeviceZeroInitializeDeviceMemoryFeaturesEXT*>(current);
                if (enabling->zeroInitializeDeviceMemory && !supported.zeroInitializeDeviceMemory) {
                    ss << "VkPhysicalDeviceZeroInitializeDeviceMemoryFeaturesEXT::zeroInitializeDeviceMemory is not supported\n";
                }
                break;
            }
            case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ZERO_INITIALIZE_WORKGROUP_MEMORY_FEATURES: {
                VkPhysicalDeviceZeroInitializeWorkgroupMemoryFeatures supported = vku::InitStructHelper();
                features_2.pNext = &supported;
                DispatchGetPhysicalDeviceFeatures2(gpu, &features_2);
                const VkPhysicalDeviceZeroInitializeWorkgroupMemoryFeatures* enabling =
                    reinterpret_cast<const VkPhysicalDeviceZeroInitializeWorkgroupMemoryFeatures*>(current);
                if (enabling->shaderZeroInitializeWorkgroupMemory && !supported.shaderZeroInitializeWorkgroupMemory) {
                    ss << "VkPhysicalDeviceZeroInitializeWorkgroupMemoryFeatures::shaderZeroInitializeWorkgroupMemory is not "
                          "supported\n";
                }
                break;
            }

            default:
                break;
        }
    }

    Location loc(vvl::Func::vkCreateDevice);
    LogWarning("WARNING-vkCreateDevice-FeatureNotPresent", instance, loc, "%s", ss.str().c_str());
}  // ReportErrorFeatureNotPresent
}  // namespace vvl