diff --git a/VulkanHppGenerator.cpp b/VulkanHppGenerator.cpp index 96c188c..bece386 100644 --- a/VulkanHppGenerator.cpp +++ b/VulkanHppGenerator.cpp @@ -478,6 +478,10 @@ ${baseTypes} #include #endif +#if !defined( VULKAN_HPP_NO_FROM_STRING ) +#include +#endif + #ifndef VULKAN_HPP_NO_EXCEPTIONS namespace std { @@ -776,6 +780,34 @@ ${enumsToString} writeToFile( str, vulkan_to_string_hpp ); } +void VulkanHppGenerator::generateFromStringHppFile() const +{ + std::string const vulkan_from_string_hpp = std::string( BASE_PATH ) + "/vulkan/" + m_api + "_from_string.hpp"; + std::cout << "VulkanHppGenerator: Generating " << vulkan_from_string_hpp << "..." << std::endl; + + std::string const vulkanHandlesHppTemplate = R"(${licenseHeader} +#ifndef VULKAN_FROM_STRING_HPP +# define VULKAN_FROM_STRING_HPP + +#include +#include +#include + +namespace VULKAN_HPP_NAMESPACE +{ +${enumsFromString} +} // namespace VULKAN_HPP_NAMESPACE +#endif +)"; + + std::string str = replaceWithMap( vulkanHandlesHppTemplate, + { { "api", m_api }, + { "enumsFromString", generateEnumsFromString() }, + { "licenseHeader", m_vulkanLicenseHeader } } ); + + writeToFile( str, vulkan_from_string_hpp ); +} + void VulkanHppGenerator::generateCppModuleFile() const { std::string const vulkan_cppm = std::string( BASE_PATH ) + "/vulkan/" + m_api + ".cppm"; @@ -6790,6 +6822,174 @@ ${functionBody} { { "argument", enumData.second.values.empty() ? "" : " value" }, { "enumName", enumName }, { "functionBody", functionBody } } ); } +std::string VulkanHppGenerator::generateEnumsFromString() const +{ + const std::string enumsFromStringTemplate = R"( +#define VULKAN_HPP_ENUM_FROM_STRING_STORAGE \ + namespace VULKAN_HPP_NAMESPACE \ + { \ + VULKAN_HPP_STORAGE_API const ::VULKAN_HPP_NAMESPACE::EnumFromStringMap enumFromStringMap; \ + } + + //========================= + //=== ENUMs from_string === + //========================= + +struct EnumFromStringMap +{ +${enumsFromStringStorage} +}; +VULKAN_HPP_STORAGE_API extern const EnumFromStringMap enumFromStringMap; + +template +std::optional from_string(const std::string&); +${enumsFromString} +)"; + + std::string enumsFromStringStorage; + std::string enumsFromString; + std::set listedEnums; + for ( auto const & feature : m_features ) + { + enumsFromStringStorage += generateEnumsFromStringStorage( feature.requireData, listedEnums, feature.name ); + } + for ( auto const & extension : m_extensions ) + { + enumsFromStringStorage += generateEnumsFromStringStorage( extension.requireData, listedEnums, extension.name ); + } + listedEnums.clear(); + for ( auto const & feature : m_features ) + { + enumsFromString += generateEnumsFromString( feature.requireData, listedEnums, feature.name ); + } + for ( auto const & extension : m_extensions ) + { + enumsFromString += generateEnumsFromString( extension.requireData, listedEnums, extension.name ); + } + + return replaceWithMap( enumsFromStringTemplate, { + { "enumsFromString", enumsFromString }, + { "enumsFromStringStorage", enumsFromStringStorage }} ); +} + +std::string VulkanHppGenerator::generateEnumsFromString( std::vector const & requireData, + std::set & listedEnums, + std::string const & title ) const +{ + std::string str; + for ( auto const & require : requireData ) + { + for ( auto const & type : require.types ) + { + auto enumIt = m_enums.find( type ); + if ( ( enumIt != m_enums.end() ) && !listedEnums.contains( type ) ) + { + listedEnums.insert( type ); + + str += "\n"; + str += generateEnumFromString( *enumIt ); + } + } + } + return addTitleAndProtection( title, str ); +} + +std::string VulkanHppGenerator::generateEnumFromString( std::pair const & enumData ) const +{ + std::string enumName = stripPrefix( enumData.first, "Vk" ); + std::string functionBody; + if ( enumData.second.values.empty() ) + { + functionBody = R"x( return std::nullopt;)x"; + } + else + { + const std::string functionBodyTemplate = + R"x( auto it = enumFromStringMap.${enumName}Entries.find(value); + if (it != enumFromStringMap.${enumName}Entries.end()) + { + return it->second; + } + return std::nullopt; +)x"; + + functionBody = replaceWithMap( functionBodyTemplate, { { "enumName", enumName } } ); + } + + const std::string enumFromStringTemplate = R"( + template<> + VULKAN_HPP_INLINE std::optional<${enumName}> from_string<${enumName}>( const std::string& ${argument} ) + { +${functionBody} + } +)"; + + return replaceWithMap( enumFromStringTemplate, + { { "argument", enumData.second.values.empty() ? "" : " value" }, { "enumName", enumName }, { "functionBody", functionBody } } ); +} + +std::string VulkanHppGenerator::generateEnumsFromStringStorage( std::vector const & requireData, + std::set & listedEnums, + std::string const & title ) const +{ + std::string str; + for ( auto const & require : requireData ) + { + for ( auto const & type : require.types ) + { + auto enumIt = m_enums.find( type ); + if ( ( enumIt != m_enums.end() ) && !listedEnums.contains( type ) ) + { + listedEnums.insert( type ); + + str += "\n"; + str += generateEnumFromStringStorage( *enumIt ); + } + } + } + return addTitleAndProtection( title, str ); +} + +std::string VulkanHppGenerator::generateEnumFromStringStorage( std::pair const & enumData ) const +{ + std::string enumName = stripPrefix( enumData.first, "Vk" ); + std::string entries; + + std::string previousEnter, previousLeave; + for ( auto const & value : enumData.second.values ) + { + // generate cases for non-alias enum values only + if ( value.alias.empty() ) + { + auto [enter, leave] = generateProtection( value.protect ); + if ( previousEnter != enter ) + { + entries += previousLeave + enter; + } + + const std::string entryTemplate = R"( { "${valueName}", ${enumName}::e${valueName} }, +)"; + entries += replaceWithMap( + entryTemplate, + { { "enumName", enumName }, { "valueName", generateEnumValueName( enumData.first, value.name, enumData.second.isBitmask ).substr( 1 ) } } ); + + previousEnter = enter; + previousLeave = leave; + } + } + entries += previousLeave; + + const std::string enumToStringTemplate = R"( + std::unordered_map ${enumName}Entries = + { +${entries} + }; +)"; + + return replaceWithMap( enumToStringTemplate, + { { "enumName", enumName }, { "entries", entries } } ); +} + std::pair VulkanHppGenerator::generateEnumSuffixes( std::string const & name, bool bitmask ) const { std::string prefix, postfix; @@ -15710,6 +15910,7 @@ int main( int argc, char ** argv ) generator.generateStaticAssertionsHppFile(); generator.generateStructsHppFile(); generator.generateToStringHppFile(); + generator.generateFromStringHppFile(); generator.generateCppModuleFile(); #if !defined( CLANG_FORMAT_EXECUTABLE ) diff --git a/VulkanHppGenerator.hpp b/VulkanHppGenerator.hpp index f3ac261..b0edb79 100644 --- a/VulkanHppGenerator.hpp +++ b/VulkanHppGenerator.hpp @@ -101,6 +101,7 @@ public: void generateStaticAssertionsHppFile() const; void generateStructsHppFile() const; void generateToStringHppFile() const; + void generateFromStringHppFile() const; void generateCppModuleFile() const; void prepareRAIIHandles(); void prepareVulkanFuncs(); @@ -701,6 +702,11 @@ private: std::string generateEnumsToString() const; std::string generateEnumsToString( std::vector const & requireData, std::set & listedEnums, std::string const & title ) const; std::string generateEnumToString( std::pair const & enumData ) const; + std::string generateEnumsFromString() const; + std::string generateEnumsFromString( std::vector const & requireData, std::set & listedEnums, std::string const & title ) const; + std::string generateEnumFromString( std::pair const & enumData ) const; + std::string generateEnumsFromStringStorage( std::vector const & requireData, std::set & listedEnums, std::string const & title ) const; + std::string generateEnumFromStringStorage( std::pair const & enumData ) const; std::pair generateEnumSuffixes( std::string const & name, bool bitmask ) const; std::string generateEnumValueName( std::string const & enumName, std::string const & valueName, bool bitmask ) const; std::string generateExtensionDependencies() const; diff --git a/vulkan/vulkan.hpp b/vulkan/vulkan.hpp index b904292..35a1ba9 100644 --- a/vulkan/vulkan.hpp +++ b/vulkan/vulkan.hpp @@ -6072,6 +6072,10 @@ namespace VULKAN_HPP_NAMESPACE # include #endif +#if !defined( VULKAN_HPP_NO_FROM_STRING ) +# include +#endif + #ifndef VULKAN_HPP_NO_EXCEPTIONS namespace std { @@ -15994,7 +15998,7 @@ namespace VULKAN_HPP_NAMESPACE # elif defined( __APPLE__ ) m_library = dlopen( "libvulkan.dylib", RTLD_NOW | RTLD_LOCAL ); # elif defined( _WIN32 ) - m_library = ::LoadLibraryA( "vulkan-1.dll" ); + m_library = ::LoadLibraryA( "vulkan-1.dll" ); # else # error unsupported platform # endif diff --git a/vulkan/vulkan_from_string.hpp b/vulkan/vulkan_from_string.hpp new file mode 100644 index 0000000..6c70898 --- /dev/null +++ b/vulkan/vulkan_from_string.hpp @@ -0,0 +1,7774 @@ +// Copyright 2015-2023 The Khronos Group Inc. +// +// SPDX-License-Identifier: Apache-2.0 OR MIT +// + +// This header is generated from the Khronos Vulkan XML API Registry. + +#ifndef VULKAN_FROM_STRING_HPP +#define VULKAN_FROM_STRING_HPP + +#include +#include +#include + +namespace VULKAN_HPP_NAMESPACE +{ + +#define VULKAN_HPP_ENUM_FROM_STRING_STORAGE \ + namespace VULKAN_HPP_NAMESPACE \ + { \ + VULKAN_HPP_STORAGE_API const ::VULKAN_HPP_NAMESPACE::EnumFromStringMap enumFromStringMap; \ + } + + //========================= + //=== ENUMs from_string === + //========================= + + struct EnumFromStringMap + { + //=== VK_VERSION_1_0 === + + std::unordered_map ResultEntries = { + { "Success", Result::eSuccess }, + { "NotReady", Result::eNotReady }, + { "Timeout", Result::eTimeout }, + { "EventSet", Result::eEventSet }, + { "EventReset", Result::eEventReset }, + { "Incomplete", Result::eIncomplete }, + { "ErrorOutOfHostMemory", Result::eErrorOutOfHostMemory }, + { "ErrorOutOfDeviceMemory", Result::eErrorOutOfDeviceMemory }, + { "ErrorInitializationFailed", Result::eErrorInitializationFailed }, + { "ErrorDeviceLost", Result::eErrorDeviceLost }, + { "ErrorMemoryMapFailed", Result::eErrorMemoryMapFailed }, + { "ErrorLayerNotPresent", Result::eErrorLayerNotPresent }, + { "ErrorExtensionNotPresent", Result::eErrorExtensionNotPresent }, + { "ErrorFeatureNotPresent", Result::eErrorFeatureNotPresent }, + { "ErrorIncompatibleDriver", Result::eErrorIncompatibleDriver }, + { "ErrorTooManyObjects", Result::eErrorTooManyObjects }, + { "ErrorFormatNotSupported", Result::eErrorFormatNotSupported }, + { "ErrorFragmentedPool", Result::eErrorFragmentedPool }, + { "ErrorUnknown", Result::eErrorUnknown }, + { "ErrorOutOfPoolMemory", Result::eErrorOutOfPoolMemory }, + { "ErrorInvalidExternalHandle", Result::eErrorInvalidExternalHandle }, + { "ErrorFragmentation", Result::eErrorFragmentation }, + { "ErrorInvalidOpaqueCaptureAddress", Result::eErrorInvalidOpaqueCaptureAddress }, + { "PipelineCompileRequired", Result::ePipelineCompileRequired }, + { "ErrorSurfaceLostKHR", Result::eErrorSurfaceLostKHR }, + { "ErrorNativeWindowInUseKHR", Result::eErrorNativeWindowInUseKHR }, + { "SuboptimalKHR", Result::eSuboptimalKHR }, + { "ErrorOutOfDateKHR", Result::eErrorOutOfDateKHR }, + { "ErrorIncompatibleDisplayKHR", Result::eErrorIncompatibleDisplayKHR }, + { "ErrorValidationFailedEXT", Result::eErrorValidationFailedEXT }, + { "ErrorInvalidShaderNV", Result::eErrorInvalidShaderNV }, + { "ErrorImageUsageNotSupportedKHR", Result::eErrorImageUsageNotSupportedKHR }, + { "ErrorVideoPictureLayoutNotSupportedKHR", Result::eErrorVideoPictureLayoutNotSupportedKHR }, + { "ErrorVideoProfileOperationNotSupportedKHR", Result::eErrorVideoProfileOperationNotSupportedKHR }, + { "ErrorVideoProfileFormatNotSupportedKHR", Result::eErrorVideoProfileFormatNotSupportedKHR }, + { "ErrorVideoProfileCodecNotSupportedKHR", Result::eErrorVideoProfileCodecNotSupportedKHR }, + { "ErrorVideoStdVersionNotSupportedKHR", Result::eErrorVideoStdVersionNotSupportedKHR }, + { "ErrorInvalidDrmFormatModifierPlaneLayoutEXT", Result::eErrorInvalidDrmFormatModifierPlaneLayoutEXT }, + { "ErrorNotPermittedKHR", Result::eErrorNotPermittedKHR }, +#if defined( VK_USE_PLATFORM_WIN32_KHR ) + { "ErrorFullScreenExclusiveModeLostEXT", Result::eErrorFullScreenExclusiveModeLostEXT }, +#endif /*VK_USE_PLATFORM_WIN32_KHR*/ + { "ThreadIdleKHR", Result::eThreadIdleKHR }, + { "ThreadDoneKHR", Result::eThreadDoneKHR }, + { "OperationDeferredKHR", Result::eOperationDeferredKHR }, + { "OperationNotDeferredKHR", Result::eOperationNotDeferredKHR }, +#if defined( VK_ENABLE_BETA_EXTENSIONS ) + { "ErrorInvalidVideoStdParametersKHR", Result::eErrorInvalidVideoStdParametersKHR }, +#endif /*VK_ENABLE_BETA_EXTENSIONS*/ + { "ErrorCompressionExhaustedEXT", Result::eErrorCompressionExhaustedEXT }, + { "ErrorIncompatibleShaderBinaryEXT", Result::eErrorIncompatibleShaderBinaryEXT }, + + }; + + std::unordered_map StructureTypeEntries = { + { "ApplicationInfo", StructureType::eApplicationInfo }, + { "InstanceCreateInfo", StructureType::eInstanceCreateInfo }, + { "DeviceQueueCreateInfo", StructureType::eDeviceQueueCreateInfo }, + { "DeviceCreateInfo", StructureType::eDeviceCreateInfo }, + { "SubmitInfo", StructureType::eSubmitInfo }, + { "MemoryAllocateInfo", StructureType::eMemoryAllocateInfo }, + { "MappedMemoryRange", StructureType::eMappedMemoryRange }, + { "BindSparseInfo", StructureType::eBindSparseInfo }, + { "FenceCreateInfo", StructureType::eFenceCreateInfo }, + { "SemaphoreCreateInfo", StructureType::eSemaphoreCreateInfo }, + { "EventCreateInfo", StructureType::eEventCreateInfo }, + { "QueryPoolCreateInfo", StructureType::eQueryPoolCreateInfo }, + { "BufferCreateInfo", StructureType::eBufferCreateInfo }, + { "BufferViewCreateInfo", StructureType::eBufferViewCreateInfo }, + { "ImageCreateInfo", StructureType::eImageCreateInfo }, + { "ImageViewCreateInfo", StructureType::eImageViewCreateInfo }, + { "ShaderModuleCreateInfo", StructureType::eShaderModuleCreateInfo }, + { "PipelineCacheCreateInfo", StructureType::ePipelineCacheCreateInfo }, + { "PipelineShaderStageCreateInfo", StructureType::ePipelineShaderStageCreateInfo }, + { "PipelineVertexInputStateCreateInfo", StructureType::ePipelineVertexInputStateCreateInfo }, + { "PipelineInputAssemblyStateCreateInfo", StructureType::ePipelineInputAssemblyStateCreateInfo }, + { "PipelineTessellationStateCreateInfo", StructureType::ePipelineTessellationStateCreateInfo }, + { "PipelineViewportStateCreateInfo", StructureType::ePipelineViewportStateCreateInfo }, + { "PipelineRasterizationStateCreateInfo", StructureType::ePipelineRasterizationStateCreateInfo }, + { "PipelineMultisampleStateCreateInfo", StructureType::ePipelineMultisampleStateCreateInfo }, + { "PipelineDepthStencilStateCreateInfo", StructureType::ePipelineDepthStencilStateCreateInfo }, + { "PipelineColorBlendStateCreateInfo", StructureType::ePipelineColorBlendStateCreateInfo }, + { "PipelineDynamicStateCreateInfo", StructureType::ePipelineDynamicStateCreateInfo }, + { "GraphicsPipelineCreateInfo", StructureType::eGraphicsPipelineCreateInfo }, + { "ComputePipelineCreateInfo", StructureType::eComputePipelineCreateInfo }, + { "PipelineLayoutCreateInfo", StructureType::ePipelineLayoutCreateInfo }, + { "SamplerCreateInfo", StructureType::eSamplerCreateInfo }, + { "DescriptorSetLayoutCreateInfo", StructureType::eDescriptorSetLayoutCreateInfo }, + { "DescriptorPoolCreateInfo", StructureType::eDescriptorPoolCreateInfo }, + { "DescriptorSetAllocateInfo", StructureType::eDescriptorSetAllocateInfo }, + { "WriteDescriptorSet", StructureType::eWriteDescriptorSet }, + { "CopyDescriptorSet", StructureType::eCopyDescriptorSet }, + { "FramebufferCreateInfo", StructureType::eFramebufferCreateInfo }, + { "RenderPassCreateInfo", StructureType::eRenderPassCreateInfo }, + { "CommandPoolCreateInfo", StructureType::eCommandPoolCreateInfo }, + { "CommandBufferAllocateInfo", StructureType::eCommandBufferAllocateInfo }, + { "CommandBufferInheritanceInfo", StructureType::eCommandBufferInheritanceInfo }, + { "CommandBufferBeginInfo", StructureType::eCommandBufferBeginInfo }, + { "RenderPassBeginInfo", StructureType::eRenderPassBeginInfo }, + { "BufferMemoryBarrier", StructureType::eBufferMemoryBarrier }, + { "ImageMemoryBarrier", StructureType::eImageMemoryBarrier }, + { "MemoryBarrier", StructureType::eMemoryBarrier }, + { "LoaderInstanceCreateInfo", StructureType::eLoaderInstanceCreateInfo }, + { "LoaderDeviceCreateInfo", StructureType::eLoaderDeviceCreateInfo }, + { "PhysicalDeviceSubgroupProperties", StructureType::ePhysicalDeviceSubgroupProperties }, + { "BindBufferMemoryInfo", StructureType::eBindBufferMemoryInfo }, + { "BindImageMemoryInfo", StructureType::eBindImageMemoryInfo }, + { "PhysicalDevice16BitStorageFeatures", StructureType::ePhysicalDevice16BitStorageFeatures }, + { "MemoryDedicatedRequirements", StructureType::eMemoryDedicatedRequirements }, + { "MemoryDedicatedAllocateInfo", StructureType::eMemoryDedicatedAllocateInfo }, + { "MemoryAllocateFlagsInfo", StructureType::eMemoryAllocateFlagsInfo }, + { "DeviceGroupRenderPassBeginInfo", StructureType::eDeviceGroupRenderPassBeginInfo }, + { "DeviceGroupCommandBufferBeginInfo", StructureType::eDeviceGroupCommandBufferBeginInfo }, + { "DeviceGroupSubmitInfo", StructureType::eDeviceGroupSubmitInfo }, + { "DeviceGroupBindSparseInfo", StructureType::eDeviceGroupBindSparseInfo }, + { "BindBufferMemoryDeviceGroupInfo", StructureType::eBindBufferMemoryDeviceGroupInfo }, + { "BindImageMemoryDeviceGroupInfo", StructureType::eBindImageMemoryDeviceGroupInfo }, + { "PhysicalDeviceGroupProperties", StructureType::ePhysicalDeviceGroupProperties }, + { "DeviceGroupDeviceCreateInfo", StructureType::eDeviceGroupDeviceCreateInfo }, + { "BufferMemoryRequirementsInfo2", StructureType::eBufferMemoryRequirementsInfo2 }, + { "ImageMemoryRequirementsInfo2", StructureType::eImageMemoryRequirementsInfo2 }, + { "ImageSparseMemoryRequirementsInfo2", StructureType::eImageSparseMemoryRequirementsInfo2 }, + { "MemoryRequirements2", StructureType::eMemoryRequirements2 }, + { "SparseImageMemoryRequirements2", StructureType::eSparseImageMemoryRequirements2 }, + { "PhysicalDeviceFeatures2", StructureType::ePhysicalDeviceFeatures2 }, + { "PhysicalDeviceProperties2", StructureType::ePhysicalDeviceProperties2 }, + { "FormatProperties2", StructureType::eFormatProperties2 }, + { "ImageFormatProperties2", StructureType::eImageFormatProperties2 }, + { "PhysicalDeviceImageFormatInfo2", StructureType::ePhysicalDeviceImageFormatInfo2 }, + { "QueueFamilyProperties2", StructureType::eQueueFamilyProperties2 }, + { "PhysicalDeviceMemoryProperties2", StructureType::ePhysicalDeviceMemoryProperties2 }, + { "SparseImageFormatProperties2", StructureType::eSparseImageFormatProperties2 }, + { "PhysicalDeviceSparseImageFormatInfo2", StructureType::ePhysicalDeviceSparseImageFormatInfo2 }, + { "PhysicalDevicePointClippingProperties", StructureType::ePhysicalDevicePointClippingProperties }, + { "RenderPassInputAttachmentAspectCreateInfo", StructureType::eRenderPassInputAttachmentAspectCreateInfo }, + { "ImageViewUsageCreateInfo", StructureType::eImageViewUsageCreateInfo }, + { "PipelineTessellationDomainOriginStateCreateInfo", StructureType::ePipelineTessellationDomainOriginStateCreateInfo }, + { "RenderPassMultiviewCreateInfo", StructureType::eRenderPassMultiviewCreateInfo }, + { "PhysicalDeviceMultiviewFeatures", StructureType::ePhysicalDeviceMultiviewFeatures }, + { "PhysicalDeviceMultiviewProperties", StructureType::ePhysicalDeviceMultiviewProperties }, + { "PhysicalDeviceVariablePointersFeatures", StructureType::ePhysicalDeviceVariablePointersFeatures }, + { "ProtectedSubmitInfo", StructureType::eProtectedSubmitInfo }, + { "PhysicalDeviceProtectedMemoryFeatures", StructureType::ePhysicalDeviceProtectedMemoryFeatures }, + { "PhysicalDeviceProtectedMemoryProperties", StructureType::ePhysicalDeviceProtectedMemoryProperties }, + { "DeviceQueueInfo2", StructureType::eDeviceQueueInfo2 }, + { "SamplerYcbcrConversionCreateInfo", StructureType::eSamplerYcbcrConversionCreateInfo }, + { "SamplerYcbcrConversionInfo", StructureType::eSamplerYcbcrConversionInfo }, + { "BindImagePlaneMemoryInfo", StructureType::eBindImagePlaneMemoryInfo }, + { "ImagePlaneMemoryRequirementsInfo", StructureType::eImagePlaneMemoryRequirementsInfo }, + { "PhysicalDeviceSamplerYcbcrConversionFeatures", StructureType::ePhysicalDeviceSamplerYcbcrConversionFeatures }, + { "SamplerYcbcrConversionImageFormatProperties", StructureType::eSamplerYcbcrConversionImageFormatProperties }, + { "DescriptorUpdateTemplateCreateInfo", StructureType::eDescriptorUpdateTemplateCreateInfo }, + { "PhysicalDeviceExternalImageFormatInfo", StructureType::ePhysicalDeviceExternalImageFormatInfo }, + { "ExternalImageFormatProperties", StructureType::eExternalImageFormatProperties }, + { "PhysicalDeviceExternalBufferInfo", StructureType::ePhysicalDeviceExternalBufferInfo }, + { "ExternalBufferProperties", StructureType::eExternalBufferProperties }, + { "PhysicalDeviceIdProperties", StructureType::ePhysicalDeviceIdProperties }, + { "ExternalMemoryBufferCreateInfo", StructureType::eExternalMemoryBufferCreateInfo }, + { "ExternalMemoryImageCreateInfo", StructureType::eExternalMemoryImageCreateInfo }, + { "ExportMemoryAllocateInfo", StructureType::eExportMemoryAllocateInfo }, + { "PhysicalDeviceExternalFenceInfo", StructureType::ePhysicalDeviceExternalFenceInfo }, + { "ExternalFenceProperties", StructureType::eExternalFenceProperties }, + { "ExportFenceCreateInfo", StructureType::eExportFenceCreateInfo }, + { "ExportSemaphoreCreateInfo", StructureType::eExportSemaphoreCreateInfo }, + { "PhysicalDeviceExternalSemaphoreInfo", StructureType::ePhysicalDeviceExternalSemaphoreInfo }, + { "ExternalSemaphoreProperties", StructureType::eExternalSemaphoreProperties }, + { "PhysicalDeviceMaintenance3Properties", StructureType::ePhysicalDeviceMaintenance3Properties }, + { "DescriptorSetLayoutSupport", StructureType::eDescriptorSetLayoutSupport }, + { "PhysicalDeviceShaderDrawParametersFeatures", StructureType::ePhysicalDeviceShaderDrawParametersFeatures }, + { "PhysicalDeviceVulkan11Features", StructureType::ePhysicalDeviceVulkan11Features }, + { "PhysicalDeviceVulkan11Properties", StructureType::ePhysicalDeviceVulkan11Properties }, + { "PhysicalDeviceVulkan12Features", StructureType::ePhysicalDeviceVulkan12Features }, + { "PhysicalDeviceVulkan12Properties", StructureType::ePhysicalDeviceVulkan12Properties }, + { "ImageFormatListCreateInfo", StructureType::eImageFormatListCreateInfo }, + { "AttachmentDescription2", StructureType::eAttachmentDescription2 }, + { "AttachmentReference2", StructureType::eAttachmentReference2 }, + { "SubpassDescription2", StructureType::eSubpassDescription2 }, + { "SubpassDependency2", StructureType::eSubpassDependency2 }, + { "RenderPassCreateInfo2", StructureType::eRenderPassCreateInfo2 }, + { "SubpassBeginInfo", StructureType::eSubpassBeginInfo }, + { "SubpassEndInfo", StructureType::eSubpassEndInfo }, + { "PhysicalDevice8BitStorageFeatures", StructureType::ePhysicalDevice8BitStorageFeatures }, + { "PhysicalDeviceDriverProperties", StructureType::ePhysicalDeviceDriverProperties }, + { "PhysicalDeviceShaderAtomicInt64Features", StructureType::ePhysicalDeviceShaderAtomicInt64Features }, + { "PhysicalDeviceShaderFloat16Int8Features", StructureType::ePhysicalDeviceShaderFloat16Int8Features }, + { "PhysicalDeviceFloatControlsProperties", StructureType::ePhysicalDeviceFloatControlsProperties }, + { "DescriptorSetLayoutBindingFlagsCreateInfo", StructureType::eDescriptorSetLayoutBindingFlagsCreateInfo }, + { "PhysicalDeviceDescriptorIndexingFeatures", StructureType::ePhysicalDeviceDescriptorIndexingFeatures }, + { "PhysicalDeviceDescriptorIndexingProperties", StructureType::ePhysicalDeviceDescriptorIndexingProperties }, + { "DescriptorSetVariableDescriptorCountAllocateInfo", StructureType::eDescriptorSetVariableDescriptorCountAllocateInfo }, + { "DescriptorSetVariableDescriptorCountLayoutSupport", StructureType::eDescriptorSetVariableDescriptorCountLayoutSupport }, + { "PhysicalDeviceDepthStencilResolveProperties", StructureType::ePhysicalDeviceDepthStencilResolveProperties }, + { "SubpassDescriptionDepthStencilResolve", StructureType::eSubpassDescriptionDepthStencilResolve }, + { "PhysicalDeviceScalarBlockLayoutFeatures", StructureType::ePhysicalDeviceScalarBlockLayoutFeatures }, + { "ImageStencilUsageCreateInfo", StructureType::eImageStencilUsageCreateInfo }, + { "PhysicalDeviceSamplerFilterMinmaxProperties", StructureType::ePhysicalDeviceSamplerFilterMinmaxProperties }, + { "SamplerReductionModeCreateInfo", StructureType::eSamplerReductionModeCreateInfo }, + { "PhysicalDeviceVulkanMemoryModelFeatures", StructureType::ePhysicalDeviceVulkanMemoryModelFeatures }, + { "PhysicalDeviceImagelessFramebufferFeatures", StructureType::ePhysicalDeviceImagelessFramebufferFeatures }, + { "FramebufferAttachmentsCreateInfo", StructureType::eFramebufferAttachmentsCreateInfo }, + { "FramebufferAttachmentImageInfo", StructureType::eFramebufferAttachmentImageInfo }, + { "RenderPassAttachmentBeginInfo", StructureType::eRenderPassAttachmentBeginInfo }, + { "PhysicalDeviceUniformBufferStandardLayoutFeatures", StructureType::ePhysicalDeviceUniformBufferStandardLayoutFeatures }, + { "PhysicalDeviceShaderSubgroupExtendedTypesFeatures", StructureType::ePhysicalDeviceShaderSubgroupExtendedTypesFeatures }, + { "PhysicalDeviceSeparateDepthStencilLayoutsFeatures", StructureType::ePhysicalDeviceSeparateDepthStencilLayoutsFeatures }, + { "AttachmentReferenceStencilLayout", StructureType::eAttachmentReferenceStencilLayout }, + { "AttachmentDescriptionStencilLayout", StructureType::eAttachmentDescriptionStencilLayout }, + { "PhysicalDeviceHostQueryResetFeatures", StructureType::ePhysicalDeviceHostQueryResetFeatures }, + { "PhysicalDeviceTimelineSemaphoreFeatures", StructureType::ePhysicalDeviceTimelineSemaphoreFeatures }, + { "PhysicalDeviceTimelineSemaphoreProperties", StructureType::ePhysicalDeviceTimelineSemaphoreProperties }, + { "SemaphoreTypeCreateInfo", StructureType::eSemaphoreTypeCreateInfo }, + { "TimelineSemaphoreSubmitInfo", StructureType::eTimelineSemaphoreSubmitInfo }, + { "SemaphoreWaitInfo", StructureType::eSemaphoreWaitInfo }, + { "SemaphoreSignalInfo", StructureType::eSemaphoreSignalInfo }, + { "PhysicalDeviceBufferDeviceAddressFeatures", StructureType::ePhysicalDeviceBufferDeviceAddressFeatures }, + { "BufferDeviceAddressInfo", StructureType::eBufferDeviceAddressInfo }, + { "BufferOpaqueCaptureAddressCreateInfo", StructureType::eBufferOpaqueCaptureAddressCreateInfo }, + { "MemoryOpaqueCaptureAddressAllocateInfo", StructureType::eMemoryOpaqueCaptureAddressAllocateInfo }, + { "DeviceMemoryOpaqueCaptureAddressInfo", StructureType::eDeviceMemoryOpaqueCaptureAddressInfo }, + { "PhysicalDeviceVulkan13Features", StructureType::ePhysicalDeviceVulkan13Features }, + { "PhysicalDeviceVulkan13Properties", StructureType::ePhysicalDeviceVulkan13Properties }, + { "PipelineCreationFeedbackCreateInfo", StructureType::ePipelineCreationFeedbackCreateInfo }, + { "PhysicalDeviceShaderTerminateInvocationFeatures", StructureType::ePhysicalDeviceShaderTerminateInvocationFeatures }, + { "PhysicalDeviceToolProperties", StructureType::ePhysicalDeviceToolProperties }, + { "PhysicalDeviceShaderDemoteToHelperInvocationFeatures", StructureType::ePhysicalDeviceShaderDemoteToHelperInvocationFeatures }, + { "PhysicalDevicePrivateDataFeatures", StructureType::ePhysicalDevicePrivateDataFeatures }, + { "DevicePrivateDataCreateInfo", StructureType::eDevicePrivateDataCreateInfo }, + { "PrivateDataSlotCreateInfo", StructureType::ePrivateDataSlotCreateInfo }, + { "PhysicalDevicePipelineCreationCacheControlFeatures", StructureType::ePhysicalDevicePipelineCreationCacheControlFeatures }, + { "MemoryBarrier2", StructureType::eMemoryBarrier2 }, + { "BufferMemoryBarrier2", StructureType::eBufferMemoryBarrier2 }, + { "ImageMemoryBarrier2", StructureType::eImageMemoryBarrier2 }, + { "DependencyInfo", StructureType::eDependencyInfo }, + { "SubmitInfo2", StructureType::eSubmitInfo2 }, + { "SemaphoreSubmitInfo", StructureType::eSemaphoreSubmitInfo }, + { "CommandBufferSubmitInfo", StructureType::eCommandBufferSubmitInfo }, + { "PhysicalDeviceSynchronization2Features", StructureType::ePhysicalDeviceSynchronization2Features }, + { "PhysicalDeviceZeroInitializeWorkgroupMemoryFeatures", StructureType::ePhysicalDeviceZeroInitializeWorkgroupMemoryFeatures }, + { "PhysicalDeviceImageRobustnessFeatures", StructureType::ePhysicalDeviceImageRobustnessFeatures }, + { "CopyBufferInfo2", StructureType::eCopyBufferInfo2 }, + { "CopyImageInfo2", StructureType::eCopyImageInfo2 }, + { "CopyBufferToImageInfo2", StructureType::eCopyBufferToImageInfo2 }, + { "CopyImageToBufferInfo2", StructureType::eCopyImageToBufferInfo2 }, + { "BlitImageInfo2", StructureType::eBlitImageInfo2 }, + { "ResolveImageInfo2", StructureType::eResolveImageInfo2 }, + { "BufferCopy2", StructureType::eBufferCopy2 }, + { "ImageCopy2", StructureType::eImageCopy2 }, + { "ImageBlit2", StructureType::eImageBlit2 }, + { "BufferImageCopy2", StructureType::eBufferImageCopy2 }, + { "ImageResolve2", StructureType::eImageResolve2 }, + { "PhysicalDeviceSubgroupSizeControlProperties", StructureType::ePhysicalDeviceSubgroupSizeControlProperties }, + { "PipelineShaderStageRequiredSubgroupSizeCreateInfo", StructureType::ePipelineShaderStageRequiredSubgroupSizeCreateInfo }, + { "PhysicalDeviceSubgroupSizeControlFeatures", StructureType::ePhysicalDeviceSubgroupSizeControlFeatures }, + { "PhysicalDeviceInlineUniformBlockFeatures", StructureType::ePhysicalDeviceInlineUniformBlockFeatures }, + { "PhysicalDeviceInlineUniformBlockProperties", StructureType::ePhysicalDeviceInlineUniformBlockProperties }, + { "WriteDescriptorSetInlineUniformBlock", StructureType::eWriteDescriptorSetInlineUniformBlock }, + { "DescriptorPoolInlineUniformBlockCreateInfo", StructureType::eDescriptorPoolInlineUniformBlockCreateInfo }, + { "PhysicalDeviceTextureCompressionAstcHdrFeatures", StructureType::ePhysicalDeviceTextureCompressionAstcHdrFeatures }, + { "RenderingInfo", StructureType::eRenderingInfo }, + { "RenderingAttachmentInfo", StructureType::eRenderingAttachmentInfo }, + { "PipelineRenderingCreateInfo", StructureType::ePipelineRenderingCreateInfo }, + { "PhysicalDeviceDynamicRenderingFeatures", StructureType::ePhysicalDeviceDynamicRenderingFeatures }, + { "CommandBufferInheritanceRenderingInfo", StructureType::eCommandBufferInheritanceRenderingInfo }, + { "PhysicalDeviceShaderIntegerDotProductFeatures", StructureType::ePhysicalDeviceShaderIntegerDotProductFeatures }, + { "PhysicalDeviceShaderIntegerDotProductProperties", StructureType::ePhysicalDeviceShaderIntegerDotProductProperties }, + { "PhysicalDeviceTexelBufferAlignmentProperties", StructureType::ePhysicalDeviceTexelBufferAlignmentProperties }, + { "FormatProperties3", StructureType::eFormatProperties3 }, + { "PhysicalDeviceMaintenance4Features", StructureType::ePhysicalDeviceMaintenance4Features }, + { "PhysicalDeviceMaintenance4Properties", StructureType::ePhysicalDeviceMaintenance4Properties }, + { "DeviceBufferMemoryRequirements", StructureType::eDeviceBufferMemoryRequirements }, + { "DeviceImageMemoryRequirements", StructureType::eDeviceImageMemoryRequirements }, + { "SwapchainCreateInfoKHR", StructureType::eSwapchainCreateInfoKHR }, + { "PresentInfoKHR", StructureType::ePresentInfoKHR }, + { "DeviceGroupPresentCapabilitiesKHR", StructureType::eDeviceGroupPresentCapabilitiesKHR }, + { "ImageSwapchainCreateInfoKHR", StructureType::eImageSwapchainCreateInfoKHR }, + { "BindImageMemorySwapchainInfoKHR", StructureType::eBindImageMemorySwapchainInfoKHR }, + { "AcquireNextImageInfoKHR", StructureType::eAcquireNextImageInfoKHR }, + { "DeviceGroupPresentInfoKHR", StructureType::eDeviceGroupPresentInfoKHR }, + { "DeviceGroupSwapchainCreateInfoKHR", StructureType::eDeviceGroupSwapchainCreateInfoKHR }, + { "DisplayModeCreateInfoKHR", StructureType::eDisplayModeCreateInfoKHR }, + { "DisplaySurfaceCreateInfoKHR", StructureType::eDisplaySurfaceCreateInfoKHR }, + { "DisplayPresentInfoKHR", StructureType::eDisplayPresentInfoKHR }, +#if defined( VK_USE_PLATFORM_XLIB_KHR ) + { "XlibSurfaceCreateInfoKHR", StructureType::eXlibSurfaceCreateInfoKHR }, +#endif /*VK_USE_PLATFORM_XLIB_KHR*/ +#if defined( VK_USE_PLATFORM_XCB_KHR ) + { "XcbSurfaceCreateInfoKHR", StructureType::eXcbSurfaceCreateInfoKHR }, +#endif /*VK_USE_PLATFORM_XCB_KHR*/ +#if defined( VK_USE_PLATFORM_WAYLAND_KHR ) + { "WaylandSurfaceCreateInfoKHR", StructureType::eWaylandSurfaceCreateInfoKHR }, +#endif /*VK_USE_PLATFORM_WAYLAND_KHR*/ +#if defined( VK_USE_PLATFORM_ANDROID_KHR ) + { "AndroidSurfaceCreateInfoKHR", StructureType::eAndroidSurfaceCreateInfoKHR }, +#endif /*VK_USE_PLATFORM_ANDROID_KHR*/ +#if defined( VK_USE_PLATFORM_WIN32_KHR ) + { "Win32SurfaceCreateInfoKHR", StructureType::eWin32SurfaceCreateInfoKHR }, +#endif /*VK_USE_PLATFORM_WIN32_KHR*/ + { "DebugReportCallbackCreateInfoEXT", StructureType::eDebugReportCallbackCreateInfoEXT }, + { "PipelineRasterizationStateRasterizationOrderAMD", StructureType::ePipelineRasterizationStateRasterizationOrderAMD }, + { "DebugMarkerObjectNameInfoEXT", StructureType::eDebugMarkerObjectNameInfoEXT }, + { "DebugMarkerObjectTagInfoEXT", StructureType::eDebugMarkerObjectTagInfoEXT }, + { "DebugMarkerMarkerInfoEXT", StructureType::eDebugMarkerMarkerInfoEXT }, + { "VideoProfileInfoKHR", StructureType::eVideoProfileInfoKHR }, + { "VideoCapabilitiesKHR", StructureType::eVideoCapabilitiesKHR }, + { "VideoPictureResourceInfoKHR", StructureType::eVideoPictureResourceInfoKHR }, + { "VideoSessionMemoryRequirementsKHR", StructureType::eVideoSessionMemoryRequirementsKHR }, + { "BindVideoSessionMemoryInfoKHR", StructureType::eBindVideoSessionMemoryInfoKHR }, + { "VideoSessionCreateInfoKHR", StructureType::eVideoSessionCreateInfoKHR }, + { "VideoSessionParametersCreateInfoKHR", StructureType::eVideoSessionParametersCreateInfoKHR }, + { "VideoSessionParametersUpdateInfoKHR", StructureType::eVideoSessionParametersUpdateInfoKHR }, + { "VideoBeginCodingInfoKHR", StructureType::eVideoBeginCodingInfoKHR }, + { "VideoEndCodingInfoKHR", StructureType::eVideoEndCodingInfoKHR }, + { "VideoCodingControlInfoKHR", StructureType::eVideoCodingControlInfoKHR }, + { "VideoReferenceSlotInfoKHR", StructureType::eVideoReferenceSlotInfoKHR }, + { "QueueFamilyVideoPropertiesKHR", StructureType::eQueueFamilyVideoPropertiesKHR }, + { "VideoProfileListInfoKHR", StructureType::eVideoProfileListInfoKHR }, + { "PhysicalDeviceVideoFormatInfoKHR", StructureType::ePhysicalDeviceVideoFormatInfoKHR }, + { "VideoFormatPropertiesKHR", StructureType::eVideoFormatPropertiesKHR }, + { "QueueFamilyQueryResultStatusPropertiesKHR", StructureType::eQueueFamilyQueryResultStatusPropertiesKHR }, + { "VideoDecodeInfoKHR", StructureType::eVideoDecodeInfoKHR }, + { "VideoDecodeCapabilitiesKHR", StructureType::eVideoDecodeCapabilitiesKHR }, + { "VideoDecodeUsageInfoKHR", StructureType::eVideoDecodeUsageInfoKHR }, + { "DedicatedAllocationImageCreateInfoNV", StructureType::eDedicatedAllocationImageCreateInfoNV }, + { "DedicatedAllocationBufferCreateInfoNV", StructureType::eDedicatedAllocationBufferCreateInfoNV }, + { "DedicatedAllocationMemoryAllocateInfoNV", StructureType::eDedicatedAllocationMemoryAllocateInfoNV }, + { "PhysicalDeviceTransformFeedbackFeaturesEXT", StructureType::ePhysicalDeviceTransformFeedbackFeaturesEXT }, + { "PhysicalDeviceTransformFeedbackPropertiesEXT", StructureType::ePhysicalDeviceTransformFeedbackPropertiesEXT }, + { "PipelineRasterizationStateStreamCreateInfoEXT", StructureType::ePipelineRasterizationStateStreamCreateInfoEXT }, + { "CuModuleCreateInfoNVX", StructureType::eCuModuleCreateInfoNVX }, + { "CuFunctionCreateInfoNVX", StructureType::eCuFunctionCreateInfoNVX }, + { "CuLaunchInfoNVX", StructureType::eCuLaunchInfoNVX }, + { "ImageViewHandleInfoNVX", StructureType::eImageViewHandleInfoNVX }, + { "ImageViewAddressPropertiesNVX", StructureType::eImageViewAddressPropertiesNVX }, +#if defined( VK_ENABLE_BETA_EXTENSIONS ) + { "VideoEncodeH264CapabilitiesEXT", StructureType::eVideoEncodeH264CapabilitiesEXT }, + { "VideoEncodeH264SessionParametersCreateInfoEXT", StructureType::eVideoEncodeH264SessionParametersCreateInfoEXT }, + { "VideoEncodeH264SessionParametersAddInfoEXT", StructureType::eVideoEncodeH264SessionParametersAddInfoEXT }, + { "VideoEncodeH264PictureInfoEXT", StructureType::eVideoEncodeH264PictureInfoEXT }, + { "VideoEncodeH264DpbSlotInfoEXT", StructureType::eVideoEncodeH264DpbSlotInfoEXT }, + { "VideoEncodeH264NaluSliceInfoEXT", StructureType::eVideoEncodeH264NaluSliceInfoEXT }, + { "VideoEncodeH264GopRemainingFrameInfoEXT", StructureType::eVideoEncodeH264GopRemainingFrameInfoEXT }, + { "VideoEncodeH264ProfileInfoEXT", StructureType::eVideoEncodeH264ProfileInfoEXT }, + { "VideoEncodeH264RateControlInfoEXT", StructureType::eVideoEncodeH264RateControlInfoEXT }, + { "VideoEncodeH264RateControlLayerInfoEXT", StructureType::eVideoEncodeH264RateControlLayerInfoEXT }, + { "VideoEncodeH264SessionCreateInfoEXT", StructureType::eVideoEncodeH264SessionCreateInfoEXT }, + { "VideoEncodeH264QualityLevelPropertiesEXT", StructureType::eVideoEncodeH264QualityLevelPropertiesEXT }, + { "VideoEncodeH264SessionParametersGetInfoEXT", StructureType::eVideoEncodeH264SessionParametersGetInfoEXT }, + { "VideoEncodeH264SessionParametersFeedbackInfoEXT", StructureType::eVideoEncodeH264SessionParametersFeedbackInfoEXT }, + { "VideoEncodeH265CapabilitiesEXT", StructureType::eVideoEncodeH265CapabilitiesEXT }, + { "VideoEncodeH265SessionParametersCreateInfoEXT", StructureType::eVideoEncodeH265SessionParametersCreateInfoEXT }, + { "VideoEncodeH265SessionParametersAddInfoEXT", StructureType::eVideoEncodeH265SessionParametersAddInfoEXT }, + { "VideoEncodeH265PictureInfoEXT", StructureType::eVideoEncodeH265PictureInfoEXT }, + { "VideoEncodeH265DpbSlotInfoEXT", StructureType::eVideoEncodeH265DpbSlotInfoEXT }, + { "VideoEncodeH265NaluSliceSegmentInfoEXT", StructureType::eVideoEncodeH265NaluSliceSegmentInfoEXT }, + { "VideoEncodeH265GopRemainingFrameInfoEXT", StructureType::eVideoEncodeH265GopRemainingFrameInfoEXT }, + { "VideoEncodeH265ProfileInfoEXT", StructureType::eVideoEncodeH265ProfileInfoEXT }, + { "VideoEncodeH265RateControlInfoEXT", StructureType::eVideoEncodeH265RateControlInfoEXT }, + { "VideoEncodeH265RateControlLayerInfoEXT", StructureType::eVideoEncodeH265RateControlLayerInfoEXT }, + { "VideoEncodeH265SessionCreateInfoEXT", StructureType::eVideoEncodeH265SessionCreateInfoEXT }, + { "VideoEncodeH265QualityLevelPropertiesEXT", StructureType::eVideoEncodeH265QualityLevelPropertiesEXT }, + { "VideoEncodeH265SessionParametersGetInfoEXT", StructureType::eVideoEncodeH265SessionParametersGetInfoEXT }, + { "VideoEncodeH265SessionParametersFeedbackInfoEXT", StructureType::eVideoEncodeH265SessionParametersFeedbackInfoEXT }, +#endif /*VK_ENABLE_BETA_EXTENSIONS*/ + { "VideoDecodeH264CapabilitiesKHR", StructureType::eVideoDecodeH264CapabilitiesKHR }, + { "VideoDecodeH264PictureInfoKHR", StructureType::eVideoDecodeH264PictureInfoKHR }, + { "VideoDecodeH264ProfileInfoKHR", StructureType::eVideoDecodeH264ProfileInfoKHR }, + { "VideoDecodeH264SessionParametersCreateInfoKHR", StructureType::eVideoDecodeH264SessionParametersCreateInfoKHR }, + { "VideoDecodeH264SessionParametersAddInfoKHR", StructureType::eVideoDecodeH264SessionParametersAddInfoKHR }, + { "VideoDecodeH264DpbSlotInfoKHR", StructureType::eVideoDecodeH264DpbSlotInfoKHR }, + { "TextureLodGatherFormatPropertiesAMD", StructureType::eTextureLodGatherFormatPropertiesAMD }, + { "RenderingFragmentShadingRateAttachmentInfoKHR", StructureType::eRenderingFragmentShadingRateAttachmentInfoKHR }, + { "RenderingFragmentDensityMapAttachmentInfoEXT", StructureType::eRenderingFragmentDensityMapAttachmentInfoEXT }, + { "AttachmentSampleCountInfoAMD", StructureType::eAttachmentSampleCountInfoAMD }, + { "MultiviewPerViewAttributesInfoNVX", StructureType::eMultiviewPerViewAttributesInfoNVX }, +#if defined( VK_USE_PLATFORM_GGP ) + { "StreamDescriptorSurfaceCreateInfoGGP", StructureType::eStreamDescriptorSurfaceCreateInfoGGP }, +#endif /*VK_USE_PLATFORM_GGP*/ + { "PhysicalDeviceCornerSampledImageFeaturesNV", StructureType::ePhysicalDeviceCornerSampledImageFeaturesNV }, + { "ExternalMemoryImageCreateInfoNV", StructureType::eExternalMemoryImageCreateInfoNV }, + { "ExportMemoryAllocateInfoNV", StructureType::eExportMemoryAllocateInfoNV }, +#if defined( VK_USE_PLATFORM_WIN32_KHR ) + { "ImportMemoryWin32HandleInfoNV", StructureType::eImportMemoryWin32HandleInfoNV }, + { "ExportMemoryWin32HandleInfoNV", StructureType::eExportMemoryWin32HandleInfoNV }, + { "Win32KeyedMutexAcquireReleaseInfoNV", StructureType::eWin32KeyedMutexAcquireReleaseInfoNV }, +#endif /*VK_USE_PLATFORM_WIN32_KHR*/ + { "ValidationFlagsEXT", StructureType::eValidationFlagsEXT }, +#if defined( VK_USE_PLATFORM_VI_NN ) + { "ViSurfaceCreateInfoNN", StructureType::eViSurfaceCreateInfoNN }, +#endif /*VK_USE_PLATFORM_VI_NN*/ + { "ImageViewAstcDecodeModeEXT", StructureType::eImageViewAstcDecodeModeEXT }, + { "PhysicalDeviceAstcDecodeFeaturesEXT", StructureType::ePhysicalDeviceAstcDecodeFeaturesEXT }, + { "PipelineRobustnessCreateInfoEXT", StructureType::ePipelineRobustnessCreateInfoEXT }, + { "PhysicalDevicePipelineRobustnessFeaturesEXT", StructureType::ePhysicalDevicePipelineRobustnessFeaturesEXT }, + { "PhysicalDevicePipelineRobustnessPropertiesEXT", StructureType::ePhysicalDevicePipelineRobustnessPropertiesEXT }, +#if defined( VK_USE_PLATFORM_WIN32_KHR ) + { "ImportMemoryWin32HandleInfoKHR", StructureType::eImportMemoryWin32HandleInfoKHR }, + { "ExportMemoryWin32HandleInfoKHR", StructureType::eExportMemoryWin32HandleInfoKHR }, + { "MemoryWin32HandlePropertiesKHR", StructureType::eMemoryWin32HandlePropertiesKHR }, + { "MemoryGetWin32HandleInfoKHR", StructureType::eMemoryGetWin32HandleInfoKHR }, +#endif /*VK_USE_PLATFORM_WIN32_KHR*/ + { "ImportMemoryFdInfoKHR", StructureType::eImportMemoryFdInfoKHR }, + { "MemoryFdPropertiesKHR", StructureType::eMemoryFdPropertiesKHR }, + { "MemoryGetFdInfoKHR", StructureType::eMemoryGetFdInfoKHR }, +#if defined( VK_USE_PLATFORM_WIN32_KHR ) + { "Win32KeyedMutexAcquireReleaseInfoKHR", StructureType::eWin32KeyedMutexAcquireReleaseInfoKHR }, + { "ImportSemaphoreWin32HandleInfoKHR", StructureType::eImportSemaphoreWin32HandleInfoKHR }, + { "ExportSemaphoreWin32HandleInfoKHR", StructureType::eExportSemaphoreWin32HandleInfoKHR }, + { "D3D12FenceSubmitInfoKHR", StructureType::eD3D12FenceSubmitInfoKHR }, + { "SemaphoreGetWin32HandleInfoKHR", StructureType::eSemaphoreGetWin32HandleInfoKHR }, +#endif /*VK_USE_PLATFORM_WIN32_KHR*/ + { "ImportSemaphoreFdInfoKHR", StructureType::eImportSemaphoreFdInfoKHR }, + { "SemaphoreGetFdInfoKHR", StructureType::eSemaphoreGetFdInfoKHR }, + { "PhysicalDevicePushDescriptorPropertiesKHR", StructureType::ePhysicalDevicePushDescriptorPropertiesKHR }, + { "CommandBufferInheritanceConditionalRenderingInfoEXT", StructureType::eCommandBufferInheritanceConditionalRenderingInfoEXT }, + { "PhysicalDeviceConditionalRenderingFeaturesEXT", StructureType::ePhysicalDeviceConditionalRenderingFeaturesEXT }, + { "ConditionalRenderingBeginInfoEXT", StructureType::eConditionalRenderingBeginInfoEXT }, + { "PresentRegionsKHR", StructureType::ePresentRegionsKHR }, + { "PipelineViewportWScalingStateCreateInfoNV", StructureType::ePipelineViewportWScalingStateCreateInfoNV }, + { "SurfaceCapabilities2EXT", StructureType::eSurfaceCapabilities2EXT }, + { "DisplayPowerInfoEXT", StructureType::eDisplayPowerInfoEXT }, + { "DeviceEventInfoEXT", StructureType::eDeviceEventInfoEXT }, + { "DisplayEventInfoEXT", StructureType::eDisplayEventInfoEXT }, + { "SwapchainCounterCreateInfoEXT", StructureType::eSwapchainCounterCreateInfoEXT }, + { "PresentTimesInfoGOOGLE", StructureType::ePresentTimesInfoGOOGLE }, + { "PhysicalDeviceMultiviewPerViewAttributesPropertiesNVX", StructureType::ePhysicalDeviceMultiviewPerViewAttributesPropertiesNVX }, + { "PipelineViewportSwizzleStateCreateInfoNV", StructureType::ePipelineViewportSwizzleStateCreateInfoNV }, + { "PhysicalDeviceDiscardRectanglePropertiesEXT", StructureType::ePhysicalDeviceDiscardRectanglePropertiesEXT }, + { "PipelineDiscardRectangleStateCreateInfoEXT", StructureType::ePipelineDiscardRectangleStateCreateInfoEXT }, + { "PhysicalDeviceConservativeRasterizationPropertiesEXT", StructureType::ePhysicalDeviceConservativeRasterizationPropertiesEXT }, + { "PipelineRasterizationConservativeStateCreateInfoEXT", StructureType::ePipelineRasterizationConservativeStateCreateInfoEXT }, + { "PhysicalDeviceDepthClipEnableFeaturesEXT", StructureType::ePhysicalDeviceDepthClipEnableFeaturesEXT }, + { "PipelineRasterizationDepthClipStateCreateInfoEXT", StructureType::ePipelineRasterizationDepthClipStateCreateInfoEXT }, + { "HdrMetadataEXT", StructureType::eHdrMetadataEXT }, + { "PhysicalDeviceRelaxedLineRasterizationFeaturesIMG", StructureType::ePhysicalDeviceRelaxedLineRasterizationFeaturesIMG }, + { "SharedPresentSurfaceCapabilitiesKHR", StructureType::eSharedPresentSurfaceCapabilitiesKHR }, +#if defined( VK_USE_PLATFORM_WIN32_KHR ) + { "ImportFenceWin32HandleInfoKHR", StructureType::eImportFenceWin32HandleInfoKHR }, + { "ExportFenceWin32HandleInfoKHR", StructureType::eExportFenceWin32HandleInfoKHR }, + { "FenceGetWin32HandleInfoKHR", StructureType::eFenceGetWin32HandleInfoKHR }, +#endif /*VK_USE_PLATFORM_WIN32_KHR*/ + { "ImportFenceFdInfoKHR", StructureType::eImportFenceFdInfoKHR }, + { "FenceGetFdInfoKHR", StructureType::eFenceGetFdInfoKHR }, + { "PhysicalDevicePerformanceQueryFeaturesKHR", StructureType::ePhysicalDevicePerformanceQueryFeaturesKHR }, + { "PhysicalDevicePerformanceQueryPropertiesKHR", StructureType::ePhysicalDevicePerformanceQueryPropertiesKHR }, + { "QueryPoolPerformanceCreateInfoKHR", StructureType::eQueryPoolPerformanceCreateInfoKHR }, + { "PerformanceQuerySubmitInfoKHR", StructureType::ePerformanceQuerySubmitInfoKHR }, + { "AcquireProfilingLockInfoKHR", StructureType::eAcquireProfilingLockInfoKHR }, + { "PerformanceCounterKHR", StructureType::ePerformanceCounterKHR }, + { "PerformanceCounterDescriptionKHR", StructureType::ePerformanceCounterDescriptionKHR }, + { "PhysicalDeviceSurfaceInfo2KHR", StructureType::ePhysicalDeviceSurfaceInfo2KHR }, + { "SurfaceCapabilities2KHR", StructureType::eSurfaceCapabilities2KHR }, + { "SurfaceFormat2KHR", StructureType::eSurfaceFormat2KHR }, + { "DisplayProperties2KHR", StructureType::eDisplayProperties2KHR }, + { "DisplayPlaneProperties2KHR", StructureType::eDisplayPlaneProperties2KHR }, + { "DisplayModeProperties2KHR", StructureType::eDisplayModeProperties2KHR }, + { "DisplayPlaneInfo2KHR", StructureType::eDisplayPlaneInfo2KHR }, + { "DisplayPlaneCapabilities2KHR", StructureType::eDisplayPlaneCapabilities2KHR }, +#if defined( VK_USE_PLATFORM_IOS_MVK ) + { "IosSurfaceCreateInfoMVK", StructureType::eIosSurfaceCreateInfoMVK }, +#endif /*VK_USE_PLATFORM_IOS_MVK*/ +#if defined( VK_USE_PLATFORM_MACOS_MVK ) + { "MacosSurfaceCreateInfoMVK", StructureType::eMacosSurfaceCreateInfoMVK }, +#endif /*VK_USE_PLATFORM_MACOS_MVK*/ + { "DebugUtilsObjectNameInfoEXT", StructureType::eDebugUtilsObjectNameInfoEXT }, + { "DebugUtilsObjectTagInfoEXT", StructureType::eDebugUtilsObjectTagInfoEXT }, + { "DebugUtilsLabelEXT", StructureType::eDebugUtilsLabelEXT }, + { "DebugUtilsMessengerCallbackDataEXT", StructureType::eDebugUtilsMessengerCallbackDataEXT }, + { "DebugUtilsMessengerCreateInfoEXT", StructureType::eDebugUtilsMessengerCreateInfoEXT }, +#if defined( VK_USE_PLATFORM_ANDROID_KHR ) + { "AndroidHardwareBufferUsageANDROID", StructureType::eAndroidHardwareBufferUsageANDROID }, + { "AndroidHardwareBufferPropertiesANDROID", StructureType::eAndroidHardwareBufferPropertiesANDROID }, + { "AndroidHardwareBufferFormatPropertiesANDROID", StructureType::eAndroidHardwareBufferFormatPropertiesANDROID }, + { "ImportAndroidHardwareBufferInfoANDROID", StructureType::eImportAndroidHardwareBufferInfoANDROID }, + { "MemoryGetAndroidHardwareBufferInfoANDROID", StructureType::eMemoryGetAndroidHardwareBufferInfoANDROID }, + { "ExternalFormatANDROID", StructureType::eExternalFormatANDROID }, + { "AndroidHardwareBufferFormatProperties2ANDROID", StructureType::eAndroidHardwareBufferFormatProperties2ANDROID }, +#endif /*VK_USE_PLATFORM_ANDROID_KHR*/ +#if defined( VK_ENABLE_BETA_EXTENSIONS ) + { "PhysicalDeviceShaderEnqueueFeaturesAMDX", StructureType::ePhysicalDeviceShaderEnqueueFeaturesAMDX }, + { "PhysicalDeviceShaderEnqueuePropertiesAMDX", StructureType::ePhysicalDeviceShaderEnqueuePropertiesAMDX }, + { "ExecutionGraphPipelineScratchSizeAMDX", StructureType::eExecutionGraphPipelineScratchSizeAMDX }, + { "ExecutionGraphPipelineCreateInfoAMDX", StructureType::eExecutionGraphPipelineCreateInfoAMDX }, + { "PipelineShaderStageNodeCreateInfoAMDX", StructureType::ePipelineShaderStageNodeCreateInfoAMDX }, +#endif /*VK_ENABLE_BETA_EXTENSIONS*/ + { "SampleLocationsInfoEXT", StructureType::eSampleLocationsInfoEXT }, + { "RenderPassSampleLocationsBeginInfoEXT", StructureType::eRenderPassSampleLocationsBeginInfoEXT }, + { "PipelineSampleLocationsStateCreateInfoEXT", StructureType::ePipelineSampleLocationsStateCreateInfoEXT }, + { "PhysicalDeviceSampleLocationsPropertiesEXT", StructureType::ePhysicalDeviceSampleLocationsPropertiesEXT }, + { "MultisamplePropertiesEXT", StructureType::eMultisamplePropertiesEXT }, + { "PhysicalDeviceBlendOperationAdvancedFeaturesEXT", StructureType::ePhysicalDeviceBlendOperationAdvancedFeaturesEXT }, + { "PhysicalDeviceBlendOperationAdvancedPropertiesEXT", StructureType::ePhysicalDeviceBlendOperationAdvancedPropertiesEXT }, + { "PipelineColorBlendAdvancedStateCreateInfoEXT", StructureType::ePipelineColorBlendAdvancedStateCreateInfoEXT }, + { "PipelineCoverageToColorStateCreateInfoNV", StructureType::ePipelineCoverageToColorStateCreateInfoNV }, + { "WriteDescriptorSetAccelerationStructureKHR", StructureType::eWriteDescriptorSetAccelerationStructureKHR }, + { "AccelerationStructureBuildGeometryInfoKHR", StructureType::eAccelerationStructureBuildGeometryInfoKHR }, + { "AccelerationStructureDeviceAddressInfoKHR", StructureType::eAccelerationStructureDeviceAddressInfoKHR }, + { "AccelerationStructureGeometryAabbsDataKHR", StructureType::eAccelerationStructureGeometryAabbsDataKHR }, + { "AccelerationStructureGeometryInstancesDataKHR", StructureType::eAccelerationStructureGeometryInstancesDataKHR }, + { "AccelerationStructureGeometryTrianglesDataKHR", StructureType::eAccelerationStructureGeometryTrianglesDataKHR }, + { "AccelerationStructureGeometryKHR", StructureType::eAccelerationStructureGeometryKHR }, + { "AccelerationStructureVersionInfoKHR", StructureType::eAccelerationStructureVersionInfoKHR }, + { "CopyAccelerationStructureInfoKHR", StructureType::eCopyAccelerationStructureInfoKHR }, + { "CopyAccelerationStructureToMemoryInfoKHR", StructureType::eCopyAccelerationStructureToMemoryInfoKHR }, + { "CopyMemoryToAccelerationStructureInfoKHR", StructureType::eCopyMemoryToAccelerationStructureInfoKHR }, + { "PhysicalDeviceAccelerationStructureFeaturesKHR", StructureType::ePhysicalDeviceAccelerationStructureFeaturesKHR }, + { "PhysicalDeviceAccelerationStructurePropertiesKHR", StructureType::ePhysicalDeviceAccelerationStructurePropertiesKHR }, + { "AccelerationStructureCreateInfoKHR", StructureType::eAccelerationStructureCreateInfoKHR }, + { "AccelerationStructureBuildSizesInfoKHR", StructureType::eAccelerationStructureBuildSizesInfoKHR }, + { "PhysicalDeviceRayTracingPipelineFeaturesKHR", StructureType::ePhysicalDeviceRayTracingPipelineFeaturesKHR }, + { "PhysicalDeviceRayTracingPipelinePropertiesKHR", StructureType::ePhysicalDeviceRayTracingPipelinePropertiesKHR }, + { "RayTracingPipelineCreateInfoKHR", StructureType::eRayTracingPipelineCreateInfoKHR }, + { "RayTracingShaderGroupCreateInfoKHR", StructureType::eRayTracingShaderGroupCreateInfoKHR }, + { "RayTracingPipelineInterfaceCreateInfoKHR", StructureType::eRayTracingPipelineInterfaceCreateInfoKHR }, + { "PhysicalDeviceRayQueryFeaturesKHR", StructureType::ePhysicalDeviceRayQueryFeaturesKHR }, + { "PipelineCoverageModulationStateCreateInfoNV", StructureType::ePipelineCoverageModulationStateCreateInfoNV }, + { "PhysicalDeviceShaderSmBuiltinsFeaturesNV", StructureType::ePhysicalDeviceShaderSmBuiltinsFeaturesNV }, + { "PhysicalDeviceShaderSmBuiltinsPropertiesNV", StructureType::ePhysicalDeviceShaderSmBuiltinsPropertiesNV }, + { "DrmFormatModifierPropertiesListEXT", StructureType::eDrmFormatModifierPropertiesListEXT }, + { "PhysicalDeviceImageDrmFormatModifierInfoEXT", StructureType::ePhysicalDeviceImageDrmFormatModifierInfoEXT }, + { "ImageDrmFormatModifierListCreateInfoEXT", StructureType::eImageDrmFormatModifierListCreateInfoEXT }, + { "ImageDrmFormatModifierExplicitCreateInfoEXT", StructureType::eImageDrmFormatModifierExplicitCreateInfoEXT }, + { "ImageDrmFormatModifierPropertiesEXT", StructureType::eImageDrmFormatModifierPropertiesEXT }, + { "DrmFormatModifierPropertiesList2EXT", StructureType::eDrmFormatModifierPropertiesList2EXT }, + { "ValidationCacheCreateInfoEXT", StructureType::eValidationCacheCreateInfoEXT }, + { "ShaderModuleValidationCacheCreateInfoEXT", StructureType::eShaderModuleValidationCacheCreateInfoEXT }, +#if defined( VK_ENABLE_BETA_EXTENSIONS ) + { "PhysicalDevicePortabilitySubsetFeaturesKHR", StructureType::ePhysicalDevicePortabilitySubsetFeaturesKHR }, + { "PhysicalDevicePortabilitySubsetPropertiesKHR", StructureType::ePhysicalDevicePortabilitySubsetPropertiesKHR }, +#endif /*VK_ENABLE_BETA_EXTENSIONS*/ + { "PipelineViewportShadingRateImageStateCreateInfoNV", StructureType::ePipelineViewportShadingRateImageStateCreateInfoNV }, + { "PhysicalDeviceShadingRateImageFeaturesNV", StructureType::ePhysicalDeviceShadingRateImageFeaturesNV }, + { "PhysicalDeviceShadingRateImagePropertiesNV", StructureType::ePhysicalDeviceShadingRateImagePropertiesNV }, + { "PipelineViewportCoarseSampleOrderStateCreateInfoNV", StructureType::ePipelineViewportCoarseSampleOrderStateCreateInfoNV }, + { "RayTracingPipelineCreateInfoNV", StructureType::eRayTracingPipelineCreateInfoNV }, + { "AccelerationStructureCreateInfoNV", StructureType::eAccelerationStructureCreateInfoNV }, + { "GeometryNV", StructureType::eGeometryNV }, + { "GeometryTrianglesNV", StructureType::eGeometryTrianglesNV }, + { "GeometryAabbNV", StructureType::eGeometryAabbNV }, + { "BindAccelerationStructureMemoryInfoNV", StructureType::eBindAccelerationStructureMemoryInfoNV }, + { "WriteDescriptorSetAccelerationStructureNV", StructureType::eWriteDescriptorSetAccelerationStructureNV }, + { "AccelerationStructureMemoryRequirementsInfoNV", StructureType::eAccelerationStructureMemoryRequirementsInfoNV }, + { "PhysicalDeviceRayTracingPropertiesNV", StructureType::ePhysicalDeviceRayTracingPropertiesNV }, + { "RayTracingShaderGroupCreateInfoNV", StructureType::eRayTracingShaderGroupCreateInfoNV }, + { "AccelerationStructureInfoNV", StructureType::eAccelerationStructureInfoNV }, + { "PhysicalDeviceRepresentativeFragmentTestFeaturesNV", StructureType::ePhysicalDeviceRepresentativeFragmentTestFeaturesNV }, + { "PipelineRepresentativeFragmentTestStateCreateInfoNV", StructureType::ePipelineRepresentativeFragmentTestStateCreateInfoNV }, + { "PhysicalDeviceImageViewImageFormatInfoEXT", StructureType::ePhysicalDeviceImageViewImageFormatInfoEXT }, + { "FilterCubicImageViewImageFormatPropertiesEXT", StructureType::eFilterCubicImageViewImageFormatPropertiesEXT }, + { "ImportMemoryHostPointerInfoEXT", StructureType::eImportMemoryHostPointerInfoEXT }, + { "MemoryHostPointerPropertiesEXT", StructureType::eMemoryHostPointerPropertiesEXT }, + { "PhysicalDeviceExternalMemoryHostPropertiesEXT", StructureType::ePhysicalDeviceExternalMemoryHostPropertiesEXT }, + { "PhysicalDeviceShaderClockFeaturesKHR", StructureType::ePhysicalDeviceShaderClockFeaturesKHR }, + { "PipelineCompilerControlCreateInfoAMD", StructureType::ePipelineCompilerControlCreateInfoAMD }, + { "CalibratedTimestampInfoEXT", StructureType::eCalibratedTimestampInfoEXT }, + { "PhysicalDeviceShaderCorePropertiesAMD", StructureType::ePhysicalDeviceShaderCorePropertiesAMD }, + { "VideoDecodeH265CapabilitiesKHR", StructureType::eVideoDecodeH265CapabilitiesKHR }, + { "VideoDecodeH265SessionParametersCreateInfoKHR", StructureType::eVideoDecodeH265SessionParametersCreateInfoKHR }, + { "VideoDecodeH265SessionParametersAddInfoKHR", StructureType::eVideoDecodeH265SessionParametersAddInfoKHR }, + { "VideoDecodeH265ProfileInfoKHR", StructureType::eVideoDecodeH265ProfileInfoKHR }, + { "VideoDecodeH265PictureInfoKHR", StructureType::eVideoDecodeH265PictureInfoKHR }, + { "VideoDecodeH265DpbSlotInfoKHR", StructureType::eVideoDecodeH265DpbSlotInfoKHR }, + { "DeviceQueueGlobalPriorityCreateInfoKHR", StructureType::eDeviceQueueGlobalPriorityCreateInfoKHR }, + { "PhysicalDeviceGlobalPriorityQueryFeaturesKHR", StructureType::ePhysicalDeviceGlobalPriorityQueryFeaturesKHR }, + { "QueueFamilyGlobalPriorityPropertiesKHR", StructureType::eQueueFamilyGlobalPriorityPropertiesKHR }, + { "DeviceMemoryOverallocationCreateInfoAMD", StructureType::eDeviceMemoryOverallocationCreateInfoAMD }, + { "PhysicalDeviceVertexAttributeDivisorPropertiesEXT", StructureType::ePhysicalDeviceVertexAttributeDivisorPropertiesEXT }, + { "PipelineVertexInputDivisorStateCreateInfoEXT", StructureType::ePipelineVertexInputDivisorStateCreateInfoEXT }, + { "PhysicalDeviceVertexAttributeDivisorFeaturesEXT", StructureType::ePhysicalDeviceVertexAttributeDivisorFeaturesEXT }, +#if defined( VK_USE_PLATFORM_GGP ) + { "PresentFrameTokenGGP", StructureType::ePresentFrameTokenGGP }, +#endif /*VK_USE_PLATFORM_GGP*/ + { "PhysicalDeviceComputeShaderDerivativesFeaturesNV", StructureType::ePhysicalDeviceComputeShaderDerivativesFeaturesNV }, + { "PhysicalDeviceMeshShaderFeaturesNV", StructureType::ePhysicalDeviceMeshShaderFeaturesNV }, + { "PhysicalDeviceMeshShaderPropertiesNV", StructureType::ePhysicalDeviceMeshShaderPropertiesNV }, + { "PhysicalDeviceShaderImageFootprintFeaturesNV", StructureType::ePhysicalDeviceShaderImageFootprintFeaturesNV }, + { "PipelineViewportExclusiveScissorStateCreateInfoNV", StructureType::ePipelineViewportExclusiveScissorStateCreateInfoNV }, + { "PhysicalDeviceExclusiveScissorFeaturesNV", StructureType::ePhysicalDeviceExclusiveScissorFeaturesNV }, + { "CheckpointDataNV", StructureType::eCheckpointDataNV }, + { "QueueFamilyCheckpointPropertiesNV", StructureType::eQueueFamilyCheckpointPropertiesNV }, + { "PhysicalDeviceShaderIntegerFunctions2FeaturesINTEL", StructureType::ePhysicalDeviceShaderIntegerFunctions2FeaturesINTEL }, + { "QueryPoolPerformanceQueryCreateInfoINTEL", StructureType::eQueryPoolPerformanceQueryCreateInfoINTEL }, + { "InitializePerformanceApiInfoINTEL", StructureType::eInitializePerformanceApiInfoINTEL }, + { "PerformanceMarkerInfoINTEL", StructureType::ePerformanceMarkerInfoINTEL }, + { "PerformanceStreamMarkerInfoINTEL", StructureType::ePerformanceStreamMarkerInfoINTEL }, + { "PerformanceOverrideInfoINTEL", StructureType::ePerformanceOverrideInfoINTEL }, + { "PerformanceConfigurationAcquireInfoINTEL", StructureType::ePerformanceConfigurationAcquireInfoINTEL }, + { "PhysicalDevicePciBusInfoPropertiesEXT", StructureType::ePhysicalDevicePciBusInfoPropertiesEXT }, + { "DisplayNativeHdrSurfaceCapabilitiesAMD", StructureType::eDisplayNativeHdrSurfaceCapabilitiesAMD }, + { "SwapchainDisplayNativeHdrCreateInfoAMD", StructureType::eSwapchainDisplayNativeHdrCreateInfoAMD }, +#if defined( VK_USE_PLATFORM_FUCHSIA ) + { "ImagepipeSurfaceCreateInfoFUCHSIA", StructureType::eImagepipeSurfaceCreateInfoFUCHSIA }, +#endif /*VK_USE_PLATFORM_FUCHSIA*/ +#if defined( VK_USE_PLATFORM_METAL_EXT ) + { "MetalSurfaceCreateInfoEXT", StructureType::eMetalSurfaceCreateInfoEXT }, +#endif /*VK_USE_PLATFORM_METAL_EXT*/ + { "PhysicalDeviceFragmentDensityMapFeaturesEXT", StructureType::ePhysicalDeviceFragmentDensityMapFeaturesEXT }, + { "PhysicalDeviceFragmentDensityMapPropertiesEXT", StructureType::ePhysicalDeviceFragmentDensityMapPropertiesEXT }, + { "RenderPassFragmentDensityMapCreateInfoEXT", StructureType::eRenderPassFragmentDensityMapCreateInfoEXT }, + { "FragmentShadingRateAttachmentInfoKHR", StructureType::eFragmentShadingRateAttachmentInfoKHR }, + { "PipelineFragmentShadingRateStateCreateInfoKHR", StructureType::ePipelineFragmentShadingRateStateCreateInfoKHR }, + { "PhysicalDeviceFragmentShadingRatePropertiesKHR", StructureType::ePhysicalDeviceFragmentShadingRatePropertiesKHR }, + { "PhysicalDeviceFragmentShadingRateFeaturesKHR", StructureType::ePhysicalDeviceFragmentShadingRateFeaturesKHR }, + { "PhysicalDeviceFragmentShadingRateKHR", StructureType::ePhysicalDeviceFragmentShadingRateKHR }, + { "PhysicalDeviceShaderCoreProperties2AMD", StructureType::ePhysicalDeviceShaderCoreProperties2AMD }, + { "PhysicalDeviceCoherentMemoryFeaturesAMD", StructureType::ePhysicalDeviceCoherentMemoryFeaturesAMD }, + { "PhysicalDeviceShaderImageAtomicInt64FeaturesEXT", StructureType::ePhysicalDeviceShaderImageAtomicInt64FeaturesEXT }, + { "PhysicalDeviceMemoryBudgetPropertiesEXT", StructureType::ePhysicalDeviceMemoryBudgetPropertiesEXT }, + { "PhysicalDeviceMemoryPriorityFeaturesEXT", StructureType::ePhysicalDeviceMemoryPriorityFeaturesEXT }, + { "MemoryPriorityAllocateInfoEXT", StructureType::eMemoryPriorityAllocateInfoEXT }, + { "SurfaceProtectedCapabilitiesKHR", StructureType::eSurfaceProtectedCapabilitiesKHR }, + { "PhysicalDeviceDedicatedAllocationImageAliasingFeaturesNV", StructureType::ePhysicalDeviceDedicatedAllocationImageAliasingFeaturesNV }, + { "PhysicalDeviceBufferDeviceAddressFeaturesEXT", StructureType::ePhysicalDeviceBufferDeviceAddressFeaturesEXT }, + { "BufferDeviceAddressCreateInfoEXT", StructureType::eBufferDeviceAddressCreateInfoEXT }, + { "ValidationFeaturesEXT", StructureType::eValidationFeaturesEXT }, + { "PhysicalDevicePresentWaitFeaturesKHR", StructureType::ePhysicalDevicePresentWaitFeaturesKHR }, + { "PhysicalDeviceCooperativeMatrixFeaturesNV", StructureType::ePhysicalDeviceCooperativeMatrixFeaturesNV }, + { "CooperativeMatrixPropertiesNV", StructureType::eCooperativeMatrixPropertiesNV }, + { "PhysicalDeviceCooperativeMatrixPropertiesNV", StructureType::ePhysicalDeviceCooperativeMatrixPropertiesNV }, + { "PhysicalDeviceCoverageReductionModeFeaturesNV", StructureType::ePhysicalDeviceCoverageReductionModeFeaturesNV }, + { "PipelineCoverageReductionStateCreateInfoNV", StructureType::ePipelineCoverageReductionStateCreateInfoNV }, + { "FramebufferMixedSamplesCombinationNV", StructureType::eFramebufferMixedSamplesCombinationNV }, + { "PhysicalDeviceFragmentShaderInterlockFeaturesEXT", StructureType::ePhysicalDeviceFragmentShaderInterlockFeaturesEXT }, + { "PhysicalDeviceYcbcrImageArraysFeaturesEXT", StructureType::ePhysicalDeviceYcbcrImageArraysFeaturesEXT }, + { "PhysicalDeviceProvokingVertexFeaturesEXT", StructureType::ePhysicalDeviceProvokingVertexFeaturesEXT }, + { "PipelineRasterizationProvokingVertexStateCreateInfoEXT", StructureType::ePipelineRasterizationProvokingVertexStateCreateInfoEXT }, + { "PhysicalDeviceProvokingVertexPropertiesEXT", StructureType::ePhysicalDeviceProvokingVertexPropertiesEXT }, +#if defined( VK_USE_PLATFORM_WIN32_KHR ) + { "SurfaceFullScreenExclusiveInfoEXT", StructureType::eSurfaceFullScreenExclusiveInfoEXT }, + { "SurfaceCapabilitiesFullScreenExclusiveEXT", StructureType::eSurfaceCapabilitiesFullScreenExclusiveEXT }, + { "SurfaceFullScreenExclusiveWin32InfoEXT", StructureType::eSurfaceFullScreenExclusiveWin32InfoEXT }, +#endif /*VK_USE_PLATFORM_WIN32_KHR*/ + { "HeadlessSurfaceCreateInfoEXT", StructureType::eHeadlessSurfaceCreateInfoEXT }, + { "PhysicalDeviceLineRasterizationFeaturesEXT", StructureType::ePhysicalDeviceLineRasterizationFeaturesEXT }, + { "PipelineRasterizationLineStateCreateInfoEXT", StructureType::ePipelineRasterizationLineStateCreateInfoEXT }, + { "PhysicalDeviceLineRasterizationPropertiesEXT", StructureType::ePhysicalDeviceLineRasterizationPropertiesEXT }, + { "PhysicalDeviceShaderAtomicFloatFeaturesEXT", StructureType::ePhysicalDeviceShaderAtomicFloatFeaturesEXT }, + { "PhysicalDeviceIndexTypeUint8FeaturesEXT", StructureType::ePhysicalDeviceIndexTypeUint8FeaturesEXT }, + { "PhysicalDeviceExtendedDynamicStateFeaturesEXT", StructureType::ePhysicalDeviceExtendedDynamicStateFeaturesEXT }, + { "PhysicalDevicePipelineExecutablePropertiesFeaturesKHR", StructureType::ePhysicalDevicePipelineExecutablePropertiesFeaturesKHR }, + { "PipelineInfoKHR", StructureType::ePipelineInfoKHR }, + { "PipelineExecutablePropertiesKHR", StructureType::ePipelineExecutablePropertiesKHR }, + { "PipelineExecutableInfoKHR", StructureType::ePipelineExecutableInfoKHR }, + { "PipelineExecutableStatisticKHR", StructureType::ePipelineExecutableStatisticKHR }, + { "PipelineExecutableInternalRepresentationKHR", StructureType::ePipelineExecutableInternalRepresentationKHR }, + { "PhysicalDeviceHostImageCopyFeaturesEXT", StructureType::ePhysicalDeviceHostImageCopyFeaturesEXT }, + { "PhysicalDeviceHostImageCopyPropertiesEXT", StructureType::ePhysicalDeviceHostImageCopyPropertiesEXT }, + { "MemoryToImageCopyEXT", StructureType::eMemoryToImageCopyEXT }, + { "ImageToMemoryCopyEXT", StructureType::eImageToMemoryCopyEXT }, + { "CopyImageToMemoryInfoEXT", StructureType::eCopyImageToMemoryInfoEXT }, + { "CopyMemoryToImageInfoEXT", StructureType::eCopyMemoryToImageInfoEXT }, + { "HostImageLayoutTransitionInfoEXT", StructureType::eHostImageLayoutTransitionInfoEXT }, + { "CopyImageToImageInfoEXT", StructureType::eCopyImageToImageInfoEXT }, + { "SubresourceHostMemcpySizeEXT", StructureType::eSubresourceHostMemcpySizeEXT }, + { "HostImageCopyDevicePerformanceQueryEXT", StructureType::eHostImageCopyDevicePerformanceQueryEXT }, + { "MemoryMapInfoKHR", StructureType::eMemoryMapInfoKHR }, + { "MemoryUnmapInfoKHR", StructureType::eMemoryUnmapInfoKHR }, + { "PhysicalDeviceShaderAtomicFloat2FeaturesEXT", StructureType::ePhysicalDeviceShaderAtomicFloat2FeaturesEXT }, + { "SurfacePresentModeEXT", StructureType::eSurfacePresentModeEXT }, + { "SurfacePresentScalingCapabilitiesEXT", StructureType::eSurfacePresentScalingCapabilitiesEXT }, + { "SurfacePresentModeCompatibilityEXT", StructureType::eSurfacePresentModeCompatibilityEXT }, + { "PhysicalDeviceSwapchainMaintenance1FeaturesEXT", StructureType::ePhysicalDeviceSwapchainMaintenance1FeaturesEXT }, + { "SwapchainPresentFenceInfoEXT", StructureType::eSwapchainPresentFenceInfoEXT }, + { "SwapchainPresentModesCreateInfoEXT", StructureType::eSwapchainPresentModesCreateInfoEXT }, + { "SwapchainPresentModeInfoEXT", StructureType::eSwapchainPresentModeInfoEXT }, + { "SwapchainPresentScalingCreateInfoEXT", StructureType::eSwapchainPresentScalingCreateInfoEXT }, + { "ReleaseSwapchainImagesInfoEXT", StructureType::eReleaseSwapchainImagesInfoEXT }, + { "PhysicalDeviceDeviceGeneratedCommandsPropertiesNV", StructureType::ePhysicalDeviceDeviceGeneratedCommandsPropertiesNV }, + { "GraphicsShaderGroupCreateInfoNV", StructureType::eGraphicsShaderGroupCreateInfoNV }, + { "GraphicsPipelineShaderGroupsCreateInfoNV", StructureType::eGraphicsPipelineShaderGroupsCreateInfoNV }, + { "IndirectCommandsLayoutTokenNV", StructureType::eIndirectCommandsLayoutTokenNV }, + { "IndirectCommandsLayoutCreateInfoNV", StructureType::eIndirectCommandsLayoutCreateInfoNV }, + { "GeneratedCommandsInfoNV", StructureType::eGeneratedCommandsInfoNV }, + { "GeneratedCommandsMemoryRequirementsInfoNV", StructureType::eGeneratedCommandsMemoryRequirementsInfoNV }, + { "PhysicalDeviceDeviceGeneratedCommandsFeaturesNV", StructureType::ePhysicalDeviceDeviceGeneratedCommandsFeaturesNV }, + { "PhysicalDeviceInheritedViewportScissorFeaturesNV", StructureType::ePhysicalDeviceInheritedViewportScissorFeaturesNV }, + { "CommandBufferInheritanceViewportScissorInfoNV", StructureType::eCommandBufferInheritanceViewportScissorInfoNV }, + { "PhysicalDeviceTexelBufferAlignmentFeaturesEXT", StructureType::ePhysicalDeviceTexelBufferAlignmentFeaturesEXT }, + { "CommandBufferInheritanceRenderPassTransformInfoQCOM", StructureType::eCommandBufferInheritanceRenderPassTransformInfoQCOM }, + { "RenderPassTransformBeginInfoQCOM", StructureType::eRenderPassTransformBeginInfoQCOM }, + { "PhysicalDeviceDepthBiasControlFeaturesEXT", StructureType::ePhysicalDeviceDepthBiasControlFeaturesEXT }, + { "DepthBiasInfoEXT", StructureType::eDepthBiasInfoEXT }, + { "DepthBiasRepresentationInfoEXT", StructureType::eDepthBiasRepresentationInfoEXT }, + { "PhysicalDeviceDeviceMemoryReportFeaturesEXT", StructureType::ePhysicalDeviceDeviceMemoryReportFeaturesEXT }, + { "DeviceDeviceMemoryReportCreateInfoEXT", StructureType::eDeviceDeviceMemoryReportCreateInfoEXT }, + { "DeviceMemoryReportCallbackDataEXT", StructureType::eDeviceMemoryReportCallbackDataEXT }, + { "PhysicalDeviceRobustness2FeaturesEXT", StructureType::ePhysicalDeviceRobustness2FeaturesEXT }, + { "PhysicalDeviceRobustness2PropertiesEXT", StructureType::ePhysicalDeviceRobustness2PropertiesEXT }, + { "SamplerCustomBorderColorCreateInfoEXT", StructureType::eSamplerCustomBorderColorCreateInfoEXT }, + { "PhysicalDeviceCustomBorderColorPropertiesEXT", StructureType::ePhysicalDeviceCustomBorderColorPropertiesEXT }, + { "PhysicalDeviceCustomBorderColorFeaturesEXT", StructureType::ePhysicalDeviceCustomBorderColorFeaturesEXT }, + { "PipelineLibraryCreateInfoKHR", StructureType::ePipelineLibraryCreateInfoKHR }, + { "PhysicalDevicePresentBarrierFeaturesNV", StructureType::ePhysicalDevicePresentBarrierFeaturesNV }, + { "SurfaceCapabilitiesPresentBarrierNV", StructureType::eSurfaceCapabilitiesPresentBarrierNV }, + { "SwapchainPresentBarrierCreateInfoNV", StructureType::eSwapchainPresentBarrierCreateInfoNV }, + { "PresentIdKHR", StructureType::ePresentIdKHR }, + { "PhysicalDevicePresentIdFeaturesKHR", StructureType::ePhysicalDevicePresentIdFeaturesKHR }, +#if defined( VK_ENABLE_BETA_EXTENSIONS ) + { "VideoEncodeInfoKHR", StructureType::eVideoEncodeInfoKHR }, + { "VideoEncodeRateControlInfoKHR", StructureType::eVideoEncodeRateControlInfoKHR }, + { "VideoEncodeRateControlLayerInfoKHR", StructureType::eVideoEncodeRateControlLayerInfoKHR }, + { "VideoEncodeCapabilitiesKHR", StructureType::eVideoEncodeCapabilitiesKHR }, + { "VideoEncodeUsageInfoKHR", StructureType::eVideoEncodeUsageInfoKHR }, + { "QueryPoolVideoEncodeFeedbackCreateInfoKHR", StructureType::eQueryPoolVideoEncodeFeedbackCreateInfoKHR }, + { "PhysicalDeviceVideoEncodeQualityLevelInfoKHR", StructureType::ePhysicalDeviceVideoEncodeQualityLevelInfoKHR }, + { "VideoEncodeQualityLevelPropertiesKHR", StructureType::eVideoEncodeQualityLevelPropertiesKHR }, + { "VideoEncodeQualityLevelInfoKHR", StructureType::eVideoEncodeQualityLevelInfoKHR }, + { "VideoEncodeSessionParametersGetInfoKHR", StructureType::eVideoEncodeSessionParametersGetInfoKHR }, + { "VideoEncodeSessionParametersFeedbackInfoKHR", StructureType::eVideoEncodeSessionParametersFeedbackInfoKHR }, +#endif /*VK_ENABLE_BETA_EXTENSIONS*/ + { "PhysicalDeviceDiagnosticsConfigFeaturesNV", StructureType::ePhysicalDeviceDiagnosticsConfigFeaturesNV }, + { "DeviceDiagnosticsConfigCreateInfoNV", StructureType::eDeviceDiagnosticsConfigCreateInfoNV }, +#if defined( VK_ENABLE_BETA_EXTENSIONS ) + { "CudaModuleCreateInfoNV", StructureType::eCudaModuleCreateInfoNV }, + { "CudaFunctionCreateInfoNV", StructureType::eCudaFunctionCreateInfoNV }, + { "CudaLaunchInfoNV", StructureType::eCudaLaunchInfoNV }, + { "PhysicalDeviceCudaKernelLaunchFeaturesNV", StructureType::ePhysicalDeviceCudaKernelLaunchFeaturesNV }, + { "PhysicalDeviceCudaKernelLaunchPropertiesNV", StructureType::ePhysicalDeviceCudaKernelLaunchPropertiesNV }, +#endif /*VK_ENABLE_BETA_EXTENSIONS*/ + { "QueryLowLatencySupportNV", StructureType::eQueryLowLatencySupportNV }, +#if defined( VK_USE_PLATFORM_METAL_EXT ) + { "ExportMetalObjectCreateInfoEXT", StructureType::eExportMetalObjectCreateInfoEXT }, + { "ExportMetalObjectsInfoEXT", StructureType::eExportMetalObjectsInfoEXT }, + { "ExportMetalDeviceInfoEXT", StructureType::eExportMetalDeviceInfoEXT }, + { "ExportMetalCommandQueueInfoEXT", StructureType::eExportMetalCommandQueueInfoEXT }, + { "ExportMetalBufferInfoEXT", StructureType::eExportMetalBufferInfoEXT }, + { "ImportMetalBufferInfoEXT", StructureType::eImportMetalBufferInfoEXT }, + { "ExportMetalTextureInfoEXT", StructureType::eExportMetalTextureInfoEXT }, + { "ImportMetalTextureInfoEXT", StructureType::eImportMetalTextureInfoEXT }, + { "ExportMetalIoSurfaceInfoEXT", StructureType::eExportMetalIoSurfaceInfoEXT }, + { "ImportMetalIoSurfaceInfoEXT", StructureType::eImportMetalIoSurfaceInfoEXT }, + { "ExportMetalSharedEventInfoEXT", StructureType::eExportMetalSharedEventInfoEXT }, + { "ImportMetalSharedEventInfoEXT", StructureType::eImportMetalSharedEventInfoEXT }, +#endif /*VK_USE_PLATFORM_METAL_EXT*/ + { "QueueFamilyCheckpointProperties2NV", StructureType::eQueueFamilyCheckpointProperties2NV }, + { "CheckpointData2NV", StructureType::eCheckpointData2NV }, + { "PhysicalDeviceDescriptorBufferPropertiesEXT", StructureType::ePhysicalDeviceDescriptorBufferPropertiesEXT }, + { "PhysicalDeviceDescriptorBufferDensityMapPropertiesEXT", StructureType::ePhysicalDeviceDescriptorBufferDensityMapPropertiesEXT }, + { "PhysicalDeviceDescriptorBufferFeaturesEXT", StructureType::ePhysicalDeviceDescriptorBufferFeaturesEXT }, + { "DescriptorAddressInfoEXT", StructureType::eDescriptorAddressInfoEXT }, + { "DescriptorGetInfoEXT", StructureType::eDescriptorGetInfoEXT }, + { "BufferCaptureDescriptorDataInfoEXT", StructureType::eBufferCaptureDescriptorDataInfoEXT }, + { "ImageCaptureDescriptorDataInfoEXT", StructureType::eImageCaptureDescriptorDataInfoEXT }, + { "ImageViewCaptureDescriptorDataInfoEXT", StructureType::eImageViewCaptureDescriptorDataInfoEXT }, + { "SamplerCaptureDescriptorDataInfoEXT", StructureType::eSamplerCaptureDescriptorDataInfoEXT }, + { "OpaqueCaptureDescriptorDataCreateInfoEXT", StructureType::eOpaqueCaptureDescriptorDataCreateInfoEXT }, + { "DescriptorBufferBindingInfoEXT", StructureType::eDescriptorBufferBindingInfoEXT }, + { "DescriptorBufferBindingPushDescriptorBufferHandleEXT", StructureType::eDescriptorBufferBindingPushDescriptorBufferHandleEXT }, + { "AccelerationStructureCaptureDescriptorDataInfoEXT", StructureType::eAccelerationStructureCaptureDescriptorDataInfoEXT }, + { "PhysicalDeviceGraphicsPipelineLibraryFeaturesEXT", StructureType::ePhysicalDeviceGraphicsPipelineLibraryFeaturesEXT }, + { "PhysicalDeviceGraphicsPipelineLibraryPropertiesEXT", StructureType::ePhysicalDeviceGraphicsPipelineLibraryPropertiesEXT }, + { "GraphicsPipelineLibraryCreateInfoEXT", StructureType::eGraphicsPipelineLibraryCreateInfoEXT }, + { "PhysicalDeviceShaderEarlyAndLateFragmentTestsFeaturesAMD", StructureType::ePhysicalDeviceShaderEarlyAndLateFragmentTestsFeaturesAMD }, + { "PhysicalDeviceFragmentShaderBarycentricFeaturesKHR", StructureType::ePhysicalDeviceFragmentShaderBarycentricFeaturesKHR }, + { "PhysicalDeviceFragmentShaderBarycentricPropertiesKHR", StructureType::ePhysicalDeviceFragmentShaderBarycentricPropertiesKHR }, + { "PhysicalDeviceShaderSubgroupUniformControlFlowFeaturesKHR", StructureType::ePhysicalDeviceShaderSubgroupUniformControlFlowFeaturesKHR }, + { "PhysicalDeviceFragmentShadingRateEnumsPropertiesNV", StructureType::ePhysicalDeviceFragmentShadingRateEnumsPropertiesNV }, + { "PhysicalDeviceFragmentShadingRateEnumsFeaturesNV", StructureType::ePhysicalDeviceFragmentShadingRateEnumsFeaturesNV }, + { "PipelineFragmentShadingRateEnumStateCreateInfoNV", StructureType::ePipelineFragmentShadingRateEnumStateCreateInfoNV }, + { "AccelerationStructureGeometryMotionTrianglesDataNV", StructureType::eAccelerationStructureGeometryMotionTrianglesDataNV }, + { "PhysicalDeviceRayTracingMotionBlurFeaturesNV", StructureType::ePhysicalDeviceRayTracingMotionBlurFeaturesNV }, + { "AccelerationStructureMotionInfoNV", StructureType::eAccelerationStructureMotionInfoNV }, + { "PhysicalDeviceMeshShaderFeaturesEXT", StructureType::ePhysicalDeviceMeshShaderFeaturesEXT }, + { "PhysicalDeviceMeshShaderPropertiesEXT", StructureType::ePhysicalDeviceMeshShaderPropertiesEXT }, + { "PhysicalDeviceYcbcr2Plane444FormatsFeaturesEXT", StructureType::ePhysicalDeviceYcbcr2Plane444FormatsFeaturesEXT }, + { "PhysicalDeviceFragmentDensityMap2FeaturesEXT", StructureType::ePhysicalDeviceFragmentDensityMap2FeaturesEXT }, + { "PhysicalDeviceFragmentDensityMap2PropertiesEXT", StructureType::ePhysicalDeviceFragmentDensityMap2PropertiesEXT }, + { "CopyCommandTransformInfoQCOM", StructureType::eCopyCommandTransformInfoQCOM }, + { "PhysicalDeviceWorkgroupMemoryExplicitLayoutFeaturesKHR", StructureType::ePhysicalDeviceWorkgroupMemoryExplicitLayoutFeaturesKHR }, + { "PhysicalDeviceImageCompressionControlFeaturesEXT", StructureType::ePhysicalDeviceImageCompressionControlFeaturesEXT }, + { "ImageCompressionControlEXT", StructureType::eImageCompressionControlEXT }, + { "ImageCompressionPropertiesEXT", StructureType::eImageCompressionPropertiesEXT }, + { "PhysicalDeviceAttachmentFeedbackLoopLayoutFeaturesEXT", StructureType::ePhysicalDeviceAttachmentFeedbackLoopLayoutFeaturesEXT }, + { "PhysicalDevice4444FormatsFeaturesEXT", StructureType::ePhysicalDevice4444FormatsFeaturesEXT }, + { "PhysicalDeviceFaultFeaturesEXT", StructureType::ePhysicalDeviceFaultFeaturesEXT }, + { "DeviceFaultCountsEXT", StructureType::eDeviceFaultCountsEXT }, + { "DeviceFaultInfoEXT", StructureType::eDeviceFaultInfoEXT }, + { "PhysicalDeviceRgba10X6FormatsFeaturesEXT", StructureType::ePhysicalDeviceRgba10X6FormatsFeaturesEXT }, +#if defined( VK_USE_PLATFORM_DIRECTFB_EXT ) + { "DirectfbSurfaceCreateInfoEXT", StructureType::eDirectfbSurfaceCreateInfoEXT }, +#endif /*VK_USE_PLATFORM_DIRECTFB_EXT*/ + { "PhysicalDeviceVertexInputDynamicStateFeaturesEXT", StructureType::ePhysicalDeviceVertexInputDynamicStateFeaturesEXT }, + { "VertexInputBindingDescription2EXT", StructureType::eVertexInputBindingDescription2EXT }, + { "VertexInputAttributeDescription2EXT", StructureType::eVertexInputAttributeDescription2EXT }, + { "PhysicalDeviceDrmPropertiesEXT", StructureType::ePhysicalDeviceDrmPropertiesEXT }, + { "PhysicalDeviceAddressBindingReportFeaturesEXT", StructureType::ePhysicalDeviceAddressBindingReportFeaturesEXT }, + { "DeviceAddressBindingCallbackDataEXT", StructureType::eDeviceAddressBindingCallbackDataEXT }, + { "PhysicalDeviceDepthClipControlFeaturesEXT", StructureType::ePhysicalDeviceDepthClipControlFeaturesEXT }, + { "PipelineViewportDepthClipControlCreateInfoEXT", StructureType::ePipelineViewportDepthClipControlCreateInfoEXT }, + { "PhysicalDevicePrimitiveTopologyListRestartFeaturesEXT", StructureType::ePhysicalDevicePrimitiveTopologyListRestartFeaturesEXT }, +#if defined( VK_USE_PLATFORM_FUCHSIA ) + { "ImportMemoryZirconHandleInfoFUCHSIA", StructureType::eImportMemoryZirconHandleInfoFUCHSIA }, + { "MemoryZirconHandlePropertiesFUCHSIA", StructureType::eMemoryZirconHandlePropertiesFUCHSIA }, + { "MemoryGetZirconHandleInfoFUCHSIA", StructureType::eMemoryGetZirconHandleInfoFUCHSIA }, + { "ImportSemaphoreZirconHandleInfoFUCHSIA", StructureType::eImportSemaphoreZirconHandleInfoFUCHSIA }, + { "SemaphoreGetZirconHandleInfoFUCHSIA", StructureType::eSemaphoreGetZirconHandleInfoFUCHSIA }, + { "BufferCollectionCreateInfoFUCHSIA", StructureType::eBufferCollectionCreateInfoFUCHSIA }, + { "ImportMemoryBufferCollectionFUCHSIA", StructureType::eImportMemoryBufferCollectionFUCHSIA }, + { "BufferCollectionImageCreateInfoFUCHSIA", StructureType::eBufferCollectionImageCreateInfoFUCHSIA }, + { "BufferCollectionPropertiesFUCHSIA", StructureType::eBufferCollectionPropertiesFUCHSIA }, + { "BufferConstraintsInfoFUCHSIA", StructureType::eBufferConstraintsInfoFUCHSIA }, + { "BufferCollectionBufferCreateInfoFUCHSIA", StructureType::eBufferCollectionBufferCreateInfoFUCHSIA }, + { "ImageConstraintsInfoFUCHSIA", StructureType::eImageConstraintsInfoFUCHSIA }, + { "ImageFormatConstraintsInfoFUCHSIA", StructureType::eImageFormatConstraintsInfoFUCHSIA }, + { "SysmemColorSpaceFUCHSIA", StructureType::eSysmemColorSpaceFUCHSIA }, + { "BufferCollectionConstraintsInfoFUCHSIA", StructureType::eBufferCollectionConstraintsInfoFUCHSIA }, +#endif /*VK_USE_PLATFORM_FUCHSIA*/ + { "SubpassShadingPipelineCreateInfoHUAWEI", StructureType::eSubpassShadingPipelineCreateInfoHUAWEI }, + { "PhysicalDeviceSubpassShadingFeaturesHUAWEI", StructureType::ePhysicalDeviceSubpassShadingFeaturesHUAWEI }, + { "PhysicalDeviceSubpassShadingPropertiesHUAWEI", StructureType::ePhysicalDeviceSubpassShadingPropertiesHUAWEI }, + { "PhysicalDeviceInvocationMaskFeaturesHUAWEI", StructureType::ePhysicalDeviceInvocationMaskFeaturesHUAWEI }, + { "MemoryGetRemoteAddressInfoNV", StructureType::eMemoryGetRemoteAddressInfoNV }, + { "PhysicalDeviceExternalMemoryRdmaFeaturesNV", StructureType::ePhysicalDeviceExternalMemoryRdmaFeaturesNV }, + { "PipelinePropertiesIdentifierEXT", StructureType::ePipelinePropertiesIdentifierEXT }, + { "PhysicalDevicePipelinePropertiesFeaturesEXT", StructureType::ePhysicalDevicePipelinePropertiesFeaturesEXT }, + { "PhysicalDeviceFrameBoundaryFeaturesEXT", StructureType::ePhysicalDeviceFrameBoundaryFeaturesEXT }, + { "FrameBoundaryEXT", StructureType::eFrameBoundaryEXT }, + { "PhysicalDeviceMultisampledRenderToSingleSampledFeaturesEXT", StructureType::ePhysicalDeviceMultisampledRenderToSingleSampledFeaturesEXT }, + { "SubpassResolvePerformanceQueryEXT", StructureType::eSubpassResolvePerformanceQueryEXT }, + { "MultisampledRenderToSingleSampledInfoEXT", StructureType::eMultisampledRenderToSingleSampledInfoEXT }, + { "PhysicalDeviceExtendedDynamicState2FeaturesEXT", StructureType::ePhysicalDeviceExtendedDynamicState2FeaturesEXT }, +#if defined( VK_USE_PLATFORM_SCREEN_QNX ) + { "ScreenSurfaceCreateInfoQNX", StructureType::eScreenSurfaceCreateInfoQNX }, +#endif /*VK_USE_PLATFORM_SCREEN_QNX*/ + { "PhysicalDeviceColorWriteEnableFeaturesEXT", StructureType::ePhysicalDeviceColorWriteEnableFeaturesEXT }, + { "PipelineColorWriteCreateInfoEXT", StructureType::ePipelineColorWriteCreateInfoEXT }, + { "PhysicalDevicePrimitivesGeneratedQueryFeaturesEXT", StructureType::ePhysicalDevicePrimitivesGeneratedQueryFeaturesEXT }, + { "PhysicalDeviceRayTracingMaintenance1FeaturesKHR", StructureType::ePhysicalDeviceRayTracingMaintenance1FeaturesKHR }, + { "PhysicalDeviceImageViewMinLodFeaturesEXT", StructureType::ePhysicalDeviceImageViewMinLodFeaturesEXT }, + { "ImageViewMinLodCreateInfoEXT", StructureType::eImageViewMinLodCreateInfoEXT }, + { "PhysicalDeviceMultiDrawFeaturesEXT", StructureType::ePhysicalDeviceMultiDrawFeaturesEXT }, + { "PhysicalDeviceMultiDrawPropertiesEXT", StructureType::ePhysicalDeviceMultiDrawPropertiesEXT }, + { "PhysicalDeviceImage2DViewOf3DFeaturesEXT", StructureType::ePhysicalDeviceImage2DViewOf3DFeaturesEXT }, + { "PhysicalDeviceShaderTileImageFeaturesEXT", StructureType::ePhysicalDeviceShaderTileImageFeaturesEXT }, + { "PhysicalDeviceShaderTileImagePropertiesEXT", StructureType::ePhysicalDeviceShaderTileImagePropertiesEXT }, + { "MicromapBuildInfoEXT", StructureType::eMicromapBuildInfoEXT }, + { "MicromapVersionInfoEXT", StructureType::eMicromapVersionInfoEXT }, + { "CopyMicromapInfoEXT", StructureType::eCopyMicromapInfoEXT }, + { "CopyMicromapToMemoryInfoEXT", StructureType::eCopyMicromapToMemoryInfoEXT }, + { "CopyMemoryToMicromapInfoEXT", StructureType::eCopyMemoryToMicromapInfoEXT }, + { "PhysicalDeviceOpacityMicromapFeaturesEXT", StructureType::ePhysicalDeviceOpacityMicromapFeaturesEXT }, + { "PhysicalDeviceOpacityMicromapPropertiesEXT", StructureType::ePhysicalDeviceOpacityMicromapPropertiesEXT }, + { "MicromapCreateInfoEXT", StructureType::eMicromapCreateInfoEXT }, + { "MicromapBuildSizesInfoEXT", StructureType::eMicromapBuildSizesInfoEXT }, + { "AccelerationStructureTrianglesOpacityMicromapEXT", StructureType::eAccelerationStructureTrianglesOpacityMicromapEXT }, +#if defined( VK_ENABLE_BETA_EXTENSIONS ) + { "PhysicalDeviceDisplacementMicromapFeaturesNV", StructureType::ePhysicalDeviceDisplacementMicromapFeaturesNV }, + { "PhysicalDeviceDisplacementMicromapPropertiesNV", StructureType::ePhysicalDeviceDisplacementMicromapPropertiesNV }, + { "AccelerationStructureTrianglesDisplacementMicromapNV", StructureType::eAccelerationStructureTrianglesDisplacementMicromapNV }, +#endif /*VK_ENABLE_BETA_EXTENSIONS*/ + { "PhysicalDeviceClusterCullingShaderFeaturesHUAWEI", StructureType::ePhysicalDeviceClusterCullingShaderFeaturesHUAWEI }, + { "PhysicalDeviceClusterCullingShaderPropertiesHUAWEI", StructureType::ePhysicalDeviceClusterCullingShaderPropertiesHUAWEI }, + { "PhysicalDeviceBorderColorSwizzleFeaturesEXT", StructureType::ePhysicalDeviceBorderColorSwizzleFeaturesEXT }, + { "SamplerBorderColorComponentMappingCreateInfoEXT", StructureType::eSamplerBorderColorComponentMappingCreateInfoEXT }, + { "PhysicalDevicePageableDeviceLocalMemoryFeaturesEXT", StructureType::ePhysicalDevicePageableDeviceLocalMemoryFeaturesEXT }, + { "PhysicalDeviceShaderCorePropertiesARM", StructureType::ePhysicalDeviceShaderCorePropertiesARM }, + { "DeviceQueueShaderCoreControlCreateInfoARM", StructureType::eDeviceQueueShaderCoreControlCreateInfoARM }, + { "PhysicalDeviceSchedulingControlsFeaturesARM", StructureType::ePhysicalDeviceSchedulingControlsFeaturesARM }, + { "PhysicalDeviceSchedulingControlsPropertiesARM", StructureType::ePhysicalDeviceSchedulingControlsPropertiesARM }, + { "PhysicalDeviceImageSlicedViewOf3DFeaturesEXT", StructureType::ePhysicalDeviceImageSlicedViewOf3DFeaturesEXT }, + { "ImageViewSlicedCreateInfoEXT", StructureType::eImageViewSlicedCreateInfoEXT }, + { "PhysicalDeviceDescriptorSetHostMappingFeaturesVALVE", StructureType::ePhysicalDeviceDescriptorSetHostMappingFeaturesVALVE }, + { "DescriptorSetBindingReferenceVALVE", StructureType::eDescriptorSetBindingReferenceVALVE }, + { "DescriptorSetLayoutHostMappingInfoVALVE", StructureType::eDescriptorSetLayoutHostMappingInfoVALVE }, + { "PhysicalDeviceDepthClampZeroOneFeaturesEXT", StructureType::ePhysicalDeviceDepthClampZeroOneFeaturesEXT }, + { "PhysicalDeviceNonSeamlessCubeMapFeaturesEXT", StructureType::ePhysicalDeviceNonSeamlessCubeMapFeaturesEXT }, + { "PhysicalDeviceFragmentDensityMapOffsetFeaturesQCOM", StructureType::ePhysicalDeviceFragmentDensityMapOffsetFeaturesQCOM }, + { "PhysicalDeviceFragmentDensityMapOffsetPropertiesQCOM", StructureType::ePhysicalDeviceFragmentDensityMapOffsetPropertiesQCOM }, + { "SubpassFragmentDensityMapOffsetEndInfoQCOM", StructureType::eSubpassFragmentDensityMapOffsetEndInfoQCOM }, + { "PhysicalDeviceCopyMemoryIndirectFeaturesNV", StructureType::ePhysicalDeviceCopyMemoryIndirectFeaturesNV }, + { "PhysicalDeviceCopyMemoryIndirectPropertiesNV", StructureType::ePhysicalDeviceCopyMemoryIndirectPropertiesNV }, + { "PhysicalDeviceMemoryDecompressionFeaturesNV", StructureType::ePhysicalDeviceMemoryDecompressionFeaturesNV }, + { "PhysicalDeviceMemoryDecompressionPropertiesNV", StructureType::ePhysicalDeviceMemoryDecompressionPropertiesNV }, + { "PhysicalDeviceDeviceGeneratedCommandsComputeFeaturesNV", StructureType::ePhysicalDeviceDeviceGeneratedCommandsComputeFeaturesNV }, + { "ComputePipelineIndirectBufferInfoNV", StructureType::eComputePipelineIndirectBufferInfoNV }, + { "PipelineIndirectDeviceAddressInfoNV", StructureType::ePipelineIndirectDeviceAddressInfoNV }, + { "PhysicalDeviceLinearColorAttachmentFeaturesNV", StructureType::ePhysicalDeviceLinearColorAttachmentFeaturesNV }, + { "PhysicalDeviceImageCompressionControlSwapchainFeaturesEXT", StructureType::ePhysicalDeviceImageCompressionControlSwapchainFeaturesEXT }, + { "PhysicalDeviceImageProcessingFeaturesQCOM", StructureType::ePhysicalDeviceImageProcessingFeaturesQCOM }, + { "PhysicalDeviceImageProcessingPropertiesQCOM", StructureType::ePhysicalDeviceImageProcessingPropertiesQCOM }, + { "ImageViewSampleWeightCreateInfoQCOM", StructureType::eImageViewSampleWeightCreateInfoQCOM }, + { "PhysicalDeviceNestedCommandBufferFeaturesEXT", StructureType::ePhysicalDeviceNestedCommandBufferFeaturesEXT }, + { "PhysicalDeviceNestedCommandBufferPropertiesEXT", StructureType::ePhysicalDeviceNestedCommandBufferPropertiesEXT }, + { "ExternalMemoryAcquireUnmodifiedEXT", StructureType::eExternalMemoryAcquireUnmodifiedEXT }, + { "PhysicalDeviceExtendedDynamicState3FeaturesEXT", StructureType::ePhysicalDeviceExtendedDynamicState3FeaturesEXT }, + { "PhysicalDeviceExtendedDynamicState3PropertiesEXT", StructureType::ePhysicalDeviceExtendedDynamicState3PropertiesEXT }, + { "PhysicalDeviceSubpassMergeFeedbackFeaturesEXT", StructureType::ePhysicalDeviceSubpassMergeFeedbackFeaturesEXT }, + { "RenderPassCreationControlEXT", StructureType::eRenderPassCreationControlEXT }, + { "RenderPassCreationFeedbackCreateInfoEXT", StructureType::eRenderPassCreationFeedbackCreateInfoEXT }, + { "RenderPassSubpassFeedbackCreateInfoEXT", StructureType::eRenderPassSubpassFeedbackCreateInfoEXT }, + { "DirectDriverLoadingInfoLUNARG", StructureType::eDirectDriverLoadingInfoLUNARG }, + { "DirectDriverLoadingListLUNARG", StructureType::eDirectDriverLoadingListLUNARG }, + { "PhysicalDeviceShaderModuleIdentifierFeaturesEXT", StructureType::ePhysicalDeviceShaderModuleIdentifierFeaturesEXT }, + { "PhysicalDeviceShaderModuleIdentifierPropertiesEXT", StructureType::ePhysicalDeviceShaderModuleIdentifierPropertiesEXT }, + { "PipelineShaderStageModuleIdentifierCreateInfoEXT", StructureType::ePipelineShaderStageModuleIdentifierCreateInfoEXT }, + { "ShaderModuleIdentifierEXT", StructureType::eShaderModuleIdentifierEXT }, + { "PhysicalDeviceRasterizationOrderAttachmentAccessFeaturesEXT", StructureType::ePhysicalDeviceRasterizationOrderAttachmentAccessFeaturesEXT }, + { "PhysicalDeviceOpticalFlowFeaturesNV", StructureType::ePhysicalDeviceOpticalFlowFeaturesNV }, + { "PhysicalDeviceOpticalFlowPropertiesNV", StructureType::ePhysicalDeviceOpticalFlowPropertiesNV }, + { "OpticalFlowImageFormatInfoNV", StructureType::eOpticalFlowImageFormatInfoNV }, + { "OpticalFlowImageFormatPropertiesNV", StructureType::eOpticalFlowImageFormatPropertiesNV }, + { "OpticalFlowSessionCreateInfoNV", StructureType::eOpticalFlowSessionCreateInfoNV }, + { "OpticalFlowExecuteInfoNV", StructureType::eOpticalFlowExecuteInfoNV }, + { "OpticalFlowSessionCreatePrivateDataInfoNV", StructureType::eOpticalFlowSessionCreatePrivateDataInfoNV }, + { "PhysicalDeviceLegacyDitheringFeaturesEXT", StructureType::ePhysicalDeviceLegacyDitheringFeaturesEXT }, + { "PhysicalDevicePipelineProtectedAccessFeaturesEXT", StructureType::ePhysicalDevicePipelineProtectedAccessFeaturesEXT }, +#if defined( VK_USE_PLATFORM_ANDROID_KHR ) + { "PhysicalDeviceExternalFormatResolveFeaturesANDROID", StructureType::ePhysicalDeviceExternalFormatResolveFeaturesANDROID }, + { "PhysicalDeviceExternalFormatResolvePropertiesANDROID", StructureType::ePhysicalDeviceExternalFormatResolvePropertiesANDROID }, + { "AndroidHardwareBufferFormatResolvePropertiesANDROID", StructureType::eAndroidHardwareBufferFormatResolvePropertiesANDROID }, +#endif /*VK_USE_PLATFORM_ANDROID_KHR*/ + { "PhysicalDeviceMaintenance5FeaturesKHR", StructureType::ePhysicalDeviceMaintenance5FeaturesKHR }, + { "PhysicalDeviceMaintenance5PropertiesKHR", StructureType::ePhysicalDeviceMaintenance5PropertiesKHR }, + { "RenderingAreaInfoKHR", StructureType::eRenderingAreaInfoKHR }, + { "DeviceImageSubresourceInfoKHR", StructureType::eDeviceImageSubresourceInfoKHR }, + { "SubresourceLayout2KHR", StructureType::eSubresourceLayout2KHR }, + { "ImageSubresource2KHR", StructureType::eImageSubresource2KHR }, + { "PipelineCreateFlags2CreateInfoKHR", StructureType::ePipelineCreateFlags2CreateInfoKHR }, + { "BufferUsageFlags2CreateInfoKHR", StructureType::eBufferUsageFlags2CreateInfoKHR }, + { "PhysicalDeviceRayTracingPositionFetchFeaturesKHR", StructureType::ePhysicalDeviceRayTracingPositionFetchFeaturesKHR }, + { "PhysicalDeviceShaderObjectFeaturesEXT", StructureType::ePhysicalDeviceShaderObjectFeaturesEXT }, + { "PhysicalDeviceShaderObjectPropertiesEXT", StructureType::ePhysicalDeviceShaderObjectPropertiesEXT }, + { "ShaderCreateInfoEXT", StructureType::eShaderCreateInfoEXT }, + { "PhysicalDeviceTilePropertiesFeaturesQCOM", StructureType::ePhysicalDeviceTilePropertiesFeaturesQCOM }, + { "TilePropertiesQCOM", StructureType::eTilePropertiesQCOM }, + { "PhysicalDeviceAmigoProfilingFeaturesSEC", StructureType::ePhysicalDeviceAmigoProfilingFeaturesSEC }, + { "AmigoProfilingSubmitInfoSEC", StructureType::eAmigoProfilingSubmitInfoSEC }, + { "PhysicalDeviceMultiviewPerViewViewportsFeaturesQCOM", StructureType::ePhysicalDeviceMultiviewPerViewViewportsFeaturesQCOM }, + { "PhysicalDeviceRayTracingInvocationReorderFeaturesNV", StructureType::ePhysicalDeviceRayTracingInvocationReorderFeaturesNV }, + { "PhysicalDeviceRayTracingInvocationReorderPropertiesNV", StructureType::ePhysicalDeviceRayTracingInvocationReorderPropertiesNV }, + { "PhysicalDeviceExtendedSparseAddressSpaceFeaturesNV", StructureType::ePhysicalDeviceExtendedSparseAddressSpaceFeaturesNV }, + { "PhysicalDeviceExtendedSparseAddressSpacePropertiesNV", StructureType::ePhysicalDeviceExtendedSparseAddressSpacePropertiesNV }, + { "PhysicalDeviceMutableDescriptorTypeFeaturesEXT", StructureType::ePhysicalDeviceMutableDescriptorTypeFeaturesEXT }, + { "MutableDescriptorTypeCreateInfoEXT", StructureType::eMutableDescriptorTypeCreateInfoEXT }, + { "PhysicalDeviceShaderCoreBuiltinsFeaturesARM", StructureType::ePhysicalDeviceShaderCoreBuiltinsFeaturesARM }, + { "PhysicalDeviceShaderCoreBuiltinsPropertiesARM", StructureType::ePhysicalDeviceShaderCoreBuiltinsPropertiesARM }, + { "PhysicalDevicePipelineLibraryGroupHandlesFeaturesEXT", StructureType::ePhysicalDevicePipelineLibraryGroupHandlesFeaturesEXT }, + { "PhysicalDeviceDynamicRenderingUnusedAttachmentsFeaturesEXT", StructureType::ePhysicalDeviceDynamicRenderingUnusedAttachmentsFeaturesEXT }, + { "LatencySleepModeInfoNV", StructureType::eLatencySleepModeInfoNV }, + { "LatencySleepInfoNV", StructureType::eLatencySleepInfoNV }, + { "SetLatencyMarkerInfoNV", StructureType::eSetLatencyMarkerInfoNV }, + { "GetLatencyMarkerInfoNV", StructureType::eGetLatencyMarkerInfoNV }, + { "LatencyTimingsFrameReportNV", StructureType::eLatencyTimingsFrameReportNV }, + { "LatencySubmissionPresentIdNV", StructureType::eLatencySubmissionPresentIdNV }, + { "OutOfBandQueueTypeInfoNV", StructureType::eOutOfBandQueueTypeInfoNV }, + { "SwapchainLatencyCreateInfoNV", StructureType::eSwapchainLatencyCreateInfoNV }, + { "LatencySurfaceCapabilitiesNV", StructureType::eLatencySurfaceCapabilitiesNV }, + { "PhysicalDeviceCooperativeMatrixFeaturesKHR", StructureType::ePhysicalDeviceCooperativeMatrixFeaturesKHR }, + { "CooperativeMatrixPropertiesKHR", StructureType::eCooperativeMatrixPropertiesKHR }, + { "PhysicalDeviceCooperativeMatrixPropertiesKHR", StructureType::ePhysicalDeviceCooperativeMatrixPropertiesKHR }, + { "PhysicalDeviceMultiviewPerViewRenderAreasFeaturesQCOM", StructureType::ePhysicalDeviceMultiviewPerViewRenderAreasFeaturesQCOM }, + { "MultiviewPerViewRenderAreasRenderPassBeginInfoQCOM", StructureType::eMultiviewPerViewRenderAreasRenderPassBeginInfoQCOM }, + { "PhysicalDeviceImageProcessing2FeaturesQCOM", StructureType::ePhysicalDeviceImageProcessing2FeaturesQCOM }, + { "PhysicalDeviceImageProcessing2PropertiesQCOM", StructureType::ePhysicalDeviceImageProcessing2PropertiesQCOM }, + { "SamplerBlockMatchWindowCreateInfoQCOM", StructureType::eSamplerBlockMatchWindowCreateInfoQCOM }, + { "SamplerCubicWeightsCreateInfoQCOM", StructureType::eSamplerCubicWeightsCreateInfoQCOM }, + { "PhysicalDeviceCubicWeightsFeaturesQCOM", StructureType::ePhysicalDeviceCubicWeightsFeaturesQCOM }, + { "BlitImageCubicWeightsInfoQCOM", StructureType::eBlitImageCubicWeightsInfoQCOM }, + { "PhysicalDeviceYcbcrDegammaFeaturesQCOM", StructureType::ePhysicalDeviceYcbcrDegammaFeaturesQCOM }, + { "SamplerYcbcrConversionYcbcrDegammaCreateInfoQCOM", StructureType::eSamplerYcbcrConversionYcbcrDegammaCreateInfoQCOM }, + { "PhysicalDeviceCubicClampFeaturesQCOM", StructureType::ePhysicalDeviceCubicClampFeaturesQCOM }, + { "PhysicalDeviceAttachmentFeedbackLoopDynamicStateFeaturesEXT", StructureType::ePhysicalDeviceAttachmentFeedbackLoopDynamicStateFeaturesEXT }, +#if defined( VK_USE_PLATFORM_SCREEN_QNX ) + { "ScreenBufferPropertiesQNX", StructureType::eScreenBufferPropertiesQNX }, + { "ScreenBufferFormatPropertiesQNX", StructureType::eScreenBufferFormatPropertiesQNX }, + { "ImportScreenBufferInfoQNX", StructureType::eImportScreenBufferInfoQNX }, + { "ExternalFormatQNX", StructureType::eExternalFormatQNX }, + { "PhysicalDeviceExternalMemoryScreenBufferFeaturesQNX", StructureType::ePhysicalDeviceExternalMemoryScreenBufferFeaturesQNX }, +#endif /*VK_USE_PLATFORM_SCREEN_QNX*/ + { "PhysicalDeviceLayeredDriverPropertiesMSFT", StructureType::ePhysicalDeviceLayeredDriverPropertiesMSFT }, + { "PhysicalDeviceDescriptorPoolOverallocationFeaturesNV", StructureType::ePhysicalDeviceDescriptorPoolOverallocationFeaturesNV }, + + }; + + std::unordered_map PipelineCacheHeaderVersionEntries = { + { "One", PipelineCacheHeaderVersion::eOne }, + + }; + + std::unordered_map ObjectTypeEntries = { + { "Unknown", ObjectType::eUnknown }, + { "Instance", ObjectType::eInstance }, + { "PhysicalDevice", ObjectType::ePhysicalDevice }, + { "Device", ObjectType::eDevice }, + { "Queue", ObjectType::eQueue }, + { "Semaphore", ObjectType::eSemaphore }, + { "CommandBuffer", ObjectType::eCommandBuffer }, + { "Fence", ObjectType::eFence }, + { "DeviceMemory", ObjectType::eDeviceMemory }, + { "Buffer", ObjectType::eBuffer }, + { "Image", ObjectType::eImage }, + { "Event", ObjectType::eEvent }, + { "QueryPool", ObjectType::eQueryPool }, + { "BufferView", ObjectType::eBufferView }, + { "ImageView", ObjectType::eImageView }, + { "ShaderModule", ObjectType::eShaderModule }, + { "PipelineCache", ObjectType::ePipelineCache }, + { "PipelineLayout", ObjectType::ePipelineLayout }, + { "RenderPass", ObjectType::eRenderPass }, + { "Pipeline", ObjectType::ePipeline }, + { "DescriptorSetLayout", ObjectType::eDescriptorSetLayout }, + { "Sampler", ObjectType::eSampler }, + { "DescriptorPool", ObjectType::eDescriptorPool }, + { "DescriptorSet", ObjectType::eDescriptorSet }, + { "Framebuffer", ObjectType::eFramebuffer }, + { "CommandPool", ObjectType::eCommandPool }, + { "SamplerYcbcrConversion", ObjectType::eSamplerYcbcrConversion }, + { "DescriptorUpdateTemplate", ObjectType::eDescriptorUpdateTemplate }, + { "PrivateDataSlot", ObjectType::ePrivateDataSlot }, + { "SurfaceKHR", ObjectType::eSurfaceKHR }, + { "SwapchainKHR", ObjectType::eSwapchainKHR }, + { "DisplayKHR", ObjectType::eDisplayKHR }, + { "DisplayModeKHR", ObjectType::eDisplayModeKHR }, + { "DebugReportCallbackEXT", ObjectType::eDebugReportCallbackEXT }, + { "VideoSessionKHR", ObjectType::eVideoSessionKHR }, + { "VideoSessionParametersKHR", ObjectType::eVideoSessionParametersKHR }, + { "CuModuleNVX", ObjectType::eCuModuleNVX }, + { "CuFunctionNVX", ObjectType::eCuFunctionNVX }, + { "DebugUtilsMessengerEXT", ObjectType::eDebugUtilsMessengerEXT }, + { "AccelerationStructureKHR", ObjectType::eAccelerationStructureKHR }, + { "ValidationCacheEXT", ObjectType::eValidationCacheEXT }, + { "AccelerationStructureNV", ObjectType::eAccelerationStructureNV }, + { "PerformanceConfigurationINTEL", ObjectType::ePerformanceConfigurationINTEL }, + { "DeferredOperationKHR", ObjectType::eDeferredOperationKHR }, + { "IndirectCommandsLayoutNV", ObjectType::eIndirectCommandsLayoutNV }, +#if defined( VK_ENABLE_BETA_EXTENSIONS ) + { "CudaModuleNV", ObjectType::eCudaModuleNV }, + { "CudaFunctionNV", ObjectType::eCudaFunctionNV }, +#endif /*VK_ENABLE_BETA_EXTENSIONS*/ +#if defined( VK_USE_PLATFORM_FUCHSIA ) + { "BufferCollectionFUCHSIA", ObjectType::eBufferCollectionFUCHSIA }, +#endif /*VK_USE_PLATFORM_FUCHSIA*/ + { "MicromapEXT", ObjectType::eMicromapEXT }, + { "OpticalFlowSessionNV", ObjectType::eOpticalFlowSessionNV }, + { "ShaderEXT", ObjectType::eShaderEXT }, + + }; + + std::unordered_map VendorIdEntries = { + { "VIV", VendorId::eVIV }, { "VSI", VendorId::eVSI }, { "Kazan", VendorId::eKazan }, { "Codeplay", VendorId::eCodeplay }, + { "MESA", VendorId::eMESA }, { "Pocl", VendorId::ePocl }, { "Mobileye", VendorId::eMobileye }, + + }; + + std::unordered_map FormatEntries = { + { "Undefined", Format::eUndefined }, + { "R4G4UnormPack8", Format::eR4G4UnormPack8 }, + { "R4G4B4A4UnormPack16", Format::eR4G4B4A4UnormPack16 }, + { "B4G4R4A4UnormPack16", Format::eB4G4R4A4UnormPack16 }, + { "R5G6B5UnormPack16", Format::eR5G6B5UnormPack16 }, + { "B5G6R5UnormPack16", Format::eB5G6R5UnormPack16 }, + { "R5G5B5A1UnormPack16", Format::eR5G5B5A1UnormPack16 }, + { "B5G5R5A1UnormPack16", Format::eB5G5R5A1UnormPack16 }, + { "A1R5G5B5UnormPack16", Format::eA1R5G5B5UnormPack16 }, + { "R8Unorm", Format::eR8Unorm }, + { "R8Snorm", Format::eR8Snorm }, + { "R8Uscaled", Format::eR8Uscaled }, + { "R8Sscaled", Format::eR8Sscaled }, + { "R8Uint", Format::eR8Uint }, + { "R8Sint", Format::eR8Sint }, + { "R8Srgb", Format::eR8Srgb }, + { "R8G8Unorm", Format::eR8G8Unorm }, + { "R8G8Snorm", Format::eR8G8Snorm }, + { "R8G8Uscaled", Format::eR8G8Uscaled }, + { "R8G8Sscaled", Format::eR8G8Sscaled }, + { "R8G8Uint", Format::eR8G8Uint }, + { "R8G8Sint", Format::eR8G8Sint }, + { "R8G8Srgb", Format::eR8G8Srgb }, + { "R8G8B8Unorm", Format::eR8G8B8Unorm }, + { "R8G8B8Snorm", Format::eR8G8B8Snorm }, + { "R8G8B8Uscaled", Format::eR8G8B8Uscaled }, + { "R8G8B8Sscaled", Format::eR8G8B8Sscaled }, + { "R8G8B8Uint", Format::eR8G8B8Uint }, + { "R8G8B8Sint", Format::eR8G8B8Sint }, + { "R8G8B8Srgb", Format::eR8G8B8Srgb }, + { "B8G8R8Unorm", Format::eB8G8R8Unorm }, + { "B8G8R8Snorm", Format::eB8G8R8Snorm }, + { "B8G8R8Uscaled", Format::eB8G8R8Uscaled }, + { "B8G8R8Sscaled", Format::eB8G8R8Sscaled }, + { "B8G8R8Uint", Format::eB8G8R8Uint }, + { "B8G8R8Sint", Format::eB8G8R8Sint }, + { "B8G8R8Srgb", Format::eB8G8R8Srgb }, + { "R8G8B8A8Unorm", Format::eR8G8B8A8Unorm }, + { "R8G8B8A8Snorm", Format::eR8G8B8A8Snorm }, + { "R8G8B8A8Uscaled", Format::eR8G8B8A8Uscaled }, + { "R8G8B8A8Sscaled", Format::eR8G8B8A8Sscaled }, + { "R8G8B8A8Uint", Format::eR8G8B8A8Uint }, + { "R8G8B8A8Sint", Format::eR8G8B8A8Sint }, + { "R8G8B8A8Srgb", Format::eR8G8B8A8Srgb }, + { "B8G8R8A8Unorm", Format::eB8G8R8A8Unorm }, + { "B8G8R8A8Snorm", Format::eB8G8R8A8Snorm }, + { "B8G8R8A8Uscaled", Format::eB8G8R8A8Uscaled }, + { "B8G8R8A8Sscaled", Format::eB8G8R8A8Sscaled }, + { "B8G8R8A8Uint", Format::eB8G8R8A8Uint }, + { "B8G8R8A8Sint", Format::eB8G8R8A8Sint }, + { "B8G8R8A8Srgb", Format::eB8G8R8A8Srgb }, + { "A8B8G8R8UnormPack32", Format::eA8B8G8R8UnormPack32 }, + { "A8B8G8R8SnormPack32", Format::eA8B8G8R8SnormPack32 }, + { "A8B8G8R8UscaledPack32", Format::eA8B8G8R8UscaledPack32 }, + { "A8B8G8R8SscaledPack32", Format::eA8B8G8R8SscaledPack32 }, + { "A8B8G8R8UintPack32", Format::eA8B8G8R8UintPack32 }, + { "A8B8G8R8SintPack32", Format::eA8B8G8R8SintPack32 }, + { "A8B8G8R8SrgbPack32", Format::eA8B8G8R8SrgbPack32 }, + { "A2R10G10B10UnormPack32", Format::eA2R10G10B10UnormPack32 }, + { "A2R10G10B10SnormPack32", Format::eA2R10G10B10SnormPack32 }, + { "A2R10G10B10UscaledPack32", Format::eA2R10G10B10UscaledPack32 }, + { "A2R10G10B10SscaledPack32", Format::eA2R10G10B10SscaledPack32 }, + { "A2R10G10B10UintPack32", Format::eA2R10G10B10UintPack32 }, + { "A2R10G10B10SintPack32", Format::eA2R10G10B10SintPack32 }, + { "A2B10G10R10UnormPack32", Format::eA2B10G10R10UnormPack32 }, + { "A2B10G10R10SnormPack32", Format::eA2B10G10R10SnormPack32 }, + { "A2B10G10R10UscaledPack32", Format::eA2B10G10R10UscaledPack32 }, + { "A2B10G10R10SscaledPack32", Format::eA2B10G10R10SscaledPack32 }, + { "A2B10G10R10UintPack32", Format::eA2B10G10R10UintPack32 }, + { "A2B10G10R10SintPack32", Format::eA2B10G10R10SintPack32 }, + { "R16Unorm", Format::eR16Unorm }, + { "R16Snorm", Format::eR16Snorm }, + { "R16Uscaled", Format::eR16Uscaled }, + { "R16Sscaled", Format::eR16Sscaled }, + { "R16Uint", Format::eR16Uint }, + { "R16Sint", Format::eR16Sint }, + { "R16Sfloat", Format::eR16Sfloat }, + { "R16G16Unorm", Format::eR16G16Unorm }, + { "R16G16Snorm", Format::eR16G16Snorm }, + { "R16G16Uscaled", Format::eR16G16Uscaled }, + { "R16G16Sscaled", Format::eR16G16Sscaled }, + { "R16G16Uint", Format::eR16G16Uint }, + { "R16G16Sint", Format::eR16G16Sint }, + { "R16G16Sfloat", Format::eR16G16Sfloat }, + { "R16G16B16Unorm", Format::eR16G16B16Unorm }, + { "R16G16B16Snorm", Format::eR16G16B16Snorm }, + { "R16G16B16Uscaled", Format::eR16G16B16Uscaled }, + { "R16G16B16Sscaled", Format::eR16G16B16Sscaled }, + { "R16G16B16Uint", Format::eR16G16B16Uint }, + { "R16G16B16Sint", Format::eR16G16B16Sint }, + { "R16G16B16Sfloat", Format::eR16G16B16Sfloat }, + { "R16G16B16A16Unorm", Format::eR16G16B16A16Unorm }, + { "R16G16B16A16Snorm", Format::eR16G16B16A16Snorm }, + { "R16G16B16A16Uscaled", Format::eR16G16B16A16Uscaled }, + { "R16G16B16A16Sscaled", Format::eR16G16B16A16Sscaled }, + { "R16G16B16A16Uint", Format::eR16G16B16A16Uint }, + { "R16G16B16A16Sint", Format::eR16G16B16A16Sint }, + { "R16G16B16A16Sfloat", Format::eR16G16B16A16Sfloat }, + { "R32Uint", Format::eR32Uint }, + { "R32Sint", Format::eR32Sint }, + { "R32Sfloat", Format::eR32Sfloat }, + { "R32G32Uint", Format::eR32G32Uint }, + { "R32G32Sint", Format::eR32G32Sint }, + { "R32G32Sfloat", Format::eR32G32Sfloat }, + { "R32G32B32Uint", Format::eR32G32B32Uint }, + { "R32G32B32Sint", Format::eR32G32B32Sint }, + { "R32G32B32Sfloat", Format::eR32G32B32Sfloat }, + { "R32G32B32A32Uint", Format::eR32G32B32A32Uint }, + { "R32G32B32A32Sint", Format::eR32G32B32A32Sint }, + { "R32G32B32A32Sfloat", Format::eR32G32B32A32Sfloat }, + { "R64Uint", Format::eR64Uint }, + { "R64Sint", Format::eR64Sint }, + { "R64Sfloat", Format::eR64Sfloat }, + { "R64G64Uint", Format::eR64G64Uint }, + { "R64G64Sint", Format::eR64G64Sint }, + { "R64G64Sfloat", Format::eR64G64Sfloat }, + { "R64G64B64Uint", Format::eR64G64B64Uint }, + { "R64G64B64Sint", Format::eR64G64B64Sint }, + { "R64G64B64Sfloat", Format::eR64G64B64Sfloat }, + { "R64G64B64A64Uint", Format::eR64G64B64A64Uint }, + { "R64G64B64A64Sint", Format::eR64G64B64A64Sint }, + { "R64G64B64A64Sfloat", Format::eR64G64B64A64Sfloat }, + { "B10G11R11UfloatPack32", Format::eB10G11R11UfloatPack32 }, + { "E5B9G9R9UfloatPack32", Format::eE5B9G9R9UfloatPack32 }, + { "D16Unorm", Format::eD16Unorm }, + { "X8D24UnormPack32", Format::eX8D24UnormPack32 }, + { "D32Sfloat", Format::eD32Sfloat }, + { "S8Uint", Format::eS8Uint }, + { "D16UnormS8Uint", Format::eD16UnormS8Uint }, + { "D24UnormS8Uint", Format::eD24UnormS8Uint }, + { "D32SfloatS8Uint", Format::eD32SfloatS8Uint }, + { "Bc1RgbUnormBlock", Format::eBc1RgbUnormBlock }, + { "Bc1RgbSrgbBlock", Format::eBc1RgbSrgbBlock }, + { "Bc1RgbaUnormBlock", Format::eBc1RgbaUnormBlock }, + { "Bc1RgbaSrgbBlock", Format::eBc1RgbaSrgbBlock }, + { "Bc2UnormBlock", Format::eBc2UnormBlock }, + { "Bc2SrgbBlock", Format::eBc2SrgbBlock }, + { "Bc3UnormBlock", Format::eBc3UnormBlock }, + { "Bc3SrgbBlock", Format::eBc3SrgbBlock }, + { "Bc4UnormBlock", Format::eBc4UnormBlock }, + { "Bc4SnormBlock", Format::eBc4SnormBlock }, + { "Bc5UnormBlock", Format::eBc5UnormBlock }, + { "Bc5SnormBlock", Format::eBc5SnormBlock }, + { "Bc6HUfloatBlock", Format::eBc6HUfloatBlock }, + { "Bc6HSfloatBlock", Format::eBc6HSfloatBlock }, + { "Bc7UnormBlock", Format::eBc7UnormBlock }, + { "Bc7SrgbBlock", Format::eBc7SrgbBlock }, + { "Etc2R8G8B8UnormBlock", Format::eEtc2R8G8B8UnormBlock }, + { "Etc2R8G8B8SrgbBlock", Format::eEtc2R8G8B8SrgbBlock }, + { "Etc2R8G8B8A1UnormBlock", Format::eEtc2R8G8B8A1UnormBlock }, + { "Etc2R8G8B8A1SrgbBlock", Format::eEtc2R8G8B8A1SrgbBlock }, + { "Etc2R8G8B8A8UnormBlock", Format::eEtc2R8G8B8A8UnormBlock }, + { "Etc2R8G8B8A8SrgbBlock", Format::eEtc2R8G8B8A8SrgbBlock }, + { "EacR11UnormBlock", Format::eEacR11UnormBlock }, + { "EacR11SnormBlock", Format::eEacR11SnormBlock }, + { "EacR11G11UnormBlock", Format::eEacR11G11UnormBlock }, + { "EacR11G11SnormBlock", Format::eEacR11G11SnormBlock }, + { "Astc4x4UnormBlock", Format::eAstc4x4UnormBlock }, + { "Astc4x4SrgbBlock", Format::eAstc4x4SrgbBlock }, + { "Astc5x4UnormBlock", Format::eAstc5x4UnormBlock }, + { "Astc5x4SrgbBlock", Format::eAstc5x4SrgbBlock }, + { "Astc5x5UnormBlock", Format::eAstc5x5UnormBlock }, + { "Astc5x5SrgbBlock", Format::eAstc5x5SrgbBlock }, + { "Astc6x5UnormBlock", Format::eAstc6x5UnormBlock }, + { "Astc6x5SrgbBlock", Format::eAstc6x5SrgbBlock }, + { "Astc6x6UnormBlock", Format::eAstc6x6UnormBlock }, + { "Astc6x6SrgbBlock", Format::eAstc6x6SrgbBlock }, + { "Astc8x5UnormBlock", Format::eAstc8x5UnormBlock }, + { "Astc8x5SrgbBlock", Format::eAstc8x5SrgbBlock }, + { "Astc8x6UnormBlock", Format::eAstc8x6UnormBlock }, + { "Astc8x6SrgbBlock", Format::eAstc8x6SrgbBlock }, + { "Astc8x8UnormBlock", Format::eAstc8x8UnormBlock }, + { "Astc8x8SrgbBlock", Format::eAstc8x8SrgbBlock }, + { "Astc10x5UnormBlock", Format::eAstc10x5UnormBlock }, + { "Astc10x5SrgbBlock", Format::eAstc10x5SrgbBlock }, + { "Astc10x6UnormBlock", Format::eAstc10x6UnormBlock }, + { "Astc10x6SrgbBlock", Format::eAstc10x6SrgbBlock }, + { "Astc10x8UnormBlock", Format::eAstc10x8UnormBlock }, + { "Astc10x8SrgbBlock", Format::eAstc10x8SrgbBlock }, + { "Astc10x10UnormBlock", Format::eAstc10x10UnormBlock }, + { "Astc10x10SrgbBlock", Format::eAstc10x10SrgbBlock }, + { "Astc12x10UnormBlock", Format::eAstc12x10UnormBlock }, + { "Astc12x10SrgbBlock", Format::eAstc12x10SrgbBlock }, + { "Astc12x12UnormBlock", Format::eAstc12x12UnormBlock }, + { "Astc12x12SrgbBlock", Format::eAstc12x12SrgbBlock }, + { "G8B8G8R8422Unorm", Format::eG8B8G8R8422Unorm }, + { "B8G8R8G8422Unorm", Format::eB8G8R8G8422Unorm }, + { "G8B8R83Plane420Unorm", Format::eG8B8R83Plane420Unorm }, + { "G8B8R82Plane420Unorm", Format::eG8B8R82Plane420Unorm }, + { "G8B8R83Plane422Unorm", Format::eG8B8R83Plane422Unorm }, + { "G8B8R82Plane422Unorm", Format::eG8B8R82Plane422Unorm }, + { "G8B8R83Plane444Unorm", Format::eG8B8R83Plane444Unorm }, + { "R10X6UnormPack16", Format::eR10X6UnormPack16 }, + { "R10X6G10X6Unorm2Pack16", Format::eR10X6G10X6Unorm2Pack16 }, + { "R10X6G10X6B10X6A10X6Unorm4Pack16", Format::eR10X6G10X6B10X6A10X6Unorm4Pack16 }, + { "G10X6B10X6G10X6R10X6422Unorm4Pack16", Format::eG10X6B10X6G10X6R10X6422Unorm4Pack16 }, + { "B10X6G10X6R10X6G10X6422Unorm4Pack16", Format::eB10X6G10X6R10X6G10X6422Unorm4Pack16 }, + { "G10X6B10X6R10X63Plane420Unorm3Pack16", Format::eG10X6B10X6R10X63Plane420Unorm3Pack16 }, + { "G10X6B10X6R10X62Plane420Unorm3Pack16", Format::eG10X6B10X6R10X62Plane420Unorm3Pack16 }, + { "G10X6B10X6R10X63Plane422Unorm3Pack16", Format::eG10X6B10X6R10X63Plane422Unorm3Pack16 }, + { "G10X6B10X6R10X62Plane422Unorm3Pack16", Format::eG10X6B10X6R10X62Plane422Unorm3Pack16 }, + { "G10X6B10X6R10X63Plane444Unorm3Pack16", Format::eG10X6B10X6R10X63Plane444Unorm3Pack16 }, + { "R12X4UnormPack16", Format::eR12X4UnormPack16 }, + { "R12X4G12X4Unorm2Pack16", Format::eR12X4G12X4Unorm2Pack16 }, + { "R12X4G12X4B12X4A12X4Unorm4Pack16", Format::eR12X4G12X4B12X4A12X4Unorm4Pack16 }, + { "G12X4B12X4G12X4R12X4422Unorm4Pack16", Format::eG12X4B12X4G12X4R12X4422Unorm4Pack16 }, + { "B12X4G12X4R12X4G12X4422Unorm4Pack16", Format::eB12X4G12X4R12X4G12X4422Unorm4Pack16 }, + { "G12X4B12X4R12X43Plane420Unorm3Pack16", Format::eG12X4B12X4R12X43Plane420Unorm3Pack16 }, + { "G12X4B12X4R12X42Plane420Unorm3Pack16", Format::eG12X4B12X4R12X42Plane420Unorm3Pack16 }, + { "G12X4B12X4R12X43Plane422Unorm3Pack16", Format::eG12X4B12X4R12X43Plane422Unorm3Pack16 }, + { "G12X4B12X4R12X42Plane422Unorm3Pack16", Format::eG12X4B12X4R12X42Plane422Unorm3Pack16 }, + { "G12X4B12X4R12X43Plane444Unorm3Pack16", Format::eG12X4B12X4R12X43Plane444Unorm3Pack16 }, + { "G16B16G16R16422Unorm", Format::eG16B16G16R16422Unorm }, + { "B16G16R16G16422Unorm", Format::eB16G16R16G16422Unorm }, + { "G16B16R163Plane420Unorm", Format::eG16B16R163Plane420Unorm }, + { "G16B16R162Plane420Unorm", Format::eG16B16R162Plane420Unorm }, + { "G16B16R163Plane422Unorm", Format::eG16B16R163Plane422Unorm }, + { "G16B16R162Plane422Unorm", Format::eG16B16R162Plane422Unorm }, + { "G16B16R163Plane444Unorm", Format::eG16B16R163Plane444Unorm }, + { "G8B8R82Plane444Unorm", Format::eG8B8R82Plane444Unorm }, + { "G10X6B10X6R10X62Plane444Unorm3Pack16", Format::eG10X6B10X6R10X62Plane444Unorm3Pack16 }, + { "G12X4B12X4R12X42Plane444Unorm3Pack16", Format::eG12X4B12X4R12X42Plane444Unorm3Pack16 }, + { "G16B16R162Plane444Unorm", Format::eG16B16R162Plane444Unorm }, + { "A4R4G4B4UnormPack16", Format::eA4R4G4B4UnormPack16 }, + { "A4B4G4R4UnormPack16", Format::eA4B4G4R4UnormPack16 }, + { "Astc4x4SfloatBlock", Format::eAstc4x4SfloatBlock }, + { "Astc5x4SfloatBlock", Format::eAstc5x4SfloatBlock }, + { "Astc5x5SfloatBlock", Format::eAstc5x5SfloatBlock }, + { "Astc6x5SfloatBlock", Format::eAstc6x5SfloatBlock }, + { "Astc6x6SfloatBlock", Format::eAstc6x6SfloatBlock }, + { "Astc8x5SfloatBlock", Format::eAstc8x5SfloatBlock }, + { "Astc8x6SfloatBlock", Format::eAstc8x6SfloatBlock }, + { "Astc8x8SfloatBlock", Format::eAstc8x8SfloatBlock }, + { "Astc10x5SfloatBlock", Format::eAstc10x5SfloatBlock }, + { "Astc10x6SfloatBlock", Format::eAstc10x6SfloatBlock }, + { "Astc10x8SfloatBlock", Format::eAstc10x8SfloatBlock }, + { "Astc10x10SfloatBlock", Format::eAstc10x10SfloatBlock }, + { "Astc12x10SfloatBlock", Format::eAstc12x10SfloatBlock }, + { "Astc12x12SfloatBlock", Format::eAstc12x12SfloatBlock }, + { "Pvrtc12BppUnormBlockIMG", Format::ePvrtc12BppUnormBlockIMG }, + { "Pvrtc14BppUnormBlockIMG", Format::ePvrtc14BppUnormBlockIMG }, + { "Pvrtc22BppUnormBlockIMG", Format::ePvrtc22BppUnormBlockIMG }, + { "Pvrtc24BppUnormBlockIMG", Format::ePvrtc24BppUnormBlockIMG }, + { "Pvrtc12BppSrgbBlockIMG", Format::ePvrtc12BppSrgbBlockIMG }, + { "Pvrtc14BppSrgbBlockIMG", Format::ePvrtc14BppSrgbBlockIMG }, + { "Pvrtc22BppSrgbBlockIMG", Format::ePvrtc22BppSrgbBlockIMG }, + { "Pvrtc24BppSrgbBlockIMG", Format::ePvrtc24BppSrgbBlockIMG }, + { "R16G16S105NV", Format::eR16G16S105NV }, + { "A1B5G5R5UnormPack16KHR", Format::eA1B5G5R5UnormPack16KHR }, + { "A8UnormKHR", Format::eA8UnormKHR }, + + }; + + std::unordered_map FormatFeatureFlagBitsEntries = { + { "SampledImage", FormatFeatureFlagBits::eSampledImage }, + { "StorageImage", FormatFeatureFlagBits::eStorageImage }, + { "StorageImageAtomic", FormatFeatureFlagBits::eStorageImageAtomic }, + { "UniformTexelBuffer", FormatFeatureFlagBits::eUniformTexelBuffer }, + { "StorageTexelBuffer", FormatFeatureFlagBits::eStorageTexelBuffer }, + { "StorageTexelBufferAtomic", FormatFeatureFlagBits::eStorageTexelBufferAtomic }, + { "VertexBuffer", FormatFeatureFlagBits::eVertexBuffer }, + { "ColorAttachment", FormatFeatureFlagBits::eColorAttachment }, + { "ColorAttachmentBlend", FormatFeatureFlagBits::eColorAttachmentBlend }, + { "DepthStencilAttachment", FormatFeatureFlagBits::eDepthStencilAttachment }, + { "BlitSrc", FormatFeatureFlagBits::eBlitSrc }, + { "BlitDst", FormatFeatureFlagBits::eBlitDst }, + { "SampledImageFilterLinear", FormatFeatureFlagBits::eSampledImageFilterLinear }, + { "TransferSrc", FormatFeatureFlagBits::eTransferSrc }, + { "TransferDst", FormatFeatureFlagBits::eTransferDst }, + { "MidpointChromaSamples", FormatFeatureFlagBits::eMidpointChromaSamples }, + { "SampledImageYcbcrConversionLinearFilter", FormatFeatureFlagBits::eSampledImageYcbcrConversionLinearFilter }, + { "SampledImageYcbcrConversionSeparateReconstructionFilter", FormatFeatureFlagBits::eSampledImageYcbcrConversionSeparateReconstructionFilter }, + { "SampledImageYcbcrConversionChromaReconstructionExplicit", FormatFeatureFlagBits::eSampledImageYcbcrConversionChromaReconstructionExplicit }, + { "SampledImageYcbcrConversionChromaReconstructionExplicitForceable", + FormatFeatureFlagBits::eSampledImageYcbcrConversionChromaReconstructionExplicitForceable }, + { "Disjoint", FormatFeatureFlagBits::eDisjoint }, + { "CositedChromaSamples", FormatFeatureFlagBits::eCositedChromaSamples }, + { "SampledImageFilterMinmax", FormatFeatureFlagBits::eSampledImageFilterMinmax }, + { "VideoDecodeOutputKHR", FormatFeatureFlagBits::eVideoDecodeOutputKHR }, + { "VideoDecodeDpbKHR", FormatFeatureFlagBits::eVideoDecodeDpbKHR }, + { "AccelerationStructureVertexBufferKHR", FormatFeatureFlagBits::eAccelerationStructureVertexBufferKHR }, + { "SampledImageFilterCubicEXT", FormatFeatureFlagBits::eSampledImageFilterCubicEXT }, + { "FragmentDensityMapEXT", FormatFeatureFlagBits::eFragmentDensityMapEXT }, + { "FragmentShadingRateAttachmentKHR", FormatFeatureFlagBits::eFragmentShadingRateAttachmentKHR }, +#if defined( VK_ENABLE_BETA_EXTENSIONS ) + { "VideoEncodeInputKHR", FormatFeatureFlagBits::eVideoEncodeInputKHR }, + { "VideoEncodeDpbKHR", FormatFeatureFlagBits::eVideoEncodeDpbKHR }, +#endif /*VK_ENABLE_BETA_EXTENSIONS*/ + + }; + + std::unordered_map ImageCreateFlagBitsEntries = { + { "SparseBinding", ImageCreateFlagBits::eSparseBinding }, + { "SparseResidency", ImageCreateFlagBits::eSparseResidency }, + { "SparseAliased", ImageCreateFlagBits::eSparseAliased }, + { "MutableFormat", ImageCreateFlagBits::eMutableFormat }, + { "CubeCompatible", ImageCreateFlagBits::eCubeCompatible }, + { "Alias", ImageCreateFlagBits::eAlias }, + { "SplitInstanceBindRegions", ImageCreateFlagBits::eSplitInstanceBindRegions }, + { "2DArrayCompatible", ImageCreateFlagBits::e2DArrayCompatible }, + { "BlockTexelViewCompatible", ImageCreateFlagBits::eBlockTexelViewCompatible }, + { "ExtendedUsage", ImageCreateFlagBits::eExtendedUsage }, + { "Protected", ImageCreateFlagBits::eProtected }, + { "Disjoint", ImageCreateFlagBits::eDisjoint }, + { "CornerSampledNV", ImageCreateFlagBits::eCornerSampledNV }, + { "SampleLocationsCompatibleDepthEXT", ImageCreateFlagBits::eSampleLocationsCompatibleDepthEXT }, + { "SubsampledEXT", ImageCreateFlagBits::eSubsampledEXT }, + { "DescriptorBufferCaptureReplayEXT", ImageCreateFlagBits::eDescriptorBufferCaptureReplayEXT }, + { "MultisampledRenderToSingleSampledEXT", ImageCreateFlagBits::eMultisampledRenderToSingleSampledEXT }, + { "2DViewCompatibleEXT", ImageCreateFlagBits::e2DViewCompatibleEXT }, + { "FragmentDensityMapOffsetQCOM", ImageCreateFlagBits::eFragmentDensityMapOffsetQCOM }, + + }; + + std::unordered_map ImageTilingEntries = { + { "Optimal", ImageTiling::eOptimal }, + { "Linear", ImageTiling::eLinear }, + { "DrmFormatModifierEXT", ImageTiling::eDrmFormatModifierEXT }, + + }; + + std::unordered_map ImageTypeEntries = { + { "1D", ImageType::e1D }, + { "2D", ImageType::e2D }, + { "3D", ImageType::e3D }, + + }; + + std::unordered_map ImageUsageFlagBitsEntries = { + { "TransferSrc", ImageUsageFlagBits::eTransferSrc }, + { "TransferDst", ImageUsageFlagBits::eTransferDst }, + { "Sampled", ImageUsageFlagBits::eSampled }, + { "Storage", ImageUsageFlagBits::eStorage }, + { "ColorAttachment", ImageUsageFlagBits::eColorAttachment }, + { "DepthStencilAttachment", ImageUsageFlagBits::eDepthStencilAttachment }, + { "TransientAttachment", ImageUsageFlagBits::eTransientAttachment }, + { "InputAttachment", ImageUsageFlagBits::eInputAttachment }, + { "VideoDecodeDstKHR", ImageUsageFlagBits::eVideoDecodeDstKHR }, + { "VideoDecodeSrcKHR", ImageUsageFlagBits::eVideoDecodeSrcKHR }, + { "VideoDecodeDpbKHR", ImageUsageFlagBits::eVideoDecodeDpbKHR }, + { "FragmentDensityMapEXT", ImageUsageFlagBits::eFragmentDensityMapEXT }, + { "FragmentShadingRateAttachmentKHR", ImageUsageFlagBits::eFragmentShadingRateAttachmentKHR }, + { "HostTransferEXT", ImageUsageFlagBits::eHostTransferEXT }, +#if defined( VK_ENABLE_BETA_EXTENSIONS ) + { "VideoEncodeDstKHR", ImageUsageFlagBits::eVideoEncodeDstKHR }, + { "VideoEncodeSrcKHR", ImageUsageFlagBits::eVideoEncodeSrcKHR }, + { "VideoEncodeDpbKHR", ImageUsageFlagBits::eVideoEncodeDpbKHR }, +#endif /*VK_ENABLE_BETA_EXTENSIONS*/ + { "AttachmentFeedbackLoopEXT", ImageUsageFlagBits::eAttachmentFeedbackLoopEXT }, + { "InvocationMaskHUAWEI", ImageUsageFlagBits::eInvocationMaskHUAWEI }, + { "SampleWeightQCOM", ImageUsageFlagBits::eSampleWeightQCOM }, + { "SampleBlockMatchQCOM", ImageUsageFlagBits::eSampleBlockMatchQCOM }, + + }; + + std::unordered_map InstanceCreateFlagBitsEntries = { + { "EnumeratePortabilityKHR", InstanceCreateFlagBits::eEnumeratePortabilityKHR }, + + }; + + std::unordered_map InternalAllocationTypeEntries = { + { "Executable", InternalAllocationType::eExecutable }, + + }; + + std::unordered_map MemoryHeapFlagBitsEntries = { + { "DeviceLocal", MemoryHeapFlagBits::eDeviceLocal }, + { "MultiInstance", MemoryHeapFlagBits::eMultiInstance }, + + }; + + std::unordered_map MemoryPropertyFlagBitsEntries = { + { "DeviceLocal", MemoryPropertyFlagBits::eDeviceLocal }, + { "HostVisible", MemoryPropertyFlagBits::eHostVisible }, + { "HostCoherent", MemoryPropertyFlagBits::eHostCoherent }, + { "HostCached", MemoryPropertyFlagBits::eHostCached }, + { "LazilyAllocated", MemoryPropertyFlagBits::eLazilyAllocated }, + { "Protected", MemoryPropertyFlagBits::eProtected }, + { "DeviceCoherentAMD", MemoryPropertyFlagBits::eDeviceCoherentAMD }, + { "DeviceUncachedAMD", MemoryPropertyFlagBits::eDeviceUncachedAMD }, + { "RdmaCapableNV", MemoryPropertyFlagBits::eRdmaCapableNV }, + + }; + + std::unordered_map PhysicalDeviceTypeEntries = { + { "Other", PhysicalDeviceType::eOther }, + { "IntegratedGpu", PhysicalDeviceType::eIntegratedGpu }, + { "DiscreteGpu", PhysicalDeviceType::eDiscreteGpu }, + { "VirtualGpu", PhysicalDeviceType::eVirtualGpu }, + { "Cpu", PhysicalDeviceType::eCpu }, + + }; + + std::unordered_map QueueFlagBitsEntries = { + { "Graphics", QueueFlagBits::eGraphics }, + { "Compute", QueueFlagBits::eCompute }, + { "Transfer", QueueFlagBits::eTransfer }, + { "SparseBinding", QueueFlagBits::eSparseBinding }, + { "Protected", QueueFlagBits::eProtected }, + { "VideoDecodeKHR", QueueFlagBits::eVideoDecodeKHR }, +#if defined( VK_ENABLE_BETA_EXTENSIONS ) + { "VideoEncodeKHR", QueueFlagBits::eVideoEncodeKHR }, +#endif /*VK_ENABLE_BETA_EXTENSIONS*/ + { "OpticalFlowNV", QueueFlagBits::eOpticalFlowNV }, + + }; + + std::unordered_map SampleCountFlagBitsEntries = { + { "1", SampleCountFlagBits::e1 }, { "2", SampleCountFlagBits::e2 }, { "4", SampleCountFlagBits::e4 }, { "8", SampleCountFlagBits::e8 }, + { "16", SampleCountFlagBits::e16 }, { "32", SampleCountFlagBits::e32 }, { "64", SampleCountFlagBits::e64 }, + + }; + + std::unordered_map SystemAllocationScopeEntries = { + { "Command", SystemAllocationScope::eCommand }, { "Object", SystemAllocationScope::eObject }, { "Cache", SystemAllocationScope::eCache }, + { "Device", SystemAllocationScope::eDevice }, { "Instance", SystemAllocationScope::eInstance }, + + }; + + std::unordered_map DeviceCreateFlagBitsEntries = { + + }; + + std::unordered_map DeviceQueueCreateFlagBitsEntries = { + { "Protected", DeviceQueueCreateFlagBits::eProtected }, + + }; + + std::unordered_map PipelineStageFlagBitsEntries = { + { "TopOfPipe", PipelineStageFlagBits::eTopOfPipe }, + { "DrawIndirect", PipelineStageFlagBits::eDrawIndirect }, + { "VertexInput", PipelineStageFlagBits::eVertexInput }, + { "VertexShader", PipelineStageFlagBits::eVertexShader }, + { "TessellationControlShader", PipelineStageFlagBits::eTessellationControlShader }, + { "TessellationEvaluationShader", PipelineStageFlagBits::eTessellationEvaluationShader }, + { "GeometryShader", PipelineStageFlagBits::eGeometryShader }, + { "FragmentShader", PipelineStageFlagBits::eFragmentShader }, + { "EarlyFragmentTests", PipelineStageFlagBits::eEarlyFragmentTests }, + { "LateFragmentTests", PipelineStageFlagBits::eLateFragmentTests }, + { "ColorAttachmentOutput", PipelineStageFlagBits::eColorAttachmentOutput }, + { "ComputeShader", PipelineStageFlagBits::eComputeShader }, + { "Transfer", PipelineStageFlagBits::eTransfer }, + { "BottomOfPipe", PipelineStageFlagBits::eBottomOfPipe }, + { "Host", PipelineStageFlagBits::eHost }, + { "AllGraphics", PipelineStageFlagBits::eAllGraphics }, + { "AllCommands", PipelineStageFlagBits::eAllCommands }, + { "None", PipelineStageFlagBits::eNone }, + { "TransformFeedbackEXT", PipelineStageFlagBits::eTransformFeedbackEXT }, + { "ConditionalRenderingEXT", PipelineStageFlagBits::eConditionalRenderingEXT }, + { "AccelerationStructureBuildKHR", PipelineStageFlagBits::eAccelerationStructureBuildKHR }, + { "RayTracingShaderKHR", PipelineStageFlagBits::eRayTracingShaderKHR }, + { "FragmentDensityProcessEXT", PipelineStageFlagBits::eFragmentDensityProcessEXT }, + { "FragmentShadingRateAttachmentKHR", PipelineStageFlagBits::eFragmentShadingRateAttachmentKHR }, + { "CommandPreprocessNV", PipelineStageFlagBits::eCommandPreprocessNV }, + { "TaskShaderEXT", PipelineStageFlagBits::eTaskShaderEXT }, + { "MeshShaderEXT", PipelineStageFlagBits::eMeshShaderEXT }, + + }; + + std::unordered_map MemoryMapFlagBitsEntries = { + + }; + + std::unordered_map ImageAspectFlagBitsEntries = { + { "Color", ImageAspectFlagBits::eColor }, + { "Depth", ImageAspectFlagBits::eDepth }, + { "Stencil", ImageAspectFlagBits::eStencil }, + { "Metadata", ImageAspectFlagBits::eMetadata }, + { "Plane0", ImageAspectFlagBits::ePlane0 }, + { "Plane1", ImageAspectFlagBits::ePlane1 }, + { "Plane2", ImageAspectFlagBits::ePlane2 }, + { "None", ImageAspectFlagBits::eNone }, + { "MemoryPlane0EXT", ImageAspectFlagBits::eMemoryPlane0EXT }, + { "MemoryPlane1EXT", ImageAspectFlagBits::eMemoryPlane1EXT }, + { "MemoryPlane2EXT", ImageAspectFlagBits::eMemoryPlane2EXT }, + { "MemoryPlane3EXT", ImageAspectFlagBits::eMemoryPlane3EXT }, + + }; + + std::unordered_map SparseImageFormatFlagBitsEntries = { + { "SingleMiptail", SparseImageFormatFlagBits::eSingleMiptail }, + { "AlignedMipSize", SparseImageFormatFlagBits::eAlignedMipSize }, + { "NonstandardBlockSize", SparseImageFormatFlagBits::eNonstandardBlockSize }, + + }; + + std::unordered_map SparseMemoryBindFlagBitsEntries = { + { "Metadata", SparseMemoryBindFlagBits::eMetadata }, + + }; + + std::unordered_map FenceCreateFlagBitsEntries = { + { "Signaled", FenceCreateFlagBits::eSignaled }, + + }; + + std::unordered_map SemaphoreCreateFlagBitsEntries = { + + }; + + std::unordered_map EventCreateFlagBitsEntries = { + { "DeviceOnly", EventCreateFlagBits::eDeviceOnly }, + + }; + + std::unordered_map QueryPipelineStatisticFlagBitsEntries = { + { "InputAssemblyVertices", QueryPipelineStatisticFlagBits::eInputAssemblyVertices }, + { "InputAssemblyPrimitives", QueryPipelineStatisticFlagBits::eInputAssemblyPrimitives }, + { "VertexShaderInvocations", QueryPipelineStatisticFlagBits::eVertexShaderInvocations }, + { "GeometryShaderInvocations", QueryPipelineStatisticFlagBits::eGeometryShaderInvocations }, + { "GeometryShaderPrimitives", QueryPipelineStatisticFlagBits::eGeometryShaderPrimitives }, + { "ClippingInvocations", QueryPipelineStatisticFlagBits::eClippingInvocations }, + { "ClippingPrimitives", QueryPipelineStatisticFlagBits::eClippingPrimitives }, + { "FragmentShaderInvocations", QueryPipelineStatisticFlagBits::eFragmentShaderInvocations }, + { "TessellationControlShaderPatches", QueryPipelineStatisticFlagBits::eTessellationControlShaderPatches }, + { "TessellationEvaluationShaderInvocations", QueryPipelineStatisticFlagBits::eTessellationEvaluationShaderInvocations }, + { "ComputeShaderInvocations", QueryPipelineStatisticFlagBits::eComputeShaderInvocations }, + { "TaskShaderInvocationsEXT", QueryPipelineStatisticFlagBits::eTaskShaderInvocationsEXT }, + { "MeshShaderInvocationsEXT", QueryPipelineStatisticFlagBits::eMeshShaderInvocationsEXT }, + { "ClusterCullingShaderInvocationsHUAWEI", QueryPipelineStatisticFlagBits::eClusterCullingShaderInvocationsHUAWEI }, + + }; + + std::unordered_map QueryResultFlagBitsEntries = { + { "64", QueryResultFlagBits::e64 }, + { "Wait", QueryResultFlagBits::eWait }, + { "WithAvailability", QueryResultFlagBits::eWithAvailability }, + { "Partial", QueryResultFlagBits::ePartial }, + { "WithStatusKHR", QueryResultFlagBits::eWithStatusKHR }, + + }; + + std::unordered_map QueryTypeEntries = { + { "Occlusion", QueryType::eOcclusion }, + { "PipelineStatistics", QueryType::ePipelineStatistics }, + { "Timestamp", QueryType::eTimestamp }, + { "ResultStatusOnlyKHR", QueryType::eResultStatusOnlyKHR }, + { "TransformFeedbackStreamEXT", QueryType::eTransformFeedbackStreamEXT }, + { "PerformanceQueryKHR", QueryType::ePerformanceQueryKHR }, + { "AccelerationStructureCompactedSizeKHR", QueryType::eAccelerationStructureCompactedSizeKHR }, + { "AccelerationStructureSerializationSizeKHR", QueryType::eAccelerationStructureSerializationSizeKHR }, + { "AccelerationStructureCompactedSizeNV", QueryType::eAccelerationStructureCompactedSizeNV }, + { "PerformanceQueryINTEL", QueryType::ePerformanceQueryINTEL }, +#if defined( VK_ENABLE_BETA_EXTENSIONS ) + { "VideoEncodeFeedbackKHR", QueryType::eVideoEncodeFeedbackKHR }, +#endif /*VK_ENABLE_BETA_EXTENSIONS*/ + { "MeshPrimitivesGeneratedEXT", QueryType::eMeshPrimitivesGeneratedEXT }, + { "PrimitivesGeneratedEXT", QueryType::ePrimitivesGeneratedEXT }, + { "AccelerationStructureSerializationBottomLevelPointersKHR", QueryType::eAccelerationStructureSerializationBottomLevelPointersKHR }, + { "AccelerationStructureSizeKHR", QueryType::eAccelerationStructureSizeKHR }, + { "MicromapSerializationSizeEXT", QueryType::eMicromapSerializationSizeEXT }, + { "MicromapCompactedSizeEXT", QueryType::eMicromapCompactedSizeEXT }, + + }; + + std::unordered_map QueryPoolCreateFlagBitsEntries = { + + }; + + std::unordered_map BufferCreateFlagBitsEntries = { + { "SparseBinding", BufferCreateFlagBits::eSparseBinding }, + { "SparseResidency", BufferCreateFlagBits::eSparseResidency }, + { "SparseAliased", BufferCreateFlagBits::eSparseAliased }, + { "Protected", BufferCreateFlagBits::eProtected }, + { "DeviceAddressCaptureReplay", BufferCreateFlagBits::eDeviceAddressCaptureReplay }, + { "DescriptorBufferCaptureReplayEXT", BufferCreateFlagBits::eDescriptorBufferCaptureReplayEXT }, + + }; + + std::unordered_map BufferUsageFlagBitsEntries = { + { "TransferSrc", BufferUsageFlagBits::eTransferSrc }, + { "TransferDst", BufferUsageFlagBits::eTransferDst }, + { "UniformTexelBuffer", BufferUsageFlagBits::eUniformTexelBuffer }, + { "StorageTexelBuffer", BufferUsageFlagBits::eStorageTexelBuffer }, + { "UniformBuffer", BufferUsageFlagBits::eUniformBuffer }, + { "StorageBuffer", BufferUsageFlagBits::eStorageBuffer }, + { "IndexBuffer", BufferUsageFlagBits::eIndexBuffer }, + { "VertexBuffer", BufferUsageFlagBits::eVertexBuffer }, + { "IndirectBuffer", BufferUsageFlagBits::eIndirectBuffer }, + { "ShaderDeviceAddress", BufferUsageFlagBits::eShaderDeviceAddress }, + { "VideoDecodeSrcKHR", BufferUsageFlagBits::eVideoDecodeSrcKHR }, + { "VideoDecodeDstKHR", BufferUsageFlagBits::eVideoDecodeDstKHR }, + { "TransformFeedbackBufferEXT", BufferUsageFlagBits::eTransformFeedbackBufferEXT }, + { "TransformFeedbackCounterBufferEXT", BufferUsageFlagBits::eTransformFeedbackCounterBufferEXT }, + { "ConditionalRenderingEXT", BufferUsageFlagBits::eConditionalRenderingEXT }, +#if defined( VK_ENABLE_BETA_EXTENSIONS ) + { "ExecutionGraphScratchAMDX", BufferUsageFlagBits::eExecutionGraphScratchAMDX }, +#endif /*VK_ENABLE_BETA_EXTENSIONS*/ + { "AccelerationStructureBuildInputReadOnlyKHR", BufferUsageFlagBits::eAccelerationStructureBuildInputReadOnlyKHR }, + { "AccelerationStructureStorageKHR", BufferUsageFlagBits::eAccelerationStructureStorageKHR }, + { "ShaderBindingTableKHR", BufferUsageFlagBits::eShaderBindingTableKHR }, +#if defined( VK_ENABLE_BETA_EXTENSIONS ) + { "VideoEncodeDstKHR", BufferUsageFlagBits::eVideoEncodeDstKHR }, + { "VideoEncodeSrcKHR", BufferUsageFlagBits::eVideoEncodeSrcKHR }, +#endif /*VK_ENABLE_BETA_EXTENSIONS*/ + { "SamplerDescriptorBufferEXT", BufferUsageFlagBits::eSamplerDescriptorBufferEXT }, + { "ResourceDescriptorBufferEXT", BufferUsageFlagBits::eResourceDescriptorBufferEXT }, + { "PushDescriptorsDescriptorBufferEXT", BufferUsageFlagBits::ePushDescriptorsDescriptorBufferEXT }, + { "MicromapBuildInputReadOnlyEXT", BufferUsageFlagBits::eMicromapBuildInputReadOnlyEXT }, + { "MicromapStorageEXT", BufferUsageFlagBits::eMicromapStorageEXT }, + + }; + + std::unordered_map SharingModeEntries = { + { "Exclusive", SharingMode::eExclusive }, + { "Concurrent", SharingMode::eConcurrent }, + + }; + + std::unordered_map BufferViewCreateFlagBitsEntries = { + + }; + + std::unordered_map ImageLayoutEntries = { + { "Undefined", ImageLayout::eUndefined }, + { "General", ImageLayout::eGeneral }, + { "ColorAttachmentOptimal", ImageLayout::eColorAttachmentOptimal }, + { "DepthStencilAttachmentOptimal", ImageLayout::eDepthStencilAttachmentOptimal }, + { "DepthStencilReadOnlyOptimal", ImageLayout::eDepthStencilReadOnlyOptimal }, + { "ShaderReadOnlyOptimal", ImageLayout::eShaderReadOnlyOptimal }, + { "TransferSrcOptimal", ImageLayout::eTransferSrcOptimal }, + { "TransferDstOptimal", ImageLayout::eTransferDstOptimal }, + { "Preinitialized", ImageLayout::ePreinitialized }, + { "DepthReadOnlyStencilAttachmentOptimal", ImageLayout::eDepthReadOnlyStencilAttachmentOptimal }, + { "DepthAttachmentStencilReadOnlyOptimal", ImageLayout::eDepthAttachmentStencilReadOnlyOptimal }, + { "DepthAttachmentOptimal", ImageLayout::eDepthAttachmentOptimal }, + { "DepthReadOnlyOptimal", ImageLayout::eDepthReadOnlyOptimal }, + { "StencilAttachmentOptimal", ImageLayout::eStencilAttachmentOptimal }, + { "StencilReadOnlyOptimal", ImageLayout::eStencilReadOnlyOptimal }, + { "ReadOnlyOptimal", ImageLayout::eReadOnlyOptimal }, + { "AttachmentOptimal", ImageLayout::eAttachmentOptimal }, + { "PresentSrcKHR", ImageLayout::ePresentSrcKHR }, + { "VideoDecodeDstKHR", ImageLayout::eVideoDecodeDstKHR }, + { "VideoDecodeSrcKHR", ImageLayout::eVideoDecodeSrcKHR }, + { "VideoDecodeDpbKHR", ImageLayout::eVideoDecodeDpbKHR }, + { "SharedPresentKHR", ImageLayout::eSharedPresentKHR }, + { "FragmentDensityMapOptimalEXT", ImageLayout::eFragmentDensityMapOptimalEXT }, + { "FragmentShadingRateAttachmentOptimalKHR", ImageLayout::eFragmentShadingRateAttachmentOptimalKHR }, +#if defined( VK_ENABLE_BETA_EXTENSIONS ) + { "VideoEncodeDstKHR", ImageLayout::eVideoEncodeDstKHR }, + { "VideoEncodeSrcKHR", ImageLayout::eVideoEncodeSrcKHR }, + { "VideoEncodeDpbKHR", ImageLayout::eVideoEncodeDpbKHR }, +#endif /*VK_ENABLE_BETA_EXTENSIONS*/ + { "AttachmentFeedbackLoopOptimalEXT", ImageLayout::eAttachmentFeedbackLoopOptimalEXT }, + + }; + + std::unordered_map ComponentSwizzleEntries = { + { "Identity", ComponentSwizzle::eIdentity }, + { "Zero", ComponentSwizzle::eZero }, + { "One", ComponentSwizzle::eOne }, + { "R", ComponentSwizzle::eR }, + { "G", ComponentSwizzle::eG }, + { "B", ComponentSwizzle::eB }, + { "A", ComponentSwizzle::eA }, + + }; + + std::unordered_map ImageViewCreateFlagBitsEntries = { + { "FragmentDensityMapDynamicEXT", ImageViewCreateFlagBits::eFragmentDensityMapDynamicEXT }, + { "DescriptorBufferCaptureReplayEXT", ImageViewCreateFlagBits::eDescriptorBufferCaptureReplayEXT }, + { "FragmentDensityMapDeferredEXT", ImageViewCreateFlagBits::eFragmentDensityMapDeferredEXT }, + + }; + + std::unordered_map ImageViewTypeEntries = { + { "1D", ImageViewType::e1D }, + { "2D", ImageViewType::e2D }, + { "3D", ImageViewType::e3D }, + { "Cube", ImageViewType::eCube }, + { "1DArray", ImageViewType::e1DArray }, + { "2DArray", ImageViewType::e2DArray }, + { "CubeArray", ImageViewType::eCubeArray }, + + }; + + std::unordered_map ShaderModuleCreateFlagBitsEntries = { + + }; + + std::unordered_map PipelineCacheCreateFlagBitsEntries = { + { "ExternallySynchronized", PipelineCacheCreateFlagBits::eExternallySynchronized }, + + }; + + std::unordered_map BlendFactorEntries = { + { "Zero", BlendFactor::eZero }, + { "One", BlendFactor::eOne }, + { "SrcColor", BlendFactor::eSrcColor }, + { "OneMinusSrcColor", BlendFactor::eOneMinusSrcColor }, + { "DstColor", BlendFactor::eDstColor }, + { "OneMinusDstColor", BlendFactor::eOneMinusDstColor }, + { "SrcAlpha", BlendFactor::eSrcAlpha }, + { "OneMinusSrcAlpha", BlendFactor::eOneMinusSrcAlpha }, + { "DstAlpha", BlendFactor::eDstAlpha }, + { "OneMinusDstAlpha", BlendFactor::eOneMinusDstAlpha }, + { "ConstantColor", BlendFactor::eConstantColor }, + { "OneMinusConstantColor", BlendFactor::eOneMinusConstantColor }, + { "ConstantAlpha", BlendFactor::eConstantAlpha }, + { "OneMinusConstantAlpha", BlendFactor::eOneMinusConstantAlpha }, + { "SrcAlphaSaturate", BlendFactor::eSrcAlphaSaturate }, + { "Src1Color", BlendFactor::eSrc1Color }, + { "OneMinusSrc1Color", BlendFactor::eOneMinusSrc1Color }, + { "Src1Alpha", BlendFactor::eSrc1Alpha }, + { "OneMinusSrc1Alpha", BlendFactor::eOneMinusSrc1Alpha }, + + }; + + std::unordered_map BlendOpEntries = { + { "Add", BlendOp::eAdd }, + { "Subtract", BlendOp::eSubtract }, + { "ReverseSubtract", BlendOp::eReverseSubtract }, + { "Min", BlendOp::eMin }, + { "Max", BlendOp::eMax }, + { "ZeroEXT", BlendOp::eZeroEXT }, + { "SrcEXT", BlendOp::eSrcEXT }, + { "DstEXT", BlendOp::eDstEXT }, + { "SrcOverEXT", BlendOp::eSrcOverEXT }, + { "DstOverEXT", BlendOp::eDstOverEXT }, + { "SrcInEXT", BlendOp::eSrcInEXT }, + { "DstInEXT", BlendOp::eDstInEXT }, + { "SrcOutEXT", BlendOp::eSrcOutEXT }, + { "DstOutEXT", BlendOp::eDstOutEXT }, + { "SrcAtopEXT", BlendOp::eSrcAtopEXT }, + { "DstAtopEXT", BlendOp::eDstAtopEXT }, + { "XorEXT", BlendOp::eXorEXT }, + { "MultiplyEXT", BlendOp::eMultiplyEXT }, + { "ScreenEXT", BlendOp::eScreenEXT }, + { "OverlayEXT", BlendOp::eOverlayEXT }, + { "DarkenEXT", BlendOp::eDarkenEXT }, + { "LightenEXT", BlendOp::eLightenEXT }, + { "ColordodgeEXT", BlendOp::eColordodgeEXT }, + { "ColorburnEXT", BlendOp::eColorburnEXT }, + { "HardlightEXT", BlendOp::eHardlightEXT }, + { "SoftlightEXT", BlendOp::eSoftlightEXT }, + { "DifferenceEXT", BlendOp::eDifferenceEXT }, + { "ExclusionEXT", BlendOp::eExclusionEXT }, + { "InvertEXT", BlendOp::eInvertEXT }, + { "InvertRgbEXT", BlendOp::eInvertRgbEXT }, + { "LineardodgeEXT", BlendOp::eLineardodgeEXT }, + { "LinearburnEXT", BlendOp::eLinearburnEXT }, + { "VividlightEXT", BlendOp::eVividlightEXT }, + { "LinearlightEXT", BlendOp::eLinearlightEXT }, + { "PinlightEXT", BlendOp::ePinlightEXT }, + { "HardmixEXT", BlendOp::eHardmixEXT }, + { "HslHueEXT", BlendOp::eHslHueEXT }, + { "HslSaturationEXT", BlendOp::eHslSaturationEXT }, + { "HslColorEXT", BlendOp::eHslColorEXT }, + { "HslLuminosityEXT", BlendOp::eHslLuminosityEXT }, + { "PlusEXT", BlendOp::ePlusEXT }, + { "PlusClampedEXT", BlendOp::ePlusClampedEXT }, + { "PlusClampedAlphaEXT", BlendOp::ePlusClampedAlphaEXT }, + { "PlusDarkerEXT", BlendOp::ePlusDarkerEXT }, + { "MinusEXT", BlendOp::eMinusEXT }, + { "MinusClampedEXT", BlendOp::eMinusClampedEXT }, + { "ContrastEXT", BlendOp::eContrastEXT }, + { "InvertOvgEXT", BlendOp::eInvertOvgEXT }, + { "RedEXT", BlendOp::eRedEXT }, + { "GreenEXT", BlendOp::eGreenEXT }, + { "BlueEXT", BlendOp::eBlueEXT }, + + }; + + std::unordered_map ColorComponentFlagBitsEntries = { + { "R", ColorComponentFlagBits::eR }, + { "G", ColorComponentFlagBits::eG }, + { "B", ColorComponentFlagBits::eB }, + { "A", ColorComponentFlagBits::eA }, + + }; + + std::unordered_map CompareOpEntries = { + { "Never", CompareOp::eNever }, + { "Less", CompareOp::eLess }, + { "Equal", CompareOp::eEqual }, + { "LessOrEqual", CompareOp::eLessOrEqual }, + { "Greater", CompareOp::eGreater }, + { "NotEqual", CompareOp::eNotEqual }, + { "GreaterOrEqual", CompareOp::eGreaterOrEqual }, + { "Always", CompareOp::eAlways }, + + }; + + std::unordered_map CullModeFlagBitsEntries = { + { "None", CullModeFlagBits::eNone }, + { "Front", CullModeFlagBits::eFront }, + { "Back", CullModeFlagBits::eBack }, + { "FrontAndBack", CullModeFlagBits::eFrontAndBack }, + + }; + + std::unordered_map DynamicStateEntries = { + { "Viewport", DynamicState::eViewport }, + { "Scissor", DynamicState::eScissor }, + { "LineWidth", DynamicState::eLineWidth }, + { "DepthBias", DynamicState::eDepthBias }, + { "BlendConstants", DynamicState::eBlendConstants }, + { "DepthBounds", DynamicState::eDepthBounds }, + { "StencilCompareMask", DynamicState::eStencilCompareMask }, + { "StencilWriteMask", DynamicState::eStencilWriteMask }, + { "StencilReference", DynamicState::eStencilReference }, + { "CullMode", DynamicState::eCullMode }, + { "FrontFace", DynamicState::eFrontFace }, + { "PrimitiveTopology", DynamicState::ePrimitiveTopology }, + { "ViewportWithCount", DynamicState::eViewportWithCount }, + { "ScissorWithCount", DynamicState::eScissorWithCount }, + { "VertexInputBindingStride", DynamicState::eVertexInputBindingStride }, + { "DepthTestEnable", DynamicState::eDepthTestEnable }, + { "DepthWriteEnable", DynamicState::eDepthWriteEnable }, + { "DepthCompareOp", DynamicState::eDepthCompareOp }, + { "DepthBoundsTestEnable", DynamicState::eDepthBoundsTestEnable }, + { "StencilTestEnable", DynamicState::eStencilTestEnable }, + { "StencilOp", DynamicState::eStencilOp }, + { "RasterizerDiscardEnable", DynamicState::eRasterizerDiscardEnable }, + { "DepthBiasEnable", DynamicState::eDepthBiasEnable }, + { "PrimitiveRestartEnable", DynamicState::ePrimitiveRestartEnable }, + { "ViewportWScalingNV", DynamicState::eViewportWScalingNV }, + { "DiscardRectangleEXT", DynamicState::eDiscardRectangleEXT }, + { "DiscardRectangleEnableEXT", DynamicState::eDiscardRectangleEnableEXT }, + { "DiscardRectangleModeEXT", DynamicState::eDiscardRectangleModeEXT }, + { "SampleLocationsEXT", DynamicState::eSampleLocationsEXT }, + { "RayTracingPipelineStackSizeKHR", DynamicState::eRayTracingPipelineStackSizeKHR }, + { "ViewportShadingRatePaletteNV", DynamicState::eViewportShadingRatePaletteNV }, + { "ViewportCoarseSampleOrderNV", DynamicState::eViewportCoarseSampleOrderNV }, + { "ExclusiveScissorEnableNV", DynamicState::eExclusiveScissorEnableNV }, + { "ExclusiveScissorNV", DynamicState::eExclusiveScissorNV }, + { "FragmentShadingRateKHR", DynamicState::eFragmentShadingRateKHR }, + { "LineStippleEXT", DynamicState::eLineStippleEXT }, + { "VertexInputEXT", DynamicState::eVertexInputEXT }, + { "PatchControlPointsEXT", DynamicState::ePatchControlPointsEXT }, + { "LogicOpEXT", DynamicState::eLogicOpEXT }, + { "ColorWriteEnableEXT", DynamicState::eColorWriteEnableEXT }, + { "TessellationDomainOriginEXT", DynamicState::eTessellationDomainOriginEXT }, + { "DepthClampEnableEXT", DynamicState::eDepthClampEnableEXT }, + { "PolygonModeEXT", DynamicState::ePolygonModeEXT }, + { "RasterizationSamplesEXT", DynamicState::eRasterizationSamplesEXT }, + { "SampleMaskEXT", DynamicState::eSampleMaskEXT }, + { "AlphaToCoverageEnableEXT", DynamicState::eAlphaToCoverageEnableEXT }, + { "AlphaToOneEnableEXT", DynamicState::eAlphaToOneEnableEXT }, + { "LogicOpEnableEXT", DynamicState::eLogicOpEnableEXT }, + { "ColorBlendEnableEXT", DynamicState::eColorBlendEnableEXT }, + { "ColorBlendEquationEXT", DynamicState::eColorBlendEquationEXT }, + { "ColorWriteMaskEXT", DynamicState::eColorWriteMaskEXT }, + { "RasterizationStreamEXT", DynamicState::eRasterizationStreamEXT }, + { "ConservativeRasterizationModeEXT", DynamicState::eConservativeRasterizationModeEXT }, + { "ExtraPrimitiveOverestimationSizeEXT", DynamicState::eExtraPrimitiveOverestimationSizeEXT }, + { "DepthClipEnableEXT", DynamicState::eDepthClipEnableEXT }, + { "SampleLocationsEnableEXT", DynamicState::eSampleLocationsEnableEXT }, + { "ColorBlendAdvancedEXT", DynamicState::eColorBlendAdvancedEXT }, + { "ProvokingVertexModeEXT", DynamicState::eProvokingVertexModeEXT }, + { "LineRasterizationModeEXT", DynamicState::eLineRasterizationModeEXT }, + { "LineStippleEnableEXT", DynamicState::eLineStippleEnableEXT }, + { "DepthClipNegativeOneToOneEXT", DynamicState::eDepthClipNegativeOneToOneEXT }, + { "ViewportWScalingEnableNV", DynamicState::eViewportWScalingEnableNV }, + { "ViewportSwizzleNV", DynamicState::eViewportSwizzleNV }, + { "CoverageToColorEnableNV", DynamicState::eCoverageToColorEnableNV }, + { "CoverageToColorLocationNV", DynamicState::eCoverageToColorLocationNV }, + { "CoverageModulationModeNV", DynamicState::eCoverageModulationModeNV }, + { "CoverageModulationTableEnableNV", DynamicState::eCoverageModulationTableEnableNV }, + { "CoverageModulationTableNV", DynamicState::eCoverageModulationTableNV }, + { "ShadingRateImageEnableNV", DynamicState::eShadingRateImageEnableNV }, + { "RepresentativeFragmentTestEnableNV", DynamicState::eRepresentativeFragmentTestEnableNV }, + { "CoverageReductionModeNV", DynamicState::eCoverageReductionModeNV }, + { "AttachmentFeedbackLoopEnableEXT", DynamicState::eAttachmentFeedbackLoopEnableEXT }, + + }; + + std::unordered_map FrontFaceEntries = { + { "CounterClockwise", FrontFace::eCounterClockwise }, + { "Clockwise", FrontFace::eClockwise }, + + }; + + std::unordered_map LogicOpEntries = { + { "Clear", LogicOp::eClear }, + { "And", LogicOp::eAnd }, + { "AndReverse", LogicOp::eAndReverse }, + { "Copy", LogicOp::eCopy }, + { "AndInverted", LogicOp::eAndInverted }, + { "NoOp", LogicOp::eNoOp }, + { "Xor", LogicOp::eXor }, + { "Or", LogicOp::eOr }, + { "Nor", LogicOp::eNor }, + { "Equivalent", LogicOp::eEquivalent }, + { "Invert", LogicOp::eInvert }, + { "OrReverse", LogicOp::eOrReverse }, + { "CopyInverted", LogicOp::eCopyInverted }, + { "OrInverted", LogicOp::eOrInverted }, + { "Nand", LogicOp::eNand }, + { "Set", LogicOp::eSet }, + + }; + + std::unordered_map PipelineCreateFlagBitsEntries = { + { "DisableOptimization", PipelineCreateFlagBits::eDisableOptimization }, + { "AllowDerivatives", PipelineCreateFlagBits::eAllowDerivatives }, + { "Derivative", PipelineCreateFlagBits::eDerivative }, + { "ViewIndexFromDeviceIndex", PipelineCreateFlagBits::eViewIndexFromDeviceIndex }, + { "DispatchBase", PipelineCreateFlagBits::eDispatchBase }, + { "FailOnPipelineCompileRequired", PipelineCreateFlagBits::eFailOnPipelineCompileRequired }, + { "EarlyReturnOnFailure", PipelineCreateFlagBits::eEarlyReturnOnFailure }, + { "RenderingFragmentShadingRateAttachmentKHR", PipelineCreateFlagBits::eRenderingFragmentShadingRateAttachmentKHR }, + { "RenderingFragmentDensityMapAttachmentEXT", PipelineCreateFlagBits::eRenderingFragmentDensityMapAttachmentEXT }, + { "RayTracingNoNullAnyHitShadersKHR", PipelineCreateFlagBits::eRayTracingNoNullAnyHitShadersKHR }, + { "RayTracingNoNullClosestHitShadersKHR", PipelineCreateFlagBits::eRayTracingNoNullClosestHitShadersKHR }, + { "RayTracingNoNullMissShadersKHR", PipelineCreateFlagBits::eRayTracingNoNullMissShadersKHR }, + { "RayTracingNoNullIntersectionShadersKHR", PipelineCreateFlagBits::eRayTracingNoNullIntersectionShadersKHR }, + { "RayTracingSkipTrianglesKHR", PipelineCreateFlagBits::eRayTracingSkipTrianglesKHR }, + { "RayTracingSkipAabbsKHR", PipelineCreateFlagBits::eRayTracingSkipAabbsKHR }, + { "RayTracingShaderGroupHandleCaptureReplayKHR", PipelineCreateFlagBits::eRayTracingShaderGroupHandleCaptureReplayKHR }, + { "DeferCompileNV", PipelineCreateFlagBits::eDeferCompileNV }, + { "CaptureStatisticsKHR", PipelineCreateFlagBits::eCaptureStatisticsKHR }, + { "CaptureInternalRepresentationsKHR", PipelineCreateFlagBits::eCaptureInternalRepresentationsKHR }, + { "IndirectBindableNV", PipelineCreateFlagBits::eIndirectBindableNV }, + { "LibraryKHR", PipelineCreateFlagBits::eLibraryKHR }, + { "DescriptorBufferEXT", PipelineCreateFlagBits::eDescriptorBufferEXT }, + { "RetainLinkTimeOptimizationInfoEXT", PipelineCreateFlagBits::eRetainLinkTimeOptimizationInfoEXT }, + { "LinkTimeOptimizationEXT", PipelineCreateFlagBits::eLinkTimeOptimizationEXT }, + { "RayTracingAllowMotionNV", PipelineCreateFlagBits::eRayTracingAllowMotionNV }, + { "ColorAttachmentFeedbackLoopEXT", PipelineCreateFlagBits::eColorAttachmentFeedbackLoopEXT }, + { "DepthStencilAttachmentFeedbackLoopEXT", PipelineCreateFlagBits::eDepthStencilAttachmentFeedbackLoopEXT }, + { "RayTracingOpacityMicromapEXT", PipelineCreateFlagBits::eRayTracingOpacityMicromapEXT }, +#if defined( VK_ENABLE_BETA_EXTENSIONS ) + { "RayTracingDisplacementMicromapNV", PipelineCreateFlagBits::eRayTracingDisplacementMicromapNV }, +#endif /*VK_ENABLE_BETA_EXTENSIONS*/ + { "NoProtectedAccessEXT", PipelineCreateFlagBits::eNoProtectedAccessEXT }, + { "ProtectedAccessOnlyEXT", PipelineCreateFlagBits::eProtectedAccessOnlyEXT }, + + }; + + std::unordered_map PipelineShaderStageCreateFlagBitsEntries = { + { "AllowVaryingSubgroupSize", PipelineShaderStageCreateFlagBits::eAllowVaryingSubgroupSize }, + { "RequireFullSubgroups", PipelineShaderStageCreateFlagBits::eRequireFullSubgroups }, + + }; + + std::unordered_map PolygonModeEntries = { + { "Fill", PolygonMode::eFill }, + { "Line", PolygonMode::eLine }, + { "Point", PolygonMode::ePoint }, + { "FillRectangleNV", PolygonMode::eFillRectangleNV }, + + }; + + std::unordered_map PrimitiveTopologyEntries = { + { "PointList", PrimitiveTopology::ePointList }, + { "LineList", PrimitiveTopology::eLineList }, + { "LineStrip", PrimitiveTopology::eLineStrip }, + { "TriangleList", PrimitiveTopology::eTriangleList }, + { "TriangleStrip", PrimitiveTopology::eTriangleStrip }, + { "TriangleFan", PrimitiveTopology::eTriangleFan }, + { "LineListWithAdjacency", PrimitiveTopology::eLineListWithAdjacency }, + { "LineStripWithAdjacency", PrimitiveTopology::eLineStripWithAdjacency }, + { "TriangleListWithAdjacency", PrimitiveTopology::eTriangleListWithAdjacency }, + { "TriangleStripWithAdjacency", PrimitiveTopology::eTriangleStripWithAdjacency }, + { "PatchList", PrimitiveTopology::ePatchList }, + + }; + + std::unordered_map ShaderStageFlagBitsEntries = { + { "Vertex", ShaderStageFlagBits::eVertex }, + { "TessellationControl", ShaderStageFlagBits::eTessellationControl }, + { "TessellationEvaluation", ShaderStageFlagBits::eTessellationEvaluation }, + { "Geometry", ShaderStageFlagBits::eGeometry }, + { "Fragment", ShaderStageFlagBits::eFragment }, + { "Compute", ShaderStageFlagBits::eCompute }, + { "AllGraphics", ShaderStageFlagBits::eAllGraphics }, + { "All", ShaderStageFlagBits::eAll }, + { "RaygenKHR", ShaderStageFlagBits::eRaygenKHR }, + { "AnyHitKHR", ShaderStageFlagBits::eAnyHitKHR }, + { "ClosestHitKHR", ShaderStageFlagBits::eClosestHitKHR }, + { "MissKHR", ShaderStageFlagBits::eMissKHR }, + { "IntersectionKHR", ShaderStageFlagBits::eIntersectionKHR }, + { "CallableKHR", ShaderStageFlagBits::eCallableKHR }, + { "TaskEXT", ShaderStageFlagBits::eTaskEXT }, + { "MeshEXT", ShaderStageFlagBits::eMeshEXT }, + { "SubpassShadingHUAWEI", ShaderStageFlagBits::eSubpassShadingHUAWEI }, + { "ClusterCullingHUAWEI", ShaderStageFlagBits::eClusterCullingHUAWEI }, + + }; + + std::unordered_map StencilOpEntries = { + { "Keep", StencilOp::eKeep }, + { "Zero", StencilOp::eZero }, + { "Replace", StencilOp::eReplace }, + { "IncrementAndClamp", StencilOp::eIncrementAndClamp }, + { "DecrementAndClamp", StencilOp::eDecrementAndClamp }, + { "Invert", StencilOp::eInvert }, + { "IncrementAndWrap", StencilOp::eIncrementAndWrap }, + { "DecrementAndWrap", StencilOp::eDecrementAndWrap }, + + }; + + std::unordered_map VertexInputRateEntries = { + { "Vertex", VertexInputRate::eVertex }, + { "Instance", VertexInputRate::eInstance }, + + }; + + std::unordered_map PipelineColorBlendStateCreateFlagBitsEntries = { + { "RasterizationOrderAttachmentAccessEXT", PipelineColorBlendStateCreateFlagBits::eRasterizationOrderAttachmentAccessEXT }, + + }; + + std::unordered_map PipelineDepthStencilStateCreateFlagBitsEntries = { + { "RasterizationOrderAttachmentDepthAccessEXT", PipelineDepthStencilStateCreateFlagBits::eRasterizationOrderAttachmentDepthAccessEXT }, + { "RasterizationOrderAttachmentStencilAccessEXT", PipelineDepthStencilStateCreateFlagBits::eRasterizationOrderAttachmentStencilAccessEXT }, + + }; + + std::unordered_map PipelineDynamicStateCreateFlagBitsEntries = { + + }; + + std::unordered_map PipelineInputAssemblyStateCreateFlagBitsEntries = { + + }; + + std::unordered_map PipelineLayoutCreateFlagBitsEntries = { + { "IndependentSetsEXT", PipelineLayoutCreateFlagBits::eIndependentSetsEXT }, + + }; + + std::unordered_map PipelineMultisampleStateCreateFlagBitsEntries = { + + }; + + std::unordered_map PipelineRasterizationStateCreateFlagBitsEntries = { + + }; + + std::unordered_map PipelineTessellationStateCreateFlagBitsEntries = { + + }; + + std::unordered_map PipelineVertexInputStateCreateFlagBitsEntries = { + + }; + + std::unordered_map PipelineViewportStateCreateFlagBitsEntries = { + + }; + + std::unordered_map BorderColorEntries = { + { "FloatTransparentBlack", BorderColor::eFloatTransparentBlack }, + { "IntTransparentBlack", BorderColor::eIntTransparentBlack }, + { "FloatOpaqueBlack", BorderColor::eFloatOpaqueBlack }, + { "IntOpaqueBlack", BorderColor::eIntOpaqueBlack }, + { "FloatOpaqueWhite", BorderColor::eFloatOpaqueWhite }, + { "IntOpaqueWhite", BorderColor::eIntOpaqueWhite }, + { "FloatCustomEXT", BorderColor::eFloatCustomEXT }, + { "IntCustomEXT", BorderColor::eIntCustomEXT }, + + }; + + std::unordered_map FilterEntries = { + { "Nearest", Filter::eNearest }, + { "Linear", Filter::eLinear }, + { "CubicEXT", Filter::eCubicEXT }, + + }; + + std::unordered_map SamplerAddressModeEntries = { + { "Repeat", SamplerAddressMode::eRepeat }, + { "MirroredRepeat", SamplerAddressMode::eMirroredRepeat }, + { "ClampToEdge", SamplerAddressMode::eClampToEdge }, + { "ClampToBorder", SamplerAddressMode::eClampToBorder }, + { "MirrorClampToEdge", SamplerAddressMode::eMirrorClampToEdge }, + + }; + + std::unordered_map SamplerCreateFlagBitsEntries = { + { "SubsampledEXT", SamplerCreateFlagBits::eSubsampledEXT }, + { "SubsampledCoarseReconstructionEXT", SamplerCreateFlagBits::eSubsampledCoarseReconstructionEXT }, + { "DescriptorBufferCaptureReplayEXT", SamplerCreateFlagBits::eDescriptorBufferCaptureReplayEXT }, + { "NonSeamlessCubeMapEXT", SamplerCreateFlagBits::eNonSeamlessCubeMapEXT }, + { "ImageProcessingQCOM", SamplerCreateFlagBits::eImageProcessingQCOM }, + + }; + + std::unordered_map SamplerMipmapModeEntries = { + { "Nearest", SamplerMipmapMode::eNearest }, + { "Linear", SamplerMipmapMode::eLinear }, + + }; + + std::unordered_map DescriptorPoolCreateFlagBitsEntries = { + { "FreeDescriptorSet", DescriptorPoolCreateFlagBits::eFreeDescriptorSet }, + { "UpdateAfterBind", DescriptorPoolCreateFlagBits::eUpdateAfterBind }, + { "HostOnlyEXT", DescriptorPoolCreateFlagBits::eHostOnlyEXT }, + { "AllowOverallocationSetsNV", DescriptorPoolCreateFlagBits::eAllowOverallocationSetsNV }, + { "AllowOverallocationPoolsNV", DescriptorPoolCreateFlagBits::eAllowOverallocationPoolsNV }, + + }; + + std::unordered_map DescriptorSetLayoutCreateFlagBitsEntries = { + { "UpdateAfterBindPool", DescriptorSetLayoutCreateFlagBits::eUpdateAfterBindPool }, + { "PushDescriptorKHR", DescriptorSetLayoutCreateFlagBits::ePushDescriptorKHR }, + { "DescriptorBufferEXT", DescriptorSetLayoutCreateFlagBits::eDescriptorBufferEXT }, + { "EmbeddedImmutableSamplersEXT", DescriptorSetLayoutCreateFlagBits::eEmbeddedImmutableSamplersEXT }, + { "IndirectBindableNV", DescriptorSetLayoutCreateFlagBits::eIndirectBindableNV }, + { "HostOnlyPoolEXT", DescriptorSetLayoutCreateFlagBits::eHostOnlyPoolEXT }, + + }; + + std::unordered_map DescriptorTypeEntries = { + { "Sampler", DescriptorType::eSampler }, + { "CombinedImageSampler", DescriptorType::eCombinedImageSampler }, + { "SampledImage", DescriptorType::eSampledImage }, + { "StorageImage", DescriptorType::eStorageImage }, + { "UniformTexelBuffer", DescriptorType::eUniformTexelBuffer }, + { "StorageTexelBuffer", DescriptorType::eStorageTexelBuffer }, + { "UniformBuffer", DescriptorType::eUniformBuffer }, + { "StorageBuffer", DescriptorType::eStorageBuffer }, + { "UniformBufferDynamic", DescriptorType::eUniformBufferDynamic }, + { "StorageBufferDynamic", DescriptorType::eStorageBufferDynamic }, + { "InputAttachment", DescriptorType::eInputAttachment }, + { "InlineUniformBlock", DescriptorType::eInlineUniformBlock }, + { "AccelerationStructureKHR", DescriptorType::eAccelerationStructureKHR }, + { "AccelerationStructureNV", DescriptorType::eAccelerationStructureNV }, + { "SampleWeightImageQCOM", DescriptorType::eSampleWeightImageQCOM }, + { "BlockMatchImageQCOM", DescriptorType::eBlockMatchImageQCOM }, + { "MutableEXT", DescriptorType::eMutableEXT }, + + }; + + std::unordered_map DescriptorPoolResetFlagBitsEntries = { + + }; + + std::unordered_map AccessFlagBitsEntries = { + { "IndirectCommandRead", AccessFlagBits::eIndirectCommandRead }, + { "IndexRead", AccessFlagBits::eIndexRead }, + { "VertexAttributeRead", AccessFlagBits::eVertexAttributeRead }, + { "UniformRead", AccessFlagBits::eUniformRead }, + { "InputAttachmentRead", AccessFlagBits::eInputAttachmentRead }, + { "ShaderRead", AccessFlagBits::eShaderRead }, + { "ShaderWrite", AccessFlagBits::eShaderWrite }, + { "ColorAttachmentRead", AccessFlagBits::eColorAttachmentRead }, + { "ColorAttachmentWrite", AccessFlagBits::eColorAttachmentWrite }, + { "DepthStencilAttachmentRead", AccessFlagBits::eDepthStencilAttachmentRead }, + { "DepthStencilAttachmentWrite", AccessFlagBits::eDepthStencilAttachmentWrite }, + { "TransferRead", AccessFlagBits::eTransferRead }, + { "TransferWrite", AccessFlagBits::eTransferWrite }, + { "HostRead", AccessFlagBits::eHostRead }, + { "HostWrite", AccessFlagBits::eHostWrite }, + { "MemoryRead", AccessFlagBits::eMemoryRead }, + { "MemoryWrite", AccessFlagBits::eMemoryWrite }, + { "None", AccessFlagBits::eNone }, + { "TransformFeedbackWriteEXT", AccessFlagBits::eTransformFeedbackWriteEXT }, + { "TransformFeedbackCounterReadEXT", AccessFlagBits::eTransformFeedbackCounterReadEXT }, + { "TransformFeedbackCounterWriteEXT", AccessFlagBits::eTransformFeedbackCounterWriteEXT }, + { "ConditionalRenderingReadEXT", AccessFlagBits::eConditionalRenderingReadEXT }, + { "ColorAttachmentReadNoncoherentEXT", AccessFlagBits::eColorAttachmentReadNoncoherentEXT }, + { "AccelerationStructureReadKHR", AccessFlagBits::eAccelerationStructureReadKHR }, + { "AccelerationStructureWriteKHR", AccessFlagBits::eAccelerationStructureWriteKHR }, + { "FragmentDensityMapReadEXT", AccessFlagBits::eFragmentDensityMapReadEXT }, + { "FragmentShadingRateAttachmentReadKHR", AccessFlagBits::eFragmentShadingRateAttachmentReadKHR }, + { "CommandPreprocessReadNV", AccessFlagBits::eCommandPreprocessReadNV }, + { "CommandPreprocessWriteNV", AccessFlagBits::eCommandPreprocessWriteNV }, + + }; + + std::unordered_map AttachmentDescriptionFlagBitsEntries = { + { "MayAlias", AttachmentDescriptionFlagBits::eMayAlias }, + + }; + + std::unordered_map AttachmentLoadOpEntries = { + { "Load", AttachmentLoadOp::eLoad }, + { "Clear", AttachmentLoadOp::eClear }, + { "DontCare", AttachmentLoadOp::eDontCare }, + { "NoneEXT", AttachmentLoadOp::eNoneEXT }, + + }; + + std::unordered_map AttachmentStoreOpEntries = { + { "Store", AttachmentStoreOp::eStore }, + { "DontCare", AttachmentStoreOp::eDontCare }, + { "None", AttachmentStoreOp::eNone }, + + }; + + std::unordered_map DependencyFlagBitsEntries = { + { "ByRegion", DependencyFlagBits::eByRegion }, + { "DeviceGroup", DependencyFlagBits::eDeviceGroup }, + { "ViewLocal", DependencyFlagBits::eViewLocal }, + { "FeedbackLoopEXT", DependencyFlagBits::eFeedbackLoopEXT }, + + }; + + std::unordered_map FramebufferCreateFlagBitsEntries = { + { "Imageless", FramebufferCreateFlagBits::eImageless }, + + }; + + std::unordered_map PipelineBindPointEntries = { + { "Graphics", PipelineBindPoint::eGraphics }, + { "Compute", PipelineBindPoint::eCompute }, +#if defined( VK_ENABLE_BETA_EXTENSIONS ) + { "ExecutionGraphAMDX", PipelineBindPoint::eExecutionGraphAMDX }, +#endif /*VK_ENABLE_BETA_EXTENSIONS*/ + { "RayTracingKHR", PipelineBindPoint::eRayTracingKHR }, + { "SubpassShadingHUAWEI", PipelineBindPoint::eSubpassShadingHUAWEI }, + + }; + + std::unordered_map RenderPassCreateFlagBitsEntries = { + { "TransformQCOM", RenderPassCreateFlagBits::eTransformQCOM }, + + }; + + std::unordered_map SubpassDescriptionFlagBitsEntries = { + { "PerViewAttributesNVX", SubpassDescriptionFlagBits::ePerViewAttributesNVX }, + { "PerViewPositionXOnlyNVX", SubpassDescriptionFlagBits::ePerViewPositionXOnlyNVX }, + { "FragmentRegionQCOM", SubpassDescriptionFlagBits::eFragmentRegionQCOM }, + { "ShaderResolveQCOM", SubpassDescriptionFlagBits::eShaderResolveQCOM }, + { "RasterizationOrderAttachmentColorAccessEXT", SubpassDescriptionFlagBits::eRasterizationOrderAttachmentColorAccessEXT }, + { "RasterizationOrderAttachmentDepthAccessEXT", SubpassDescriptionFlagBits::eRasterizationOrderAttachmentDepthAccessEXT }, + { "RasterizationOrderAttachmentStencilAccessEXT", SubpassDescriptionFlagBits::eRasterizationOrderAttachmentStencilAccessEXT }, + { "EnableLegacyDitheringEXT", SubpassDescriptionFlagBits::eEnableLegacyDitheringEXT }, + + }; + + std::unordered_map CommandPoolCreateFlagBitsEntries = { + { "Transient", CommandPoolCreateFlagBits::eTransient }, + { "ResetCommandBuffer", CommandPoolCreateFlagBits::eResetCommandBuffer }, + { "Protected", CommandPoolCreateFlagBits::eProtected }, + + }; + + std::unordered_map CommandPoolResetFlagBitsEntries = { + { "ReleaseResources", CommandPoolResetFlagBits::eReleaseResources }, + + }; + + std::unordered_map CommandBufferLevelEntries = { + { "Primary", CommandBufferLevel::ePrimary }, + { "Secondary", CommandBufferLevel::eSecondary }, + + }; + + std::unordered_map CommandBufferResetFlagBitsEntries = { + { "ReleaseResources", CommandBufferResetFlagBits::eReleaseResources }, + + }; + + std::unordered_map CommandBufferUsageFlagBitsEntries = { + { "OneTimeSubmit", CommandBufferUsageFlagBits::eOneTimeSubmit }, + { "RenderPassContinue", CommandBufferUsageFlagBits::eRenderPassContinue }, + { "SimultaneousUse", CommandBufferUsageFlagBits::eSimultaneousUse }, + + }; + + std::unordered_map QueryControlFlagBitsEntries = { + { "Precise", QueryControlFlagBits::ePrecise }, + + }; + + std::unordered_map IndexTypeEntries = { + { "Uint16", IndexType::eUint16 }, + { "Uint32", IndexType::eUint32 }, + { "NoneKHR", IndexType::eNoneKHR }, + { "Uint8EXT", IndexType::eUint8EXT }, + + }; + + std::unordered_map StencilFaceFlagBitsEntries = { + { "Front", StencilFaceFlagBits::eFront }, + { "Back", StencilFaceFlagBits::eBack }, + { "FrontAndBack", StencilFaceFlagBits::eFrontAndBack }, + + }; + + std::unordered_map SubpassContentsEntries = { + { "Inline", SubpassContents::eInline }, + { "SecondaryCommandBuffers", SubpassContents::eSecondaryCommandBuffers }, + { "InlineAndSecondaryCommandBuffersEXT", SubpassContents::eInlineAndSecondaryCommandBuffersEXT }, + + }; + + //=== VK_VERSION_1_1 === + + std::unordered_map SubgroupFeatureFlagBitsEntries = { + { "Basic", SubgroupFeatureFlagBits::eBasic }, + { "Vote", SubgroupFeatureFlagBits::eVote }, + { "Arithmetic", SubgroupFeatureFlagBits::eArithmetic }, + { "Ballot", SubgroupFeatureFlagBits::eBallot }, + { "Shuffle", SubgroupFeatureFlagBits::eShuffle }, + { "ShuffleRelative", SubgroupFeatureFlagBits::eShuffleRelative }, + { "Clustered", SubgroupFeatureFlagBits::eClustered }, + { "Quad", SubgroupFeatureFlagBits::eQuad }, + { "PartitionedNV", SubgroupFeatureFlagBits::ePartitionedNV }, + + }; + + std::unordered_map PeerMemoryFeatureFlagBitsEntries = { + { "CopySrc", PeerMemoryFeatureFlagBits::eCopySrc }, + { "CopyDst", PeerMemoryFeatureFlagBits::eCopyDst }, + { "GenericSrc", PeerMemoryFeatureFlagBits::eGenericSrc }, + { "GenericDst", PeerMemoryFeatureFlagBits::eGenericDst }, + + }; + + std::unordered_map MemoryAllocateFlagBitsEntries = { + { "DeviceMask", MemoryAllocateFlagBits::eDeviceMask }, + { "DeviceAddress", MemoryAllocateFlagBits::eDeviceAddress }, + { "DeviceAddressCaptureReplay", MemoryAllocateFlagBits::eDeviceAddressCaptureReplay }, + + }; + + std::unordered_map CommandPoolTrimFlagBitsEntries = { + + }; + + std::unordered_map PointClippingBehaviorEntries = { + { "AllClipPlanes", PointClippingBehavior::eAllClipPlanes }, + { "UserClipPlanesOnly", PointClippingBehavior::eUserClipPlanesOnly }, + + }; + + std::unordered_map TessellationDomainOriginEntries = { + { "UpperLeft", TessellationDomainOrigin::eUpperLeft }, + { "LowerLeft", TessellationDomainOrigin::eLowerLeft }, + + }; + + std::unordered_map SamplerYcbcrModelConversionEntries = { + { "RgbIdentity", SamplerYcbcrModelConversion::eRgbIdentity }, { "YcbcrIdentity", SamplerYcbcrModelConversion::eYcbcrIdentity }, + { "Ycbcr709", SamplerYcbcrModelConversion::eYcbcr709 }, { "Ycbcr601", SamplerYcbcrModelConversion::eYcbcr601 }, + { "Ycbcr2020", SamplerYcbcrModelConversion::eYcbcr2020 }, + + }; + + std::unordered_map SamplerYcbcrRangeEntries = { + { "ItuFull", SamplerYcbcrRange::eItuFull }, + { "ItuNarrow", SamplerYcbcrRange::eItuNarrow }, + + }; + + std::unordered_map ChromaLocationEntries = { + { "CositedEven", ChromaLocation::eCositedEven }, + { "Midpoint", ChromaLocation::eMidpoint }, + + }; + + std::unordered_map DescriptorUpdateTemplateTypeEntries = { + { "DescriptorSet", DescriptorUpdateTemplateType::eDescriptorSet }, + { "PushDescriptorsKHR", DescriptorUpdateTemplateType::ePushDescriptorsKHR }, + + }; + + std::unordered_map DescriptorUpdateTemplateCreateFlagBitsEntries = { + + }; + + std::unordered_map ExternalMemoryHandleTypeFlagBitsEntries = { + { "OpaqueFd", ExternalMemoryHandleTypeFlagBits::eOpaqueFd }, + { "OpaqueWin32", ExternalMemoryHandleTypeFlagBits::eOpaqueWin32 }, + { "OpaqueWin32Kmt", ExternalMemoryHandleTypeFlagBits::eOpaqueWin32Kmt }, + { "D3D11Texture", ExternalMemoryHandleTypeFlagBits::eD3D11Texture }, + { "D3D11TextureKmt", ExternalMemoryHandleTypeFlagBits::eD3D11TextureKmt }, + { "D3D12Heap", ExternalMemoryHandleTypeFlagBits::eD3D12Heap }, + { "D3D12Resource", ExternalMemoryHandleTypeFlagBits::eD3D12Resource }, + { "DmaBufEXT", ExternalMemoryHandleTypeFlagBits::eDmaBufEXT }, +#if defined( VK_USE_PLATFORM_ANDROID_KHR ) + { "AndroidHardwareBufferANDROID", ExternalMemoryHandleTypeFlagBits::eAndroidHardwareBufferANDROID }, +#endif /*VK_USE_PLATFORM_ANDROID_KHR*/ + { "HostAllocationEXT", ExternalMemoryHandleTypeFlagBits::eHostAllocationEXT }, + { "HostMappedForeignMemoryEXT", ExternalMemoryHandleTypeFlagBits::eHostMappedForeignMemoryEXT }, +#if defined( VK_USE_PLATFORM_FUCHSIA ) + { "ZirconVmoFUCHSIA", ExternalMemoryHandleTypeFlagBits::eZirconVmoFUCHSIA }, +#endif /*VK_USE_PLATFORM_FUCHSIA*/ + { "RdmaAddressNV", ExternalMemoryHandleTypeFlagBits::eRdmaAddressNV }, +#if defined( VK_USE_PLATFORM_SCREEN_QNX ) + { "ScreenBufferQNX", ExternalMemoryHandleTypeFlagBits::eScreenBufferQNX }, +#endif /*VK_USE_PLATFORM_SCREEN_QNX*/ + + }; + + std::unordered_map ExternalMemoryFeatureFlagBitsEntries = { + { "DedicatedOnly", ExternalMemoryFeatureFlagBits::eDedicatedOnly }, + { "Exportable", ExternalMemoryFeatureFlagBits::eExportable }, + { "Importable", ExternalMemoryFeatureFlagBits::eImportable }, + + }; + + std::unordered_map ExternalFenceHandleTypeFlagBitsEntries = { + { "OpaqueFd", ExternalFenceHandleTypeFlagBits::eOpaqueFd }, + { "OpaqueWin32", ExternalFenceHandleTypeFlagBits::eOpaqueWin32 }, + { "OpaqueWin32Kmt", ExternalFenceHandleTypeFlagBits::eOpaqueWin32Kmt }, + { "SyncFd", ExternalFenceHandleTypeFlagBits::eSyncFd }, + + }; + + std::unordered_map ExternalFenceFeatureFlagBitsEntries = { + { "Exportable", ExternalFenceFeatureFlagBits::eExportable }, + { "Importable", ExternalFenceFeatureFlagBits::eImportable }, + + }; + + std::unordered_map FenceImportFlagBitsEntries = { + { "Temporary", FenceImportFlagBits::eTemporary }, + + }; + + std::unordered_map SemaphoreImportFlagBitsEntries = { + { "Temporary", SemaphoreImportFlagBits::eTemporary }, + + }; + + std::unordered_map ExternalSemaphoreHandleTypeFlagBitsEntries = { + { "OpaqueFd", ExternalSemaphoreHandleTypeFlagBits::eOpaqueFd }, + { "OpaqueWin32", ExternalSemaphoreHandleTypeFlagBits::eOpaqueWin32 }, + { "OpaqueWin32Kmt", ExternalSemaphoreHandleTypeFlagBits::eOpaqueWin32Kmt }, + { "D3D12Fence", ExternalSemaphoreHandleTypeFlagBits::eD3D12Fence }, + { "SyncFd", ExternalSemaphoreHandleTypeFlagBits::eSyncFd }, +#if defined( VK_USE_PLATFORM_FUCHSIA ) + { "ZirconEventFUCHSIA", ExternalSemaphoreHandleTypeFlagBits::eZirconEventFUCHSIA }, +#endif /*VK_USE_PLATFORM_FUCHSIA*/ + + }; + + std::unordered_map ExternalSemaphoreFeatureFlagBitsEntries = { + { "Exportable", ExternalSemaphoreFeatureFlagBits::eExportable }, + { "Importable", ExternalSemaphoreFeatureFlagBits::eImportable }, + + }; + + //=== VK_VERSION_1_2 === + + std::unordered_map DriverIdEntries = { + { "AmdProprietary", DriverId::eAmdProprietary }, + { "AmdOpenSource", DriverId::eAmdOpenSource }, + { "MesaRadv", DriverId::eMesaRadv }, + { "NvidiaProprietary", DriverId::eNvidiaProprietary }, + { "IntelProprietaryWindows", DriverId::eIntelProprietaryWindows }, + { "IntelOpenSourceMESA", DriverId::eIntelOpenSourceMESA }, + { "ImaginationProprietary", DriverId::eImaginationProprietary }, + { "QualcommProprietary", DriverId::eQualcommProprietary }, + { "ArmProprietary", DriverId::eArmProprietary }, + { "GoogleSwiftshader", DriverId::eGoogleSwiftshader }, + { "GgpProprietary", DriverId::eGgpProprietary }, + { "BroadcomProprietary", DriverId::eBroadcomProprietary }, + { "MesaLlvmpipe", DriverId::eMesaLlvmpipe }, + { "Moltenvk", DriverId::eMoltenvk }, + { "CoreaviProprietary", DriverId::eCoreaviProprietary }, + { "JuiceProprietary", DriverId::eJuiceProprietary }, + { "VerisiliconProprietary", DriverId::eVerisiliconProprietary }, + { "MesaTurnip", DriverId::eMesaTurnip }, + { "MesaV3Dv", DriverId::eMesaV3Dv }, + { "MesaPanvk", DriverId::eMesaPanvk }, + { "SamsungProprietary", DriverId::eSamsungProprietary }, + { "MesaVenus", DriverId::eMesaVenus }, + { "MesaDozen", DriverId::eMesaDozen }, + { "MesaNvk", DriverId::eMesaNvk }, + { "ImaginationOpenSourceMESA", DriverId::eImaginationOpenSourceMESA }, + { "MesaAgxv", DriverId::eMesaAgxv }, + + }; + + std::unordered_map ShaderFloatControlsIndependenceEntries = { + { "32BitOnly", ShaderFloatControlsIndependence::e32BitOnly }, + { "All", ShaderFloatControlsIndependence::eAll }, + { "None", ShaderFloatControlsIndependence::eNone }, + + }; + + std::unordered_map DescriptorBindingFlagBitsEntries = { + { "UpdateAfterBind", DescriptorBindingFlagBits::eUpdateAfterBind }, + { "UpdateUnusedWhilePending", DescriptorBindingFlagBits::eUpdateUnusedWhilePending }, + { "PartiallyBound", DescriptorBindingFlagBits::ePartiallyBound }, + { "VariableDescriptorCount", DescriptorBindingFlagBits::eVariableDescriptorCount }, + + }; + + std::unordered_map ResolveModeFlagBitsEntries = { + { "None", ResolveModeFlagBits::eNone }, + { "SampleZero", ResolveModeFlagBits::eSampleZero }, + { "Average", ResolveModeFlagBits::eAverage }, + { "Min", ResolveModeFlagBits::eMin }, + { "Max", ResolveModeFlagBits::eMax }, +#if defined( VK_USE_PLATFORM_ANDROID_KHR ) + { "ExternalFormatDownsampleANDROID", ResolveModeFlagBits::eExternalFormatDownsampleANDROID }, +#endif /*VK_USE_PLATFORM_ANDROID_KHR*/ + + }; + + std::unordered_map SamplerReductionModeEntries = { + { "WeightedAverage", SamplerReductionMode::eWeightedAverage }, + { "Min", SamplerReductionMode::eMin }, + { "Max", SamplerReductionMode::eMax }, + { "WeightedAverageRangeclampQCOM", SamplerReductionMode::eWeightedAverageRangeclampQCOM }, + + }; + + std::unordered_map SemaphoreTypeEntries = { + { "Binary", SemaphoreType::eBinary }, + { "Timeline", SemaphoreType::eTimeline }, + + }; + + std::unordered_map SemaphoreWaitFlagBitsEntries = { + { "Any", SemaphoreWaitFlagBits::eAny }, + + }; + + //=== VK_VERSION_1_3 === + + std::unordered_map PipelineCreationFeedbackFlagBitsEntries = { + { "Valid", PipelineCreationFeedbackFlagBits::eValid }, + { "ApplicationPipelineCacheHit", PipelineCreationFeedbackFlagBits::eApplicationPipelineCacheHit }, + { "BasePipelineAcceleration", PipelineCreationFeedbackFlagBits::eBasePipelineAcceleration }, + + }; + + std::unordered_map ToolPurposeFlagBitsEntries = { + { "Validation", ToolPurposeFlagBits::eValidation }, + { "Profiling", ToolPurposeFlagBits::eProfiling }, + { "Tracing", ToolPurposeFlagBits::eTracing }, + { "AdditionalFeatures", ToolPurposeFlagBits::eAdditionalFeatures }, + { "ModifyingFeatures", ToolPurposeFlagBits::eModifyingFeatures }, + { "DebugReportingEXT", ToolPurposeFlagBits::eDebugReportingEXT }, + { "DebugMarkersEXT", ToolPurposeFlagBits::eDebugMarkersEXT }, + + }; + + std::unordered_map PrivateDataSlotCreateFlagBitsEntries = { + + }; + + std::unordered_map PipelineStageFlagBits2Entries = { + { "None", PipelineStageFlagBits2::eNone }, + { "TopOfPipe", PipelineStageFlagBits2::eTopOfPipe }, + { "DrawIndirect", PipelineStageFlagBits2::eDrawIndirect }, + { "VertexInput", PipelineStageFlagBits2::eVertexInput }, + { "VertexShader", PipelineStageFlagBits2::eVertexShader }, + { "TessellationControlShader", PipelineStageFlagBits2::eTessellationControlShader }, + { "TessellationEvaluationShader", PipelineStageFlagBits2::eTessellationEvaluationShader }, + { "GeometryShader", PipelineStageFlagBits2::eGeometryShader }, + { "FragmentShader", PipelineStageFlagBits2::eFragmentShader }, + { "EarlyFragmentTests", PipelineStageFlagBits2::eEarlyFragmentTests }, + { "LateFragmentTests", PipelineStageFlagBits2::eLateFragmentTests }, + { "ColorAttachmentOutput", PipelineStageFlagBits2::eColorAttachmentOutput }, + { "ComputeShader", PipelineStageFlagBits2::eComputeShader }, + { "AllTransfer", PipelineStageFlagBits2::eAllTransfer }, + { "BottomOfPipe", PipelineStageFlagBits2::eBottomOfPipe }, + { "Host", PipelineStageFlagBits2::eHost }, + { "AllGraphics", PipelineStageFlagBits2::eAllGraphics }, + { "AllCommands", PipelineStageFlagBits2::eAllCommands }, + { "Copy", PipelineStageFlagBits2::eCopy }, + { "Resolve", PipelineStageFlagBits2::eResolve }, + { "Blit", PipelineStageFlagBits2::eBlit }, + { "Clear", PipelineStageFlagBits2::eClear }, + { "IndexInput", PipelineStageFlagBits2::eIndexInput }, + { "VertexAttributeInput", PipelineStageFlagBits2::eVertexAttributeInput }, + { "PreRasterizationShaders", PipelineStageFlagBits2::ePreRasterizationShaders }, + { "VideoDecodeKHR", PipelineStageFlagBits2::eVideoDecodeKHR }, +#if defined( VK_ENABLE_BETA_EXTENSIONS ) + { "VideoEncodeKHR", PipelineStageFlagBits2::eVideoEncodeKHR }, +#endif /*VK_ENABLE_BETA_EXTENSIONS*/ + { "TransformFeedbackEXT", PipelineStageFlagBits2::eTransformFeedbackEXT }, + { "ConditionalRenderingEXT", PipelineStageFlagBits2::eConditionalRenderingEXT }, + { "CommandPreprocessNV", PipelineStageFlagBits2::eCommandPreprocessNV }, + { "FragmentShadingRateAttachmentKHR", PipelineStageFlagBits2::eFragmentShadingRateAttachmentKHR }, + { "AccelerationStructureBuildKHR", PipelineStageFlagBits2::eAccelerationStructureBuildKHR }, + { "RayTracingShaderKHR", PipelineStageFlagBits2::eRayTracingShaderKHR }, + { "FragmentDensityProcessEXT", PipelineStageFlagBits2::eFragmentDensityProcessEXT }, + { "TaskShaderEXT", PipelineStageFlagBits2::eTaskShaderEXT }, + { "MeshShaderEXT", PipelineStageFlagBits2::eMeshShaderEXT }, + { "SubpassShaderHUAWEI", PipelineStageFlagBits2::eSubpassShaderHUAWEI }, + { "InvocationMaskHUAWEI", PipelineStageFlagBits2::eInvocationMaskHUAWEI }, + { "AccelerationStructureCopyKHR", PipelineStageFlagBits2::eAccelerationStructureCopyKHR }, + { "MicromapBuildEXT", PipelineStageFlagBits2::eMicromapBuildEXT }, + { "ClusterCullingShaderHUAWEI", PipelineStageFlagBits2::eClusterCullingShaderHUAWEI }, + { "OpticalFlowNV", PipelineStageFlagBits2::eOpticalFlowNV }, + + }; + + std::unordered_map AccessFlagBits2Entries = { + { "None", AccessFlagBits2::eNone }, + { "IndirectCommandRead", AccessFlagBits2::eIndirectCommandRead }, + { "IndexRead", AccessFlagBits2::eIndexRead }, + { "VertexAttributeRead", AccessFlagBits2::eVertexAttributeRead }, + { "UniformRead", AccessFlagBits2::eUniformRead }, + { "InputAttachmentRead", AccessFlagBits2::eInputAttachmentRead }, + { "ShaderRead", AccessFlagBits2::eShaderRead }, + { "ShaderWrite", AccessFlagBits2::eShaderWrite }, + { "ColorAttachmentRead", AccessFlagBits2::eColorAttachmentRead }, + { "ColorAttachmentWrite", AccessFlagBits2::eColorAttachmentWrite }, + { "DepthStencilAttachmentRead", AccessFlagBits2::eDepthStencilAttachmentRead }, + { "DepthStencilAttachmentWrite", AccessFlagBits2::eDepthStencilAttachmentWrite }, + { "TransferRead", AccessFlagBits2::eTransferRead }, + { "TransferWrite", AccessFlagBits2::eTransferWrite }, + { "HostRead", AccessFlagBits2::eHostRead }, + { "HostWrite", AccessFlagBits2::eHostWrite }, + { "MemoryRead", AccessFlagBits2::eMemoryRead }, + { "MemoryWrite", AccessFlagBits2::eMemoryWrite }, + { "ShaderSampledRead", AccessFlagBits2::eShaderSampledRead }, + { "ShaderStorageRead", AccessFlagBits2::eShaderStorageRead }, + { "ShaderStorageWrite", AccessFlagBits2::eShaderStorageWrite }, + { "VideoDecodeReadKHR", AccessFlagBits2::eVideoDecodeReadKHR }, + { "VideoDecodeWriteKHR", AccessFlagBits2::eVideoDecodeWriteKHR }, +#if defined( VK_ENABLE_BETA_EXTENSIONS ) + { "VideoEncodeReadKHR", AccessFlagBits2::eVideoEncodeReadKHR }, + { "VideoEncodeWriteKHR", AccessFlagBits2::eVideoEncodeWriteKHR }, +#endif /*VK_ENABLE_BETA_EXTENSIONS*/ + { "TransformFeedbackWriteEXT", AccessFlagBits2::eTransformFeedbackWriteEXT }, + { "TransformFeedbackCounterReadEXT", AccessFlagBits2::eTransformFeedbackCounterReadEXT }, + { "TransformFeedbackCounterWriteEXT", AccessFlagBits2::eTransformFeedbackCounterWriteEXT }, + { "ConditionalRenderingReadEXT", AccessFlagBits2::eConditionalRenderingReadEXT }, + { "CommandPreprocessReadNV", AccessFlagBits2::eCommandPreprocessReadNV }, + { "CommandPreprocessWriteNV", AccessFlagBits2::eCommandPreprocessWriteNV }, + { "FragmentShadingRateAttachmentReadKHR", AccessFlagBits2::eFragmentShadingRateAttachmentReadKHR }, + { "AccelerationStructureReadKHR", AccessFlagBits2::eAccelerationStructureReadKHR }, + { "AccelerationStructureWriteKHR", AccessFlagBits2::eAccelerationStructureWriteKHR }, + { "FragmentDensityMapReadEXT", AccessFlagBits2::eFragmentDensityMapReadEXT }, + { "ColorAttachmentReadNoncoherentEXT", AccessFlagBits2::eColorAttachmentReadNoncoherentEXT }, + { "DescriptorBufferReadEXT", AccessFlagBits2::eDescriptorBufferReadEXT }, + { "InvocationMaskReadHUAWEI", AccessFlagBits2::eInvocationMaskReadHUAWEI }, + { "ShaderBindingTableReadKHR", AccessFlagBits2::eShaderBindingTableReadKHR }, + { "MicromapReadEXT", AccessFlagBits2::eMicromapReadEXT }, + { "MicromapWriteEXT", AccessFlagBits2::eMicromapWriteEXT }, + { "OpticalFlowReadNV", AccessFlagBits2::eOpticalFlowReadNV }, + { "OpticalFlowWriteNV", AccessFlagBits2::eOpticalFlowWriteNV }, + + }; + + std::unordered_map SubmitFlagBitsEntries = { + { "Protected", SubmitFlagBits::eProtected }, + + }; + + std::unordered_map RenderingFlagBitsEntries = { + { "ContentsSecondaryCommandBuffers", RenderingFlagBits::eContentsSecondaryCommandBuffers }, + { "Suspending", RenderingFlagBits::eSuspending }, + { "Resuming", RenderingFlagBits::eResuming }, + { "ContentsInlineEXT", RenderingFlagBits::eContentsInlineEXT }, + { "EnableLegacyDitheringEXT", RenderingFlagBits::eEnableLegacyDitheringEXT }, + + }; + + std::unordered_map FormatFeatureFlagBits2Entries = { + { "SampledImage", FormatFeatureFlagBits2::eSampledImage }, + { "StorageImage", FormatFeatureFlagBits2::eStorageImage }, + { "StorageImageAtomic", FormatFeatureFlagBits2::eStorageImageAtomic }, + { "UniformTexelBuffer", FormatFeatureFlagBits2::eUniformTexelBuffer }, + { "StorageTexelBuffer", FormatFeatureFlagBits2::eStorageTexelBuffer }, + { "StorageTexelBufferAtomic", FormatFeatureFlagBits2::eStorageTexelBufferAtomic }, + { "VertexBuffer", FormatFeatureFlagBits2::eVertexBuffer }, + { "ColorAttachment", FormatFeatureFlagBits2::eColorAttachment }, + { "ColorAttachmentBlend", FormatFeatureFlagBits2::eColorAttachmentBlend }, + { "DepthStencilAttachment", FormatFeatureFlagBits2::eDepthStencilAttachment }, + { "BlitSrc", FormatFeatureFlagBits2::eBlitSrc }, + { "BlitDst", FormatFeatureFlagBits2::eBlitDst }, + { "SampledImageFilterLinear", FormatFeatureFlagBits2::eSampledImageFilterLinear }, + { "SampledImageFilterCubic", FormatFeatureFlagBits2::eSampledImageFilterCubic }, + { "TransferSrc", FormatFeatureFlagBits2::eTransferSrc }, + { "TransferDst", FormatFeatureFlagBits2::eTransferDst }, + { "SampledImageFilterMinmax", FormatFeatureFlagBits2::eSampledImageFilterMinmax }, + { "MidpointChromaSamples", FormatFeatureFlagBits2::eMidpointChromaSamples }, + { "SampledImageYcbcrConversionLinearFilter", FormatFeatureFlagBits2::eSampledImageYcbcrConversionLinearFilter }, + { "SampledImageYcbcrConversionSeparateReconstructionFilter", FormatFeatureFlagBits2::eSampledImageYcbcrConversionSeparateReconstructionFilter }, + { "SampledImageYcbcrConversionChromaReconstructionExplicit", FormatFeatureFlagBits2::eSampledImageYcbcrConversionChromaReconstructionExplicit }, + { "SampledImageYcbcrConversionChromaReconstructionExplicitForceable", + FormatFeatureFlagBits2::eSampledImageYcbcrConversionChromaReconstructionExplicitForceable }, + { "Disjoint", FormatFeatureFlagBits2::eDisjoint }, + { "CositedChromaSamples", FormatFeatureFlagBits2::eCositedChromaSamples }, + { "StorageReadWithoutFormat", FormatFeatureFlagBits2::eStorageReadWithoutFormat }, + { "StorageWriteWithoutFormat", FormatFeatureFlagBits2::eStorageWriteWithoutFormat }, + { "SampledImageDepthComparison", FormatFeatureFlagBits2::eSampledImageDepthComparison }, + { "VideoDecodeOutputKHR", FormatFeatureFlagBits2::eVideoDecodeOutputKHR }, + { "VideoDecodeDpbKHR", FormatFeatureFlagBits2::eVideoDecodeDpbKHR }, + { "AccelerationStructureVertexBufferKHR", FormatFeatureFlagBits2::eAccelerationStructureVertexBufferKHR }, + { "FragmentDensityMapEXT", FormatFeatureFlagBits2::eFragmentDensityMapEXT }, + { "FragmentShadingRateAttachmentKHR", FormatFeatureFlagBits2::eFragmentShadingRateAttachmentKHR }, + { "HostImageTransferEXT", FormatFeatureFlagBits2::eHostImageTransferEXT }, +#if defined( VK_ENABLE_BETA_EXTENSIONS ) + { "VideoEncodeInputKHR", FormatFeatureFlagBits2::eVideoEncodeInputKHR }, + { "VideoEncodeDpbKHR", FormatFeatureFlagBits2::eVideoEncodeDpbKHR }, +#endif /*VK_ENABLE_BETA_EXTENSIONS*/ + { "LinearColorAttachmentNV", FormatFeatureFlagBits2::eLinearColorAttachmentNV }, + { "WeightImageQCOM", FormatFeatureFlagBits2::eWeightImageQCOM }, + { "WeightSampledImageQCOM", FormatFeatureFlagBits2::eWeightSampledImageQCOM }, + { "BlockMatchingQCOM", FormatFeatureFlagBits2::eBlockMatchingQCOM }, + { "BoxFilterSampledQCOM", FormatFeatureFlagBits2::eBoxFilterSampledQCOM }, + { "OpticalFlowImageNV", FormatFeatureFlagBits2::eOpticalFlowImageNV }, + { "OpticalFlowVectorNV", FormatFeatureFlagBits2::eOpticalFlowVectorNV }, + { "OpticalFlowCostNV", FormatFeatureFlagBits2::eOpticalFlowCostNV }, + + }; + + //=== VK_KHR_surface === + + std::unordered_map SurfaceTransformFlagBitsKHREntries = { + { "Identity", SurfaceTransformFlagBitsKHR::eIdentity }, + { "Rotate90", SurfaceTransformFlagBitsKHR::eRotate90 }, + { "Rotate180", SurfaceTransformFlagBitsKHR::eRotate180 }, + { "Rotate270", SurfaceTransformFlagBitsKHR::eRotate270 }, + { "HorizontalMirror", SurfaceTransformFlagBitsKHR::eHorizontalMirror }, + { "HorizontalMirrorRotate90", SurfaceTransformFlagBitsKHR::eHorizontalMirrorRotate90 }, + { "HorizontalMirrorRotate180", SurfaceTransformFlagBitsKHR::eHorizontalMirrorRotate180 }, + { "HorizontalMirrorRotate270", SurfaceTransformFlagBitsKHR::eHorizontalMirrorRotate270 }, + { "Inherit", SurfaceTransformFlagBitsKHR::eInherit }, + + }; + + std::unordered_map PresentModeKHREntries = { + { "Immediate", PresentModeKHR::eImmediate }, + { "Mailbox", PresentModeKHR::eMailbox }, + { "Fifo", PresentModeKHR::eFifo }, + { "FifoRelaxed", PresentModeKHR::eFifoRelaxed }, + { "SharedDemandRefresh", PresentModeKHR::eSharedDemandRefresh }, + { "SharedContinuousRefresh", PresentModeKHR::eSharedContinuousRefresh }, + + }; + + std::unordered_map ColorSpaceKHREntries = { + { "SrgbNonlinear", ColorSpaceKHR::eSrgbNonlinear }, + { "DisplayP3NonlinearEXT", ColorSpaceKHR::eDisplayP3NonlinearEXT }, + { "ExtendedSrgbLinearEXT", ColorSpaceKHR::eExtendedSrgbLinearEXT }, + { "DisplayP3LinearEXT", ColorSpaceKHR::eDisplayP3LinearEXT }, + { "DciP3NonlinearEXT", ColorSpaceKHR::eDciP3NonlinearEXT }, + { "Bt709LinearEXT", ColorSpaceKHR::eBt709LinearEXT }, + { "Bt709NonlinearEXT", ColorSpaceKHR::eBt709NonlinearEXT }, + { "Bt2020LinearEXT", ColorSpaceKHR::eBt2020LinearEXT }, + { "Hdr10St2084EXT", ColorSpaceKHR::eHdr10St2084EXT }, + { "DolbyvisionEXT", ColorSpaceKHR::eDolbyvisionEXT }, + { "Hdr10HlgEXT", ColorSpaceKHR::eHdr10HlgEXT }, + { "AdobergbLinearEXT", ColorSpaceKHR::eAdobergbLinearEXT }, + { "AdobergbNonlinearEXT", ColorSpaceKHR::eAdobergbNonlinearEXT }, + { "PassThroughEXT", ColorSpaceKHR::ePassThroughEXT }, + { "ExtendedSrgbNonlinearEXT", ColorSpaceKHR::eExtendedSrgbNonlinearEXT }, + { "DisplayNativeAMD", ColorSpaceKHR::eDisplayNativeAMD }, + + }; + + std::unordered_map CompositeAlphaFlagBitsKHREntries = { + { "Opaque", CompositeAlphaFlagBitsKHR::eOpaque }, + { "PreMultiplied", CompositeAlphaFlagBitsKHR::ePreMultiplied }, + { "PostMultiplied", CompositeAlphaFlagBitsKHR::ePostMultiplied }, + { "Inherit", CompositeAlphaFlagBitsKHR::eInherit }, + + }; + + //=== VK_KHR_swapchain === + + std::unordered_map SwapchainCreateFlagBitsKHREntries = { + { "SplitInstanceBindRegions", SwapchainCreateFlagBitsKHR::eSplitInstanceBindRegions }, + { "Protected", SwapchainCreateFlagBitsKHR::eProtected }, + { "MutableFormat", SwapchainCreateFlagBitsKHR::eMutableFormat }, + { "DeferredMemoryAllocationEXT", SwapchainCreateFlagBitsKHR::eDeferredMemoryAllocationEXT }, + + }; + + std::unordered_map DeviceGroupPresentModeFlagBitsKHREntries = { + { "Local", DeviceGroupPresentModeFlagBitsKHR::eLocal }, + { "Remote", DeviceGroupPresentModeFlagBitsKHR::eRemote }, + { "Sum", DeviceGroupPresentModeFlagBitsKHR::eSum }, + { "LocalMultiDevice", DeviceGroupPresentModeFlagBitsKHR::eLocalMultiDevice }, + + }; + + //=== VK_KHR_display === + + std::unordered_map DisplayPlaneAlphaFlagBitsKHREntries = { + { "Opaque", DisplayPlaneAlphaFlagBitsKHR::eOpaque }, + { "Global", DisplayPlaneAlphaFlagBitsKHR::eGlobal }, + { "PerPixel", DisplayPlaneAlphaFlagBitsKHR::ePerPixel }, + { "PerPixelPremultiplied", DisplayPlaneAlphaFlagBitsKHR::ePerPixelPremultiplied }, + + }; + + std::unordered_map DisplayModeCreateFlagBitsKHREntries = { + + }; + + std::unordered_map DisplaySurfaceCreateFlagBitsKHREntries = { + + }; + +#if defined( VK_USE_PLATFORM_XLIB_KHR ) + //=== VK_KHR_xlib_surface === + + std::unordered_map XlibSurfaceCreateFlagBitsKHREntries = { + + }; +#endif /*VK_USE_PLATFORM_XLIB_KHR*/ + +#if defined( VK_USE_PLATFORM_XCB_KHR ) + //=== VK_KHR_xcb_surface === + + std::unordered_map XcbSurfaceCreateFlagBitsKHREntries = { + + }; +#endif /*VK_USE_PLATFORM_XCB_KHR*/ + +#if defined( VK_USE_PLATFORM_WAYLAND_KHR ) + //=== VK_KHR_wayland_surface === + + std::unordered_map WaylandSurfaceCreateFlagBitsKHREntries = { + + }; +#endif /*VK_USE_PLATFORM_WAYLAND_KHR*/ + +#if defined( VK_USE_PLATFORM_ANDROID_KHR ) + //=== VK_KHR_android_surface === + + std::unordered_map AndroidSurfaceCreateFlagBitsKHREntries = { + + }; +#endif /*VK_USE_PLATFORM_ANDROID_KHR*/ + +#if defined( VK_USE_PLATFORM_WIN32_KHR ) + //=== VK_KHR_win32_surface === + + std::unordered_map Win32SurfaceCreateFlagBitsKHREntries = { + + }; +#endif /*VK_USE_PLATFORM_WIN32_KHR*/ + + //=== VK_EXT_debug_report === + + std::unordered_map DebugReportFlagBitsEXTEntries = { + { "Information", DebugReportFlagBitsEXT::eInformation }, + { "Warning", DebugReportFlagBitsEXT::eWarning }, + { "PerformanceWarning", DebugReportFlagBitsEXT::ePerformanceWarning }, + { "Error", DebugReportFlagBitsEXT::eError }, + { "Debug", DebugReportFlagBitsEXT::eDebug }, + + }; + + std::unordered_map DebugReportObjectTypeEXTEntries = { + { "Unknown", DebugReportObjectTypeEXT::eUnknown }, + { "Instance", DebugReportObjectTypeEXT::eInstance }, + { "PhysicalDevice", DebugReportObjectTypeEXT::ePhysicalDevice }, + { "Device", DebugReportObjectTypeEXT::eDevice }, + { "Queue", DebugReportObjectTypeEXT::eQueue }, + { "Semaphore", DebugReportObjectTypeEXT::eSemaphore }, + { "CommandBuffer", DebugReportObjectTypeEXT::eCommandBuffer }, + { "Fence", DebugReportObjectTypeEXT::eFence }, + { "DeviceMemory", DebugReportObjectTypeEXT::eDeviceMemory }, + { "Buffer", DebugReportObjectTypeEXT::eBuffer }, + { "Image", DebugReportObjectTypeEXT::eImage }, + { "Event", DebugReportObjectTypeEXT::eEvent }, + { "QueryPool", DebugReportObjectTypeEXT::eQueryPool }, + { "BufferView", DebugReportObjectTypeEXT::eBufferView }, + { "ImageView", DebugReportObjectTypeEXT::eImageView }, + { "ShaderModule", DebugReportObjectTypeEXT::eShaderModule }, + { "PipelineCache", DebugReportObjectTypeEXT::ePipelineCache }, + { "PipelineLayout", DebugReportObjectTypeEXT::ePipelineLayout }, + { "RenderPass", DebugReportObjectTypeEXT::eRenderPass }, + { "Pipeline", DebugReportObjectTypeEXT::ePipeline }, + { "DescriptorSetLayout", DebugReportObjectTypeEXT::eDescriptorSetLayout }, + { "Sampler", DebugReportObjectTypeEXT::eSampler }, + { "DescriptorPool", DebugReportObjectTypeEXT::eDescriptorPool }, + { "DescriptorSet", DebugReportObjectTypeEXT::eDescriptorSet }, + { "Framebuffer", DebugReportObjectTypeEXT::eFramebuffer }, + { "CommandPool", DebugReportObjectTypeEXT::eCommandPool }, + { "SurfaceKHR", DebugReportObjectTypeEXT::eSurfaceKHR }, + { "SwapchainKHR", DebugReportObjectTypeEXT::eSwapchainKHR }, + { "DebugReportCallbackEXT", DebugReportObjectTypeEXT::eDebugReportCallbackEXT }, + { "DisplayKHR", DebugReportObjectTypeEXT::eDisplayKHR }, + { "DisplayModeKHR", DebugReportObjectTypeEXT::eDisplayModeKHR }, + { "ValidationCacheEXT", DebugReportObjectTypeEXT::eValidationCacheEXT }, + { "SamplerYcbcrConversion", DebugReportObjectTypeEXT::eSamplerYcbcrConversion }, + { "DescriptorUpdateTemplate", DebugReportObjectTypeEXT::eDescriptorUpdateTemplate }, + { "CuModuleNVX", DebugReportObjectTypeEXT::eCuModuleNVX }, + { "CuFunctionNVX", DebugReportObjectTypeEXT::eCuFunctionNVX }, + { "AccelerationStructureKHR", DebugReportObjectTypeEXT::eAccelerationStructureKHR }, + { "AccelerationStructureNV", DebugReportObjectTypeEXT::eAccelerationStructureNV }, +#if defined( VK_ENABLE_BETA_EXTENSIONS ) + { "CudaModuleNV", DebugReportObjectTypeEXT::eCudaModuleNV }, + { "CudaFunctionNV", DebugReportObjectTypeEXT::eCudaFunctionNV }, +#endif /*VK_ENABLE_BETA_EXTENSIONS*/ +#if defined( VK_USE_PLATFORM_FUCHSIA ) + { "BufferCollectionFUCHSIA", DebugReportObjectTypeEXT::eBufferCollectionFUCHSIA }, +#endif /*VK_USE_PLATFORM_FUCHSIA*/ + + }; + + //=== VK_AMD_rasterization_order === + + std::unordered_map RasterizationOrderAMDEntries = { + { "Strict", RasterizationOrderAMD::eStrict }, + { "Relaxed", RasterizationOrderAMD::eRelaxed }, + + }; + + //=== VK_KHR_video_queue === + + std::unordered_map VideoCodecOperationFlagBitsKHREntries = { + { "None", VideoCodecOperationFlagBitsKHR::eNone }, +#if defined( VK_ENABLE_BETA_EXTENSIONS ) + { "EncodeH264EXT", VideoCodecOperationFlagBitsKHR::eEncodeH264EXT }, + { "EncodeH265EXT", VideoCodecOperationFlagBitsKHR::eEncodeH265EXT }, +#endif /*VK_ENABLE_BETA_EXTENSIONS*/ + { "DecodeH264", VideoCodecOperationFlagBitsKHR::eDecodeH264 }, + { "DecodeH265", VideoCodecOperationFlagBitsKHR::eDecodeH265 }, + + }; + + std::unordered_map VideoChromaSubsamplingFlagBitsKHREntries = { + { "Invalid", VideoChromaSubsamplingFlagBitsKHR::eInvalid }, { "Monochrome", VideoChromaSubsamplingFlagBitsKHR::eMonochrome }, + { "420", VideoChromaSubsamplingFlagBitsKHR::e420 }, { "422", VideoChromaSubsamplingFlagBitsKHR::e422 }, + { "444", VideoChromaSubsamplingFlagBitsKHR::e444 }, + + }; + + std::unordered_map VideoComponentBitDepthFlagBitsKHREntries = { + { "Invalid", VideoComponentBitDepthFlagBitsKHR::eInvalid }, + { "8", VideoComponentBitDepthFlagBitsKHR::e8 }, + { "10", VideoComponentBitDepthFlagBitsKHR::e10 }, + { "12", VideoComponentBitDepthFlagBitsKHR::e12 }, + + }; + + std::unordered_map VideoCapabilityFlagBitsKHREntries = { + { "ProtectedContent", VideoCapabilityFlagBitsKHR::eProtectedContent }, + { "SeparateReferenceImages", VideoCapabilityFlagBitsKHR::eSeparateReferenceImages }, + + }; + + std::unordered_map VideoSessionCreateFlagBitsKHREntries = { + { "ProtectedContent", VideoSessionCreateFlagBitsKHR::eProtectedContent }, +#if defined( VK_ENABLE_BETA_EXTENSIONS ) + { "AllowEncodeParameterOptimizations", VideoSessionCreateFlagBitsKHR::eAllowEncodeParameterOptimizations }, +#endif /*VK_ENABLE_BETA_EXTENSIONS*/ + + }; + + std::unordered_map VideoCodingControlFlagBitsKHREntries = { + { "Reset", VideoCodingControlFlagBitsKHR::eReset }, +#if defined( VK_ENABLE_BETA_EXTENSIONS ) + { "EncodeRateControl", VideoCodingControlFlagBitsKHR::eEncodeRateControl }, + { "EncodeQualityLevel", VideoCodingControlFlagBitsKHR::eEncodeQualityLevel }, +#endif /*VK_ENABLE_BETA_EXTENSIONS*/ + + }; + + std::unordered_map QueryResultStatusKHREntries = { + { "Error", QueryResultStatusKHR::eError }, + { "NotReady", QueryResultStatusKHR::eNotReady }, + { "Complete", QueryResultStatusKHR::eComplete }, +#if defined( VK_ENABLE_BETA_EXTENSIONS ) + { "InsufficientBitstreamBufferRange", QueryResultStatusKHR::eInsufficientBitstreamBufferRange }, +#endif /*VK_ENABLE_BETA_EXTENSIONS*/ + + }; + + std::unordered_map VideoSessionParametersCreateFlagBitsKHREntries = { + + }; + + std::unordered_map VideoBeginCodingFlagBitsKHREntries = { + + }; + + std::unordered_map VideoEndCodingFlagBitsKHREntries = { + + }; + + //=== VK_KHR_video_decode_queue === + + std::unordered_map VideoDecodeCapabilityFlagBitsKHREntries = { + { "DpbAndOutputCoincide", VideoDecodeCapabilityFlagBitsKHR::eDpbAndOutputCoincide }, + { "DpbAndOutputDistinct", VideoDecodeCapabilityFlagBitsKHR::eDpbAndOutputDistinct }, + + }; + + std::unordered_map VideoDecodeUsageFlagBitsKHREntries = { + { "Default", VideoDecodeUsageFlagBitsKHR::eDefault }, + { "Transcoding", VideoDecodeUsageFlagBitsKHR::eTranscoding }, + { "Offline", VideoDecodeUsageFlagBitsKHR::eOffline }, + { "Streaming", VideoDecodeUsageFlagBitsKHR::eStreaming }, + + }; + + std::unordered_map VideoDecodeFlagBitsKHREntries = { + + }; + + //=== VK_EXT_transform_feedback === + + std::unordered_map PipelineRasterizationStateStreamCreateFlagBitsEXTEntries = { + + }; + +#if defined( VK_ENABLE_BETA_EXTENSIONS ) + //=== VK_EXT_video_encode_h264 === + + std::unordered_map VideoEncodeH264CapabilityFlagBitsEXTEntries = { + { "HrdCompliance", VideoEncodeH264CapabilityFlagBitsEXT::eHrdCompliance }, + { "PredictionWeightTableGenerated", VideoEncodeH264CapabilityFlagBitsEXT::ePredictionWeightTableGenerated }, + { "RowUnalignedSlice", VideoEncodeH264CapabilityFlagBitsEXT::eRowUnalignedSlice }, + { "DifferentSliceType", VideoEncodeH264CapabilityFlagBitsEXT::eDifferentSliceType }, + { "BFrameInL0List", VideoEncodeH264CapabilityFlagBitsEXT::eBFrameInL0List }, + { "BFrameInL1List", VideoEncodeH264CapabilityFlagBitsEXT::eBFrameInL1List }, + { "PerPictureTypeMinMaxQp", VideoEncodeH264CapabilityFlagBitsEXT::ePerPictureTypeMinMaxQp }, + { "PerSliceConstantQp", VideoEncodeH264CapabilityFlagBitsEXT::ePerSliceConstantQp }, + { "GeneratePrefixNalu", VideoEncodeH264CapabilityFlagBitsEXT::eGeneratePrefixNalu }, + + }; + + std::unordered_map VideoEncodeH264StdFlagBitsEXTEntries = { + { "SeparateColorPlaneFlagSet", VideoEncodeH264StdFlagBitsEXT::eSeparateColorPlaneFlagSet }, + { "QpprimeYZeroTransformBypassFlagSet", VideoEncodeH264StdFlagBitsEXT::eQpprimeYZeroTransformBypassFlagSet }, + { "ScalingMatrixPresentFlagSet", VideoEncodeH264StdFlagBitsEXT::eScalingMatrixPresentFlagSet }, + { "ChromaQpIndexOffset", VideoEncodeH264StdFlagBitsEXT::eChromaQpIndexOffset }, + { "SecondChromaQpIndexOffset", VideoEncodeH264StdFlagBitsEXT::eSecondChromaQpIndexOffset }, + { "PicInitQpMinus26", VideoEncodeH264StdFlagBitsEXT::ePicInitQpMinus26 }, + { "WeightedPredFlagSet", VideoEncodeH264StdFlagBitsEXT::eWeightedPredFlagSet }, + { "WeightedBipredIdcExplicit", VideoEncodeH264StdFlagBitsEXT::eWeightedBipredIdcExplicit }, + { "WeightedBipredIdcImplicit", VideoEncodeH264StdFlagBitsEXT::eWeightedBipredIdcImplicit }, + { "Transform8X8ModeFlagSet", VideoEncodeH264StdFlagBitsEXT::eTransform8X8ModeFlagSet }, + { "DirectSpatialMvPredFlagUnset", VideoEncodeH264StdFlagBitsEXT::eDirectSpatialMvPredFlagUnset }, + { "EntropyCodingModeFlagUnset", VideoEncodeH264StdFlagBitsEXT::eEntropyCodingModeFlagUnset }, + { "EntropyCodingModeFlagSet", VideoEncodeH264StdFlagBitsEXT::eEntropyCodingModeFlagSet }, + { "Direct8X8InferenceFlagUnset", VideoEncodeH264StdFlagBitsEXT::eDirect8X8InferenceFlagUnset }, + { "ConstrainedIntraPredFlagSet", VideoEncodeH264StdFlagBitsEXT::eConstrainedIntraPredFlagSet }, + { "DeblockingFilterDisabled", VideoEncodeH264StdFlagBitsEXT::eDeblockingFilterDisabled }, + { "DeblockingFilterEnabled", VideoEncodeH264StdFlagBitsEXT::eDeblockingFilterEnabled }, + { "DeblockingFilterPartial", VideoEncodeH264StdFlagBitsEXT::eDeblockingFilterPartial }, + { "SliceQpDelta", VideoEncodeH264StdFlagBitsEXT::eSliceQpDelta }, + { "DifferentSliceQpDelta", VideoEncodeH264StdFlagBitsEXT::eDifferentSliceQpDelta }, + + }; + + std::unordered_map VideoEncodeH264RateControlFlagBitsEXTEntries = { + { "AttemptHrdCompliance", VideoEncodeH264RateControlFlagBitsEXT::eAttemptHrdCompliance }, + { "RegularGop", VideoEncodeH264RateControlFlagBitsEXT::eRegularGop }, + { "ReferencePatternFlat", VideoEncodeH264RateControlFlagBitsEXT::eReferencePatternFlat }, + { "ReferencePatternDyadic", VideoEncodeH264RateControlFlagBitsEXT::eReferencePatternDyadic }, + { "TemporalLayerPatternDyadic", VideoEncodeH264RateControlFlagBitsEXT::eTemporalLayerPatternDyadic }, + + }; +#endif /*VK_ENABLE_BETA_EXTENSIONS*/ + +#if defined( VK_ENABLE_BETA_EXTENSIONS ) + //=== VK_EXT_video_encode_h265 === + + std::unordered_map VideoEncodeH265CapabilityFlagBitsEXTEntries = { + { "HrdCompliance", VideoEncodeH265CapabilityFlagBitsEXT::eHrdCompliance }, + { "PredictionWeightTableGenerated", VideoEncodeH265CapabilityFlagBitsEXT::ePredictionWeightTableGenerated }, + { "RowUnalignedSliceSegment", VideoEncodeH265CapabilityFlagBitsEXT::eRowUnalignedSliceSegment }, + { "DifferentSliceSegmentType", VideoEncodeH265CapabilityFlagBitsEXT::eDifferentSliceSegmentType }, + { "BFrameInL0List", VideoEncodeH265CapabilityFlagBitsEXT::eBFrameInL0List }, + { "BFrameInL1List", VideoEncodeH265CapabilityFlagBitsEXT::eBFrameInL1List }, + { "PerPictureTypeMinMaxQp", VideoEncodeH265CapabilityFlagBitsEXT::ePerPictureTypeMinMaxQp }, + { "PerSliceSegmentConstantQp", VideoEncodeH265CapabilityFlagBitsEXT::ePerSliceSegmentConstantQp }, + { "MultipleTilesPerSliceSegment", VideoEncodeH265CapabilityFlagBitsEXT::eMultipleTilesPerSliceSegment }, + { "MultipleSliceSegmentsPerTile", VideoEncodeH265CapabilityFlagBitsEXT::eMultipleSliceSegmentsPerTile }, + + }; + + std::unordered_map VideoEncodeH265StdFlagBitsEXTEntries = { + { "SeparateColorPlaneFlagSet", VideoEncodeH265StdFlagBitsEXT::eSeparateColorPlaneFlagSet }, + { "SampleAdaptiveOffsetEnabledFlagSet", VideoEncodeH265StdFlagBitsEXT::eSampleAdaptiveOffsetEnabledFlagSet }, + { "ScalingListDataPresentFlagSet", VideoEncodeH265StdFlagBitsEXT::eScalingListDataPresentFlagSet }, + { "PcmEnabledFlagSet", VideoEncodeH265StdFlagBitsEXT::ePcmEnabledFlagSet }, + { "SpsTemporalMvpEnabledFlagSet", VideoEncodeH265StdFlagBitsEXT::eSpsTemporalMvpEnabledFlagSet }, + { "InitQpMinus26", VideoEncodeH265StdFlagBitsEXT::eInitQpMinus26 }, + { "WeightedPredFlagSet", VideoEncodeH265StdFlagBitsEXT::eWeightedPredFlagSet }, + { "WeightedBipredFlagSet", VideoEncodeH265StdFlagBitsEXT::eWeightedBipredFlagSet }, + { "Log2ParallelMergeLevelMinus2", VideoEncodeH265StdFlagBitsEXT::eLog2ParallelMergeLevelMinus2 }, + { "SignDataHidingEnabledFlagSet", VideoEncodeH265StdFlagBitsEXT::eSignDataHidingEnabledFlagSet }, + { "TransformSkipEnabledFlagSet", VideoEncodeH265StdFlagBitsEXT::eTransformSkipEnabledFlagSet }, + { "TransformSkipEnabledFlagUnset", VideoEncodeH265StdFlagBitsEXT::eTransformSkipEnabledFlagUnset }, + { "PpsSliceChromaQpOffsetsPresentFlagSet", VideoEncodeH265StdFlagBitsEXT::ePpsSliceChromaQpOffsetsPresentFlagSet }, + { "TransquantBypassEnabledFlagSet", VideoEncodeH265StdFlagBitsEXT::eTransquantBypassEnabledFlagSet }, + { "ConstrainedIntraPredFlagSet", VideoEncodeH265StdFlagBitsEXT::eConstrainedIntraPredFlagSet }, + { "EntropyCodingSyncEnabledFlagSet", VideoEncodeH265StdFlagBitsEXT::eEntropyCodingSyncEnabledFlagSet }, + { "DeblockingFilterOverrideEnabledFlagSet", VideoEncodeH265StdFlagBitsEXT::eDeblockingFilterOverrideEnabledFlagSet }, + { "DependentSliceSegmentsEnabledFlagSet", VideoEncodeH265StdFlagBitsEXT::eDependentSliceSegmentsEnabledFlagSet }, + { "DependentSliceSegmentFlagSet", VideoEncodeH265StdFlagBitsEXT::eDependentSliceSegmentFlagSet }, + { "SliceQpDelta", VideoEncodeH265StdFlagBitsEXT::eSliceQpDelta }, + { "DifferentSliceQpDelta", VideoEncodeH265StdFlagBitsEXT::eDifferentSliceQpDelta }, + + }; + + std::unordered_map VideoEncodeH265CtbSizeFlagBitsEXTEntries = { + { "16", VideoEncodeH265CtbSizeFlagBitsEXT::e16 }, + { "32", VideoEncodeH265CtbSizeFlagBitsEXT::e32 }, + { "64", VideoEncodeH265CtbSizeFlagBitsEXT::e64 }, + + }; + + std::unordered_map VideoEncodeH265TransformBlockSizeFlagBitsEXTEntries = { + { "4", VideoEncodeH265TransformBlockSizeFlagBitsEXT::e4 }, + { "8", VideoEncodeH265TransformBlockSizeFlagBitsEXT::e8 }, + { "16", VideoEncodeH265TransformBlockSizeFlagBitsEXT::e16 }, + { "32", VideoEncodeH265TransformBlockSizeFlagBitsEXT::e32 }, + + }; + + std::unordered_map VideoEncodeH265RateControlFlagBitsEXTEntries = { + { "AttemptHrdCompliance", VideoEncodeH265RateControlFlagBitsEXT::eAttemptHrdCompliance }, + { "RegularGop", VideoEncodeH265RateControlFlagBitsEXT::eRegularGop }, + { "ReferencePatternFlat", VideoEncodeH265RateControlFlagBitsEXT::eReferencePatternFlat }, + { "ReferencePatternDyadic", VideoEncodeH265RateControlFlagBitsEXT::eReferencePatternDyadic }, + { "TemporalSubLayerPatternDyadic", VideoEncodeH265RateControlFlagBitsEXT::eTemporalSubLayerPatternDyadic }, + + }; +#endif /*VK_ENABLE_BETA_EXTENSIONS*/ + + //=== VK_KHR_video_decode_h264 === + + std::unordered_map VideoDecodeH264PictureLayoutFlagBitsKHREntries = { + { "Progressive", VideoDecodeH264PictureLayoutFlagBitsKHR::eProgressive }, + { "InterlacedInterleavedLines", VideoDecodeH264PictureLayoutFlagBitsKHR::eInterlacedInterleavedLines }, + { "InterlacedSeparatePlanes", VideoDecodeH264PictureLayoutFlagBitsKHR::eInterlacedSeparatePlanes }, + + }; + + //=== VK_AMD_shader_info === + + std::unordered_map ShaderInfoTypeAMDEntries = { + { "Statistics", ShaderInfoTypeAMD::eStatistics }, + { "Binary", ShaderInfoTypeAMD::eBinary }, + { "Disassembly", ShaderInfoTypeAMD::eDisassembly }, + + }; + +#if defined( VK_USE_PLATFORM_GGP ) + //=== VK_GGP_stream_descriptor_surface === + + std::unordered_map StreamDescriptorSurfaceCreateFlagBitsGGPEntries = { + + }; +#endif /*VK_USE_PLATFORM_GGP*/ + + //=== VK_NV_external_memory_capabilities === + + std::unordered_map ExternalMemoryHandleTypeFlagBitsNVEntries = { + { "OpaqueWin32", ExternalMemoryHandleTypeFlagBitsNV::eOpaqueWin32 }, + { "OpaqueWin32Kmt", ExternalMemoryHandleTypeFlagBitsNV::eOpaqueWin32Kmt }, + { "D3D11Image", ExternalMemoryHandleTypeFlagBitsNV::eD3D11Image }, + { "D3D11ImageKmt", ExternalMemoryHandleTypeFlagBitsNV::eD3D11ImageKmt }, + + }; + + std::unordered_map ExternalMemoryFeatureFlagBitsNVEntries = { + { "DedicatedOnly", ExternalMemoryFeatureFlagBitsNV::eDedicatedOnly }, + { "Exportable", ExternalMemoryFeatureFlagBitsNV::eExportable }, + { "Importable", ExternalMemoryFeatureFlagBitsNV::eImportable }, + + }; + + //=== VK_EXT_validation_flags === + + std::unordered_map ValidationCheckEXTEntries = { + { "All", ValidationCheckEXT::eAll }, + { "Shaders", ValidationCheckEXT::eShaders }, + + }; + +#if defined( VK_USE_PLATFORM_VI_NN ) + //=== VK_NN_vi_surface === + + std::unordered_map ViSurfaceCreateFlagBitsNNEntries = { + + }; +#endif /*VK_USE_PLATFORM_VI_NN*/ + + //=== VK_EXT_pipeline_robustness === + + std::unordered_map PipelineRobustnessBufferBehaviorEXTEntries = { + { "DeviceDefault", PipelineRobustnessBufferBehaviorEXT::eDeviceDefault }, + { "Disabled", PipelineRobustnessBufferBehaviorEXT::eDisabled }, + { "RobustBufferAccess", PipelineRobustnessBufferBehaviorEXT::eRobustBufferAccess }, + { "RobustBufferAccess2", PipelineRobustnessBufferBehaviorEXT::eRobustBufferAccess2 }, + + }; + + std::unordered_map PipelineRobustnessImageBehaviorEXTEntries = { + { "DeviceDefault", PipelineRobustnessImageBehaviorEXT::eDeviceDefault }, + { "Disabled", PipelineRobustnessImageBehaviorEXT::eDisabled }, + { "RobustImageAccess", PipelineRobustnessImageBehaviorEXT::eRobustImageAccess }, + { "RobustImageAccess2", PipelineRobustnessImageBehaviorEXT::eRobustImageAccess2 }, + + }; + + //=== VK_EXT_conditional_rendering === + + std::unordered_map ConditionalRenderingFlagBitsEXTEntries = { + { "Inverted", ConditionalRenderingFlagBitsEXT::eInverted }, + + }; + + //=== VK_EXT_display_surface_counter === + + std::unordered_map SurfaceCounterFlagBitsEXTEntries = { + { "Vblank", SurfaceCounterFlagBitsEXT::eVblank }, + + }; + + //=== VK_EXT_display_control === + + std::unordered_map DisplayPowerStateEXTEntries = { + { "Off", DisplayPowerStateEXT::eOff }, + { "Suspend", DisplayPowerStateEXT::eSuspend }, + { "On", DisplayPowerStateEXT::eOn }, + + }; + + std::unordered_map DeviceEventTypeEXTEntries = { + { "DisplayHotplug", DeviceEventTypeEXT::eDisplayHotplug }, + + }; + + std::unordered_map DisplayEventTypeEXTEntries = { + { "FirstPixelOut", DisplayEventTypeEXT::eFirstPixelOut }, + + }; + + //=== VK_NV_viewport_swizzle === + + std::unordered_map ViewportCoordinateSwizzleNVEntries = { + { "PositiveX", ViewportCoordinateSwizzleNV::ePositiveX }, { "NegativeX", ViewportCoordinateSwizzleNV::eNegativeX }, + { "PositiveY", ViewportCoordinateSwizzleNV::ePositiveY }, { "NegativeY", ViewportCoordinateSwizzleNV::eNegativeY }, + { "PositiveZ", ViewportCoordinateSwizzleNV::ePositiveZ }, { "NegativeZ", ViewportCoordinateSwizzleNV::eNegativeZ }, + { "PositiveW", ViewportCoordinateSwizzleNV::ePositiveW }, { "NegativeW", ViewportCoordinateSwizzleNV::eNegativeW }, + + }; + + std::unordered_map PipelineViewportSwizzleStateCreateFlagBitsNVEntries = { + + }; + + //=== VK_EXT_discard_rectangles === + + std::unordered_map DiscardRectangleModeEXTEntries = { + { "Inclusive", DiscardRectangleModeEXT::eInclusive }, + { "Exclusive", DiscardRectangleModeEXT::eExclusive }, + + }; + + std::unordered_map PipelineDiscardRectangleStateCreateFlagBitsEXTEntries = { + + }; + + //=== VK_EXT_conservative_rasterization === + + std::unordered_map ConservativeRasterizationModeEXTEntries = { + { "Disabled", ConservativeRasterizationModeEXT::eDisabled }, + { "Overestimate", ConservativeRasterizationModeEXT::eOverestimate }, + { "Underestimate", ConservativeRasterizationModeEXT::eUnderestimate }, + + }; + + std::unordered_map PipelineRasterizationConservativeStateCreateFlagBitsEXTEntries = { + + }; + + //=== VK_EXT_depth_clip_enable === + + std::unordered_map PipelineRasterizationDepthClipStateCreateFlagBitsEXTEntries = { + + }; + + //=== VK_KHR_performance_query === + + std::unordered_map PerformanceCounterDescriptionFlagBitsKHREntries = { + { "PerformanceImpacting", PerformanceCounterDescriptionFlagBitsKHR::ePerformanceImpacting }, + { "ConcurrentlyImpacted", PerformanceCounterDescriptionFlagBitsKHR::eConcurrentlyImpacted }, + + }; + + std::unordered_map PerformanceCounterScopeKHREntries = { + { "CommandBuffer", PerformanceCounterScopeKHR::eCommandBuffer }, + { "RenderPass", PerformanceCounterScopeKHR::eRenderPass }, + { "Command", PerformanceCounterScopeKHR::eCommand }, + + }; + + std::unordered_map PerformanceCounterStorageKHREntries = { + { "Int32", PerformanceCounterStorageKHR::eInt32 }, { "Int64", PerformanceCounterStorageKHR::eInt64 }, + { "Uint32", PerformanceCounterStorageKHR::eUint32 }, { "Uint64", PerformanceCounterStorageKHR::eUint64 }, + { "Float32", PerformanceCounterStorageKHR::eFloat32 }, { "Float64", PerformanceCounterStorageKHR::eFloat64 }, + + }; + + std::unordered_map PerformanceCounterUnitKHREntries = { + { "Generic", PerformanceCounterUnitKHR::eGeneric }, + { "Percentage", PerformanceCounterUnitKHR::ePercentage }, + { "Nanoseconds", PerformanceCounterUnitKHR::eNanoseconds }, + { "Bytes", PerformanceCounterUnitKHR::eBytes }, + { "BytesPerSecond", PerformanceCounterUnitKHR::eBytesPerSecond }, + { "Kelvin", PerformanceCounterUnitKHR::eKelvin }, + { "Watts", PerformanceCounterUnitKHR::eWatts }, + { "Volts", PerformanceCounterUnitKHR::eVolts }, + { "Amps", PerformanceCounterUnitKHR::eAmps }, + { "Hertz", PerformanceCounterUnitKHR::eHertz }, + { "Cycles", PerformanceCounterUnitKHR::eCycles }, + + }; + + std::unordered_map AcquireProfilingLockFlagBitsKHREntries = { + + }; + +#if defined( VK_USE_PLATFORM_IOS_MVK ) + //=== VK_MVK_ios_surface === + + std::unordered_map IOSSurfaceCreateFlagBitsMVKEntries = { + + }; +#endif /*VK_USE_PLATFORM_IOS_MVK*/ + +#if defined( VK_USE_PLATFORM_MACOS_MVK ) + //=== VK_MVK_macos_surface === + + std::unordered_map MacOSSurfaceCreateFlagBitsMVKEntries = { + + }; +#endif /*VK_USE_PLATFORM_MACOS_MVK*/ + + //=== VK_EXT_debug_utils === + + std::unordered_map DebugUtilsMessageSeverityFlagBitsEXTEntries = { + { "Verbose", DebugUtilsMessageSeverityFlagBitsEXT::eVerbose }, + { "Info", DebugUtilsMessageSeverityFlagBitsEXT::eInfo }, + { "Warning", DebugUtilsMessageSeverityFlagBitsEXT::eWarning }, + { "Error", DebugUtilsMessageSeverityFlagBitsEXT::eError }, + + }; + + std::unordered_map DebugUtilsMessageTypeFlagBitsEXTEntries = { + { "General", DebugUtilsMessageTypeFlagBitsEXT::eGeneral }, + { "Validation", DebugUtilsMessageTypeFlagBitsEXT::eValidation }, + { "Performance", DebugUtilsMessageTypeFlagBitsEXT::ePerformance }, + { "DeviceAddressBinding", DebugUtilsMessageTypeFlagBitsEXT::eDeviceAddressBinding }, + + }; + + std::unordered_map DebugUtilsMessengerCallbackDataFlagBitsEXTEntries = { + + }; + + std::unordered_map DebugUtilsMessengerCreateFlagBitsEXTEntries = { + + }; + + //=== VK_EXT_blend_operation_advanced === + + std::unordered_map BlendOverlapEXTEntries = { + { "Uncorrelated", BlendOverlapEXT::eUncorrelated }, + { "Disjoint", BlendOverlapEXT::eDisjoint }, + { "Conjoint", BlendOverlapEXT::eConjoint }, + + }; + + //=== VK_NV_fragment_coverage_to_color === + + std::unordered_map PipelineCoverageToColorStateCreateFlagBitsNVEntries = { + + }; + + //=== VK_KHR_acceleration_structure === + + std::unordered_map AccelerationStructureTypeKHREntries = { + { "TopLevel", AccelerationStructureTypeKHR::eTopLevel }, + { "BottomLevel", AccelerationStructureTypeKHR::eBottomLevel }, + { "Generic", AccelerationStructureTypeKHR::eGeneric }, + + }; + + std::unordered_map AccelerationStructureBuildTypeKHREntries = { + { "Host", AccelerationStructureBuildTypeKHR::eHost }, + { "Device", AccelerationStructureBuildTypeKHR::eDevice }, + { "HostOrDevice", AccelerationStructureBuildTypeKHR::eHostOrDevice }, + + }; + + std::unordered_map GeometryFlagBitsKHREntries = { + { "Opaque", GeometryFlagBitsKHR::eOpaque }, + { "NoDuplicateAnyHitInvocation", GeometryFlagBitsKHR::eNoDuplicateAnyHitInvocation }, + + }; + + std::unordered_map GeometryInstanceFlagBitsKHREntries = { + { "TriangleFacingCullDisable", GeometryInstanceFlagBitsKHR::eTriangleFacingCullDisable }, + { "TriangleFlipFacing", GeometryInstanceFlagBitsKHR::eTriangleFlipFacing }, + { "ForceOpaque", GeometryInstanceFlagBitsKHR::eForceOpaque }, + { "ForceNoOpaque", GeometryInstanceFlagBitsKHR::eForceNoOpaque }, + { "ForceOpacityMicromap2StateEXT", GeometryInstanceFlagBitsKHR::eForceOpacityMicromap2StateEXT }, + { "DisableOpacityMicromapsEXT", GeometryInstanceFlagBitsKHR::eDisableOpacityMicromapsEXT }, + + }; + + std::unordered_map BuildAccelerationStructureFlagBitsKHREntries = { + { "AllowUpdate", BuildAccelerationStructureFlagBitsKHR::eAllowUpdate }, + { "AllowCompaction", BuildAccelerationStructureFlagBitsKHR::eAllowCompaction }, + { "PreferFastTrace", BuildAccelerationStructureFlagBitsKHR::ePreferFastTrace }, + { "PreferFastBuild", BuildAccelerationStructureFlagBitsKHR::ePreferFastBuild }, + { "LowMemory", BuildAccelerationStructureFlagBitsKHR::eLowMemory }, + { "MotionNV", BuildAccelerationStructureFlagBitsKHR::eMotionNV }, + { "AllowOpacityMicromapUpdateEXT", BuildAccelerationStructureFlagBitsKHR::eAllowOpacityMicromapUpdateEXT }, + { "AllowDisableOpacityMicromapsEXT", BuildAccelerationStructureFlagBitsKHR::eAllowDisableOpacityMicromapsEXT }, + { "AllowOpacityMicromapDataUpdateEXT", BuildAccelerationStructureFlagBitsKHR::eAllowOpacityMicromapDataUpdateEXT }, +#if defined( VK_ENABLE_BETA_EXTENSIONS ) + { "AllowDisplacementMicromapUpdateNV", BuildAccelerationStructureFlagBitsKHR::eAllowDisplacementMicromapUpdateNV }, +#endif /*VK_ENABLE_BETA_EXTENSIONS*/ + { "AllowDataAccess", BuildAccelerationStructureFlagBitsKHR::eAllowDataAccess }, + + }; + + std::unordered_map CopyAccelerationStructureModeKHREntries = { + { "Clone", CopyAccelerationStructureModeKHR::eClone }, + { "Compact", CopyAccelerationStructureModeKHR::eCompact }, + { "Serialize", CopyAccelerationStructureModeKHR::eSerialize }, + { "Deserialize", CopyAccelerationStructureModeKHR::eDeserialize }, + + }; + + std::unordered_map GeometryTypeKHREntries = { + { "Triangles", GeometryTypeKHR::eTriangles }, + { "Aabbs", GeometryTypeKHR::eAabbs }, + { "Instances", GeometryTypeKHR::eInstances }, + + }; + + std::unordered_map AccelerationStructureCompatibilityKHREntries = { + { "Compatible", AccelerationStructureCompatibilityKHR::eCompatible }, + { "Incompatible", AccelerationStructureCompatibilityKHR::eIncompatible }, + + }; + + std::unordered_map AccelerationStructureCreateFlagBitsKHREntries = { + { "DeviceAddressCaptureReplay", AccelerationStructureCreateFlagBitsKHR::eDeviceAddressCaptureReplay }, + { "DescriptorBufferCaptureReplayEXT", AccelerationStructureCreateFlagBitsKHR::eDescriptorBufferCaptureReplayEXT }, + { "MotionNV", AccelerationStructureCreateFlagBitsKHR::eMotionNV }, + + }; + + std::unordered_map BuildAccelerationStructureModeKHREntries = { + { "Build", BuildAccelerationStructureModeKHR::eBuild }, + { "Update", BuildAccelerationStructureModeKHR::eUpdate }, + + }; + + //=== VK_KHR_ray_tracing_pipeline === + + std::unordered_map RayTracingShaderGroupTypeKHREntries = { + { "General", RayTracingShaderGroupTypeKHR::eGeneral }, + { "TrianglesHitGroup", RayTracingShaderGroupTypeKHR::eTrianglesHitGroup }, + { "ProceduralHitGroup", RayTracingShaderGroupTypeKHR::eProceduralHitGroup }, + + }; + + std::unordered_map ShaderGroupShaderKHREntries = { + { "General", ShaderGroupShaderKHR::eGeneral }, + { "ClosestHit", ShaderGroupShaderKHR::eClosestHit }, + { "AnyHit", ShaderGroupShaderKHR::eAnyHit }, + { "Intersection", ShaderGroupShaderKHR::eIntersection }, + + }; + + //=== VK_NV_framebuffer_mixed_samples === + + std::unordered_map CoverageModulationModeNVEntries = { + { "None", CoverageModulationModeNV::eNone }, + { "Rgb", CoverageModulationModeNV::eRgb }, + { "Alpha", CoverageModulationModeNV::eAlpha }, + { "Rgba", CoverageModulationModeNV::eRgba }, + + }; + + std::unordered_map PipelineCoverageModulationStateCreateFlagBitsNVEntries = { + + }; + + //=== VK_EXT_validation_cache === + + std::unordered_map ValidationCacheHeaderVersionEXTEntries = { + { "One", ValidationCacheHeaderVersionEXT::eOne }, + + }; + + std::unordered_map ValidationCacheCreateFlagBitsEXTEntries = { + + }; + + //=== VK_NV_shading_rate_image === + + std::unordered_map ShadingRatePaletteEntryNVEntries = { + { "NoInvocations", ShadingRatePaletteEntryNV::eNoInvocations }, + { "16InvocationsPerPixel", ShadingRatePaletteEntryNV::e16InvocationsPerPixel }, + { "8InvocationsPerPixel", ShadingRatePaletteEntryNV::e8InvocationsPerPixel }, + { "4InvocationsPerPixel", ShadingRatePaletteEntryNV::e4InvocationsPerPixel }, + { "2InvocationsPerPixel", ShadingRatePaletteEntryNV::e2InvocationsPerPixel }, + { "1InvocationPerPixel", ShadingRatePaletteEntryNV::e1InvocationPerPixel }, + { "1InvocationPer2X1Pixels", ShadingRatePaletteEntryNV::e1InvocationPer2X1Pixels }, + { "1InvocationPer1X2Pixels", ShadingRatePaletteEntryNV::e1InvocationPer1X2Pixels }, + { "1InvocationPer2X2Pixels", ShadingRatePaletteEntryNV::e1InvocationPer2X2Pixels }, + { "1InvocationPer4X2Pixels", ShadingRatePaletteEntryNV::e1InvocationPer4X2Pixels }, + { "1InvocationPer2X4Pixels", ShadingRatePaletteEntryNV::e1InvocationPer2X4Pixels }, + { "1InvocationPer4X4Pixels", ShadingRatePaletteEntryNV::e1InvocationPer4X4Pixels }, + + }; + + std::unordered_map CoarseSampleOrderTypeNVEntries = { + { "Default", CoarseSampleOrderTypeNV::eDefault }, + { "Custom", CoarseSampleOrderTypeNV::eCustom }, + { "PixelMajor", CoarseSampleOrderTypeNV::ePixelMajor }, + { "SampleMajor", CoarseSampleOrderTypeNV::eSampleMajor }, + + }; + + //=== VK_NV_ray_tracing === + + std::unordered_map AccelerationStructureMemoryRequirementsTypeNVEntries = { + { "Object", AccelerationStructureMemoryRequirementsTypeNV::eObject }, + { "BuildScratch", AccelerationStructureMemoryRequirementsTypeNV::eBuildScratch }, + { "UpdateScratch", AccelerationStructureMemoryRequirementsTypeNV::eUpdateScratch }, + + }; + + //=== VK_AMD_pipeline_compiler_control === + + std::unordered_map PipelineCompilerControlFlagBitsAMDEntries = { + + }; + + //=== VK_EXT_calibrated_timestamps === + + std::unordered_map TimeDomainEXTEntries = { + { "Device", TimeDomainEXT::eDevice }, + { "ClockMonotonic", TimeDomainEXT::eClockMonotonic }, + { "ClockMonotonicRaw", TimeDomainEXT::eClockMonotonicRaw }, + { "QueryPerformanceCounter", TimeDomainEXT::eQueryPerformanceCounter }, + + }; + + //=== VK_KHR_global_priority === + + std::unordered_map QueueGlobalPriorityKHREntries = { + { "Low", QueueGlobalPriorityKHR::eLow }, + { "Medium", QueueGlobalPriorityKHR::eMedium }, + { "High", QueueGlobalPriorityKHR::eHigh }, + { "Realtime", QueueGlobalPriorityKHR::eRealtime }, + + }; + + //=== VK_AMD_memory_overallocation_behavior === + + std::unordered_map MemoryOverallocationBehaviorAMDEntries = { + { "Default", MemoryOverallocationBehaviorAMD::eDefault }, + { "Allowed", MemoryOverallocationBehaviorAMD::eAllowed }, + { "Disallowed", MemoryOverallocationBehaviorAMD::eDisallowed }, + + }; + + //=== VK_INTEL_performance_query === + + std::unordered_map PerformanceConfigurationTypeINTELEntries = { + { "CommandQueueMetricsDiscoveryActivated", PerformanceConfigurationTypeINTEL::eCommandQueueMetricsDiscoveryActivated }, + + }; + + std::unordered_map QueryPoolSamplingModeINTELEntries = { + { "Manual", QueryPoolSamplingModeINTEL::eManual }, + + }; + + std::unordered_map PerformanceOverrideTypeINTELEntries = { + { "NullHardware", PerformanceOverrideTypeINTEL::eNullHardware }, + { "FlushGpuCaches", PerformanceOverrideTypeINTEL::eFlushGpuCaches }, + + }; + + std::unordered_map PerformanceParameterTypeINTELEntries = { + { "HwCountersSupported", PerformanceParameterTypeINTEL::eHwCountersSupported }, + { "StreamMarkerValidBits", PerformanceParameterTypeINTEL::eStreamMarkerValidBits }, + + }; + + std::unordered_map PerformanceValueTypeINTELEntries = { + { "Uint32", PerformanceValueTypeINTEL::eUint32 }, { "Uint64", PerformanceValueTypeINTEL::eUint64 }, { "Float", PerformanceValueTypeINTEL::eFloat }, + { "Bool", PerformanceValueTypeINTEL::eBool }, { "String", PerformanceValueTypeINTEL::eString }, + + }; + +#if defined( VK_USE_PLATFORM_FUCHSIA ) + //=== VK_FUCHSIA_imagepipe_surface === + + std::unordered_map ImagePipeSurfaceCreateFlagBitsFUCHSIAEntries = { + + }; +#endif /*VK_USE_PLATFORM_FUCHSIA*/ + +#if defined( VK_USE_PLATFORM_METAL_EXT ) + //=== VK_EXT_metal_surface === + + std::unordered_map MetalSurfaceCreateFlagBitsEXTEntries = { + + }; +#endif /*VK_USE_PLATFORM_METAL_EXT*/ + + //=== VK_KHR_fragment_shading_rate === + + std::unordered_map FragmentShadingRateCombinerOpKHREntries = { + { "Keep", FragmentShadingRateCombinerOpKHR::eKeep }, { "Replace", FragmentShadingRateCombinerOpKHR::eReplace }, + { "Min", FragmentShadingRateCombinerOpKHR::eMin }, { "Max", FragmentShadingRateCombinerOpKHR::eMax }, + { "Mul", FragmentShadingRateCombinerOpKHR::eMul }, + + }; + + //=== VK_AMD_shader_core_properties2 === + + std::unordered_map ShaderCorePropertiesFlagBitsAMDEntries = { + + }; + + //=== VK_EXT_validation_features === + + std::unordered_map ValidationFeatureEnableEXTEntries = { + { "GpuAssisted", ValidationFeatureEnableEXT::eGpuAssisted }, + { "GpuAssistedReserveBindingSlot", ValidationFeatureEnableEXT::eGpuAssistedReserveBindingSlot }, + { "BestPractices", ValidationFeatureEnableEXT::eBestPractices }, + { "DebugPrintf", ValidationFeatureEnableEXT::eDebugPrintf }, + { "SynchronizationValidation", ValidationFeatureEnableEXT::eSynchronizationValidation }, + + }; + + std::unordered_map ValidationFeatureDisableEXTEntries = { + { "All", ValidationFeatureDisableEXT::eAll }, + { "Shaders", ValidationFeatureDisableEXT::eShaders }, + { "ThreadSafety", ValidationFeatureDisableEXT::eThreadSafety }, + { "ApiParameters", ValidationFeatureDisableEXT::eApiParameters }, + { "ObjectLifetimes", ValidationFeatureDisableEXT::eObjectLifetimes }, + { "CoreChecks", ValidationFeatureDisableEXT::eCoreChecks }, + { "UniqueHandles", ValidationFeatureDisableEXT::eUniqueHandles }, + { "ShaderValidationCache", ValidationFeatureDisableEXT::eShaderValidationCache }, + + }; + + //=== VK_NV_coverage_reduction_mode === + + std::unordered_map CoverageReductionModeNVEntries = { + { "Merge", CoverageReductionModeNV::eMerge }, + { "Truncate", CoverageReductionModeNV::eTruncate }, + + }; + + std::unordered_map PipelineCoverageReductionStateCreateFlagBitsNVEntries = { + + }; + + //=== VK_EXT_provoking_vertex === + + std::unordered_map ProvokingVertexModeEXTEntries = { + { "FirstVertex", ProvokingVertexModeEXT::eFirstVertex }, + { "LastVertex", ProvokingVertexModeEXT::eLastVertex }, + + }; + +#if defined( VK_USE_PLATFORM_WIN32_KHR ) + //=== VK_EXT_full_screen_exclusive === + + std::unordered_map FullScreenExclusiveEXTEntries = { + { "Default", FullScreenExclusiveEXT::eDefault }, + { "Allowed", FullScreenExclusiveEXT::eAllowed }, + { "Disallowed", FullScreenExclusiveEXT::eDisallowed }, + { "ApplicationControlled", FullScreenExclusiveEXT::eApplicationControlled }, + + }; +#endif /*VK_USE_PLATFORM_WIN32_KHR*/ + + //=== VK_EXT_headless_surface === + + std::unordered_map HeadlessSurfaceCreateFlagBitsEXTEntries = { + + }; + + //=== VK_EXT_line_rasterization === + + std::unordered_map LineRasterizationModeEXTEntries = { + { "Default", LineRasterizationModeEXT::eDefault }, + { "Rectangular", LineRasterizationModeEXT::eRectangular }, + { "Bresenham", LineRasterizationModeEXT::eBresenham }, + { "RectangularSmooth", LineRasterizationModeEXT::eRectangularSmooth }, + + }; + + //=== VK_KHR_pipeline_executable_properties === + + std::unordered_map PipelineExecutableStatisticFormatKHREntries = { + { "Bool32", PipelineExecutableStatisticFormatKHR::eBool32 }, + { "Int64", PipelineExecutableStatisticFormatKHR::eInt64 }, + { "Uint64", PipelineExecutableStatisticFormatKHR::eUint64 }, + { "Float64", PipelineExecutableStatisticFormatKHR::eFloat64 }, + + }; + + //=== VK_EXT_host_image_copy === + + std::unordered_map HostImageCopyFlagBitsEXTEntries = { + { "Memcpy", HostImageCopyFlagBitsEXT::eMemcpy }, + + }; + + //=== VK_KHR_map_memory2 === + + std::unordered_map MemoryUnmapFlagBitsKHREntries = { + + }; + + //=== VK_EXT_surface_maintenance1 === + + std::unordered_map PresentScalingFlagBitsEXTEntries = { + { "OneToOne", PresentScalingFlagBitsEXT::eOneToOne }, + { "AspectRatioStretch", PresentScalingFlagBitsEXT::eAspectRatioStretch }, + { "Stretch", PresentScalingFlagBitsEXT::eStretch }, + + }; + + std::unordered_map PresentGravityFlagBitsEXTEntries = { + { "Min", PresentGravityFlagBitsEXT::eMin }, + { "Max", PresentGravityFlagBitsEXT::eMax }, + { "Centered", PresentGravityFlagBitsEXT::eCentered }, + + }; + + //=== VK_NV_device_generated_commands === + + std::unordered_map IndirectStateFlagBitsNVEntries = { + { "FlagFrontface", IndirectStateFlagBitsNV::eFlagFrontface }, + + }; + + std::unordered_map IndirectCommandsTokenTypeNVEntries = { + { "ShaderGroup", IndirectCommandsTokenTypeNV::eShaderGroup }, + { "StateFlags", IndirectCommandsTokenTypeNV::eStateFlags }, + { "IndexBuffer", IndirectCommandsTokenTypeNV::eIndexBuffer }, + { "VertexBuffer", IndirectCommandsTokenTypeNV::eVertexBuffer }, + { "PushConstant", IndirectCommandsTokenTypeNV::ePushConstant }, + { "DrawIndexed", IndirectCommandsTokenTypeNV::eDrawIndexed }, + { "Draw", IndirectCommandsTokenTypeNV::eDraw }, + { "DrawTasks", IndirectCommandsTokenTypeNV::eDrawTasks }, + { "DrawMeshTasks", IndirectCommandsTokenTypeNV::eDrawMeshTasks }, + { "Pipeline", IndirectCommandsTokenTypeNV::ePipeline }, + { "Dispatch", IndirectCommandsTokenTypeNV::eDispatch }, + + }; + + std::unordered_map IndirectCommandsLayoutUsageFlagBitsNVEntries = { + { "ExplicitPreprocess", IndirectCommandsLayoutUsageFlagBitsNV::eExplicitPreprocess }, + { "IndexedSequences", IndirectCommandsLayoutUsageFlagBitsNV::eIndexedSequences }, + { "UnorderedSequences", IndirectCommandsLayoutUsageFlagBitsNV::eUnorderedSequences }, + + }; + + //=== VK_EXT_depth_bias_control === + + std::unordered_map DepthBiasRepresentationEXTEntries = { + { "LeastRepresentableValueFormat", DepthBiasRepresentationEXT::eLeastRepresentableValueFormat }, + { "LeastRepresentableValueForceUnorm", DepthBiasRepresentationEXT::eLeastRepresentableValueForceUnorm }, + { "Float", DepthBiasRepresentationEXT::eFloat }, + + }; + + //=== VK_EXT_device_memory_report === + + std::unordered_map DeviceMemoryReportEventTypeEXTEntries = { + { "Allocate", DeviceMemoryReportEventTypeEXT::eAllocate }, + { "Free", DeviceMemoryReportEventTypeEXT::eFree }, + { "Import", DeviceMemoryReportEventTypeEXT::eImport }, + { "Unimport", DeviceMemoryReportEventTypeEXT::eUnimport }, + { "AllocationFailed", DeviceMemoryReportEventTypeEXT::eAllocationFailed }, + + }; + + std::unordered_map DeviceMemoryReportFlagBitsEXTEntries = { + + }; + +#if defined( VK_ENABLE_BETA_EXTENSIONS ) + //=== VK_KHR_video_encode_queue === + + std::unordered_map VideoEncodeCapabilityFlagBitsKHREntries = { + { "PrecedingExternallyEncodedBytes", VideoEncodeCapabilityFlagBitsKHR::ePrecedingExternallyEncodedBytes }, + { "InsufficientstreamBufferRangeDetectionBit", VideoEncodeCapabilityFlagBitsKHR::eInsufficientstreamBufferRangeDetectionBit }, + + }; + + std::unordered_map VideoEncodeFeedbackFlagBitsKHREntries = { + { "streamBufferOffsetBit", VideoEncodeFeedbackFlagBitsKHR::estreamBufferOffsetBit }, + { "streamBytesWrittenBit", VideoEncodeFeedbackFlagBitsKHR::estreamBytesWrittenBit }, + { "streamHasOverridesBit", VideoEncodeFeedbackFlagBitsKHR::estreamHasOverridesBit }, + + }; + + std::unordered_map VideoEncodeUsageFlagBitsKHREntries = { + { "Default", VideoEncodeUsageFlagBitsKHR::eDefault }, { "Transcoding", VideoEncodeUsageFlagBitsKHR::eTranscoding }, + { "Streaming", VideoEncodeUsageFlagBitsKHR::eStreaming }, { "Recording", VideoEncodeUsageFlagBitsKHR::eRecording }, + { "Conferencing", VideoEncodeUsageFlagBitsKHR::eConferencing }, + + }; + + std::unordered_map VideoEncodeContentFlagBitsKHREntries = { + { "Default", VideoEncodeContentFlagBitsKHR::eDefault }, + { "Camera", VideoEncodeContentFlagBitsKHR::eCamera }, + { "Desktop", VideoEncodeContentFlagBitsKHR::eDesktop }, + { "Rendered", VideoEncodeContentFlagBitsKHR::eRendered }, + + }; + + std::unordered_map VideoEncodeTuningModeKHREntries = { + { "Default", VideoEncodeTuningModeKHR::eDefault }, { "HighQuality", VideoEncodeTuningModeKHR::eHighQuality }, + { "LowLatency", VideoEncodeTuningModeKHR::eLowLatency }, { "UltraLowLatency", VideoEncodeTuningModeKHR::eUltraLowLatency }, + { "Lossless", VideoEncodeTuningModeKHR::eLossless }, + + }; + + std::unordered_map VideoEncodeRateControlModeFlagBitsKHREntries = { + { "Default", VideoEncodeRateControlModeFlagBitsKHR::eDefault }, + { "Disabled", VideoEncodeRateControlModeFlagBitsKHR::eDisabled }, + { "Cbr", VideoEncodeRateControlModeFlagBitsKHR::eCbr }, + { "Vbr", VideoEncodeRateControlModeFlagBitsKHR::eVbr }, + + }; + + std::unordered_map VideoEncodeFlagBitsKHREntries = { + + }; + + std::unordered_map VideoEncodeRateControlFlagBitsKHREntries = { + + }; +#endif /*VK_ENABLE_BETA_EXTENSIONS*/ + + //=== VK_NV_device_diagnostics_config === + + std::unordered_map DeviceDiagnosticsConfigFlagBitsNVEntries = { + { "EnableShaderDebugInfo", DeviceDiagnosticsConfigFlagBitsNV::eEnableShaderDebugInfo }, + { "EnableResourceTracking", DeviceDiagnosticsConfigFlagBitsNV::eEnableResourceTracking }, + { "EnableAutomaticCheckpoints", DeviceDiagnosticsConfigFlagBitsNV::eEnableAutomaticCheckpoints }, + { "EnableShaderErrorReporting", DeviceDiagnosticsConfigFlagBitsNV::eEnableShaderErrorReporting }, + + }; + +#if defined( VK_USE_PLATFORM_METAL_EXT ) + //=== VK_EXT_metal_objects === + + std::unordered_map ExportMetalObjectTypeFlagBitsEXTEntries = { + { "MetalDevice", ExportMetalObjectTypeFlagBitsEXT::eMetalDevice }, { "MetalCommandQueue", ExportMetalObjectTypeFlagBitsEXT::eMetalCommandQueue }, + { "MetalBuffer", ExportMetalObjectTypeFlagBitsEXT::eMetalBuffer }, { "MetalTexture", ExportMetalObjectTypeFlagBitsEXT::eMetalTexture }, + { "MetalIosurface", ExportMetalObjectTypeFlagBitsEXT::eMetalIosurface }, { "MetalSharedEvent", ExportMetalObjectTypeFlagBitsEXT::eMetalSharedEvent }, + + }; +#endif /*VK_USE_PLATFORM_METAL_EXT*/ + + //=== VK_EXT_graphics_pipeline_library === + + std::unordered_map GraphicsPipelineLibraryFlagBitsEXTEntries = { + { "VertexInputInterface", GraphicsPipelineLibraryFlagBitsEXT::eVertexInputInterface }, + { "PreRasterizationShaders", GraphicsPipelineLibraryFlagBitsEXT::ePreRasterizationShaders }, + { "FragmentShader", GraphicsPipelineLibraryFlagBitsEXT::eFragmentShader }, + { "FragmentOutputInterface", GraphicsPipelineLibraryFlagBitsEXT::eFragmentOutputInterface }, + + }; + + //=== VK_NV_fragment_shading_rate_enums === + + std::unordered_map FragmentShadingRateNVEntries = { + { "1InvocationPerPixel", FragmentShadingRateNV::e1InvocationPerPixel }, + { "1InvocationPer1X2Pixels", FragmentShadingRateNV::e1InvocationPer1X2Pixels }, + { "1InvocationPer2X1Pixels", FragmentShadingRateNV::e1InvocationPer2X1Pixels }, + { "1InvocationPer2X2Pixels", FragmentShadingRateNV::e1InvocationPer2X2Pixels }, + { "1InvocationPer2X4Pixels", FragmentShadingRateNV::e1InvocationPer2X4Pixels }, + { "1InvocationPer4X2Pixels", FragmentShadingRateNV::e1InvocationPer4X2Pixels }, + { "1InvocationPer4X4Pixels", FragmentShadingRateNV::e1InvocationPer4X4Pixels }, + { "2InvocationsPerPixel", FragmentShadingRateNV::e2InvocationsPerPixel }, + { "4InvocationsPerPixel", FragmentShadingRateNV::e4InvocationsPerPixel }, + { "8InvocationsPerPixel", FragmentShadingRateNV::e8InvocationsPerPixel }, + { "16InvocationsPerPixel", FragmentShadingRateNV::e16InvocationsPerPixel }, + { "NoInvocations", FragmentShadingRateNV::eNoInvocations }, + + }; + + std::unordered_map FragmentShadingRateTypeNVEntries = { + { "FragmentSize", FragmentShadingRateTypeNV::eFragmentSize }, + { "Enums", FragmentShadingRateTypeNV::eEnums }, + + }; + + //=== VK_NV_ray_tracing_motion_blur === + + std::unordered_map AccelerationStructureMotionInstanceTypeNVEntries = { + { "Static", AccelerationStructureMotionInstanceTypeNV::eStatic }, + { "MatrixMotion", AccelerationStructureMotionInstanceTypeNV::eMatrixMotion }, + { "SrtMotion", AccelerationStructureMotionInstanceTypeNV::eSrtMotion }, + + }; + + std::unordered_map AccelerationStructureMotionInfoFlagBitsNVEntries = { + + }; + + std::unordered_map AccelerationStructureMotionInstanceFlagBitsNVEntries = { + + }; + + //=== VK_EXT_image_compression_control === + + std::unordered_map ImageCompressionFlagBitsEXTEntries = { + { "Default", ImageCompressionFlagBitsEXT::eDefault }, + { "FixedRateDefault", ImageCompressionFlagBitsEXT::eFixedRateDefault }, + { "FixedRateExplicit", ImageCompressionFlagBitsEXT::eFixedRateExplicit }, + { "Disabled", ImageCompressionFlagBitsEXT::eDisabled }, + + }; + + std::unordered_map ImageCompressionFixedRateFlagBitsEXTEntries = { + { "None", ImageCompressionFixedRateFlagBitsEXT::eNone }, { "1Bpc", ImageCompressionFixedRateFlagBitsEXT::e1Bpc }, + { "2Bpc", ImageCompressionFixedRateFlagBitsEXT::e2Bpc }, { "3Bpc", ImageCompressionFixedRateFlagBitsEXT::e3Bpc }, + { "4Bpc", ImageCompressionFixedRateFlagBitsEXT::e4Bpc }, { "5Bpc", ImageCompressionFixedRateFlagBitsEXT::e5Bpc }, + { "6Bpc", ImageCompressionFixedRateFlagBitsEXT::e6Bpc }, { "7Bpc", ImageCompressionFixedRateFlagBitsEXT::e7Bpc }, + { "8Bpc", ImageCompressionFixedRateFlagBitsEXT::e8Bpc }, { "9Bpc", ImageCompressionFixedRateFlagBitsEXT::e9Bpc }, + { "10Bpc", ImageCompressionFixedRateFlagBitsEXT::e10Bpc }, { "11Bpc", ImageCompressionFixedRateFlagBitsEXT::e11Bpc }, + { "12Bpc", ImageCompressionFixedRateFlagBitsEXT::e12Bpc }, { "13Bpc", ImageCompressionFixedRateFlagBitsEXT::e13Bpc }, + { "14Bpc", ImageCompressionFixedRateFlagBitsEXT::e14Bpc }, { "15Bpc", ImageCompressionFixedRateFlagBitsEXT::e15Bpc }, + { "16Bpc", ImageCompressionFixedRateFlagBitsEXT::e16Bpc }, { "17Bpc", ImageCompressionFixedRateFlagBitsEXT::e17Bpc }, + { "18Bpc", ImageCompressionFixedRateFlagBitsEXT::e18Bpc }, { "19Bpc", ImageCompressionFixedRateFlagBitsEXT::e19Bpc }, + { "20Bpc", ImageCompressionFixedRateFlagBitsEXT::e20Bpc }, { "21Bpc", ImageCompressionFixedRateFlagBitsEXT::e21Bpc }, + { "22Bpc", ImageCompressionFixedRateFlagBitsEXT::e22Bpc }, { "23Bpc", ImageCompressionFixedRateFlagBitsEXT::e23Bpc }, + { "24Bpc", ImageCompressionFixedRateFlagBitsEXT::e24Bpc }, + + }; + + //=== VK_EXT_device_fault === + + std::unordered_map DeviceFaultAddressTypeEXTEntries = { + { "None", DeviceFaultAddressTypeEXT::eNone }, + { "ReadInvalid", DeviceFaultAddressTypeEXT::eReadInvalid }, + { "WriteInvalid", DeviceFaultAddressTypeEXT::eWriteInvalid }, + { "ExecuteInvalid", DeviceFaultAddressTypeEXT::eExecuteInvalid }, + { "InstructionPointerUnknown", DeviceFaultAddressTypeEXT::eInstructionPointerUnknown }, + { "InstructionPointerInvalid", DeviceFaultAddressTypeEXT::eInstructionPointerInvalid }, + { "InstructionPointerFault", DeviceFaultAddressTypeEXT::eInstructionPointerFault }, + + }; + + std::unordered_map DeviceFaultVendorBinaryHeaderVersionEXTEntries = { + { "One", DeviceFaultVendorBinaryHeaderVersionEXT::eOne }, + + }; + +#if defined( VK_USE_PLATFORM_DIRECTFB_EXT ) + //=== VK_EXT_directfb_surface === + + std::unordered_map DirectFBSurfaceCreateFlagBitsEXTEntries = { + + }; +#endif /*VK_USE_PLATFORM_DIRECTFB_EXT*/ + + //=== VK_EXT_device_address_binding_report === + + std::unordered_map DeviceAddressBindingFlagBitsEXTEntries = { + { "InternalObject", DeviceAddressBindingFlagBitsEXT::eInternalObject }, + + }; + + std::unordered_map DeviceAddressBindingTypeEXTEntries = { + { "Bind", DeviceAddressBindingTypeEXT::eBind }, + { "Unbind", DeviceAddressBindingTypeEXT::eUnbind }, + + }; + +#if defined( VK_USE_PLATFORM_FUCHSIA ) + //=== VK_FUCHSIA_buffer_collection === + + std::unordered_map ImageConstraintsInfoFlagBitsFUCHSIAEntries = { + { "CpuReadRarely", ImageConstraintsInfoFlagBitsFUCHSIA::eCpuReadRarely }, + { "CpuReadOften", ImageConstraintsInfoFlagBitsFUCHSIA::eCpuReadOften }, + { "CpuWriteRarely", ImageConstraintsInfoFlagBitsFUCHSIA::eCpuWriteRarely }, + { "CpuWriteOften", ImageConstraintsInfoFlagBitsFUCHSIA::eCpuWriteOften }, + { "ProtectedOptional", ImageConstraintsInfoFlagBitsFUCHSIA::eProtectedOptional }, + + }; + + std::unordered_map ImageFormatConstraintsFlagBitsFUCHSIAEntries = { + + }; +#endif /*VK_USE_PLATFORM_FUCHSIA*/ + + //=== VK_EXT_frame_boundary === + + std::unordered_map FrameBoundaryFlagBitsEXTEntries = { + { "FrameEnd", FrameBoundaryFlagBitsEXT::eFrameEnd }, + + }; + +#if defined( VK_USE_PLATFORM_SCREEN_QNX ) + //=== VK_QNX_screen_surface === + + std::unordered_map ScreenSurfaceCreateFlagBitsQNXEntries = { + + }; +#endif /*VK_USE_PLATFORM_SCREEN_QNX*/ + + //=== VK_EXT_opacity_micromap === + + std::unordered_map MicromapTypeEXTEntries = { + { "OpacityMicromap", MicromapTypeEXT::eOpacityMicromap }, +#if defined( VK_ENABLE_BETA_EXTENSIONS ) + { "DisplacementMicromapNV", MicromapTypeEXT::eDisplacementMicromapNV }, +#endif /*VK_ENABLE_BETA_EXTENSIONS*/ + + }; + + std::unordered_map BuildMicromapFlagBitsEXTEntries = { + { "PreferFastTrace", BuildMicromapFlagBitsEXT::ePreferFastTrace }, + { "PreferFastBuild", BuildMicromapFlagBitsEXT::ePreferFastBuild }, + { "AllowCompaction", BuildMicromapFlagBitsEXT::eAllowCompaction }, + + }; + + std::unordered_map CopyMicromapModeEXTEntries = { + { "Clone", CopyMicromapModeEXT::eClone }, + { "Serialize", CopyMicromapModeEXT::eSerialize }, + { "Deserialize", CopyMicromapModeEXT::eDeserialize }, + { "Compact", CopyMicromapModeEXT::eCompact }, + + }; + + std::unordered_map MicromapCreateFlagBitsEXTEntries = { + { "DeviceAddressCaptureReplay", MicromapCreateFlagBitsEXT::eDeviceAddressCaptureReplay }, + + }; + + std::unordered_map BuildMicromapModeEXTEntries = { + { "Build", BuildMicromapModeEXT::eBuild }, + + }; + + std::unordered_map OpacityMicromapFormatEXTEntries = { + { "2State", OpacityMicromapFormatEXT::e2State }, + { "4State", OpacityMicromapFormatEXT::e4State }, + + }; + + std::unordered_map OpacityMicromapSpecialIndexEXTEntries = { + { "FullyTransparent", OpacityMicromapSpecialIndexEXT::eFullyTransparent }, + { "FullyOpaque", OpacityMicromapSpecialIndexEXT::eFullyOpaque }, + { "FullyUnknownTransparent", OpacityMicromapSpecialIndexEXT::eFullyUnknownTransparent }, + { "FullyUnknownOpaque", OpacityMicromapSpecialIndexEXT::eFullyUnknownOpaque }, + + }; + +#if defined( VK_ENABLE_BETA_EXTENSIONS ) + //=== VK_NV_displacement_micromap === + + std::unordered_map DisplacementMicromapFormatNVEntries = { + { "64Triangles64Bytes", DisplacementMicromapFormatNV::e64Triangles64Bytes }, + { "256Triangles128Bytes", DisplacementMicromapFormatNV::e256Triangles128Bytes }, + { "1024Triangles128Bytes", DisplacementMicromapFormatNV::e1024Triangles128Bytes }, + + }; +#endif /*VK_ENABLE_BETA_EXTENSIONS*/ + + //=== VK_ARM_scheduling_controls === + + std::unordered_map PhysicalDeviceSchedulingControlsFlagBitsARMEntries = { + { "ShaderCoreCount", PhysicalDeviceSchedulingControlsFlagBitsARM::eShaderCoreCount }, + + }; + + //=== VK_NV_memory_decompression === + + std::unordered_map MemoryDecompressionMethodFlagBitsNVEntries = { + { "Gdeflate10", MemoryDecompressionMethodFlagBitsNV::eGdeflate10 }, + + }; + + //=== VK_EXT_subpass_merge_feedback === + + std::unordered_map SubpassMergeStatusEXTEntries = { + { "Merged", SubpassMergeStatusEXT::eMerged }, + { "Disallowed", SubpassMergeStatusEXT::eDisallowed }, + { "NotMergedSideEffects", SubpassMergeStatusEXT::eNotMergedSideEffects }, + { "NotMergedSamplesMismatch", SubpassMergeStatusEXT::eNotMergedSamplesMismatch }, + { "NotMergedViewsMismatch", SubpassMergeStatusEXT::eNotMergedViewsMismatch }, + { "NotMergedAliasing", SubpassMergeStatusEXT::eNotMergedAliasing }, + { "NotMergedDependencies", SubpassMergeStatusEXT::eNotMergedDependencies }, + { "NotMergedIncompatibleInputAttachment", SubpassMergeStatusEXT::eNotMergedIncompatibleInputAttachment }, + { "NotMergedTooManyAttachments", SubpassMergeStatusEXT::eNotMergedTooManyAttachments }, + { "NotMergedInsufficientStorage", SubpassMergeStatusEXT::eNotMergedInsufficientStorage }, + { "NotMergedDepthStencilCount", SubpassMergeStatusEXT::eNotMergedDepthStencilCount }, + { "NotMergedResolveAttachmentReuse", SubpassMergeStatusEXT::eNotMergedResolveAttachmentReuse }, + { "NotMergedSingleSubpass", SubpassMergeStatusEXT::eNotMergedSingleSubpass }, + { "NotMergedUnspecified", SubpassMergeStatusEXT::eNotMergedUnspecified }, + + }; + + //=== VK_LUNARG_direct_driver_loading === + + std::unordered_map DirectDriverLoadingModeLUNARGEntries = { + { "Exclusive", DirectDriverLoadingModeLUNARG::eExclusive }, + { "Inclusive", DirectDriverLoadingModeLUNARG::eInclusive }, + + }; + + std::unordered_map DirectDriverLoadingFlagBitsLUNARGEntries = { + + }; + + //=== VK_NV_optical_flow === + + std::unordered_map OpticalFlowUsageFlagBitsNVEntries = { + { "Unknown", OpticalFlowUsageFlagBitsNV::eUnknown }, { "Input", OpticalFlowUsageFlagBitsNV::eInput }, + { "Output", OpticalFlowUsageFlagBitsNV::eOutput }, { "Hint", OpticalFlowUsageFlagBitsNV::eHint }, + { "Cost", OpticalFlowUsageFlagBitsNV::eCost }, { "GlobalFlow", OpticalFlowUsageFlagBitsNV::eGlobalFlow }, + + }; + + std::unordered_map OpticalFlowGridSizeFlagBitsNVEntries = { + { "Unknown", OpticalFlowGridSizeFlagBitsNV::eUnknown }, { "1X1", OpticalFlowGridSizeFlagBitsNV::e1X1 }, { "2X2", OpticalFlowGridSizeFlagBitsNV::e2X2 }, + { "4X4", OpticalFlowGridSizeFlagBitsNV::e4X4 }, { "8X8", OpticalFlowGridSizeFlagBitsNV::e8X8 }, + + }; + + std::unordered_map OpticalFlowPerformanceLevelNVEntries = { + { "Unknown", OpticalFlowPerformanceLevelNV::eUnknown }, + { "Slow", OpticalFlowPerformanceLevelNV::eSlow }, + { "Medium", OpticalFlowPerformanceLevelNV::eMedium }, + { "Fast", OpticalFlowPerformanceLevelNV::eFast }, + + }; + + std::unordered_map OpticalFlowSessionBindingPointNVEntries = { + { "Unknown", OpticalFlowSessionBindingPointNV::eUnknown }, + { "Input", OpticalFlowSessionBindingPointNV::eInput }, + { "Reference", OpticalFlowSessionBindingPointNV::eReference }, + { "Hint", OpticalFlowSessionBindingPointNV::eHint }, + { "FlowVector", OpticalFlowSessionBindingPointNV::eFlowVector }, + { "BackwardFlowVector", OpticalFlowSessionBindingPointNV::eBackwardFlowVector }, + { "Cost", OpticalFlowSessionBindingPointNV::eCost }, + { "BackwardCost", OpticalFlowSessionBindingPointNV::eBackwardCost }, + { "GlobalFlow", OpticalFlowSessionBindingPointNV::eGlobalFlow }, + + }; + + std::unordered_map OpticalFlowSessionCreateFlagBitsNVEntries = { + { "EnableHint", OpticalFlowSessionCreateFlagBitsNV::eEnableHint }, + { "EnableCost", OpticalFlowSessionCreateFlagBitsNV::eEnableCost }, + { "EnableGlobalFlow", OpticalFlowSessionCreateFlagBitsNV::eEnableGlobalFlow }, + { "AllowRegions", OpticalFlowSessionCreateFlagBitsNV::eAllowRegions }, + { "BothDirections", OpticalFlowSessionCreateFlagBitsNV::eBothDirections }, + + }; + + std::unordered_map OpticalFlowExecuteFlagBitsNVEntries = { + { "DisableTemporalHints", OpticalFlowExecuteFlagBitsNV::eDisableTemporalHints }, + + }; + + //=== VK_KHR_maintenance5 === + + std::unordered_map PipelineCreateFlagBits2KHREntries = { + { "DisableOptimization", PipelineCreateFlagBits2KHR::eDisableOptimization }, + { "AllowDerivatives", PipelineCreateFlagBits2KHR::eAllowDerivatives }, + { "Derivative", PipelineCreateFlagBits2KHR::eDerivative }, + { "ViewIndexFromDeviceIndex", PipelineCreateFlagBits2KHR::eViewIndexFromDeviceIndex }, + { "DispatchBase", PipelineCreateFlagBits2KHR::eDispatchBase }, + { "DeferCompileNV", PipelineCreateFlagBits2KHR::eDeferCompileNV }, + { "CaptureStatistics", PipelineCreateFlagBits2KHR::eCaptureStatistics }, + { "CaptureInternalRepresentations", PipelineCreateFlagBits2KHR::eCaptureInternalRepresentations }, + { "FailOnPipelineCompileRequired", PipelineCreateFlagBits2KHR::eFailOnPipelineCompileRequired }, + { "EarlyReturnOnFailure", PipelineCreateFlagBits2KHR::eEarlyReturnOnFailure }, + { "LinkTimeOptimizationEXT", PipelineCreateFlagBits2KHR::eLinkTimeOptimizationEXT }, + { "RetainLinkTimeOptimizationInfoEXT", PipelineCreateFlagBits2KHR::eRetainLinkTimeOptimizationInfoEXT }, + { "Library", PipelineCreateFlagBits2KHR::eLibrary }, + { "RayTracingSkipTriangles", PipelineCreateFlagBits2KHR::eRayTracingSkipTriangles }, + { "RayTracingSkipAabbs", PipelineCreateFlagBits2KHR::eRayTracingSkipAabbs }, + { "RayTracingNoNullAnyHitShaders", PipelineCreateFlagBits2KHR::eRayTracingNoNullAnyHitShaders }, + { "RayTracingNoNullClosestHitShaders", PipelineCreateFlagBits2KHR::eRayTracingNoNullClosestHitShaders }, + { "RayTracingNoNullMissShaders", PipelineCreateFlagBits2KHR::eRayTracingNoNullMissShaders }, + { "RayTracingNoNullIntersectionShaders", PipelineCreateFlagBits2KHR::eRayTracingNoNullIntersectionShaders }, + { "RayTracingShaderGroupHandleCaptureReplay", PipelineCreateFlagBits2KHR::eRayTracingShaderGroupHandleCaptureReplay }, + { "IndirectBindableNV", PipelineCreateFlagBits2KHR::eIndirectBindableNV }, + { "RayTracingAllowMotionNV", PipelineCreateFlagBits2KHR::eRayTracingAllowMotionNV }, + { "RenderingFragmentShadingRateAttachment", PipelineCreateFlagBits2KHR::eRenderingFragmentShadingRateAttachment }, + { "RenderingFragmentDensityMapAttachmentEXT", PipelineCreateFlagBits2KHR::eRenderingFragmentDensityMapAttachmentEXT }, + { "RayTracingOpacityMicromapEXT", PipelineCreateFlagBits2KHR::eRayTracingOpacityMicromapEXT }, + { "ColorAttachmentFeedbackLoopEXT", PipelineCreateFlagBits2KHR::eColorAttachmentFeedbackLoopEXT }, + { "DepthStencilAttachmentFeedbackLoopEXT", PipelineCreateFlagBits2KHR::eDepthStencilAttachmentFeedbackLoopEXT }, + { "NoProtectedAccessEXT", PipelineCreateFlagBits2KHR::eNoProtectedAccessEXT }, + { "ProtectedAccessOnlyEXT", PipelineCreateFlagBits2KHR::eProtectedAccessOnlyEXT }, + { "RayTracingDisplacementMicromapNV", PipelineCreateFlagBits2KHR::eRayTracingDisplacementMicromapNV }, + { "DescriptorBufferEXT", PipelineCreateFlagBits2KHR::eDescriptorBufferEXT }, + + }; + + std::unordered_map BufferUsageFlagBits2KHREntries = { + { "TransferSrc", BufferUsageFlagBits2KHR::eTransferSrc }, + { "TransferDst", BufferUsageFlagBits2KHR::eTransferDst }, + { "UniformTexelBuffer", BufferUsageFlagBits2KHR::eUniformTexelBuffer }, + { "StorageTexelBuffer", BufferUsageFlagBits2KHR::eStorageTexelBuffer }, + { "UniformBuffer", BufferUsageFlagBits2KHR::eUniformBuffer }, + { "StorageBuffer", BufferUsageFlagBits2KHR::eStorageBuffer }, + { "IndexBuffer", BufferUsageFlagBits2KHR::eIndexBuffer }, + { "VertexBuffer", BufferUsageFlagBits2KHR::eVertexBuffer }, + { "IndirectBuffer", BufferUsageFlagBits2KHR::eIndirectBuffer }, +#if defined( VK_ENABLE_BETA_EXTENSIONS ) + { "ExecutionGraphScratchAMDX", BufferUsageFlagBits2KHR::eExecutionGraphScratchAMDX }, +#endif /*VK_ENABLE_BETA_EXTENSIONS*/ + { "ConditionalRenderingEXT", BufferUsageFlagBits2KHR::eConditionalRenderingEXT }, + { "ShaderBindingTable", BufferUsageFlagBits2KHR::eShaderBindingTable }, + { "TransformFeedbackBufferEXT", BufferUsageFlagBits2KHR::eTransformFeedbackBufferEXT }, + { "TransformFeedbackCounterBufferEXT", BufferUsageFlagBits2KHR::eTransformFeedbackCounterBufferEXT }, + { "VideoDecodeSrc", BufferUsageFlagBits2KHR::eVideoDecodeSrc }, + { "VideoDecodeDst", BufferUsageFlagBits2KHR::eVideoDecodeDst }, +#if defined( VK_ENABLE_BETA_EXTENSIONS ) + { "VideoEncodeDst", BufferUsageFlagBits2KHR::eVideoEncodeDst }, + { "VideoEncodeSrc", BufferUsageFlagBits2KHR::eVideoEncodeSrc }, +#endif /*VK_ENABLE_BETA_EXTENSIONS*/ + { "ShaderDeviceAddress", BufferUsageFlagBits2KHR::eShaderDeviceAddress }, + { "AccelerationStructureBuildInputReadOnly", BufferUsageFlagBits2KHR::eAccelerationStructureBuildInputReadOnly }, + { "AccelerationStructureStorage", BufferUsageFlagBits2KHR::eAccelerationStructureStorage }, + { "SamplerDescriptorBufferEXT", BufferUsageFlagBits2KHR::eSamplerDescriptorBufferEXT }, + { "ResourceDescriptorBufferEXT", BufferUsageFlagBits2KHR::eResourceDescriptorBufferEXT }, + { "PushDescriptorsDescriptorBufferEXT", BufferUsageFlagBits2KHR::ePushDescriptorsDescriptorBufferEXT }, + { "MicromapBuildInputReadOnlyEXT", BufferUsageFlagBits2KHR::eMicromapBuildInputReadOnlyEXT }, + { "MicromapStorageEXT", BufferUsageFlagBits2KHR::eMicromapStorageEXT }, + + }; + + //=== VK_EXT_shader_object === + + std::unordered_map ShaderCreateFlagBitsEXTEntries = { + { "LinkStage", ShaderCreateFlagBitsEXT::eLinkStage }, + { "AllowVaryingSubgroupSize", ShaderCreateFlagBitsEXT::eAllowVaryingSubgroupSize }, + { "RequireFullSubgroups", ShaderCreateFlagBitsEXT::eRequireFullSubgroups }, + { "NoTaskShader", ShaderCreateFlagBitsEXT::eNoTaskShader }, + { "DispatchBase", ShaderCreateFlagBitsEXT::eDispatchBase }, + { "FragmentShadingRateAttachment", ShaderCreateFlagBitsEXT::eFragmentShadingRateAttachment }, + { "FragmentDensityMapAttachment", ShaderCreateFlagBitsEXT::eFragmentDensityMapAttachment }, + + }; + + std::unordered_map ShaderCodeTypeEXTEntries = { + { "Binary", ShaderCodeTypeEXT::eBinary }, + { "Spirv", ShaderCodeTypeEXT::eSpirv }, + + }; + + //=== VK_NV_ray_tracing_invocation_reorder === + + std::unordered_map RayTracingInvocationReorderModeNVEntries = { + { "None", RayTracingInvocationReorderModeNV::eNone }, + { "Reorder", RayTracingInvocationReorderModeNV::eReorder }, + + }; + + //=== VK_NV_low_latency2 === + + std::unordered_map LatencyMarkerNVEntries = { + { "SimulationStart", LatencyMarkerNV::eSimulationStart }, + { "SimulationEnd", LatencyMarkerNV::eSimulationEnd }, + { "RendersubmitStart", LatencyMarkerNV::eRendersubmitStart }, + { "RendersubmitEnd", LatencyMarkerNV::eRendersubmitEnd }, + { "PresentStart", LatencyMarkerNV::ePresentStart }, + { "PresentEnd", LatencyMarkerNV::ePresentEnd }, + { "InputSample", LatencyMarkerNV::eInputSample }, + { "TriggerFlash", LatencyMarkerNV::eTriggerFlash }, + { "OutOfBandRendersubmitStart", LatencyMarkerNV::eOutOfBandRendersubmitStart }, + { "OutOfBandRendersubmitEnd", LatencyMarkerNV::eOutOfBandRendersubmitEnd }, + { "OutOfBandPresentStart", LatencyMarkerNV::eOutOfBandPresentStart }, + { "OutOfBandPresentEnd", LatencyMarkerNV::eOutOfBandPresentEnd }, + + }; + + std::unordered_map OutOfBandQueueTypeNVEntries = { + { "Render", OutOfBandQueueTypeNV::eRender }, + { "Present", OutOfBandQueueTypeNV::ePresent }, + + }; + + //=== VK_KHR_cooperative_matrix === + + std::unordered_map ScopeKHREntries = { + { "Device", ScopeKHR::eDevice }, + { "Workgroup", ScopeKHR::eWorkgroup }, + { "Subgroup", ScopeKHR::eSubgroup }, + { "QueueFamily", ScopeKHR::eQueueFamily }, + + }; + + std::unordered_map ComponentTypeKHREntries = { + { "Float16", ComponentTypeKHR::eFloat16 }, { "Float32", ComponentTypeKHR::eFloat32 }, { "Float64", ComponentTypeKHR::eFloat64 }, + { "Sint8", ComponentTypeKHR::eSint8 }, { "Sint16", ComponentTypeKHR::eSint16 }, { "Sint32", ComponentTypeKHR::eSint32 }, + { "Sint64", ComponentTypeKHR::eSint64 }, { "Uint8", ComponentTypeKHR::eUint8 }, { "Uint16", ComponentTypeKHR::eUint16 }, + { "Uint32", ComponentTypeKHR::eUint32 }, { "Uint64", ComponentTypeKHR::eUint64 }, + + }; + + //=== VK_QCOM_image_processing2 === + + std::unordered_map BlockMatchWindowCompareModeQCOMEntries = { + { "Min", BlockMatchWindowCompareModeQCOM::eMin }, + { "Max", BlockMatchWindowCompareModeQCOM::eMax }, + + }; + + //=== VK_QCOM_filter_cubic_weights === + + std::unordered_map CubicFilterWeightsQCOMEntries = { + { "CatmullRom", CubicFilterWeightsQCOM::eCatmullRom }, + { "ZeroTangentCardinal", CubicFilterWeightsQCOM::eZeroTangentCardinal }, + { "BSpline", CubicFilterWeightsQCOM::eBSpline }, + { "MitchellNetravali", CubicFilterWeightsQCOM::eMitchellNetravali }, + + }; + + //=== VK_MSFT_layered_driver === + + std::unordered_map LayeredDriverUnderlyingApiMSFTEntries = { + { "None", LayeredDriverUnderlyingApiMSFT::eNone }, + { "D3D12", LayeredDriverUnderlyingApiMSFT::eD3D12 }, + + }; + }; + + VULKAN_HPP_STORAGE_API extern const EnumFromStringMap enumFromStringMap; + + template + std::optional from_string( const std::string & ); + + //=== VK_VERSION_1_0 === + + template <> + VULKAN_HPP_INLINE std::optional from_string( const std::string & value ) + { + auto it = enumFromStringMap.ResultEntries.find( value ); + if ( it != enumFromStringMap.ResultEntries.end() ) + { + return it->second; + } + return std::nullopt; + } + + template <> + VULKAN_HPP_INLINE std::optional from_string( const std::string & value ) + { + auto it = enumFromStringMap.StructureTypeEntries.find( value ); + if ( it != enumFromStringMap.StructureTypeEntries.end() ) + { + return it->second; + } + return std::nullopt; + } + + template <> + VULKAN_HPP_INLINE std::optional from_string( const std::string & value ) + { + auto it = enumFromStringMap.PipelineCacheHeaderVersionEntries.find( value ); + if ( it != enumFromStringMap.PipelineCacheHeaderVersionEntries.end() ) + { + return it->second; + } + return std::nullopt; + } + + template <> + VULKAN_HPP_INLINE std::optional from_string( const std::string & value ) + { + auto it = enumFromStringMap.ObjectTypeEntries.find( value ); + if ( it != enumFromStringMap.ObjectTypeEntries.end() ) + { + return it->second; + } + return std::nullopt; + } + + template <> + VULKAN_HPP_INLINE std::optional from_string( const std::string & value ) + { + auto it = enumFromStringMap.VendorIdEntries.find( value ); + if ( it != enumFromStringMap.VendorIdEntries.end() ) + { + return it->second; + } + return std::nullopt; + } + + template <> + VULKAN_HPP_INLINE std::optional from_string( const std::string & value ) + { + auto it = enumFromStringMap.FormatEntries.find( value ); + if ( it != enumFromStringMap.FormatEntries.end() ) + { + return it->second; + } + return std::nullopt; + } + + template <> + VULKAN_HPP_INLINE std::optional from_string( const std::string & value ) + { + auto it = enumFromStringMap.FormatFeatureFlagBitsEntries.find( value ); + if ( it != enumFromStringMap.FormatFeatureFlagBitsEntries.end() ) + { + return it->second; + } + return std::nullopt; + } + + template <> + VULKAN_HPP_INLINE std::optional from_string( const std::string & value ) + { + auto it = enumFromStringMap.ImageCreateFlagBitsEntries.find( value ); + if ( it != enumFromStringMap.ImageCreateFlagBitsEntries.end() ) + { + return it->second; + } + return std::nullopt; + } + + template <> + VULKAN_HPP_INLINE std::optional from_string( const std::string & value ) + { + auto it = enumFromStringMap.ImageTilingEntries.find( value ); + if ( it != enumFromStringMap.ImageTilingEntries.end() ) + { + return it->second; + } + return std::nullopt; + } + + template <> + VULKAN_HPP_INLINE std::optional from_string( const std::string & value ) + { + auto it = enumFromStringMap.ImageTypeEntries.find( value ); + if ( it != enumFromStringMap.ImageTypeEntries.end() ) + { + return it->second; + } + return std::nullopt; + } + + template <> + VULKAN_HPP_INLINE std::optional from_string( const std::string & value ) + { + auto it = enumFromStringMap.ImageUsageFlagBitsEntries.find( value ); + if ( it != enumFromStringMap.ImageUsageFlagBitsEntries.end() ) + { + return it->second; + } + return std::nullopt; + } + + template <> + VULKAN_HPP_INLINE std::optional from_string( const std::string & value ) + { + auto it = enumFromStringMap.InstanceCreateFlagBitsEntries.find( value ); + if ( it != enumFromStringMap.InstanceCreateFlagBitsEntries.end() ) + { + return it->second; + } + return std::nullopt; + } + + template <> + VULKAN_HPP_INLINE std::optional from_string( const std::string & value ) + { + auto it = enumFromStringMap.InternalAllocationTypeEntries.find( value ); + if ( it != enumFromStringMap.InternalAllocationTypeEntries.end() ) + { + return it->second; + } + return std::nullopt; + } + + template <> + VULKAN_HPP_INLINE std::optional from_string( const std::string & value ) + { + auto it = enumFromStringMap.MemoryHeapFlagBitsEntries.find( value ); + if ( it != enumFromStringMap.MemoryHeapFlagBitsEntries.end() ) + { + return it->second; + } + return std::nullopt; + } + + template <> + VULKAN_HPP_INLINE std::optional from_string( const std::string & value ) + { + auto it = enumFromStringMap.MemoryPropertyFlagBitsEntries.find( value ); + if ( it != enumFromStringMap.MemoryPropertyFlagBitsEntries.end() ) + { + return it->second; + } + return std::nullopt; + } + + template <> + VULKAN_HPP_INLINE std::optional from_string( const std::string & value ) + { + auto it = enumFromStringMap.PhysicalDeviceTypeEntries.find( value ); + if ( it != enumFromStringMap.PhysicalDeviceTypeEntries.end() ) + { + return it->second; + } + return std::nullopt; + } + + template <> + VULKAN_HPP_INLINE std::optional from_string( const std::string & value ) + { + auto it = enumFromStringMap.QueueFlagBitsEntries.find( value ); + if ( it != enumFromStringMap.QueueFlagBitsEntries.end() ) + { + return it->second; + } + return std::nullopt; + } + + template <> + VULKAN_HPP_INLINE std::optional from_string( const std::string & value ) + { + auto it = enumFromStringMap.SampleCountFlagBitsEntries.find( value ); + if ( it != enumFromStringMap.SampleCountFlagBitsEntries.end() ) + { + return it->second; + } + return std::nullopt; + } + + template <> + VULKAN_HPP_INLINE std::optional from_string( const std::string & value ) + { + auto it = enumFromStringMap.SystemAllocationScopeEntries.find( value ); + if ( it != enumFromStringMap.SystemAllocationScopeEntries.end() ) + { + return it->second; + } + return std::nullopt; + } + + template <> + VULKAN_HPP_INLINE std::optional from_string( const std::string & ) + { + return std::nullopt; + } + + template <> + VULKAN_HPP_INLINE std::optional from_string( const std::string & value ) + { + auto it = enumFromStringMap.DeviceQueueCreateFlagBitsEntries.find( value ); + if ( it != enumFromStringMap.DeviceQueueCreateFlagBitsEntries.end() ) + { + return it->second; + } + return std::nullopt; + } + + template <> + VULKAN_HPP_INLINE std::optional from_string( const std::string & value ) + { + auto it = enumFromStringMap.PipelineStageFlagBitsEntries.find( value ); + if ( it != enumFromStringMap.PipelineStageFlagBitsEntries.end() ) + { + return it->second; + } + return std::nullopt; + } + + template <> + VULKAN_HPP_INLINE std::optional from_string( const std::string & ) + { + return std::nullopt; + } + + template <> + VULKAN_HPP_INLINE std::optional from_string( const std::string & value ) + { + auto it = enumFromStringMap.ImageAspectFlagBitsEntries.find( value ); + if ( it != enumFromStringMap.ImageAspectFlagBitsEntries.end() ) + { + return it->second; + } + return std::nullopt; + } + + template <> + VULKAN_HPP_INLINE std::optional from_string( const std::string & value ) + { + auto it = enumFromStringMap.SparseImageFormatFlagBitsEntries.find( value ); + if ( it != enumFromStringMap.SparseImageFormatFlagBitsEntries.end() ) + { + return it->second; + } + return std::nullopt; + } + + template <> + VULKAN_HPP_INLINE std::optional from_string( const std::string & value ) + { + auto it = enumFromStringMap.SparseMemoryBindFlagBitsEntries.find( value ); + if ( it != enumFromStringMap.SparseMemoryBindFlagBitsEntries.end() ) + { + return it->second; + } + return std::nullopt; + } + + template <> + VULKAN_HPP_INLINE std::optional from_string( const std::string & value ) + { + auto it = enumFromStringMap.FenceCreateFlagBitsEntries.find( value ); + if ( it != enumFromStringMap.FenceCreateFlagBitsEntries.end() ) + { + return it->second; + } + return std::nullopt; + } + + template <> + VULKAN_HPP_INLINE std::optional from_string( const std::string & ) + { + return std::nullopt; + } + + template <> + VULKAN_HPP_INLINE std::optional from_string( const std::string & value ) + { + auto it = enumFromStringMap.EventCreateFlagBitsEntries.find( value ); + if ( it != enumFromStringMap.EventCreateFlagBitsEntries.end() ) + { + return it->second; + } + return std::nullopt; + } + + template <> + VULKAN_HPP_INLINE std::optional from_string( const std::string & value ) + { + auto it = enumFromStringMap.QueryPipelineStatisticFlagBitsEntries.find( value ); + if ( it != enumFromStringMap.QueryPipelineStatisticFlagBitsEntries.end() ) + { + return it->second; + } + return std::nullopt; + } + + template <> + VULKAN_HPP_INLINE std::optional from_string( const std::string & value ) + { + auto it = enumFromStringMap.QueryResultFlagBitsEntries.find( value ); + if ( it != enumFromStringMap.QueryResultFlagBitsEntries.end() ) + { + return it->second; + } + return std::nullopt; + } + + template <> + VULKAN_HPP_INLINE std::optional from_string( const std::string & value ) + { + auto it = enumFromStringMap.QueryTypeEntries.find( value ); + if ( it != enumFromStringMap.QueryTypeEntries.end() ) + { + return it->second; + } + return std::nullopt; + } + + template <> + VULKAN_HPP_INLINE std::optional from_string( const std::string & ) + { + return std::nullopt; + } + + template <> + VULKAN_HPP_INLINE std::optional from_string( const std::string & value ) + { + auto it = enumFromStringMap.BufferCreateFlagBitsEntries.find( value ); + if ( it != enumFromStringMap.BufferCreateFlagBitsEntries.end() ) + { + return it->second; + } + return std::nullopt; + } + + template <> + VULKAN_HPP_INLINE std::optional from_string( const std::string & value ) + { + auto it = enumFromStringMap.BufferUsageFlagBitsEntries.find( value ); + if ( it != enumFromStringMap.BufferUsageFlagBitsEntries.end() ) + { + return it->second; + } + return std::nullopt; + } + + template <> + VULKAN_HPP_INLINE std::optional from_string( const std::string & value ) + { + auto it = enumFromStringMap.SharingModeEntries.find( value ); + if ( it != enumFromStringMap.SharingModeEntries.end() ) + { + return it->second; + } + return std::nullopt; + } + + template <> + VULKAN_HPP_INLINE std::optional from_string( const std::string & ) + { + return std::nullopt; + } + + template <> + VULKAN_HPP_INLINE std::optional from_string( const std::string & value ) + { + auto it = enumFromStringMap.ImageLayoutEntries.find( value ); + if ( it != enumFromStringMap.ImageLayoutEntries.end() ) + { + return it->second; + } + return std::nullopt; + } + + template <> + VULKAN_HPP_INLINE std::optional from_string( const std::string & value ) + { + auto it = enumFromStringMap.ComponentSwizzleEntries.find( value ); + if ( it != enumFromStringMap.ComponentSwizzleEntries.end() ) + { + return it->second; + } + return std::nullopt; + } + + template <> + VULKAN_HPP_INLINE std::optional from_string( const std::string & value ) + { + auto it = enumFromStringMap.ImageViewCreateFlagBitsEntries.find( value ); + if ( it != enumFromStringMap.ImageViewCreateFlagBitsEntries.end() ) + { + return it->second; + } + return std::nullopt; + } + + template <> + VULKAN_HPP_INLINE std::optional from_string( const std::string & value ) + { + auto it = enumFromStringMap.ImageViewTypeEntries.find( value ); + if ( it != enumFromStringMap.ImageViewTypeEntries.end() ) + { + return it->second; + } + return std::nullopt; + } + + template <> + VULKAN_HPP_INLINE std::optional from_string( const std::string & ) + { + return std::nullopt; + } + + template <> + VULKAN_HPP_INLINE std::optional from_string( const std::string & value ) + { + auto it = enumFromStringMap.PipelineCacheCreateFlagBitsEntries.find( value ); + if ( it != enumFromStringMap.PipelineCacheCreateFlagBitsEntries.end() ) + { + return it->second; + } + return std::nullopt; + } + + template <> + VULKAN_HPP_INLINE std::optional from_string( const std::string & value ) + { + auto it = enumFromStringMap.BlendFactorEntries.find( value ); + if ( it != enumFromStringMap.BlendFactorEntries.end() ) + { + return it->second; + } + return std::nullopt; + } + + template <> + VULKAN_HPP_INLINE std::optional from_string( const std::string & value ) + { + auto it = enumFromStringMap.BlendOpEntries.find( value ); + if ( it != enumFromStringMap.BlendOpEntries.end() ) + { + return it->second; + } + return std::nullopt; + } + + template <> + VULKAN_HPP_INLINE std::optional from_string( const std::string & value ) + { + auto it = enumFromStringMap.ColorComponentFlagBitsEntries.find( value ); + if ( it != enumFromStringMap.ColorComponentFlagBitsEntries.end() ) + { + return it->second; + } + return std::nullopt; + } + + template <> + VULKAN_HPP_INLINE std::optional from_string( const std::string & value ) + { + auto it = enumFromStringMap.CompareOpEntries.find( value ); + if ( it != enumFromStringMap.CompareOpEntries.end() ) + { + return it->second; + } + return std::nullopt; + } + + template <> + VULKAN_HPP_INLINE std::optional from_string( const std::string & value ) + { + auto it = enumFromStringMap.CullModeFlagBitsEntries.find( value ); + if ( it != enumFromStringMap.CullModeFlagBitsEntries.end() ) + { + return it->second; + } + return std::nullopt; + } + + template <> + VULKAN_HPP_INLINE std::optional from_string( const std::string & value ) + { + auto it = enumFromStringMap.DynamicStateEntries.find( value ); + if ( it != enumFromStringMap.DynamicStateEntries.end() ) + { + return it->second; + } + return std::nullopt; + } + + template <> + VULKAN_HPP_INLINE std::optional from_string( const std::string & value ) + { + auto it = enumFromStringMap.FrontFaceEntries.find( value ); + if ( it != enumFromStringMap.FrontFaceEntries.end() ) + { + return it->second; + } + return std::nullopt; + } + + template <> + VULKAN_HPP_INLINE std::optional from_string( const std::string & value ) + { + auto it = enumFromStringMap.LogicOpEntries.find( value ); + if ( it != enumFromStringMap.LogicOpEntries.end() ) + { + return it->second; + } + return std::nullopt; + } + + template <> + VULKAN_HPP_INLINE std::optional from_string( const std::string & value ) + { + auto it = enumFromStringMap.PipelineCreateFlagBitsEntries.find( value ); + if ( it != enumFromStringMap.PipelineCreateFlagBitsEntries.end() ) + { + return it->second; + } + return std::nullopt; + } + + template <> + VULKAN_HPP_INLINE std::optional from_string( const std::string & value ) + { + auto it = enumFromStringMap.PipelineShaderStageCreateFlagBitsEntries.find( value ); + if ( it != enumFromStringMap.PipelineShaderStageCreateFlagBitsEntries.end() ) + { + return it->second; + } + return std::nullopt; + } + + template <> + VULKAN_HPP_INLINE std::optional from_string( const std::string & value ) + { + auto it = enumFromStringMap.PolygonModeEntries.find( value ); + if ( it != enumFromStringMap.PolygonModeEntries.end() ) + { + return it->second; + } + return std::nullopt; + } + + template <> + VULKAN_HPP_INLINE std::optional from_string( const std::string & value ) + { + auto it = enumFromStringMap.PrimitiveTopologyEntries.find( value ); + if ( it != enumFromStringMap.PrimitiveTopologyEntries.end() ) + { + return it->second; + } + return std::nullopt; + } + + template <> + VULKAN_HPP_INLINE std::optional from_string( const std::string & value ) + { + auto it = enumFromStringMap.ShaderStageFlagBitsEntries.find( value ); + if ( it != enumFromStringMap.ShaderStageFlagBitsEntries.end() ) + { + return it->second; + } + return std::nullopt; + } + + template <> + VULKAN_HPP_INLINE std::optional from_string( const std::string & value ) + { + auto it = enumFromStringMap.StencilOpEntries.find( value ); + if ( it != enumFromStringMap.StencilOpEntries.end() ) + { + return it->second; + } + return std::nullopt; + } + + template <> + VULKAN_HPP_INLINE std::optional from_string( const std::string & value ) + { + auto it = enumFromStringMap.VertexInputRateEntries.find( value ); + if ( it != enumFromStringMap.VertexInputRateEntries.end() ) + { + return it->second; + } + return std::nullopt; + } + + template <> + VULKAN_HPP_INLINE std::optional from_string( const std::string & value ) + { + auto it = enumFromStringMap.PipelineColorBlendStateCreateFlagBitsEntries.find( value ); + if ( it != enumFromStringMap.PipelineColorBlendStateCreateFlagBitsEntries.end() ) + { + return it->second; + } + return std::nullopt; + } + + template <> + VULKAN_HPP_INLINE std::optional from_string( const std::string & value ) + { + auto it = enumFromStringMap.PipelineDepthStencilStateCreateFlagBitsEntries.find( value ); + if ( it != enumFromStringMap.PipelineDepthStencilStateCreateFlagBitsEntries.end() ) + { + return it->second; + } + return std::nullopt; + } + + template <> + VULKAN_HPP_INLINE std::optional from_string( const std::string & ) + { + return std::nullopt; + } + + template <> + VULKAN_HPP_INLINE std::optional from_string( const std::string & ) + { + return std::nullopt; + } + + template <> + VULKAN_HPP_INLINE std::optional from_string( const std::string & value ) + { + auto it = enumFromStringMap.PipelineLayoutCreateFlagBitsEntries.find( value ); + if ( it != enumFromStringMap.PipelineLayoutCreateFlagBitsEntries.end() ) + { + return it->second; + } + return std::nullopt; + } + + template <> + VULKAN_HPP_INLINE std::optional from_string( const std::string & ) + { + return std::nullopt; + } + + template <> + VULKAN_HPP_INLINE std::optional from_string( const std::string & ) + { + return std::nullopt; + } + + template <> + VULKAN_HPP_INLINE std::optional from_string( const std::string & ) + { + return std::nullopt; + } + + template <> + VULKAN_HPP_INLINE std::optional from_string( const std::string & ) + { + return std::nullopt; + } + + template <> + VULKAN_HPP_INLINE std::optional from_string( const std::string & ) + { + return std::nullopt; + } + + template <> + VULKAN_HPP_INLINE std::optional from_string( const std::string & value ) + { + auto it = enumFromStringMap.BorderColorEntries.find( value ); + if ( it != enumFromStringMap.BorderColorEntries.end() ) + { + return it->second; + } + return std::nullopt; + } + + template <> + VULKAN_HPP_INLINE std::optional from_string( const std::string & value ) + { + auto it = enumFromStringMap.FilterEntries.find( value ); + if ( it != enumFromStringMap.FilterEntries.end() ) + { + return it->second; + } + return std::nullopt; + } + + template <> + VULKAN_HPP_INLINE std::optional from_string( const std::string & value ) + { + auto it = enumFromStringMap.SamplerAddressModeEntries.find( value ); + if ( it != enumFromStringMap.SamplerAddressModeEntries.end() ) + { + return it->second; + } + return std::nullopt; + } + + template <> + VULKAN_HPP_INLINE std::optional from_string( const std::string & value ) + { + auto it = enumFromStringMap.SamplerCreateFlagBitsEntries.find( value ); + if ( it != enumFromStringMap.SamplerCreateFlagBitsEntries.end() ) + { + return it->second; + } + return std::nullopt; + } + + template <> + VULKAN_HPP_INLINE std::optional from_string( const std::string & value ) + { + auto it = enumFromStringMap.SamplerMipmapModeEntries.find( value ); + if ( it != enumFromStringMap.SamplerMipmapModeEntries.end() ) + { + return it->second; + } + return std::nullopt; + } + + template <> + VULKAN_HPP_INLINE std::optional from_string( const std::string & value ) + { + auto it = enumFromStringMap.DescriptorPoolCreateFlagBitsEntries.find( value ); + if ( it != enumFromStringMap.DescriptorPoolCreateFlagBitsEntries.end() ) + { + return it->second; + } + return std::nullopt; + } + + template <> + VULKAN_HPP_INLINE std::optional from_string( const std::string & value ) + { + auto it = enumFromStringMap.DescriptorSetLayoutCreateFlagBitsEntries.find( value ); + if ( it != enumFromStringMap.DescriptorSetLayoutCreateFlagBitsEntries.end() ) + { + return it->second; + } + return std::nullopt; + } + + template <> + VULKAN_HPP_INLINE std::optional from_string( const std::string & value ) + { + auto it = enumFromStringMap.DescriptorTypeEntries.find( value ); + if ( it != enumFromStringMap.DescriptorTypeEntries.end() ) + { + return it->second; + } + return std::nullopt; + } + + template <> + VULKAN_HPP_INLINE std::optional from_string( const std::string & ) + { + return std::nullopt; + } + + template <> + VULKAN_HPP_INLINE std::optional from_string( const std::string & value ) + { + auto it = enumFromStringMap.AccessFlagBitsEntries.find( value ); + if ( it != enumFromStringMap.AccessFlagBitsEntries.end() ) + { + return it->second; + } + return std::nullopt; + } + + template <> + VULKAN_HPP_INLINE std::optional from_string( const std::string & value ) + { + auto it = enumFromStringMap.AttachmentDescriptionFlagBitsEntries.find( value ); + if ( it != enumFromStringMap.AttachmentDescriptionFlagBitsEntries.end() ) + { + return it->second; + } + return std::nullopt; + } + + template <> + VULKAN_HPP_INLINE std::optional from_string( const std::string & value ) + { + auto it = enumFromStringMap.AttachmentLoadOpEntries.find( value ); + if ( it != enumFromStringMap.AttachmentLoadOpEntries.end() ) + { + return it->second; + } + return std::nullopt; + } + + template <> + VULKAN_HPP_INLINE std::optional from_string( const std::string & value ) + { + auto it = enumFromStringMap.AttachmentStoreOpEntries.find( value ); + if ( it != enumFromStringMap.AttachmentStoreOpEntries.end() ) + { + return it->second; + } + return std::nullopt; + } + + template <> + VULKAN_HPP_INLINE std::optional from_string( const std::string & value ) + { + auto it = enumFromStringMap.DependencyFlagBitsEntries.find( value ); + if ( it != enumFromStringMap.DependencyFlagBitsEntries.end() ) + { + return it->second; + } + return std::nullopt; + } + + template <> + VULKAN_HPP_INLINE std::optional from_string( const std::string & value ) + { + auto it = enumFromStringMap.FramebufferCreateFlagBitsEntries.find( value ); + if ( it != enumFromStringMap.FramebufferCreateFlagBitsEntries.end() ) + { + return it->second; + } + return std::nullopt; + } + + template <> + VULKAN_HPP_INLINE std::optional from_string( const std::string & value ) + { + auto it = enumFromStringMap.PipelineBindPointEntries.find( value ); + if ( it != enumFromStringMap.PipelineBindPointEntries.end() ) + { + return it->second; + } + return std::nullopt; + } + + template <> + VULKAN_HPP_INLINE std::optional from_string( const std::string & value ) + { + auto it = enumFromStringMap.RenderPassCreateFlagBitsEntries.find( value ); + if ( it != enumFromStringMap.RenderPassCreateFlagBitsEntries.end() ) + { + return it->second; + } + return std::nullopt; + } + + template <> + VULKAN_HPP_INLINE std::optional from_string( const std::string & value ) + { + auto it = enumFromStringMap.SubpassDescriptionFlagBitsEntries.find( value ); + if ( it != enumFromStringMap.SubpassDescriptionFlagBitsEntries.end() ) + { + return it->second; + } + return std::nullopt; + } + + template <> + VULKAN_HPP_INLINE std::optional from_string( const std::string & value ) + { + auto it = enumFromStringMap.CommandPoolCreateFlagBitsEntries.find( value ); + if ( it != enumFromStringMap.CommandPoolCreateFlagBitsEntries.end() ) + { + return it->second; + } + return std::nullopt; + } + + template <> + VULKAN_HPP_INLINE std::optional from_string( const std::string & value ) + { + auto it = enumFromStringMap.CommandPoolResetFlagBitsEntries.find( value ); + if ( it != enumFromStringMap.CommandPoolResetFlagBitsEntries.end() ) + { + return it->second; + } + return std::nullopt; + } + + template <> + VULKAN_HPP_INLINE std::optional from_string( const std::string & value ) + { + auto it = enumFromStringMap.CommandBufferLevelEntries.find( value ); + if ( it != enumFromStringMap.CommandBufferLevelEntries.end() ) + { + return it->second; + } + return std::nullopt; + } + + template <> + VULKAN_HPP_INLINE std::optional from_string( const std::string & value ) + { + auto it = enumFromStringMap.CommandBufferResetFlagBitsEntries.find( value ); + if ( it != enumFromStringMap.CommandBufferResetFlagBitsEntries.end() ) + { + return it->second; + } + return std::nullopt; + } + + template <> + VULKAN_HPP_INLINE std::optional from_string( const std::string & value ) + { + auto it = enumFromStringMap.CommandBufferUsageFlagBitsEntries.find( value ); + if ( it != enumFromStringMap.CommandBufferUsageFlagBitsEntries.end() ) + { + return it->second; + } + return std::nullopt; + } + + template <> + VULKAN_HPP_INLINE std::optional from_string( const std::string & value ) + { + auto it = enumFromStringMap.QueryControlFlagBitsEntries.find( value ); + if ( it != enumFromStringMap.QueryControlFlagBitsEntries.end() ) + { + return it->second; + } + return std::nullopt; + } + + template <> + VULKAN_HPP_INLINE std::optional from_string( const std::string & value ) + { + auto it = enumFromStringMap.IndexTypeEntries.find( value ); + if ( it != enumFromStringMap.IndexTypeEntries.end() ) + { + return it->second; + } + return std::nullopt; + } + + template <> + VULKAN_HPP_INLINE std::optional from_string( const std::string & value ) + { + auto it = enumFromStringMap.StencilFaceFlagBitsEntries.find( value ); + if ( it != enumFromStringMap.StencilFaceFlagBitsEntries.end() ) + { + return it->second; + } + return std::nullopt; + } + + template <> + VULKAN_HPP_INLINE std::optional from_string( const std::string & value ) + { + auto it = enumFromStringMap.SubpassContentsEntries.find( value ); + if ( it != enumFromStringMap.SubpassContentsEntries.end() ) + { + return it->second; + } + return std::nullopt; + } + + //=== VK_VERSION_1_1 === + + template <> + VULKAN_HPP_INLINE std::optional from_string( const std::string & value ) + { + auto it = enumFromStringMap.SubgroupFeatureFlagBitsEntries.find( value ); + if ( it != enumFromStringMap.SubgroupFeatureFlagBitsEntries.end() ) + { + return it->second; + } + return std::nullopt; + } + + template <> + VULKAN_HPP_INLINE std::optional from_string( const std::string & value ) + { + auto it = enumFromStringMap.PeerMemoryFeatureFlagBitsEntries.find( value ); + if ( it != enumFromStringMap.PeerMemoryFeatureFlagBitsEntries.end() ) + { + return it->second; + } + return std::nullopt; + } + + template <> + VULKAN_HPP_INLINE std::optional from_string( const std::string & value ) + { + auto it = enumFromStringMap.MemoryAllocateFlagBitsEntries.find( value ); + if ( it != enumFromStringMap.MemoryAllocateFlagBitsEntries.end() ) + { + return it->second; + } + return std::nullopt; + } + + template <> + VULKAN_HPP_INLINE std::optional from_string( const std::string & ) + { + return std::nullopt; + } + + template <> + VULKAN_HPP_INLINE std::optional from_string( const std::string & value ) + { + auto it = enumFromStringMap.PointClippingBehaviorEntries.find( value ); + if ( it != enumFromStringMap.PointClippingBehaviorEntries.end() ) + { + return it->second; + } + return std::nullopt; + } + + template <> + VULKAN_HPP_INLINE std::optional from_string( const std::string & value ) + { + auto it = enumFromStringMap.TessellationDomainOriginEntries.find( value ); + if ( it != enumFromStringMap.TessellationDomainOriginEntries.end() ) + { + return it->second; + } + return std::nullopt; + } + + template <> + VULKAN_HPP_INLINE std::optional from_string( const std::string & value ) + { + auto it = enumFromStringMap.SamplerYcbcrModelConversionEntries.find( value ); + if ( it != enumFromStringMap.SamplerYcbcrModelConversionEntries.end() ) + { + return it->second; + } + return std::nullopt; + } + + template <> + VULKAN_HPP_INLINE std::optional from_string( const std::string & value ) + { + auto it = enumFromStringMap.SamplerYcbcrRangeEntries.find( value ); + if ( it != enumFromStringMap.SamplerYcbcrRangeEntries.end() ) + { + return it->second; + } + return std::nullopt; + } + + template <> + VULKAN_HPP_INLINE std::optional from_string( const std::string & value ) + { + auto it = enumFromStringMap.ChromaLocationEntries.find( value ); + if ( it != enumFromStringMap.ChromaLocationEntries.end() ) + { + return it->second; + } + return std::nullopt; + } + + template <> + VULKAN_HPP_INLINE std::optional from_string( const std::string & value ) + { + auto it = enumFromStringMap.DescriptorUpdateTemplateTypeEntries.find( value ); + if ( it != enumFromStringMap.DescriptorUpdateTemplateTypeEntries.end() ) + { + return it->second; + } + return std::nullopt; + } + + template <> + VULKAN_HPP_INLINE std::optional from_string( const std::string & ) + { + return std::nullopt; + } + + template <> + VULKAN_HPP_INLINE std::optional from_string( const std::string & value ) + { + auto it = enumFromStringMap.ExternalMemoryHandleTypeFlagBitsEntries.find( value ); + if ( it != enumFromStringMap.ExternalMemoryHandleTypeFlagBitsEntries.end() ) + { + return it->second; + } + return std::nullopt; + } + + template <> + VULKAN_HPP_INLINE std::optional from_string( const std::string & value ) + { + auto it = enumFromStringMap.ExternalMemoryFeatureFlagBitsEntries.find( value ); + if ( it != enumFromStringMap.ExternalMemoryFeatureFlagBitsEntries.end() ) + { + return it->second; + } + return std::nullopt; + } + + template <> + VULKAN_HPP_INLINE std::optional from_string( const std::string & value ) + { + auto it = enumFromStringMap.ExternalFenceHandleTypeFlagBitsEntries.find( value ); + if ( it != enumFromStringMap.ExternalFenceHandleTypeFlagBitsEntries.end() ) + { + return it->second; + } + return std::nullopt; + } + + template <> + VULKAN_HPP_INLINE std::optional from_string( const std::string & value ) + { + auto it = enumFromStringMap.ExternalFenceFeatureFlagBitsEntries.find( value ); + if ( it != enumFromStringMap.ExternalFenceFeatureFlagBitsEntries.end() ) + { + return it->second; + } + return std::nullopt; + } + + template <> + VULKAN_HPP_INLINE std::optional from_string( const std::string & value ) + { + auto it = enumFromStringMap.FenceImportFlagBitsEntries.find( value ); + if ( it != enumFromStringMap.FenceImportFlagBitsEntries.end() ) + { + return it->second; + } + return std::nullopt; + } + + template <> + VULKAN_HPP_INLINE std::optional from_string( const std::string & value ) + { + auto it = enumFromStringMap.SemaphoreImportFlagBitsEntries.find( value ); + if ( it != enumFromStringMap.SemaphoreImportFlagBitsEntries.end() ) + { + return it->second; + } + return std::nullopt; + } + + template <> + VULKAN_HPP_INLINE std::optional from_string( const std::string & value ) + { + auto it = enumFromStringMap.ExternalSemaphoreHandleTypeFlagBitsEntries.find( value ); + if ( it != enumFromStringMap.ExternalSemaphoreHandleTypeFlagBitsEntries.end() ) + { + return it->second; + } + return std::nullopt; + } + + template <> + VULKAN_HPP_INLINE std::optional from_string( const std::string & value ) + { + auto it = enumFromStringMap.ExternalSemaphoreFeatureFlagBitsEntries.find( value ); + if ( it != enumFromStringMap.ExternalSemaphoreFeatureFlagBitsEntries.end() ) + { + return it->second; + } + return std::nullopt; + } + + //=== VK_VERSION_1_2 === + + template <> + VULKAN_HPP_INLINE std::optional from_string( const std::string & value ) + { + auto it = enumFromStringMap.DriverIdEntries.find( value ); + if ( it != enumFromStringMap.DriverIdEntries.end() ) + { + return it->second; + } + return std::nullopt; + } + + template <> + VULKAN_HPP_INLINE std::optional from_string( const std::string & value ) + { + auto it = enumFromStringMap.ShaderFloatControlsIndependenceEntries.find( value ); + if ( it != enumFromStringMap.ShaderFloatControlsIndependenceEntries.end() ) + { + return it->second; + } + return std::nullopt; + } + + template <> + VULKAN_HPP_INLINE std::optional from_string( const std::string & value ) + { + auto it = enumFromStringMap.DescriptorBindingFlagBitsEntries.find( value ); + if ( it != enumFromStringMap.DescriptorBindingFlagBitsEntries.end() ) + { + return it->second; + } + return std::nullopt; + } + + template <> + VULKAN_HPP_INLINE std::optional from_string( const std::string & value ) + { + auto it = enumFromStringMap.ResolveModeFlagBitsEntries.find( value ); + if ( it != enumFromStringMap.ResolveModeFlagBitsEntries.end() ) + { + return it->second; + } + return std::nullopt; + } + + template <> + VULKAN_HPP_INLINE std::optional from_string( const std::string & value ) + { + auto it = enumFromStringMap.SamplerReductionModeEntries.find( value ); + if ( it != enumFromStringMap.SamplerReductionModeEntries.end() ) + { + return it->second; + } + return std::nullopt; + } + + template <> + VULKAN_HPP_INLINE std::optional from_string( const std::string & value ) + { + auto it = enumFromStringMap.SemaphoreTypeEntries.find( value ); + if ( it != enumFromStringMap.SemaphoreTypeEntries.end() ) + { + return it->second; + } + return std::nullopt; + } + + template <> + VULKAN_HPP_INLINE std::optional from_string( const std::string & value ) + { + auto it = enumFromStringMap.SemaphoreWaitFlagBitsEntries.find( value ); + if ( it != enumFromStringMap.SemaphoreWaitFlagBitsEntries.end() ) + { + return it->second; + } + return std::nullopt; + } + + //=== VK_VERSION_1_3 === + + template <> + VULKAN_HPP_INLINE std::optional from_string( const std::string & value ) + { + auto it = enumFromStringMap.PipelineCreationFeedbackFlagBitsEntries.find( value ); + if ( it != enumFromStringMap.PipelineCreationFeedbackFlagBitsEntries.end() ) + { + return it->second; + } + return std::nullopt; + } + + template <> + VULKAN_HPP_INLINE std::optional from_string( const std::string & value ) + { + auto it = enumFromStringMap.ToolPurposeFlagBitsEntries.find( value ); + if ( it != enumFromStringMap.ToolPurposeFlagBitsEntries.end() ) + { + return it->second; + } + return std::nullopt; + } + + template <> + VULKAN_HPP_INLINE std::optional from_string( const std::string & ) + { + return std::nullopt; + } + + template <> + VULKAN_HPP_INLINE std::optional from_string( const std::string & value ) + { + auto it = enumFromStringMap.PipelineStageFlagBits2Entries.find( value ); + if ( it != enumFromStringMap.PipelineStageFlagBits2Entries.end() ) + { + return it->second; + } + return std::nullopt; + } + + template <> + VULKAN_HPP_INLINE std::optional from_string( const std::string & value ) + { + auto it = enumFromStringMap.AccessFlagBits2Entries.find( value ); + if ( it != enumFromStringMap.AccessFlagBits2Entries.end() ) + { + return it->second; + } + return std::nullopt; + } + + template <> + VULKAN_HPP_INLINE std::optional from_string( const std::string & value ) + { + auto it = enumFromStringMap.SubmitFlagBitsEntries.find( value ); + if ( it != enumFromStringMap.SubmitFlagBitsEntries.end() ) + { + return it->second; + } + return std::nullopt; + } + + template <> + VULKAN_HPP_INLINE std::optional from_string( const std::string & value ) + { + auto it = enumFromStringMap.RenderingFlagBitsEntries.find( value ); + if ( it != enumFromStringMap.RenderingFlagBitsEntries.end() ) + { + return it->second; + } + return std::nullopt; + } + + template <> + VULKAN_HPP_INLINE std::optional from_string( const std::string & value ) + { + auto it = enumFromStringMap.FormatFeatureFlagBits2Entries.find( value ); + if ( it != enumFromStringMap.FormatFeatureFlagBits2Entries.end() ) + { + return it->second; + } + return std::nullopt; + } + + //=== VK_KHR_surface === + + template <> + VULKAN_HPP_INLINE std::optional from_string( const std::string & value ) + { + auto it = enumFromStringMap.SurfaceTransformFlagBitsKHREntries.find( value ); + if ( it != enumFromStringMap.SurfaceTransformFlagBitsKHREntries.end() ) + { + return it->second; + } + return std::nullopt; + } + + template <> + VULKAN_HPP_INLINE std::optional from_string( const std::string & value ) + { + auto it = enumFromStringMap.PresentModeKHREntries.find( value ); + if ( it != enumFromStringMap.PresentModeKHREntries.end() ) + { + return it->second; + } + return std::nullopt; + } + + template <> + VULKAN_HPP_INLINE std::optional from_string( const std::string & value ) + { + auto it = enumFromStringMap.ColorSpaceKHREntries.find( value ); + if ( it != enumFromStringMap.ColorSpaceKHREntries.end() ) + { + return it->second; + } + return std::nullopt; + } + + template <> + VULKAN_HPP_INLINE std::optional from_string( const std::string & value ) + { + auto it = enumFromStringMap.CompositeAlphaFlagBitsKHREntries.find( value ); + if ( it != enumFromStringMap.CompositeAlphaFlagBitsKHREntries.end() ) + { + return it->second; + } + return std::nullopt; + } + + //=== VK_KHR_swapchain === + + template <> + VULKAN_HPP_INLINE std::optional from_string( const std::string & value ) + { + auto it = enumFromStringMap.SwapchainCreateFlagBitsKHREntries.find( value ); + if ( it != enumFromStringMap.SwapchainCreateFlagBitsKHREntries.end() ) + { + return it->second; + } + return std::nullopt; + } + + template <> + VULKAN_HPP_INLINE std::optional from_string( const std::string & value ) + { + auto it = enumFromStringMap.DeviceGroupPresentModeFlagBitsKHREntries.find( value ); + if ( it != enumFromStringMap.DeviceGroupPresentModeFlagBitsKHREntries.end() ) + { + return it->second; + } + return std::nullopt; + } + + //=== VK_KHR_display === + + template <> + VULKAN_HPP_INLINE std::optional from_string( const std::string & value ) + { + auto it = enumFromStringMap.DisplayPlaneAlphaFlagBitsKHREntries.find( value ); + if ( it != enumFromStringMap.DisplayPlaneAlphaFlagBitsKHREntries.end() ) + { + return it->second; + } + return std::nullopt; + } + + template <> + VULKAN_HPP_INLINE std::optional from_string( const std::string & ) + { + return std::nullopt; + } + + template <> + VULKAN_HPP_INLINE std::optional from_string( const std::string & ) + { + return std::nullopt; + } + +#if defined( VK_USE_PLATFORM_XLIB_KHR ) + //=== VK_KHR_xlib_surface === + + template <> + VULKAN_HPP_INLINE std::optional from_string( const std::string & ) + { + return std::nullopt; + } +#endif /*VK_USE_PLATFORM_XLIB_KHR*/ + +#if defined( VK_USE_PLATFORM_XCB_KHR ) + //=== VK_KHR_xcb_surface === + + template <> + VULKAN_HPP_INLINE std::optional from_string( const std::string & ) + { + return std::nullopt; + } +#endif /*VK_USE_PLATFORM_XCB_KHR*/ + +#if defined( VK_USE_PLATFORM_WAYLAND_KHR ) + //=== VK_KHR_wayland_surface === + + template <> + VULKAN_HPP_INLINE std::optional from_string( const std::string & ) + { + return std::nullopt; + } +#endif /*VK_USE_PLATFORM_WAYLAND_KHR*/ + +#if defined( VK_USE_PLATFORM_ANDROID_KHR ) + //=== VK_KHR_android_surface === + + template <> + VULKAN_HPP_INLINE std::optional from_string( const std::string & ) + { + return std::nullopt; + } +#endif /*VK_USE_PLATFORM_ANDROID_KHR*/ + +#if defined( VK_USE_PLATFORM_WIN32_KHR ) + //=== VK_KHR_win32_surface === + + template <> + VULKAN_HPP_INLINE std::optional from_string( const std::string & ) + { + return std::nullopt; + } +#endif /*VK_USE_PLATFORM_WIN32_KHR*/ + + //=== VK_EXT_debug_report === + + template <> + VULKAN_HPP_INLINE std::optional from_string( const std::string & value ) + { + auto it = enumFromStringMap.DebugReportFlagBitsEXTEntries.find( value ); + if ( it != enumFromStringMap.DebugReportFlagBitsEXTEntries.end() ) + { + return it->second; + } + return std::nullopt; + } + + template <> + VULKAN_HPP_INLINE std::optional from_string( const std::string & value ) + { + auto it = enumFromStringMap.DebugReportObjectTypeEXTEntries.find( value ); + if ( it != enumFromStringMap.DebugReportObjectTypeEXTEntries.end() ) + { + return it->second; + } + return std::nullopt; + } + + //=== VK_AMD_rasterization_order === + + template <> + VULKAN_HPP_INLINE std::optional from_string( const std::string & value ) + { + auto it = enumFromStringMap.RasterizationOrderAMDEntries.find( value ); + if ( it != enumFromStringMap.RasterizationOrderAMDEntries.end() ) + { + return it->second; + } + return std::nullopt; + } + + //=== VK_KHR_video_queue === + + template <> + VULKAN_HPP_INLINE std::optional from_string( const std::string & value ) + { + auto it = enumFromStringMap.VideoCodecOperationFlagBitsKHREntries.find( value ); + if ( it != enumFromStringMap.VideoCodecOperationFlagBitsKHREntries.end() ) + { + return it->second; + } + return std::nullopt; + } + + template <> + VULKAN_HPP_INLINE std::optional from_string( const std::string & value ) + { + auto it = enumFromStringMap.VideoChromaSubsamplingFlagBitsKHREntries.find( value ); + if ( it != enumFromStringMap.VideoChromaSubsamplingFlagBitsKHREntries.end() ) + { + return it->second; + } + return std::nullopt; + } + + template <> + VULKAN_HPP_INLINE std::optional from_string( const std::string & value ) + { + auto it = enumFromStringMap.VideoComponentBitDepthFlagBitsKHREntries.find( value ); + if ( it != enumFromStringMap.VideoComponentBitDepthFlagBitsKHREntries.end() ) + { + return it->second; + } + return std::nullopt; + } + + template <> + VULKAN_HPP_INLINE std::optional from_string( const std::string & value ) + { + auto it = enumFromStringMap.VideoCapabilityFlagBitsKHREntries.find( value ); + if ( it != enumFromStringMap.VideoCapabilityFlagBitsKHREntries.end() ) + { + return it->second; + } + return std::nullopt; + } + + template <> + VULKAN_HPP_INLINE std::optional from_string( const std::string & value ) + { + auto it = enumFromStringMap.VideoSessionCreateFlagBitsKHREntries.find( value ); + if ( it != enumFromStringMap.VideoSessionCreateFlagBitsKHREntries.end() ) + { + return it->second; + } + return std::nullopt; + } + + template <> + VULKAN_HPP_INLINE std::optional from_string( const std::string & value ) + { + auto it = enumFromStringMap.VideoCodingControlFlagBitsKHREntries.find( value ); + if ( it != enumFromStringMap.VideoCodingControlFlagBitsKHREntries.end() ) + { + return it->second; + } + return std::nullopt; + } + + template <> + VULKAN_HPP_INLINE std::optional from_string( const std::string & value ) + { + auto it = enumFromStringMap.QueryResultStatusKHREntries.find( value ); + if ( it != enumFromStringMap.QueryResultStatusKHREntries.end() ) + { + return it->second; + } + return std::nullopt; + } + + template <> + VULKAN_HPP_INLINE std::optional from_string( const std::string & ) + { + return std::nullopt; + } + + template <> + VULKAN_HPP_INLINE std::optional from_string( const std::string & ) + { + return std::nullopt; + } + + template <> + VULKAN_HPP_INLINE std::optional from_string( const std::string & ) + { + return std::nullopt; + } + + //=== VK_KHR_video_decode_queue === + + template <> + VULKAN_HPP_INLINE std::optional from_string( const std::string & value ) + { + auto it = enumFromStringMap.VideoDecodeCapabilityFlagBitsKHREntries.find( value ); + if ( it != enumFromStringMap.VideoDecodeCapabilityFlagBitsKHREntries.end() ) + { + return it->second; + } + return std::nullopt; + } + + template <> + VULKAN_HPP_INLINE std::optional from_string( const std::string & value ) + { + auto it = enumFromStringMap.VideoDecodeUsageFlagBitsKHREntries.find( value ); + if ( it != enumFromStringMap.VideoDecodeUsageFlagBitsKHREntries.end() ) + { + return it->second; + } + return std::nullopt; + } + + template <> + VULKAN_HPP_INLINE std::optional from_string( const std::string & ) + { + return std::nullopt; + } + + //=== VK_EXT_transform_feedback === + + template <> + VULKAN_HPP_INLINE std::optional + from_string( const std::string & ) + { + return std::nullopt; + } + +#if defined( VK_ENABLE_BETA_EXTENSIONS ) + //=== VK_EXT_video_encode_h264 === + + template <> + VULKAN_HPP_INLINE std::optional from_string( const std::string & value ) + { + auto it = enumFromStringMap.VideoEncodeH264CapabilityFlagBitsEXTEntries.find( value ); + if ( it != enumFromStringMap.VideoEncodeH264CapabilityFlagBitsEXTEntries.end() ) + { + return it->second; + } + return std::nullopt; + } + + template <> + VULKAN_HPP_INLINE std::optional from_string( const std::string & value ) + { + auto it = enumFromStringMap.VideoEncodeH264StdFlagBitsEXTEntries.find( value ); + if ( it != enumFromStringMap.VideoEncodeH264StdFlagBitsEXTEntries.end() ) + { + return it->second; + } + return std::nullopt; + } + + template <> + VULKAN_HPP_INLINE std::optional from_string( const std::string & value ) + { + auto it = enumFromStringMap.VideoEncodeH264RateControlFlagBitsEXTEntries.find( value ); + if ( it != enumFromStringMap.VideoEncodeH264RateControlFlagBitsEXTEntries.end() ) + { + return it->second; + } + return std::nullopt; + } +#endif /*VK_ENABLE_BETA_EXTENSIONS*/ + +#if defined( VK_ENABLE_BETA_EXTENSIONS ) + //=== VK_EXT_video_encode_h265 === + + template <> + VULKAN_HPP_INLINE std::optional from_string( const std::string & value ) + { + auto it = enumFromStringMap.VideoEncodeH265CapabilityFlagBitsEXTEntries.find( value ); + if ( it != enumFromStringMap.VideoEncodeH265CapabilityFlagBitsEXTEntries.end() ) + { + return it->second; + } + return std::nullopt; + } + + template <> + VULKAN_HPP_INLINE std::optional from_string( const std::string & value ) + { + auto it = enumFromStringMap.VideoEncodeH265StdFlagBitsEXTEntries.find( value ); + if ( it != enumFromStringMap.VideoEncodeH265StdFlagBitsEXTEntries.end() ) + { + return it->second; + } + return std::nullopt; + } + + template <> + VULKAN_HPP_INLINE std::optional from_string( const std::string & value ) + { + auto it = enumFromStringMap.VideoEncodeH265CtbSizeFlagBitsEXTEntries.find( value ); + if ( it != enumFromStringMap.VideoEncodeH265CtbSizeFlagBitsEXTEntries.end() ) + { + return it->second; + } + return std::nullopt; + } + + template <> + VULKAN_HPP_INLINE std::optional + from_string( const std::string & value ) + { + auto it = enumFromStringMap.VideoEncodeH265TransformBlockSizeFlagBitsEXTEntries.find( value ); + if ( it != enumFromStringMap.VideoEncodeH265TransformBlockSizeFlagBitsEXTEntries.end() ) + { + return it->second; + } + return std::nullopt; + } + + template <> + VULKAN_HPP_INLINE std::optional from_string( const std::string & value ) + { + auto it = enumFromStringMap.VideoEncodeH265RateControlFlagBitsEXTEntries.find( value ); + if ( it != enumFromStringMap.VideoEncodeH265RateControlFlagBitsEXTEntries.end() ) + { + return it->second; + } + return std::nullopt; + } +#endif /*VK_ENABLE_BETA_EXTENSIONS*/ + + //=== VK_KHR_video_decode_h264 === + + template <> + VULKAN_HPP_INLINE std::optional from_string( const std::string & value ) + { + auto it = enumFromStringMap.VideoDecodeH264PictureLayoutFlagBitsKHREntries.find( value ); + if ( it != enumFromStringMap.VideoDecodeH264PictureLayoutFlagBitsKHREntries.end() ) + { + return it->second; + } + return std::nullopt; + } + + //=== VK_AMD_shader_info === + + template <> + VULKAN_HPP_INLINE std::optional from_string( const std::string & value ) + { + auto it = enumFromStringMap.ShaderInfoTypeAMDEntries.find( value ); + if ( it != enumFromStringMap.ShaderInfoTypeAMDEntries.end() ) + { + return it->second; + } + return std::nullopt; + } + +#if defined( VK_USE_PLATFORM_GGP ) + //=== VK_GGP_stream_descriptor_surface === + + template <> + VULKAN_HPP_INLINE std::optional from_string( const std::string & ) + { + return std::nullopt; + } +#endif /*VK_USE_PLATFORM_GGP*/ + + //=== VK_NV_external_memory_capabilities === + + template <> + VULKAN_HPP_INLINE std::optional from_string( const std::string & value ) + { + auto it = enumFromStringMap.ExternalMemoryHandleTypeFlagBitsNVEntries.find( value ); + if ( it != enumFromStringMap.ExternalMemoryHandleTypeFlagBitsNVEntries.end() ) + { + return it->second; + } + return std::nullopt; + } + + template <> + VULKAN_HPP_INLINE std::optional from_string( const std::string & value ) + { + auto it = enumFromStringMap.ExternalMemoryFeatureFlagBitsNVEntries.find( value ); + if ( it != enumFromStringMap.ExternalMemoryFeatureFlagBitsNVEntries.end() ) + { + return it->second; + } + return std::nullopt; + } + + //=== VK_EXT_validation_flags === + + template <> + VULKAN_HPP_INLINE std::optional from_string( const std::string & value ) + { + auto it = enumFromStringMap.ValidationCheckEXTEntries.find( value ); + if ( it != enumFromStringMap.ValidationCheckEXTEntries.end() ) + { + return it->second; + } + return std::nullopt; + } + +#if defined( VK_USE_PLATFORM_VI_NN ) + //=== VK_NN_vi_surface === + + template <> + VULKAN_HPP_INLINE std::optional from_string( const std::string & ) + { + return std::nullopt; + } +#endif /*VK_USE_PLATFORM_VI_NN*/ + + //=== VK_EXT_pipeline_robustness === + + template <> + VULKAN_HPP_INLINE std::optional from_string( const std::string & value ) + { + auto it = enumFromStringMap.PipelineRobustnessBufferBehaviorEXTEntries.find( value ); + if ( it != enumFromStringMap.PipelineRobustnessBufferBehaviorEXTEntries.end() ) + { + return it->second; + } + return std::nullopt; + } + + template <> + VULKAN_HPP_INLINE std::optional from_string( const std::string & value ) + { + auto it = enumFromStringMap.PipelineRobustnessImageBehaviorEXTEntries.find( value ); + if ( it != enumFromStringMap.PipelineRobustnessImageBehaviorEXTEntries.end() ) + { + return it->second; + } + return std::nullopt; + } + + //=== VK_EXT_conditional_rendering === + + template <> + VULKAN_HPP_INLINE std::optional from_string( const std::string & value ) + { + auto it = enumFromStringMap.ConditionalRenderingFlagBitsEXTEntries.find( value ); + if ( it != enumFromStringMap.ConditionalRenderingFlagBitsEXTEntries.end() ) + { + return it->second; + } + return std::nullopt; + } + + //=== VK_EXT_display_surface_counter === + + template <> + VULKAN_HPP_INLINE std::optional from_string( const std::string & value ) + { + auto it = enumFromStringMap.SurfaceCounterFlagBitsEXTEntries.find( value ); + if ( it != enumFromStringMap.SurfaceCounterFlagBitsEXTEntries.end() ) + { + return it->second; + } + return std::nullopt; + } + + //=== VK_EXT_display_control === + + template <> + VULKAN_HPP_INLINE std::optional from_string( const std::string & value ) + { + auto it = enumFromStringMap.DisplayPowerStateEXTEntries.find( value ); + if ( it != enumFromStringMap.DisplayPowerStateEXTEntries.end() ) + { + return it->second; + } + return std::nullopt; + } + + template <> + VULKAN_HPP_INLINE std::optional from_string( const std::string & value ) + { + auto it = enumFromStringMap.DeviceEventTypeEXTEntries.find( value ); + if ( it != enumFromStringMap.DeviceEventTypeEXTEntries.end() ) + { + return it->second; + } + return std::nullopt; + } + + template <> + VULKAN_HPP_INLINE std::optional from_string( const std::string & value ) + { + auto it = enumFromStringMap.DisplayEventTypeEXTEntries.find( value ); + if ( it != enumFromStringMap.DisplayEventTypeEXTEntries.end() ) + { + return it->second; + } + return std::nullopt; + } + + //=== VK_NV_viewport_swizzle === + + template <> + VULKAN_HPP_INLINE std::optional from_string( const std::string & value ) + { + auto it = enumFromStringMap.ViewportCoordinateSwizzleNVEntries.find( value ); + if ( it != enumFromStringMap.ViewportCoordinateSwizzleNVEntries.end() ) + { + return it->second; + } + return std::nullopt; + } + + template <> + VULKAN_HPP_INLINE std::optional from_string( const std::string & ) + { + return std::nullopt; + } + + //=== VK_EXT_discard_rectangles === + + template <> + VULKAN_HPP_INLINE std::optional from_string( const std::string & value ) + { + auto it = enumFromStringMap.DiscardRectangleModeEXTEntries.find( value ); + if ( it != enumFromStringMap.DiscardRectangleModeEXTEntries.end() ) + { + return it->second; + } + return std::nullopt; + } + + template <> + VULKAN_HPP_INLINE std::optional + from_string( const std::string & ) + { + return std::nullopt; + } + + //=== VK_EXT_conservative_rasterization === + + template <> + VULKAN_HPP_INLINE std::optional from_string( const std::string & value ) + { + auto it = enumFromStringMap.ConservativeRasterizationModeEXTEntries.find( value ); + if ( it != enumFromStringMap.ConservativeRasterizationModeEXTEntries.end() ) + { + return it->second; + } + return std::nullopt; + } + + template <> + VULKAN_HPP_INLINE std::optional + from_string( const std::string & ) + { + return std::nullopt; + } + + //=== VK_EXT_depth_clip_enable === + + template <> + VULKAN_HPP_INLINE std::optional + from_string( const std::string & ) + { + return std::nullopt; + } + + //=== VK_KHR_performance_query === + + template <> + VULKAN_HPP_INLINE std::optional from_string( const std::string & value ) + { + auto it = enumFromStringMap.PerformanceCounterDescriptionFlagBitsKHREntries.find( value ); + if ( it != enumFromStringMap.PerformanceCounterDescriptionFlagBitsKHREntries.end() ) + { + return it->second; + } + return std::nullopt; + } + + template <> + VULKAN_HPP_INLINE std::optional from_string( const std::string & value ) + { + auto it = enumFromStringMap.PerformanceCounterScopeKHREntries.find( value ); + if ( it != enumFromStringMap.PerformanceCounterScopeKHREntries.end() ) + { + return it->second; + } + return std::nullopt; + } + + template <> + VULKAN_HPP_INLINE std::optional from_string( const std::string & value ) + { + auto it = enumFromStringMap.PerformanceCounterStorageKHREntries.find( value ); + if ( it != enumFromStringMap.PerformanceCounterStorageKHREntries.end() ) + { + return it->second; + } + return std::nullopt; + } + + template <> + VULKAN_HPP_INLINE std::optional from_string( const std::string & value ) + { + auto it = enumFromStringMap.PerformanceCounterUnitKHREntries.find( value ); + if ( it != enumFromStringMap.PerformanceCounterUnitKHREntries.end() ) + { + return it->second; + } + return std::nullopt; + } + + template <> + VULKAN_HPP_INLINE std::optional from_string( const std::string & ) + { + return std::nullopt; + } + +#if defined( VK_USE_PLATFORM_IOS_MVK ) + //=== VK_MVK_ios_surface === + + template <> + VULKAN_HPP_INLINE std::optional from_string( const std::string & ) + { + return std::nullopt; + } +#endif /*VK_USE_PLATFORM_IOS_MVK*/ + +#if defined( VK_USE_PLATFORM_MACOS_MVK ) + //=== VK_MVK_macos_surface === + + template <> + VULKAN_HPP_INLINE std::optional from_string( const std::string & ) + { + return std::nullopt; + } +#endif /*VK_USE_PLATFORM_MACOS_MVK*/ + + //=== VK_EXT_debug_utils === + + template <> + VULKAN_HPP_INLINE std::optional from_string( const std::string & value ) + { + auto it = enumFromStringMap.DebugUtilsMessageSeverityFlagBitsEXTEntries.find( value ); + if ( it != enumFromStringMap.DebugUtilsMessageSeverityFlagBitsEXTEntries.end() ) + { + return it->second; + } + return std::nullopt; + } + + template <> + VULKAN_HPP_INLINE std::optional from_string( const std::string & value ) + { + auto it = enumFromStringMap.DebugUtilsMessageTypeFlagBitsEXTEntries.find( value ); + if ( it != enumFromStringMap.DebugUtilsMessageTypeFlagBitsEXTEntries.end() ) + { + return it->second; + } + return std::nullopt; + } + + template <> + VULKAN_HPP_INLINE std::optional from_string( const std::string & ) + { + return std::nullopt; + } + + template <> + VULKAN_HPP_INLINE std::optional from_string( const std::string & ) + { + return std::nullopt; + } + + //=== VK_EXT_blend_operation_advanced === + + template <> + VULKAN_HPP_INLINE std::optional from_string( const std::string & value ) + { + auto it = enumFromStringMap.BlendOverlapEXTEntries.find( value ); + if ( it != enumFromStringMap.BlendOverlapEXTEntries.end() ) + { + return it->second; + } + return std::nullopt; + } + + //=== VK_NV_fragment_coverage_to_color === + + template <> + VULKAN_HPP_INLINE std::optional from_string( const std::string & ) + { + return std::nullopt; + } + + //=== VK_KHR_acceleration_structure === + + template <> + VULKAN_HPP_INLINE std::optional from_string( const std::string & value ) + { + auto it = enumFromStringMap.AccelerationStructureTypeKHREntries.find( value ); + if ( it != enumFromStringMap.AccelerationStructureTypeKHREntries.end() ) + { + return it->second; + } + return std::nullopt; + } + + template <> + VULKAN_HPP_INLINE std::optional from_string( const std::string & value ) + { + auto it = enumFromStringMap.AccelerationStructureBuildTypeKHREntries.find( value ); + if ( it != enumFromStringMap.AccelerationStructureBuildTypeKHREntries.end() ) + { + return it->second; + } + return std::nullopt; + } + + template <> + VULKAN_HPP_INLINE std::optional from_string( const std::string & value ) + { + auto it = enumFromStringMap.GeometryFlagBitsKHREntries.find( value ); + if ( it != enumFromStringMap.GeometryFlagBitsKHREntries.end() ) + { + return it->second; + } + return std::nullopt; + } + + template <> + VULKAN_HPP_INLINE std::optional from_string( const std::string & value ) + { + auto it = enumFromStringMap.GeometryInstanceFlagBitsKHREntries.find( value ); + if ( it != enumFromStringMap.GeometryInstanceFlagBitsKHREntries.end() ) + { + return it->second; + } + return std::nullopt; + } + + template <> + VULKAN_HPP_INLINE std::optional from_string( const std::string & value ) + { + auto it = enumFromStringMap.BuildAccelerationStructureFlagBitsKHREntries.find( value ); + if ( it != enumFromStringMap.BuildAccelerationStructureFlagBitsKHREntries.end() ) + { + return it->second; + } + return std::nullopt; + } + + template <> + VULKAN_HPP_INLINE std::optional from_string( const std::string & value ) + { + auto it = enumFromStringMap.CopyAccelerationStructureModeKHREntries.find( value ); + if ( it != enumFromStringMap.CopyAccelerationStructureModeKHREntries.end() ) + { + return it->second; + } + return std::nullopt; + } + + template <> + VULKAN_HPP_INLINE std::optional from_string( const std::string & value ) + { + auto it = enumFromStringMap.GeometryTypeKHREntries.find( value ); + if ( it != enumFromStringMap.GeometryTypeKHREntries.end() ) + { + return it->second; + } + return std::nullopt; + } + + template <> + VULKAN_HPP_INLINE std::optional from_string( const std::string & value ) + { + auto it = enumFromStringMap.AccelerationStructureCompatibilityKHREntries.find( value ); + if ( it != enumFromStringMap.AccelerationStructureCompatibilityKHREntries.end() ) + { + return it->second; + } + return std::nullopt; + } + + template <> + VULKAN_HPP_INLINE std::optional from_string( const std::string & value ) + { + auto it = enumFromStringMap.AccelerationStructureCreateFlagBitsKHREntries.find( value ); + if ( it != enumFromStringMap.AccelerationStructureCreateFlagBitsKHREntries.end() ) + { + return it->second; + } + return std::nullopt; + } + + template <> + VULKAN_HPP_INLINE std::optional from_string( const std::string & value ) + { + auto it = enumFromStringMap.BuildAccelerationStructureModeKHREntries.find( value ); + if ( it != enumFromStringMap.BuildAccelerationStructureModeKHREntries.end() ) + { + return it->second; + } + return std::nullopt; + } + + //=== VK_KHR_ray_tracing_pipeline === + + template <> + VULKAN_HPP_INLINE std::optional from_string( const std::string & value ) + { + auto it = enumFromStringMap.RayTracingShaderGroupTypeKHREntries.find( value ); + if ( it != enumFromStringMap.RayTracingShaderGroupTypeKHREntries.end() ) + { + return it->second; + } + return std::nullopt; + } + + template <> + VULKAN_HPP_INLINE std::optional from_string( const std::string & value ) + { + auto it = enumFromStringMap.ShaderGroupShaderKHREntries.find( value ); + if ( it != enumFromStringMap.ShaderGroupShaderKHREntries.end() ) + { + return it->second; + } + return std::nullopt; + } + + //=== VK_NV_framebuffer_mixed_samples === + + template <> + VULKAN_HPP_INLINE std::optional from_string( const std::string & value ) + { + auto it = enumFromStringMap.CoverageModulationModeNVEntries.find( value ); + if ( it != enumFromStringMap.CoverageModulationModeNVEntries.end() ) + { + return it->second; + } + return std::nullopt; + } + + template <> + VULKAN_HPP_INLINE std::optional + from_string( const std::string & ) + { + return std::nullopt; + } + + //=== VK_EXT_validation_cache === + + template <> + VULKAN_HPP_INLINE std::optional from_string( const std::string & value ) + { + auto it = enumFromStringMap.ValidationCacheHeaderVersionEXTEntries.find( value ); + if ( it != enumFromStringMap.ValidationCacheHeaderVersionEXTEntries.end() ) + { + return it->second; + } + return std::nullopt; + } + + template <> + VULKAN_HPP_INLINE std::optional from_string( const std::string & ) + { + return std::nullopt; + } + + //=== VK_NV_shading_rate_image === + + template <> + VULKAN_HPP_INLINE std::optional from_string( const std::string & value ) + { + auto it = enumFromStringMap.ShadingRatePaletteEntryNVEntries.find( value ); + if ( it != enumFromStringMap.ShadingRatePaletteEntryNVEntries.end() ) + { + return it->second; + } + return std::nullopt; + } + + template <> + VULKAN_HPP_INLINE std::optional from_string( const std::string & value ) + { + auto it = enumFromStringMap.CoarseSampleOrderTypeNVEntries.find( value ); + if ( it != enumFromStringMap.CoarseSampleOrderTypeNVEntries.end() ) + { + return it->second; + } + return std::nullopt; + } + + //=== VK_NV_ray_tracing === + + template <> + VULKAN_HPP_INLINE std::optional + from_string( const std::string & value ) + { + auto it = enumFromStringMap.AccelerationStructureMemoryRequirementsTypeNVEntries.find( value ); + if ( it != enumFromStringMap.AccelerationStructureMemoryRequirementsTypeNVEntries.end() ) + { + return it->second; + } + return std::nullopt; + } + + //=== VK_AMD_pipeline_compiler_control === + + template <> + VULKAN_HPP_INLINE std::optional from_string( const std::string & ) + { + return std::nullopt; + } + + //=== VK_EXT_calibrated_timestamps === + + template <> + VULKAN_HPP_INLINE std::optional from_string( const std::string & value ) + { + auto it = enumFromStringMap.TimeDomainEXTEntries.find( value ); + if ( it != enumFromStringMap.TimeDomainEXTEntries.end() ) + { + return it->second; + } + return std::nullopt; + } + + //=== VK_KHR_global_priority === + + template <> + VULKAN_HPP_INLINE std::optional from_string( const std::string & value ) + { + auto it = enumFromStringMap.QueueGlobalPriorityKHREntries.find( value ); + if ( it != enumFromStringMap.QueueGlobalPriorityKHREntries.end() ) + { + return it->second; + } + return std::nullopt; + } + + //=== VK_AMD_memory_overallocation_behavior === + + template <> + VULKAN_HPP_INLINE std::optional from_string( const std::string & value ) + { + auto it = enumFromStringMap.MemoryOverallocationBehaviorAMDEntries.find( value ); + if ( it != enumFromStringMap.MemoryOverallocationBehaviorAMDEntries.end() ) + { + return it->second; + } + return std::nullopt; + } + + //=== VK_INTEL_performance_query === + + template <> + VULKAN_HPP_INLINE std::optional from_string( const std::string & value ) + { + auto it = enumFromStringMap.PerformanceConfigurationTypeINTELEntries.find( value ); + if ( it != enumFromStringMap.PerformanceConfigurationTypeINTELEntries.end() ) + { + return it->second; + } + return std::nullopt; + } + + template <> + VULKAN_HPP_INLINE std::optional from_string( const std::string & value ) + { + auto it = enumFromStringMap.QueryPoolSamplingModeINTELEntries.find( value ); + if ( it != enumFromStringMap.QueryPoolSamplingModeINTELEntries.end() ) + { + return it->second; + } + return std::nullopt; + } + + template <> + VULKAN_HPP_INLINE std::optional from_string( const std::string & value ) + { + auto it = enumFromStringMap.PerformanceOverrideTypeINTELEntries.find( value ); + if ( it != enumFromStringMap.PerformanceOverrideTypeINTELEntries.end() ) + { + return it->second; + } + return std::nullopt; + } + + template <> + VULKAN_HPP_INLINE std::optional from_string( const std::string & value ) + { + auto it = enumFromStringMap.PerformanceParameterTypeINTELEntries.find( value ); + if ( it != enumFromStringMap.PerformanceParameterTypeINTELEntries.end() ) + { + return it->second; + } + return std::nullopt; + } + + template <> + VULKAN_HPP_INLINE std::optional from_string( const std::string & value ) + { + auto it = enumFromStringMap.PerformanceValueTypeINTELEntries.find( value ); + if ( it != enumFromStringMap.PerformanceValueTypeINTELEntries.end() ) + { + return it->second; + } + return std::nullopt; + } + +#if defined( VK_USE_PLATFORM_FUCHSIA ) + //=== VK_FUCHSIA_imagepipe_surface === + + template <> + VULKAN_HPP_INLINE std::optional from_string( const std::string & ) + { + return std::nullopt; + } +#endif /*VK_USE_PLATFORM_FUCHSIA*/ + +#if defined( VK_USE_PLATFORM_METAL_EXT ) + //=== VK_EXT_metal_surface === + + template <> + VULKAN_HPP_INLINE std::optional from_string( const std::string & ) + { + return std::nullopt; + } +#endif /*VK_USE_PLATFORM_METAL_EXT*/ + + //=== VK_KHR_fragment_shading_rate === + + template <> + VULKAN_HPP_INLINE std::optional from_string( const std::string & value ) + { + auto it = enumFromStringMap.FragmentShadingRateCombinerOpKHREntries.find( value ); + if ( it != enumFromStringMap.FragmentShadingRateCombinerOpKHREntries.end() ) + { + return it->second; + } + return std::nullopt; + } + + //=== VK_AMD_shader_core_properties2 === + + template <> + VULKAN_HPP_INLINE std::optional from_string( const std::string & ) + { + return std::nullopt; + } + + //=== VK_EXT_validation_features === + + template <> + VULKAN_HPP_INLINE std::optional from_string( const std::string & value ) + { + auto it = enumFromStringMap.ValidationFeatureEnableEXTEntries.find( value ); + if ( it != enumFromStringMap.ValidationFeatureEnableEXTEntries.end() ) + { + return it->second; + } + return std::nullopt; + } + + template <> + VULKAN_HPP_INLINE std::optional from_string( const std::string & value ) + { + auto it = enumFromStringMap.ValidationFeatureDisableEXTEntries.find( value ); + if ( it != enumFromStringMap.ValidationFeatureDisableEXTEntries.end() ) + { + return it->second; + } + return std::nullopt; + } + + //=== VK_NV_coverage_reduction_mode === + + template <> + VULKAN_HPP_INLINE std::optional from_string( const std::string & value ) + { + auto it = enumFromStringMap.CoverageReductionModeNVEntries.find( value ); + if ( it != enumFromStringMap.CoverageReductionModeNVEntries.end() ) + { + return it->second; + } + return std::nullopt; + } + + template <> + VULKAN_HPP_INLINE std::optional + from_string( const std::string & ) + { + return std::nullopt; + } + + //=== VK_EXT_provoking_vertex === + + template <> + VULKAN_HPP_INLINE std::optional from_string( const std::string & value ) + { + auto it = enumFromStringMap.ProvokingVertexModeEXTEntries.find( value ); + if ( it != enumFromStringMap.ProvokingVertexModeEXTEntries.end() ) + { + return it->second; + } + return std::nullopt; + } + +#if defined( VK_USE_PLATFORM_WIN32_KHR ) + //=== VK_EXT_full_screen_exclusive === + + template <> + VULKAN_HPP_INLINE std::optional from_string( const std::string & value ) + { + auto it = enumFromStringMap.FullScreenExclusiveEXTEntries.find( value ); + if ( it != enumFromStringMap.FullScreenExclusiveEXTEntries.end() ) + { + return it->second; + } + return std::nullopt; + } +#endif /*VK_USE_PLATFORM_WIN32_KHR*/ + + //=== VK_EXT_headless_surface === + + template <> + VULKAN_HPP_INLINE std::optional from_string( const std::string & ) + { + return std::nullopt; + } + + //=== VK_EXT_line_rasterization === + + template <> + VULKAN_HPP_INLINE std::optional from_string( const std::string & value ) + { + auto it = enumFromStringMap.LineRasterizationModeEXTEntries.find( value ); + if ( it != enumFromStringMap.LineRasterizationModeEXTEntries.end() ) + { + return it->second; + } + return std::nullopt; + } + + //=== VK_KHR_pipeline_executable_properties === + + template <> + VULKAN_HPP_INLINE std::optional from_string( const std::string & value ) + { + auto it = enumFromStringMap.PipelineExecutableStatisticFormatKHREntries.find( value ); + if ( it != enumFromStringMap.PipelineExecutableStatisticFormatKHREntries.end() ) + { + return it->second; + } + return std::nullopt; + } + + //=== VK_EXT_host_image_copy === + + template <> + VULKAN_HPP_INLINE std::optional from_string( const std::string & value ) + { + auto it = enumFromStringMap.HostImageCopyFlagBitsEXTEntries.find( value ); + if ( it != enumFromStringMap.HostImageCopyFlagBitsEXTEntries.end() ) + { + return it->second; + } + return std::nullopt; + } + + //=== VK_KHR_map_memory2 === + + template <> + VULKAN_HPP_INLINE std::optional from_string( const std::string & ) + { + return std::nullopt; + } + + //=== VK_EXT_surface_maintenance1 === + + template <> + VULKAN_HPP_INLINE std::optional from_string( const std::string & value ) + { + auto it = enumFromStringMap.PresentScalingFlagBitsEXTEntries.find( value ); + if ( it != enumFromStringMap.PresentScalingFlagBitsEXTEntries.end() ) + { + return it->second; + } + return std::nullopt; + } + + template <> + VULKAN_HPP_INLINE std::optional from_string( const std::string & value ) + { + auto it = enumFromStringMap.PresentGravityFlagBitsEXTEntries.find( value ); + if ( it != enumFromStringMap.PresentGravityFlagBitsEXTEntries.end() ) + { + return it->second; + } + return std::nullopt; + } + + //=== VK_NV_device_generated_commands === + + template <> + VULKAN_HPP_INLINE std::optional from_string( const std::string & value ) + { + auto it = enumFromStringMap.IndirectStateFlagBitsNVEntries.find( value ); + if ( it != enumFromStringMap.IndirectStateFlagBitsNVEntries.end() ) + { + return it->second; + } + return std::nullopt; + } + + template <> + VULKAN_HPP_INLINE std::optional from_string( const std::string & value ) + { + auto it = enumFromStringMap.IndirectCommandsTokenTypeNVEntries.find( value ); + if ( it != enumFromStringMap.IndirectCommandsTokenTypeNVEntries.end() ) + { + return it->second; + } + return std::nullopt; + } + + template <> + VULKAN_HPP_INLINE std::optional from_string( const std::string & value ) + { + auto it = enumFromStringMap.IndirectCommandsLayoutUsageFlagBitsNVEntries.find( value ); + if ( it != enumFromStringMap.IndirectCommandsLayoutUsageFlagBitsNVEntries.end() ) + { + return it->second; + } + return std::nullopt; + } + + //=== VK_EXT_depth_bias_control === + + template <> + VULKAN_HPP_INLINE std::optional from_string( const std::string & value ) + { + auto it = enumFromStringMap.DepthBiasRepresentationEXTEntries.find( value ); + if ( it != enumFromStringMap.DepthBiasRepresentationEXTEntries.end() ) + { + return it->second; + } + return std::nullopt; + } + + //=== VK_EXT_device_memory_report === + + template <> + VULKAN_HPP_INLINE std::optional from_string( const std::string & value ) + { + auto it = enumFromStringMap.DeviceMemoryReportEventTypeEXTEntries.find( value ); + if ( it != enumFromStringMap.DeviceMemoryReportEventTypeEXTEntries.end() ) + { + return it->second; + } + return std::nullopt; + } + + template <> + VULKAN_HPP_INLINE std::optional from_string( const std::string & ) + { + return std::nullopt; + } + +#if defined( VK_ENABLE_BETA_EXTENSIONS ) + //=== VK_KHR_video_encode_queue === + + template <> + VULKAN_HPP_INLINE std::optional from_string( const std::string & value ) + { + auto it = enumFromStringMap.VideoEncodeCapabilityFlagBitsKHREntries.find( value ); + if ( it != enumFromStringMap.VideoEncodeCapabilityFlagBitsKHREntries.end() ) + { + return it->second; + } + return std::nullopt; + } + + template <> + VULKAN_HPP_INLINE std::optional from_string( const std::string & value ) + { + auto it = enumFromStringMap.VideoEncodeFeedbackFlagBitsKHREntries.find( value ); + if ( it != enumFromStringMap.VideoEncodeFeedbackFlagBitsKHREntries.end() ) + { + return it->second; + } + return std::nullopt; + } + + template <> + VULKAN_HPP_INLINE std::optional from_string( const std::string & value ) + { + auto it = enumFromStringMap.VideoEncodeUsageFlagBitsKHREntries.find( value ); + if ( it != enumFromStringMap.VideoEncodeUsageFlagBitsKHREntries.end() ) + { + return it->second; + } + return std::nullopt; + } + + template <> + VULKAN_HPP_INLINE std::optional from_string( const std::string & value ) + { + auto it = enumFromStringMap.VideoEncodeContentFlagBitsKHREntries.find( value ); + if ( it != enumFromStringMap.VideoEncodeContentFlagBitsKHREntries.end() ) + { + return it->second; + } + return std::nullopt; + } + + template <> + VULKAN_HPP_INLINE std::optional from_string( const std::string & value ) + { + auto it = enumFromStringMap.VideoEncodeTuningModeKHREntries.find( value ); + if ( it != enumFromStringMap.VideoEncodeTuningModeKHREntries.end() ) + { + return it->second; + } + return std::nullopt; + } + + template <> + VULKAN_HPP_INLINE std::optional from_string( const std::string & value ) + { + auto it = enumFromStringMap.VideoEncodeRateControlModeFlagBitsKHREntries.find( value ); + if ( it != enumFromStringMap.VideoEncodeRateControlModeFlagBitsKHREntries.end() ) + { + return it->second; + } + return std::nullopt; + } + + template <> + VULKAN_HPP_INLINE std::optional from_string( const std::string & ) + { + return std::nullopt; + } + + template <> + VULKAN_HPP_INLINE std::optional from_string( const std::string & ) + { + return std::nullopt; + } +#endif /*VK_ENABLE_BETA_EXTENSIONS*/ + + //=== VK_NV_device_diagnostics_config === + + template <> + VULKAN_HPP_INLINE std::optional from_string( const std::string & value ) + { + auto it = enumFromStringMap.DeviceDiagnosticsConfigFlagBitsNVEntries.find( value ); + if ( it != enumFromStringMap.DeviceDiagnosticsConfigFlagBitsNVEntries.end() ) + { + return it->second; + } + return std::nullopt; + } + +#if defined( VK_USE_PLATFORM_METAL_EXT ) + //=== VK_EXT_metal_objects === + + template <> + VULKAN_HPP_INLINE std::optional from_string( const std::string & value ) + { + auto it = enumFromStringMap.ExportMetalObjectTypeFlagBitsEXTEntries.find( value ); + if ( it != enumFromStringMap.ExportMetalObjectTypeFlagBitsEXTEntries.end() ) + { + return it->second; + } + return std::nullopt; + } +#endif /*VK_USE_PLATFORM_METAL_EXT*/ + + //=== VK_EXT_graphics_pipeline_library === + + template <> + VULKAN_HPP_INLINE std::optional from_string( const std::string & value ) + { + auto it = enumFromStringMap.GraphicsPipelineLibraryFlagBitsEXTEntries.find( value ); + if ( it != enumFromStringMap.GraphicsPipelineLibraryFlagBitsEXTEntries.end() ) + { + return it->second; + } + return std::nullopt; + } + + //=== VK_NV_fragment_shading_rate_enums === + + template <> + VULKAN_HPP_INLINE std::optional from_string( const std::string & value ) + { + auto it = enumFromStringMap.FragmentShadingRateNVEntries.find( value ); + if ( it != enumFromStringMap.FragmentShadingRateNVEntries.end() ) + { + return it->second; + } + return std::nullopt; + } + + template <> + VULKAN_HPP_INLINE std::optional from_string( const std::string & value ) + { + auto it = enumFromStringMap.FragmentShadingRateTypeNVEntries.find( value ); + if ( it != enumFromStringMap.FragmentShadingRateTypeNVEntries.end() ) + { + return it->second; + } + return std::nullopt; + } + + //=== VK_NV_ray_tracing_motion_blur === + + template <> + VULKAN_HPP_INLINE std::optional from_string( const std::string & value ) + { + auto it = enumFromStringMap.AccelerationStructureMotionInstanceTypeNVEntries.find( value ); + if ( it != enumFromStringMap.AccelerationStructureMotionInstanceTypeNVEntries.end() ) + { + return it->second; + } + return std::nullopt; + } + + template <> + VULKAN_HPP_INLINE std::optional from_string( const std::string & ) + { + return std::nullopt; + } + + template <> + VULKAN_HPP_INLINE std::optional + from_string( const std::string & ) + { + return std::nullopt; + } + + //=== VK_EXT_image_compression_control === + + template <> + VULKAN_HPP_INLINE std::optional from_string( const std::string & value ) + { + auto it = enumFromStringMap.ImageCompressionFlagBitsEXTEntries.find( value ); + if ( it != enumFromStringMap.ImageCompressionFlagBitsEXTEntries.end() ) + { + return it->second; + } + return std::nullopt; + } + + template <> + VULKAN_HPP_INLINE std::optional from_string( const std::string & value ) + { + auto it = enumFromStringMap.ImageCompressionFixedRateFlagBitsEXTEntries.find( value ); + if ( it != enumFromStringMap.ImageCompressionFixedRateFlagBitsEXTEntries.end() ) + { + return it->second; + } + return std::nullopt; + } + + //=== VK_EXT_device_fault === + + template <> + VULKAN_HPP_INLINE std::optional from_string( const std::string & value ) + { + auto it = enumFromStringMap.DeviceFaultAddressTypeEXTEntries.find( value ); + if ( it != enumFromStringMap.DeviceFaultAddressTypeEXTEntries.end() ) + { + return it->second; + } + return std::nullopt; + } + + template <> + VULKAN_HPP_INLINE std::optional from_string( const std::string & value ) + { + auto it = enumFromStringMap.DeviceFaultVendorBinaryHeaderVersionEXTEntries.find( value ); + if ( it != enumFromStringMap.DeviceFaultVendorBinaryHeaderVersionEXTEntries.end() ) + { + return it->second; + } + return std::nullopt; + } + +#if defined( VK_USE_PLATFORM_DIRECTFB_EXT ) + //=== VK_EXT_directfb_surface === + + template <> + VULKAN_HPP_INLINE std::optional from_string( const std::string & ) + { + return std::nullopt; + } +#endif /*VK_USE_PLATFORM_DIRECTFB_EXT*/ + + //=== VK_EXT_device_address_binding_report === + + template <> + VULKAN_HPP_INLINE std::optional from_string( const std::string & value ) + { + auto it = enumFromStringMap.DeviceAddressBindingFlagBitsEXTEntries.find( value ); + if ( it != enumFromStringMap.DeviceAddressBindingFlagBitsEXTEntries.end() ) + { + return it->second; + } + return std::nullopt; + } + + template <> + VULKAN_HPP_INLINE std::optional from_string( const std::string & value ) + { + auto it = enumFromStringMap.DeviceAddressBindingTypeEXTEntries.find( value ); + if ( it != enumFromStringMap.DeviceAddressBindingTypeEXTEntries.end() ) + { + return it->second; + } + return std::nullopt; + } + +#if defined( VK_USE_PLATFORM_FUCHSIA ) + //=== VK_FUCHSIA_buffer_collection === + + template <> + VULKAN_HPP_INLINE std::optional from_string( const std::string & value ) + { + auto it = enumFromStringMap.ImageConstraintsInfoFlagBitsFUCHSIAEntries.find( value ); + if ( it != enumFromStringMap.ImageConstraintsInfoFlagBitsFUCHSIAEntries.end() ) + { + return it->second; + } + return std::nullopt; + } + + template <> + VULKAN_HPP_INLINE std::optional from_string( const std::string & ) + { + return std::nullopt; + } +#endif /*VK_USE_PLATFORM_FUCHSIA*/ + + //=== VK_EXT_frame_boundary === + + template <> + VULKAN_HPP_INLINE std::optional from_string( const std::string & value ) + { + auto it = enumFromStringMap.FrameBoundaryFlagBitsEXTEntries.find( value ); + if ( it != enumFromStringMap.FrameBoundaryFlagBitsEXTEntries.end() ) + { + return it->second; + } + return std::nullopt; + } + +#if defined( VK_USE_PLATFORM_SCREEN_QNX ) + //=== VK_QNX_screen_surface === + + template <> + VULKAN_HPP_INLINE std::optional from_string( const std::string & ) + { + return std::nullopt; + } +#endif /*VK_USE_PLATFORM_SCREEN_QNX*/ + + //=== VK_EXT_opacity_micromap === + + template <> + VULKAN_HPP_INLINE std::optional from_string( const std::string & value ) + { + auto it = enumFromStringMap.MicromapTypeEXTEntries.find( value ); + if ( it != enumFromStringMap.MicromapTypeEXTEntries.end() ) + { + return it->second; + } + return std::nullopt; + } + + template <> + VULKAN_HPP_INLINE std::optional from_string( const std::string & value ) + { + auto it = enumFromStringMap.BuildMicromapFlagBitsEXTEntries.find( value ); + if ( it != enumFromStringMap.BuildMicromapFlagBitsEXTEntries.end() ) + { + return it->second; + } + return std::nullopt; + } + + template <> + VULKAN_HPP_INLINE std::optional from_string( const std::string & value ) + { + auto it = enumFromStringMap.CopyMicromapModeEXTEntries.find( value ); + if ( it != enumFromStringMap.CopyMicromapModeEXTEntries.end() ) + { + return it->second; + } + return std::nullopt; + } + + template <> + VULKAN_HPP_INLINE std::optional from_string( const std::string & value ) + { + auto it = enumFromStringMap.MicromapCreateFlagBitsEXTEntries.find( value ); + if ( it != enumFromStringMap.MicromapCreateFlagBitsEXTEntries.end() ) + { + return it->second; + } + return std::nullopt; + } + + template <> + VULKAN_HPP_INLINE std::optional from_string( const std::string & value ) + { + auto it = enumFromStringMap.BuildMicromapModeEXTEntries.find( value ); + if ( it != enumFromStringMap.BuildMicromapModeEXTEntries.end() ) + { + return it->second; + } + return std::nullopt; + } + + template <> + VULKAN_HPP_INLINE std::optional from_string( const std::string & value ) + { + auto it = enumFromStringMap.OpacityMicromapFormatEXTEntries.find( value ); + if ( it != enumFromStringMap.OpacityMicromapFormatEXTEntries.end() ) + { + return it->second; + } + return std::nullopt; + } + + template <> + VULKAN_HPP_INLINE std::optional from_string( const std::string & value ) + { + auto it = enumFromStringMap.OpacityMicromapSpecialIndexEXTEntries.find( value ); + if ( it != enumFromStringMap.OpacityMicromapSpecialIndexEXTEntries.end() ) + { + return it->second; + } + return std::nullopt; + } + +#if defined( VK_ENABLE_BETA_EXTENSIONS ) + //=== VK_NV_displacement_micromap === + + template <> + VULKAN_HPP_INLINE std::optional from_string( const std::string & value ) + { + auto it = enumFromStringMap.DisplacementMicromapFormatNVEntries.find( value ); + if ( it != enumFromStringMap.DisplacementMicromapFormatNVEntries.end() ) + { + return it->second; + } + return std::nullopt; + } +#endif /*VK_ENABLE_BETA_EXTENSIONS*/ + + //=== VK_ARM_scheduling_controls === + + template <> + VULKAN_HPP_INLINE std::optional + from_string( const std::string & value ) + { + auto it = enumFromStringMap.PhysicalDeviceSchedulingControlsFlagBitsARMEntries.find( value ); + if ( it != enumFromStringMap.PhysicalDeviceSchedulingControlsFlagBitsARMEntries.end() ) + { + return it->second; + } + return std::nullopt; + } + + //=== VK_NV_memory_decompression === + + template <> + VULKAN_HPP_INLINE std::optional from_string( const std::string & value ) + { + auto it = enumFromStringMap.MemoryDecompressionMethodFlagBitsNVEntries.find( value ); + if ( it != enumFromStringMap.MemoryDecompressionMethodFlagBitsNVEntries.end() ) + { + return it->second; + } + return std::nullopt; + } + + //=== VK_EXT_subpass_merge_feedback === + + template <> + VULKAN_HPP_INLINE std::optional from_string( const std::string & value ) + { + auto it = enumFromStringMap.SubpassMergeStatusEXTEntries.find( value ); + if ( it != enumFromStringMap.SubpassMergeStatusEXTEntries.end() ) + { + return it->second; + } + return std::nullopt; + } + + //=== VK_LUNARG_direct_driver_loading === + + template <> + VULKAN_HPP_INLINE std::optional from_string( const std::string & value ) + { + auto it = enumFromStringMap.DirectDriverLoadingModeLUNARGEntries.find( value ); + if ( it != enumFromStringMap.DirectDriverLoadingModeLUNARGEntries.end() ) + { + return it->second; + } + return std::nullopt; + } + + template <> + VULKAN_HPP_INLINE std::optional from_string( const std::string & ) + { + return std::nullopt; + } + + //=== VK_NV_optical_flow === + + template <> + VULKAN_HPP_INLINE std::optional from_string( const std::string & value ) + { + auto it = enumFromStringMap.OpticalFlowUsageFlagBitsNVEntries.find( value ); + if ( it != enumFromStringMap.OpticalFlowUsageFlagBitsNVEntries.end() ) + { + return it->second; + } + return std::nullopt; + } + + template <> + VULKAN_HPP_INLINE std::optional from_string( const std::string & value ) + { + auto it = enumFromStringMap.OpticalFlowGridSizeFlagBitsNVEntries.find( value ); + if ( it != enumFromStringMap.OpticalFlowGridSizeFlagBitsNVEntries.end() ) + { + return it->second; + } + return std::nullopt; + } + + template <> + VULKAN_HPP_INLINE std::optional from_string( const std::string & value ) + { + auto it = enumFromStringMap.OpticalFlowPerformanceLevelNVEntries.find( value ); + if ( it != enumFromStringMap.OpticalFlowPerformanceLevelNVEntries.end() ) + { + return it->second; + } + return std::nullopt; + } + + template <> + VULKAN_HPP_INLINE std::optional from_string( const std::string & value ) + { + auto it = enumFromStringMap.OpticalFlowSessionBindingPointNVEntries.find( value ); + if ( it != enumFromStringMap.OpticalFlowSessionBindingPointNVEntries.end() ) + { + return it->second; + } + return std::nullopt; + } + + template <> + VULKAN_HPP_INLINE std::optional from_string( const std::string & value ) + { + auto it = enumFromStringMap.OpticalFlowSessionCreateFlagBitsNVEntries.find( value ); + if ( it != enumFromStringMap.OpticalFlowSessionCreateFlagBitsNVEntries.end() ) + { + return it->second; + } + return std::nullopt; + } + + template <> + VULKAN_HPP_INLINE std::optional from_string( const std::string & value ) + { + auto it = enumFromStringMap.OpticalFlowExecuteFlagBitsNVEntries.find( value ); + if ( it != enumFromStringMap.OpticalFlowExecuteFlagBitsNVEntries.end() ) + { + return it->second; + } + return std::nullopt; + } + + //=== VK_KHR_maintenance5 === + + template <> + VULKAN_HPP_INLINE std::optional from_string( const std::string & value ) + { + auto it = enumFromStringMap.PipelineCreateFlagBits2KHREntries.find( value ); + if ( it != enumFromStringMap.PipelineCreateFlagBits2KHREntries.end() ) + { + return it->second; + } + return std::nullopt; + } + + template <> + VULKAN_HPP_INLINE std::optional from_string( const std::string & value ) + { + auto it = enumFromStringMap.BufferUsageFlagBits2KHREntries.find( value ); + if ( it != enumFromStringMap.BufferUsageFlagBits2KHREntries.end() ) + { + return it->second; + } + return std::nullopt; + } + + //=== VK_EXT_shader_object === + + template <> + VULKAN_HPP_INLINE std::optional from_string( const std::string & value ) + { + auto it = enumFromStringMap.ShaderCreateFlagBitsEXTEntries.find( value ); + if ( it != enumFromStringMap.ShaderCreateFlagBitsEXTEntries.end() ) + { + return it->second; + } + return std::nullopt; + } + + template <> + VULKAN_HPP_INLINE std::optional from_string( const std::string & value ) + { + auto it = enumFromStringMap.ShaderCodeTypeEXTEntries.find( value ); + if ( it != enumFromStringMap.ShaderCodeTypeEXTEntries.end() ) + { + return it->second; + } + return std::nullopt; + } + + //=== VK_NV_ray_tracing_invocation_reorder === + + template <> + VULKAN_HPP_INLINE std::optional from_string( const std::string & value ) + { + auto it = enumFromStringMap.RayTracingInvocationReorderModeNVEntries.find( value ); + if ( it != enumFromStringMap.RayTracingInvocationReorderModeNVEntries.end() ) + { + return it->second; + } + return std::nullopt; + } + + //=== VK_NV_low_latency2 === + + template <> + VULKAN_HPP_INLINE std::optional from_string( const std::string & value ) + { + auto it = enumFromStringMap.LatencyMarkerNVEntries.find( value ); + if ( it != enumFromStringMap.LatencyMarkerNVEntries.end() ) + { + return it->second; + } + return std::nullopt; + } + + template <> + VULKAN_HPP_INLINE std::optional from_string( const std::string & value ) + { + auto it = enumFromStringMap.OutOfBandQueueTypeNVEntries.find( value ); + if ( it != enumFromStringMap.OutOfBandQueueTypeNVEntries.end() ) + { + return it->second; + } + return std::nullopt; + } + + //=== VK_KHR_cooperative_matrix === + + template <> + VULKAN_HPP_INLINE std::optional from_string( const std::string & value ) + { + auto it = enumFromStringMap.ScopeKHREntries.find( value ); + if ( it != enumFromStringMap.ScopeKHREntries.end() ) + { + return it->second; + } + return std::nullopt; + } + + template <> + VULKAN_HPP_INLINE std::optional from_string( const std::string & value ) + { + auto it = enumFromStringMap.ComponentTypeKHREntries.find( value ); + if ( it != enumFromStringMap.ComponentTypeKHREntries.end() ) + { + return it->second; + } + return std::nullopt; + } + + //=== VK_QCOM_image_processing2 === + + template <> + VULKAN_HPP_INLINE std::optional from_string( const std::string & value ) + { + auto it = enumFromStringMap.BlockMatchWindowCompareModeQCOMEntries.find( value ); + if ( it != enumFromStringMap.BlockMatchWindowCompareModeQCOMEntries.end() ) + { + return it->second; + } + return std::nullopt; + } + + //=== VK_QCOM_filter_cubic_weights === + + template <> + VULKAN_HPP_INLINE std::optional from_string( const std::string & value ) + { + auto it = enumFromStringMap.CubicFilterWeightsQCOMEntries.find( value ); + if ( it != enumFromStringMap.CubicFilterWeightsQCOMEntries.end() ) + { + return it->second; + } + return std::nullopt; + } + + //=== VK_MSFT_layered_driver === + + template <> + VULKAN_HPP_INLINE std::optional from_string( const std::string & value ) + { + auto it = enumFromStringMap.LayeredDriverUnderlyingApiMSFTEntries.find( value ); + if ( it != enumFromStringMap.LayeredDriverUnderlyingApiMSFTEntries.end() ) + { + return it->second; + } + return std::nullopt; + } + +} // namespace VULKAN_HPP_NAMESPACE +#endif diff --git a/vulkan/vulkan_funcs.hpp b/vulkan/vulkan_funcs.hpp index 644f4ef..d5adf7e 100644 --- a/vulkan/vulkan_funcs.hpp +++ b/vulkan/vulkan_funcs.hpp @@ -17525,7 +17525,7 @@ namespace VULKAN_HPP_NAMESPACE # else template VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS VULKAN_HPP_INLINE typename ResultValueType::type - Device::acquireFullScreenExclusiveModeEXT( VULKAN_HPP_NAMESPACE::SwapchainKHR swapchain, Dispatch const & d ) const + Device::acquireFullScreenExclusiveModeEXT( VULKAN_HPP_NAMESPACE::SwapchainKHR swapchain, Dispatch const & d ) const { VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); @@ -17547,7 +17547,7 @@ namespace VULKAN_HPP_NAMESPACE # else template VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS VULKAN_HPP_INLINE typename ResultValueType::type - Device::releaseFullScreenExclusiveModeEXT( VULKAN_HPP_NAMESPACE::SwapchainKHR swapchain, Dispatch const & d ) const + Device::releaseFullScreenExclusiveModeEXT( VULKAN_HPP_NAMESPACE::SwapchainKHR swapchain, Dispatch const & d ) const { VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); @@ -20238,7 +20238,7 @@ namespace VULKAN_HPP_NAMESPACE # else template VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS VULKAN_HPP_INLINE typename ResultValueType::type - PhysicalDevice::acquireWinrtDisplayNV( VULKAN_HPP_NAMESPACE::DisplayKHR display, Dispatch const & d ) const + PhysicalDevice::acquireWinrtDisplayNV( VULKAN_HPP_NAMESPACE::DisplayKHR display, Dispatch const & d ) const { VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );