From b0bf764266175bb051486aa92455963f3e11149c Mon Sep 17 00:00:00 2001 From: asuessenbach Date: Tue, 8 Jun 2021 11:08:11 +0200 Subject: [PATCH] Re-arranged handling of FlagBits not listed as required for a Flags. --- VulkanHppGenerator.cpp | 191 ++++---- VulkanHppGenerator.hpp | 21 +- vulkan/vulkan.hpp | 983 ++++++++++++++++++++++------------------- 3 files changed, 631 insertions(+), 564 deletions(-) diff --git a/VulkanHppGenerator.cpp b/VulkanHppGenerator.cpp index 5137a56..ac34610 100644 --- a/VulkanHppGenerator.cpp +++ b/VulkanHppGenerator.cpp @@ -715,6 +715,16 @@ VulkanHppGenerator::VulkanHppGenerator( tinyxml2::XMLDocument const & document ) readRegistry( elements[0] ); checkCorrectness(); + // some "FlagBits" enums are not specified, but needed for our "Flags" handling -> add them here + for ( auto & feature : m_features ) + { + addMissingFlagBits( feature.second.types, feature.first ); + } + for ( auto & ext : m_extensions ) + { + addMissingFlagBits( ext.second.types, ext.first ); + } + for ( auto extensionIt = m_extensions.begin(); extensionIt != m_extensions.end(); ++extensionIt ) { int number = atoi( extensionIt->second.number.c_str() ); @@ -746,6 +756,46 @@ void VulkanHppGenerator::addCommand( std::string const & name, CommandData & com "command list of handle <" + handleIt->first + "> already holds a commnand <" + name + ">" ); } +void VulkanHppGenerator::addMissingFlagBits( std::vector & types, std::string const & referencedIn ) +{ + std::vector newTypes; + for ( auto & type : types ) + { + auto bitmaskIt = m_bitmasks.find( type ); + if ( ( bitmaskIt != m_bitmasks.end() ) && bitmaskIt->second.requirements.empty() ) + { + size_t pos = bitmaskIt->first.find( "Flags" ); + assert( pos != std::string::npos ); + std::string flagBits = bitmaskIt->first.substr( 0, pos + 4 ) + "Bit" + bitmaskIt->first.substr( pos + 4 ); + bitmaskIt->second.requirements = flagBits; + + // some flagsBits are specified but never listed as required for any flags! + // so, even if this bitmask has not enum listed as required, it might still already exist in the enums list + if ( m_enums.find( flagBits ) == m_enums.end() ) + { + EnumData flagBitsData( 0 ); + flagBitsData.isBitmask = true; + m_enums.insert( std::make_pair( flagBits, flagBitsData ) ); + + assert( m_types.find( flagBits ) == m_types.end() ); + TypeData typeData( TypeCategory::Bitmask ); + typeData.referencedIn = referencedIn; + m_types.insert( std::make_pair( flagBits, typeData ) ); + } + else + { + assert( m_types.find( flagBits ) != m_types.end() ); + } + + assert( std::find_if( types.begin(), + types.end(), + [&flagBits]( std::string const & type ) { return ( type == flagBits ); } ) == types.end() ); + newTypes.push_back( flagBits ); + } + } + types.insert( types.end(), newTypes.begin(), newTypes.end() ); +} + void VulkanHppGenerator::appendArgumentPlainType( std::string & str, ParamData const & paramData ) const { // this parameter is just a plain type @@ -889,11 +939,11 @@ void VulkanHppGenerator::appendBitmasks( std::string & str ) const str += "\n //=== " + feature.first + " ===\n"; for ( auto const & type : feature.second.types ) { - auto bitmaskIt = m_bitmasks.find( type.first ); + auto bitmaskIt = m_bitmasks.find( type ); if ( bitmaskIt != m_bitmasks.end() ) { - assert( listedBitmasks.find( type.first ) == listedBitmasks.end() ); - listedBitmasks.insert( type.first ); + assert( listedBitmasks.find( type ) == listedBitmasks.end() ); + listedBitmasks.insert( type ); appendBitmask( str, bitmaskIt ); } } @@ -959,33 +1009,7 @@ void VulkanHppGenerator::appendBitmask( std::string & str, std::vector const & enumValues ) const { // each Flags class is using the class 'Flags' with the corresponding FlagBits enum as the template parameter - // if there's no enum for the FlagBits, introduce an artificial empty one - std::string emptyEnumName; - if ( enumName.empty() ) - { - emptyEnumName = bitmaskName; - size_t pos = emptyEnumName.rfind( "Flags" ); - assert( pos != std::string::npos ); - emptyEnumName.replace( pos, 5, "FlagBits" ); - - // if this emptyEnumName is not in the list of enums, list it here - if ( m_enums.find( "Vk" + emptyEnumName ) == m_enums.end() ) - { - const std::string templateString = R"x( - enum class ${enumName} : ${bitmaskType} - {}; - - VULKAN_HPP_INLINE std::string to_string( ${enumName} ) - { - return "(void)"; - } -)x"; - - str += replaceWithMap( templateString, { { "enumName", emptyEnumName }, { "bitmaskType", bitmaskType } } ); - } - } - std::string name = ( enumName.empty() ? emptyEnumName : enumName ); - str += "\n using " + bitmaskName + " = Flags<" + name + ">;\n"; + str += "\n using " + bitmaskName + " = Flags<" + enumName + ">;\n"; if ( !enumValues.empty() ) { @@ -996,7 +1020,7 @@ void VulkanHppGenerator::appendBitmask( std::string & str, { std::string enter, leave; std::tie( enter, leave ) = generateProtection( value.extension ); - std::string valueName = generateEnumValueName( "Vk" + name, value.name, true, m_tags ); + std::string valueName = generateEnumValueName( "Vk" + enumName, value.name, true, m_tags ); allFlags += ( ( previousEnter != enter ) ? ( "\n" + previousLeave + enter ) : "\n" ) + " " + ( encounteredFlag ? "| " : " " ) + bitmaskType + "( " + enumName + "::" + valueName + " )"; encounteredFlag = true; @@ -2730,11 +2754,11 @@ void VulkanHppGenerator::appendEnums( std::string & str ) const str += "\n //=== " + feature.first + " ===\n"; for ( auto const & type : feature.second.types ) { - auto enumIt = m_enums.find( type.first ); + auto enumIt = m_enums.find( type ); if ( enumIt != m_enums.end() ) { - assert( listedEnums.find( type.first ) == listedEnums.end() ); - listedEnums.insert( type.first ); + assert( listedEnums.find( type ) == listedEnums.end() ); + listedEnums.insert( type ); str += "\n"; appendEnum( str, *enumIt ); @@ -11225,6 +11249,16 @@ void VulkanHppGenerator::checkCorrectness() } } + // enum checks by features and extensions + for ( auto & feature : m_features ) + { + checkEnumCorrectness( feature.second.types ); + } + for ( auto & ext : m_extensions ) + { + checkEnumCorrectness( ext.second.types ); + } + // extension checks for ( auto const & extension : m_extensions ) { @@ -11421,6 +11455,29 @@ void VulkanHppGenerator::checkCorrectness() assert( sTypeValues.empty() ); } +void VulkanHppGenerator::checkEnumCorrectness( std::vector const & types ) const +{ + for ( auto const & type : types ) + { + auto enumIt = m_enums.find( type ); + if ( ( enumIt != m_enums.end() ) && enumIt->second.isBitmask ) + { + auto bitmaskIt = + std::find_if( m_bitmasks.begin(), + m_bitmasks.end(), + [&enumIt]( auto const & bitmask ) { return bitmask.second.requirements == enumIt->first; } ); + check( bitmaskIt != m_bitmasks.end(), + enumIt->second.xmlLine, + "enum <" + enumIt->first + + "> is not listed as an requires or bitvalues for any bitmask in the types section" ); + check( ( enumIt->second.bitwidth != "64" ) || ( bitmaskIt->second.type == "VkFlags64" ), + enumIt->second.xmlLine, + "enum <" + enumIt->first + "> is marked with bitwidth <64> but corresponding bitmask <" + + bitmaskIt->first + "> is not of type " ); + } + } +} + bool VulkanHppGenerator::containsArray( std::string const & type ) const { // a simple recursive check if a type is or contains an array @@ -12835,18 +12892,9 @@ void VulkanHppGenerator::readEnums( tinyxml2::XMLElement const * element ) if ( bitmask ) { check( name.find( "FlagBits" ) != std::string::npos, line, "bitmask <" + name + "> does not contain " ); - auto bitmaskIt = std::find_if( m_bitmasks.begin(), - m_bitmasks.end(), - [&name]( auto const & bitmask ) { return bitmask.second.requirements == name; } ); - check( bitmaskIt != m_bitmasks.end(), - line, - "enum <" + name + "> is not listed as an requires or bitvalues for any bitmask in the types section" ); - check( ( bitwidth != "64" ) || ( bitmaskIt->second.type == "VkFlags64" ), - line, - "enum <" + name + "> is marked with bitwidth <64> but corresponding bitmask <" + bitmaskIt->first + - "> is not of type " ); } enumIt->second.isBitmask = bitmask; + enumIt->second.bitwidth = bitwidth; // read the names of the enum values for ( auto child : children ) @@ -13326,13 +13374,8 @@ void VulkanHppGenerator::readFeatureRequireType( tinyxml2::XMLElement const * std::string name = attributes.find( "name" )->second; auto featureTypeIt = std::find_if( featureIt->second.types.begin(), featureIt->second.types.end(), - [&name]( std::pair const & typeLine ) - { return ( typeLine.first == name ) && ( typeLine.second != 0 ); } ); - check( featureTypeIt == featureIt->second.types.end(), - line, - "type <" + name + "> already listed for this feature on line " + - ( ( featureTypeIt == featureIt->second.types.end() ) ? "" : std::to_string( featureTypeIt->second ) ) + - " !" ); + [&name]( std::string const & type ) { return type == name; } ); + check( featureTypeIt == featureIt->second.types.end(), line, "type <" + name + "> already listed for this feature!" ); // some types are in fact includes (like vk_platform) or defines (like VK_API_VERSION) if ( ( m_defines.find( name ) == m_defines.end() ) && ( m_includes.find( name ) == m_includes.end() ) ) @@ -13344,51 +13387,7 @@ void VulkanHppGenerator::readFeatureRequireType( tinyxml2::XMLElement const * "type <" + name + "> already listed on feature <" + typeIt->second.referencedIn + ">" ); typeIt->second.referencedIn = featureIt->first; - // add missing FlagBits here! - if ( ( name != "VkFlags" ) && endsWith( name, "Flags" ) ) - { - assert( !featureIt->second.types.empty() ); - std::string flagBits = name.substr( 0, name.length() - 5 ) + "FlagBits"; - if ( featureIt->second.types.back().first != flagBits ) - { - assert( std::find_if( featureIt->second.types.begin(), - featureIt->second.types.end(), - [&flagBits]( std::pair const & typeLine ) - { return ( typeLine.first == flagBits ); } ) == featureIt->second.types.end() ); - featureIt->second.types.push_back( std::make_pair( flagBits, 0 ) ); - } - } - - // filter out FlagBits that are listed after their Flags! - // (and therefore have been added right before that Flags, above) - bool skipIt = false; - if ( endsWith( name, "FlagBits" ) ) - { - assert( !featureIt->second.types.empty() ); - std::string flags = name.substr( 0, name.length() - 4 ) + "s"; - if ( featureIt->second.types.back().first == flags ) - { - skipIt = true; - auto flagBitsIt = std::find_if( featureIt->second.types.begin(), - featureIt->second.types.end(), - [&name]( std::pair const & typeLine ) - { return ( typeLine.first == name ); } ); - assert( flagBitsIt != featureIt->second.types.end() ); - assert( flagBitsIt->second == 0 ); - flagBitsIt->second = line; - } - else - { - assert( std::find_if( featureIt->second.types.begin(), - featureIt->second.types.end(), - [&flags]( std::pair const & typeLine ) - { return ( typeLine.first == flags ); } ) == featureIt->second.types.end() ); - } - } - if ( !skipIt ) - { - featureIt->second.types.push_back( std::make_pair( name, line ) ); - } + featureIt->second.types.push_back( name ); } } diff --git a/VulkanHppGenerator.hpp b/VulkanHppGenerator.hpp index b419307..d30100a 100644 --- a/VulkanHppGenerator.hpp +++ b/VulkanHppGenerator.hpp @@ -158,6 +158,7 @@ private: std::string alias; // alias for this enum std::map aliases; + std::string bitwidth; bool isBitmask = false; std::vector values; int xmlLine; @@ -169,7 +170,7 @@ private: std::vector commands; std::string number; - std::vector> types; + std::vector types; }; struct ExtensionData @@ -292,6 +293,7 @@ private: private: void addCommand( std::string const & name, CommandData & commandData ); + void addMissingFlagBits( std::vector & types, std::string const & referencedIn ); void appendArgumentPlainType( std::string & str, ParamData const & paramData ) const; void appendArguments( std::string & str, CommandData const & commandData, @@ -1067,6 +1069,7 @@ private: std::map> const & countToVectorMap, std::set const & skippedParams ) const; void checkCorrectness(); + void checkEnumCorrectness( std::vector const & types ) const; bool containsArray( std::string const & type ) const; bool containsUnion( std::string const & type ) const; size_t determineDefaultStartIndex( std::vector const & params, @@ -1197,14 +1200,14 @@ private: void readTypeEnum( tinyxml2::XMLElement const * element, std::map const & attributes ); void readTypeInclude( tinyxml2::XMLElement const * element, std::map const & attributes ); TypeInfo readTypeInfo( tinyxml2::XMLElement const * element ) const; - void readTypes( tinyxml2::XMLElement const * element ); - void registerDeleter( std::string const & name, std::pair const & commandData ); - void renameFunctionParameters(); - void rescheduleRAIIHandle( std::string & str, - std::pair const & handle, - std::set & listedHandles, - std::set const & specialFunctions ) const; - void setVulkanLicenseHeader( int line, std::string const & comment ); + void readTypes( tinyxml2::XMLElement const * element ); + void registerDeleter( std::string const & name, std::pair const & commandData ); + void renameFunctionParameters(); + void rescheduleRAIIHandle( std::string & str, + std::pair const & handle, + std::set & listedHandles, + std::set const & specialFunctions ) const; + void setVulkanLicenseHeader( int line, std::string const & comment ); std::string toString( TypeCategory category ); private: diff --git a/vulkan/vulkan.hpp b/vulkan/vulkan.hpp index 4359dcc..6bcf61f 100644 --- a/vulkan/vulkan.hpp +++ b/vulkan/vulkan.hpp @@ -8267,15 +8267,6 @@ namespace VULKAN_HPP_NAMESPACE } } - enum class InstanceCreateFlagBits - { - }; - - VULKAN_HPP_INLINE std::string to_string( InstanceCreateFlagBits ) - { - return "(void)"; - } - enum class InternalAllocationType { eExecutable = VK_INTERNAL_ALLOCATION_TYPE_EXECUTABLE @@ -8435,15 +8426,6 @@ namespace VULKAN_HPP_NAMESPACE } } - enum class DeviceCreateFlagBits - { - }; - - VULKAN_HPP_INLINE std::string to_string( DeviceCreateFlagBits ) - { - return "(void)"; - } - enum class DeviceQueueCreateFlagBits : VkDeviceQueueCreateFlags { eProtected = VK_DEVICE_QUEUE_CREATE_PROTECTED_BIT @@ -8660,15 +8642,6 @@ namespace VULKAN_HPP_NAMESPACE } } - enum class QueryPoolCreateFlagBits - { - }; - - VULKAN_HPP_INLINE std::string to_string( QueryPoolCreateFlagBits ) - { - return "(void)"; - } - enum class QueryResultFlagBits : VkQueryResultFlags { e64 = VK_QUERY_RESULT_64_BIT, @@ -10153,6 +10126,159 @@ namespace VULKAN_HPP_NAMESPACE } } + enum class InstanceCreateFlagBits + { + }; + + VULKAN_HPP_INLINE std::string to_string( InstanceCreateFlagBits ) + { + return "(void)"; + } + + enum class DeviceCreateFlagBits + { + }; + + VULKAN_HPP_INLINE std::string to_string( DeviceCreateFlagBits ) + { + return "(void)"; + } + + enum class MemoryMapFlagBits : VkMemoryMapFlags + { + }; + + VULKAN_HPP_INLINE std::string to_string( MemoryMapFlagBits ) + { + return "(void)"; + } + + enum class SemaphoreCreateFlagBits : VkSemaphoreCreateFlags + { + }; + + VULKAN_HPP_INLINE std::string to_string( SemaphoreCreateFlagBits ) + { + return "(void)"; + } + + enum class QueryPoolCreateFlagBits + { + }; + + VULKAN_HPP_INLINE std::string to_string( QueryPoolCreateFlagBits ) + { + return "(void)"; + } + + enum class BufferViewCreateFlagBits : VkBufferViewCreateFlags + { + }; + + VULKAN_HPP_INLINE std::string to_string( BufferViewCreateFlagBits ) + { + return "(void)"; + } + + enum class PipelineColorBlendStateCreateFlagBits : VkPipelineColorBlendStateCreateFlags + { + }; + + VULKAN_HPP_INLINE std::string to_string( PipelineColorBlendStateCreateFlagBits ) + { + return "(void)"; + } + + enum class PipelineDepthStencilStateCreateFlagBits : VkPipelineDepthStencilStateCreateFlags + { + }; + + VULKAN_HPP_INLINE std::string to_string( PipelineDepthStencilStateCreateFlagBits ) + { + return "(void)"; + } + + enum class PipelineDynamicStateCreateFlagBits : VkPipelineDynamicStateCreateFlags + { + }; + + VULKAN_HPP_INLINE std::string to_string( PipelineDynamicStateCreateFlagBits ) + { + return "(void)"; + } + + enum class PipelineInputAssemblyStateCreateFlagBits : VkPipelineInputAssemblyStateCreateFlags + { + }; + + VULKAN_HPP_INLINE std::string to_string( PipelineInputAssemblyStateCreateFlagBits ) + { + return "(void)"; + } + + enum class PipelineLayoutCreateFlagBits : VkPipelineLayoutCreateFlags + { + }; + + VULKAN_HPP_INLINE std::string to_string( PipelineLayoutCreateFlagBits ) + { + return "(void)"; + } + + enum class PipelineMultisampleStateCreateFlagBits : VkPipelineMultisampleStateCreateFlags + { + }; + + VULKAN_HPP_INLINE std::string to_string( PipelineMultisampleStateCreateFlagBits ) + { + return "(void)"; + } + + enum class PipelineRasterizationStateCreateFlagBits : VkPipelineRasterizationStateCreateFlags + { + }; + + VULKAN_HPP_INLINE std::string to_string( PipelineRasterizationStateCreateFlagBits ) + { + return "(void)"; + } + + enum class PipelineTessellationStateCreateFlagBits : VkPipelineTessellationStateCreateFlags + { + }; + + VULKAN_HPP_INLINE std::string to_string( PipelineTessellationStateCreateFlagBits ) + { + return "(void)"; + } + + enum class PipelineVertexInputStateCreateFlagBits : VkPipelineVertexInputStateCreateFlags + { + }; + + VULKAN_HPP_INLINE std::string to_string( PipelineVertexInputStateCreateFlagBits ) + { + return "(void)"; + } + + enum class PipelineViewportStateCreateFlagBits : VkPipelineViewportStateCreateFlags + { + }; + + VULKAN_HPP_INLINE std::string to_string( PipelineViewportStateCreateFlagBits ) + { + return "(void)"; + } + + enum class DescriptorPoolResetFlagBits : VkDescriptorPoolResetFlags + { + }; + + VULKAN_HPP_INLINE std::string to_string( DescriptorPoolResetFlagBits ) + { + return "(void)"; + } + //=== VK_VERSION_1_1 === enum class SubgroupFeatureFlagBits : VkSubgroupFeatureFlags @@ -10512,6 +10638,24 @@ namespace VULKAN_HPP_NAMESPACE } } + enum class CommandPoolTrimFlagBits : VkCommandPoolTrimFlags + { + }; + + VULKAN_HPP_INLINE std::string to_string( CommandPoolTrimFlagBits ) + { + return "(void)"; + } + + enum class DescriptorUpdateTemplateCreateFlagBits : VkDescriptorUpdateTemplateCreateFlags + { + }; + + VULKAN_HPP_INLINE std::string to_string( DescriptorUpdateTemplateCreateFlagBits ) + { + return "(void)"; + } + //=== VK_VERSION_1_2 === enum class DriverId @@ -10857,6 +11001,89 @@ namespace VULKAN_HPP_NAMESPACE } } + enum class DisplayModeCreateFlagBitsKHR : VkDisplayModeCreateFlagsKHR + { + }; + + VULKAN_HPP_INLINE std::string to_string( DisplayModeCreateFlagBitsKHR ) + { + return "(void)"; + } + + enum class DisplaySurfaceCreateFlagBitsKHR : VkDisplaySurfaceCreateFlagsKHR + { + }; + + VULKAN_HPP_INLINE std::string to_string( DisplaySurfaceCreateFlagBitsKHR ) + { + return "(void)"; + } + +#if defined( VK_USE_PLATFORM_XLIB_KHR ) + //=== VK_KHR_xlib_surface === + + enum class XlibSurfaceCreateFlagBitsKHR : VkXlibSurfaceCreateFlagsKHR + { + }; + + VULKAN_HPP_INLINE std::string to_string( XlibSurfaceCreateFlagBitsKHR ) + { + return "(void)"; + } +#endif /*VK_USE_PLATFORM_XLIB_KHR*/ + +#if defined( VK_USE_PLATFORM_XCB_KHR ) + //=== VK_KHR_xcb_surface === + + enum class XcbSurfaceCreateFlagBitsKHR : VkXcbSurfaceCreateFlagsKHR + { + }; + + VULKAN_HPP_INLINE std::string to_string( XcbSurfaceCreateFlagBitsKHR ) + { + return "(void)"; + } +#endif /*VK_USE_PLATFORM_XCB_KHR*/ + +#if defined( VK_USE_PLATFORM_WAYLAND_KHR ) + //=== VK_KHR_wayland_surface === + + enum class WaylandSurfaceCreateFlagBitsKHR : VkWaylandSurfaceCreateFlagsKHR + { + }; + + VULKAN_HPP_INLINE std::string to_string( WaylandSurfaceCreateFlagBitsKHR ) + { + return "(void)"; + } +#endif /*VK_USE_PLATFORM_WAYLAND_KHR*/ + +#if defined( VK_USE_PLATFORM_ANDROID_KHR ) + //=== VK_KHR_android_surface === + + enum class AndroidSurfaceCreateFlagBitsKHR : VkAndroidSurfaceCreateFlagsKHR + { + }; + + VULKAN_HPP_INLINE std::string to_string( AndroidSurfaceCreateFlagBitsKHR ) + { + return "(void)"; + } +#endif /*VK_USE_PLATFORM_ANDROID_KHR*/ + +#if defined( VK_USE_PLATFORM_WIN32_KHR ) + //=== VK_KHR_win32_surface === + + enum class Win32SurfaceCreateFlagBitsKHR : VkWin32SurfaceCreateFlagsKHR + { + }; + + VULKAN_HPP_INLINE std::string to_string( Win32SurfaceCreateFlagBitsKHR ) + { + return "(void)"; + } +#endif /*VK_USE_PLATFORM_WIN32_KHR*/ + //=== VK_EXT_debug_report === enum class DebugReportFlagBitsEXT : VkDebugReportFlagsEXT @@ -11145,6 +11372,24 @@ namespace VULKAN_HPP_NAMESPACE default: return "invalid ( " + VULKAN_HPP_NAMESPACE::toHexString( static_cast( value ) ) + " )"; } } + + enum class VideoBeginCodingFlagBitsKHR : VkVideoBeginCodingFlagsKHR + { + }; + + VULKAN_HPP_INLINE std::string to_string( VideoBeginCodingFlagBitsKHR ) + { + return "(void)"; + } + + enum class VideoEndCodingFlagBitsKHR : VkVideoEndCodingFlagsKHR + { + }; + + VULKAN_HPP_INLINE std::string to_string( VideoEndCodingFlagBitsKHR ) + { + return "(void)"; + } #endif /*VK_ENABLE_BETA_EXTENSIONS*/ #if defined( VK_ENABLE_BETA_EXTENSIONS ) @@ -11167,6 +11412,17 @@ namespace VULKAN_HPP_NAMESPACE } #endif /*VK_ENABLE_BETA_EXTENSIONS*/ + //=== VK_EXT_transform_feedback === + + enum class PipelineRasterizationStateStreamCreateFlagBitsEXT : VkPipelineRasterizationStateStreamCreateFlagsEXT + { + }; + + VULKAN_HPP_INLINE std::string to_string( PipelineRasterizationStateStreamCreateFlagBitsEXT ) + { + return "(void)"; + } + #if defined( VK_ENABLE_BETA_EXTENSIONS ) //=== VK_EXT_video_encode_h264 === @@ -11295,6 +11551,15 @@ namespace VULKAN_HPP_NAMESPACE default: return "invalid ( " + VULKAN_HPP_NAMESPACE::toHexString( static_cast( value ) ) + " )"; } } + + enum class VideoDecodeH264CreateFlagBitsEXT : VkVideoDecodeH264CreateFlagsEXT + { + }; + + VULKAN_HPP_INLINE std::string to_string( VideoDecodeH264CreateFlagBitsEXT ) + { + return "(void)"; + } #endif /*VK_ENABLE_BETA_EXTENSIONS*/ //=== VK_AMD_shader_info === @@ -11317,6 +11582,19 @@ namespace VULKAN_HPP_NAMESPACE } } +#if defined( VK_USE_PLATFORM_GGP ) + //=== VK_GGP_stream_descriptor_surface === + + enum class StreamDescriptorSurfaceCreateFlagBitsGGP : VkStreamDescriptorSurfaceCreateFlagsGGP + { + }; + + VULKAN_HPP_INLINE std::string to_string( StreamDescriptorSurfaceCreateFlagBitsGGP ) + { + return "(void)"; + } +#endif /*VK_USE_PLATFORM_GGP*/ + //=== VK_NV_external_memory_capabilities === enum class ExternalMemoryHandleTypeFlagBitsNV : VkExternalMemoryHandleTypeFlagsNV @@ -11375,6 +11653,19 @@ namespace VULKAN_HPP_NAMESPACE } } +#if defined( VK_USE_PLATFORM_VI_NN ) + //=== VK_NN_vi_surface === + + enum class ViSurfaceCreateFlagBitsNN : VkViSurfaceCreateFlagsNN + { + }; + + VULKAN_HPP_INLINE std::string to_string( ViSurfaceCreateFlagBitsNN ) + { + return "(void)"; + } +#endif /*VK_USE_PLATFORM_VI_NN*/ + //=== VK_EXT_conditional_rendering === enum class ConditionalRenderingFlagBitsEXT : VkConditionalRenderingFlagsEXT @@ -11485,6 +11776,15 @@ namespace VULKAN_HPP_NAMESPACE } } + enum class PipelineViewportSwizzleStateCreateFlagBitsNV : VkPipelineViewportSwizzleStateCreateFlagsNV + { + }; + + VULKAN_HPP_INLINE std::string to_string( PipelineViewportSwizzleStateCreateFlagBitsNV ) + { + return "(void)"; + } + //=== VK_EXT_discard_rectangles === enum class DiscardRectangleModeEXT @@ -11503,6 +11803,15 @@ namespace VULKAN_HPP_NAMESPACE } } + enum class PipelineDiscardRectangleStateCreateFlagBitsEXT : VkPipelineDiscardRectangleStateCreateFlagsEXT + { + }; + + VULKAN_HPP_INLINE std::string to_string( PipelineDiscardRectangleStateCreateFlagBitsEXT ) + { + return "(void)"; + } + //=== VK_EXT_conservative_rasterization === enum class ConservativeRasterizationModeEXT @@ -11523,6 +11832,27 @@ namespace VULKAN_HPP_NAMESPACE } } + enum class + PipelineRasterizationConservativeStateCreateFlagBitsEXT : VkPipelineRasterizationConservativeStateCreateFlagsEXT + { + }; + + VULKAN_HPP_INLINE std::string to_string( PipelineRasterizationConservativeStateCreateFlagBitsEXT ) + { + return "(void)"; + } + + //=== VK_EXT_depth_clip_enable === + + enum class PipelineRasterizationDepthClipStateCreateFlagBitsEXT : VkPipelineRasterizationDepthClipStateCreateFlagsEXT + { + }; + + VULKAN_HPP_INLINE std::string to_string( PipelineRasterizationDepthClipStateCreateFlagBitsEXT ) + { + return "(void)"; + } + //=== VK_KHR_performance_query === enum class PerformanceCounterDescriptionFlagBitsKHR : VkPerformanceCounterDescriptionFlagsKHR @@ -11629,6 +11959,32 @@ namespace VULKAN_HPP_NAMESPACE return "(void)"; } +#if defined( VK_USE_PLATFORM_IOS_MVK ) + //=== VK_MVK_ios_surface === + + enum class IOSSurfaceCreateFlagBitsMVK : VkIOSSurfaceCreateFlagsMVK + { + }; + + VULKAN_HPP_INLINE std::string to_string( IOSSurfaceCreateFlagBitsMVK ) + { + return "(void)"; + } +#endif /*VK_USE_PLATFORM_IOS_MVK*/ + +#if defined( VK_USE_PLATFORM_MACOS_MVK ) + //=== VK_MVK_macos_surface === + + enum class MacOSSurfaceCreateFlagBitsMVK : VkMacOSSurfaceCreateFlagsMVK + { + }; + + VULKAN_HPP_INLINE std::string to_string( MacOSSurfaceCreateFlagBitsMVK ) + { + return "(void)"; + } +#endif /*VK_USE_PLATFORM_MACOS_MVK*/ + //=== VK_EXT_debug_utils === enum class DebugUtilsMessageSeverityFlagBitsEXT : VkDebugUtilsMessageSeverityFlagsEXT @@ -11669,6 +12025,24 @@ namespace VULKAN_HPP_NAMESPACE } } + enum class DebugUtilsMessengerCallbackDataFlagBitsEXT : VkDebugUtilsMessengerCallbackDataFlagsEXT + { + }; + + VULKAN_HPP_INLINE std::string to_string( DebugUtilsMessengerCallbackDataFlagBitsEXT ) + { + return "(void)"; + } + + enum class DebugUtilsMessengerCreateFlagBitsEXT : VkDebugUtilsMessengerCreateFlagsEXT + { + }; + + VULKAN_HPP_INLINE std::string to_string( DebugUtilsMessengerCreateFlagBitsEXT ) + { + return "(void)"; + } + //=== VK_EXT_blend_operation_advanced === enum class BlendOverlapEXT @@ -11689,6 +12063,17 @@ namespace VULKAN_HPP_NAMESPACE } } + //=== VK_NV_fragment_coverage_to_color === + + enum class PipelineCoverageToColorStateCreateFlagBitsNV : VkPipelineCoverageToColorStateCreateFlagsNV + { + }; + + VULKAN_HPP_INLINE std::string to_string( PipelineCoverageToColorStateCreateFlagBitsNV ) + { + return "(void)"; + } + //=== VK_KHR_acceleration_structure === enum class AccelerationStructureTypeKHR @@ -11898,6 +12283,15 @@ namespace VULKAN_HPP_NAMESPACE } } + enum class PipelineCoverageModulationStateCreateFlagBitsNV : VkPipelineCoverageModulationStateCreateFlagsNV + { + }; + + VULKAN_HPP_INLINE std::string to_string( PipelineCoverageModulationStateCreateFlagBitsNV ) + { + return "(void)"; + } + //=== VK_EXT_validation_cache === enum class ValidationCacheHeaderVersionEXT @@ -11914,6 +12308,15 @@ namespace VULKAN_HPP_NAMESPACE } } + enum class ValidationCacheCreateFlagBitsEXT : VkValidationCacheCreateFlagsEXT + { + }; + + VULKAN_HPP_INLINE std::string to_string( ValidationCacheCreateFlagBitsEXT ) + { + return "(void)"; + } + //=== VK_NV_shading_rate_image === enum class ShadingRatePaletteEntryNV @@ -12047,6 +12450,19 @@ namespace VULKAN_HPP_NAMESPACE } } +#if defined( VK_ENABLE_BETA_EXTENSIONS ) + //=== VK_EXT_video_decode_h265 === + + enum class VideoDecodeH265CreateFlagBitsEXT : VkVideoDecodeH265CreateFlagsEXT + { + }; + + VULKAN_HPP_INLINE std::string to_string( VideoDecodeH265CreateFlagBitsEXT ) + { + return "(void)"; + } +#endif /*VK_ENABLE_BETA_EXTENSIONS*/ + //=== VK_AMD_memory_overallocation_behavior === enum class MemoryOverallocationBehaviorAMD @@ -12173,6 +12589,32 @@ namespace VULKAN_HPP_NAMESPACE } } +#if defined( VK_USE_PLATFORM_FUCHSIA ) + //=== VK_FUCHSIA_imagepipe_surface === + + enum class ImagePipeSurfaceCreateFlagBitsFUCHSIA : VkImagePipeSurfaceCreateFlagsFUCHSIA + { + }; + + VULKAN_HPP_INLINE std::string to_string( ImagePipeSurfaceCreateFlagBitsFUCHSIA ) + { + return "(void)"; + } +#endif /*VK_USE_PLATFORM_FUCHSIA*/ + +#if defined( VK_USE_PLATFORM_METAL_EXT ) + //=== VK_EXT_metal_surface === + + enum class MetalSurfaceCreateFlagBitsEXT : VkMetalSurfaceCreateFlagsEXT + { + }; + + VULKAN_HPP_INLINE std::string to_string( MetalSurfaceCreateFlagBitsEXT ) + { + return "(void)"; + } +#endif /*VK_USE_PLATFORM_METAL_EXT*/ + //=== VK_KHR_fragment_shading_rate === enum class FragmentShadingRateCombinerOpKHR @@ -12362,6 +12804,15 @@ namespace VULKAN_HPP_NAMESPACE } } + enum class PipelineCoverageReductionStateCreateFlagBitsNV : VkPipelineCoverageReductionStateCreateFlagsNV + { + }; + + VULKAN_HPP_INLINE std::string to_string( PipelineCoverageReductionStateCreateFlagBitsNV ) + { + return "(void)"; + } + //=== VK_EXT_provoking_vertex === enum class ProvokingVertexModeEXT @@ -12404,6 +12855,17 @@ namespace VULKAN_HPP_NAMESPACE } #endif /*VK_USE_PLATFORM_WIN32_KHR*/ + //=== VK_EXT_headless_surface === + + enum class HeadlessSurfaceCreateFlagBitsEXT : VkHeadlessSurfaceCreateFlagsEXT + { + }; + + VULKAN_HPP_INLINE std::string to_string( HeadlessSurfaceCreateFlagBitsEXT ) + { + return "(void)"; + } + //=== VK_EXT_line_rasterization === enum class LineRasterizationModeEXT @@ -12534,6 +12996,15 @@ namespace VULKAN_HPP_NAMESPACE } } + enum class DeviceMemoryReportFlagBitsEXT : VkDeviceMemoryReportFlagsEXT + { + }; + + VULKAN_HPP_INLINE std::string to_string( DeviceMemoryReportFlagBitsEXT ) + { + return "(void)"; + } + //=== VK_EXT_private_data === enum class PrivateDataSlotCreateFlagBitsEXT : VkPrivateDataSlotCreateFlagsEXT @@ -12872,6 +13343,19 @@ namespace VULKAN_HPP_NAMESPACE } } +#if defined( VK_USE_PLATFORM_DIRECTFB_EXT ) + //=== VK_EXT_directfb_surface === + + enum class DirectFBSurfaceCreateFlagBitsEXT : VkDirectFBSurfaceCreateFlagsEXT + { + }; + + VULKAN_HPP_INLINE std::string to_string( DirectFBSurfaceCreateFlagBitsEXT ) + { + return "(void)"; + } +#endif /*VK_USE_PLATFORM_DIRECTFB_EXT*/ + //=== VK_KHR_ray_tracing_pipeline === enum class RayTracingShaderGroupTypeKHR @@ -12913,6 +13397,19 @@ namespace VULKAN_HPP_NAMESPACE } } +#if defined( VK_USE_PLATFORM_SCREEN_QNX ) + //=== VK_QNX_screen_surface === + + enum class ScreenSurfaceCreateFlagBitsQNX : VkScreenSurfaceCreateFlagsQNX + { + }; + + VULKAN_HPP_INLINE std::string to_string( ScreenSurfaceCreateFlagBitsQNX ) + { + return "(void)"; + } +#endif /*VK_USE_PLATFORM_SCREEN_QNX*/ + template struct cpp_type {}; @@ -13692,15 +14189,6 @@ namespace VULKAN_HPP_NAMESPACE return "{ " + result.substr( 0, result.size() - 3 ) + " }"; } - enum class MemoryMapFlagBits : VkFlags - { - }; - - VULKAN_HPP_INLINE std::string to_string( MemoryMapFlagBits ) - { - return "(void)"; - } - using MemoryMapFlags = Flags; VULKAN_HPP_INLINE std::string to_string( MemoryMapFlags ) @@ -13921,15 +14409,6 @@ namespace VULKAN_HPP_NAMESPACE return "{ " + result.substr( 0, result.size() - 3 ) + " }"; } - enum class SemaphoreCreateFlagBits : VkFlags - { - }; - - VULKAN_HPP_INLINE std::string to_string( SemaphoreCreateFlagBits ) - { - return "(void)"; - } - using SemaphoreCreateFlags = Flags; VULKAN_HPP_INLINE std::string to_string( SemaphoreCreateFlags ) @@ -14287,15 +14766,6 @@ namespace VULKAN_HPP_NAMESPACE return "{ " + result.substr( 0, result.size() - 3 ) + " }"; } - enum class BufferViewCreateFlagBits : VkFlags - { - }; - - VULKAN_HPP_INLINE std::string to_string( BufferViewCreateFlagBits ) - { - return "(void)"; - } - using BufferViewCreateFlags = Flags; VULKAN_HPP_INLINE std::string to_string( BufferViewCreateFlags ) @@ -14506,15 +14976,6 @@ namespace VULKAN_HPP_NAMESPACE return "{ " + result.substr( 0, result.size() - 3 ) + " }"; } - enum class PipelineColorBlendStateCreateFlagBits : VkFlags - { - }; - - VULKAN_HPP_INLINE std::string to_string( PipelineColorBlendStateCreateFlagBits ) - { - return "(void)"; - } - using PipelineColorBlendStateCreateFlags = Flags; VULKAN_HPP_INLINE std::string to_string( PipelineColorBlendStateCreateFlags ) @@ -14619,15 +15080,6 @@ namespace VULKAN_HPP_NAMESPACE return "{ " + result.substr( 0, result.size() - 3 ) + " }"; } - enum class PipelineDepthStencilStateCreateFlagBits : VkFlags - { - }; - - VULKAN_HPP_INLINE std::string to_string( PipelineDepthStencilStateCreateFlagBits ) - { - return "(void)"; - } - using PipelineDepthStencilStateCreateFlags = Flags; VULKAN_HPP_INLINE std::string to_string( PipelineDepthStencilStateCreateFlags ) @@ -14635,15 +15087,6 @@ namespace VULKAN_HPP_NAMESPACE return "{}"; } - enum class PipelineDynamicStateCreateFlagBits : VkFlags - { - }; - - VULKAN_HPP_INLINE std::string to_string( PipelineDynamicStateCreateFlagBits ) - { - return "(void)"; - } - using PipelineDynamicStateCreateFlags = Flags; VULKAN_HPP_INLINE std::string to_string( PipelineDynamicStateCreateFlags ) @@ -14651,15 +15094,6 @@ namespace VULKAN_HPP_NAMESPACE return "{}"; } - enum class PipelineInputAssemblyStateCreateFlagBits : VkFlags - { - }; - - VULKAN_HPP_INLINE std::string to_string( PipelineInputAssemblyStateCreateFlagBits ) - { - return "(void)"; - } - using PipelineInputAssemblyStateCreateFlags = Flags; VULKAN_HPP_INLINE std::string to_string( PipelineInputAssemblyStateCreateFlags ) @@ -14667,15 +15101,6 @@ namespace VULKAN_HPP_NAMESPACE return "{}"; } - enum class PipelineLayoutCreateFlagBits : VkFlags - { - }; - - VULKAN_HPP_INLINE std::string to_string( PipelineLayoutCreateFlagBits ) - { - return "(void)"; - } - using PipelineLayoutCreateFlags = Flags; VULKAN_HPP_INLINE std::string to_string( PipelineLayoutCreateFlags ) @@ -14683,15 +15108,6 @@ namespace VULKAN_HPP_NAMESPACE return "{}"; } - enum class PipelineMultisampleStateCreateFlagBits : VkFlags - { - }; - - VULKAN_HPP_INLINE std::string to_string( PipelineMultisampleStateCreateFlagBits ) - { - return "(void)"; - } - using PipelineMultisampleStateCreateFlags = Flags; VULKAN_HPP_INLINE std::string to_string( PipelineMultisampleStateCreateFlags ) @@ -14699,15 +15115,6 @@ namespace VULKAN_HPP_NAMESPACE return "{}"; } - enum class PipelineRasterizationStateCreateFlagBits : VkFlags - { - }; - - VULKAN_HPP_INLINE std::string to_string( PipelineRasterizationStateCreateFlagBits ) - { - return "(void)"; - } - using PipelineRasterizationStateCreateFlags = Flags; VULKAN_HPP_INLINE std::string to_string( PipelineRasterizationStateCreateFlags ) @@ -14764,15 +15171,6 @@ namespace VULKAN_HPP_NAMESPACE return "{ " + result.substr( 0, result.size() - 3 ) + " }"; } - enum class PipelineTessellationStateCreateFlagBits : VkFlags - { - }; - - VULKAN_HPP_INLINE std::string to_string( PipelineTessellationStateCreateFlagBits ) - { - return "(void)"; - } - using PipelineTessellationStateCreateFlags = Flags; VULKAN_HPP_INLINE std::string to_string( PipelineTessellationStateCreateFlags ) @@ -14780,15 +15178,6 @@ namespace VULKAN_HPP_NAMESPACE return "{}"; } - enum class PipelineVertexInputStateCreateFlagBits : VkFlags - { - }; - - VULKAN_HPP_INLINE std::string to_string( PipelineVertexInputStateCreateFlagBits ) - { - return "(void)"; - } - using PipelineVertexInputStateCreateFlags = Flags; VULKAN_HPP_INLINE std::string to_string( PipelineVertexInputStateCreateFlags ) @@ -14796,15 +15185,6 @@ namespace VULKAN_HPP_NAMESPACE return "{}"; } - enum class PipelineViewportStateCreateFlagBits : VkFlags - { - }; - - VULKAN_HPP_INLINE std::string to_string( PipelineViewportStateCreateFlagBits ) - { - return "(void)"; - } - using PipelineViewportStateCreateFlags = Flags; VULKAN_HPP_INLINE std::string to_string( PipelineViewportStateCreateFlags ) @@ -14990,15 +15370,6 @@ namespace VULKAN_HPP_NAMESPACE return "{ " + result.substr( 0, result.size() - 3 ) + " }"; } - enum class DescriptorPoolResetFlagBits : VkFlags - { - }; - - VULKAN_HPP_INLINE std::string to_string( DescriptorPoolResetFlagBits ) - { - return "(void)"; - } - using DescriptorPoolResetFlags = Flags; VULKAN_HPP_INLINE std::string to_string( DescriptorPoolResetFlags ) @@ -15884,15 +16255,6 @@ namespace VULKAN_HPP_NAMESPACE return "{ " + result.substr( 0, result.size() - 3 ) + " }"; } - enum class CommandPoolTrimFlagBits : VkFlags - { - }; - - VULKAN_HPP_INLINE std::string to_string( CommandPoolTrimFlagBits ) - { - return "(void)"; - } - using CommandPoolTrimFlags = Flags; using CommandPoolTrimFlagsKHR = CommandPoolTrimFlags; @@ -15902,15 +16264,6 @@ namespace VULKAN_HPP_NAMESPACE return "{}"; } - enum class DescriptorUpdateTemplateCreateFlagBits : VkFlags - { - }; - - VULKAN_HPP_INLINE std::string to_string( DescriptorUpdateTemplateCreateFlagBits ) - { - return "(void)"; - } - using DescriptorUpdateTemplateCreateFlags = Flags; using DescriptorUpdateTemplateCreateFlagsKHR = DescriptorUpdateTemplateCreateFlags; @@ -16711,15 +17064,6 @@ namespace VULKAN_HPP_NAMESPACE //=== VK_KHR_display === - enum class DisplayModeCreateFlagBitsKHR : VkFlags - { - }; - - VULKAN_HPP_INLINE std::string to_string( DisplayModeCreateFlagBitsKHR ) - { - return "(void)"; - } - using DisplayModeCreateFlagsKHR = Flags; VULKAN_HPP_INLINE std::string to_string( DisplayModeCreateFlagsKHR ) @@ -16781,15 +17125,6 @@ namespace VULKAN_HPP_NAMESPACE return "{ " + result.substr( 0, result.size() - 3 ) + " }"; } - enum class DisplaySurfaceCreateFlagBitsKHR : VkFlags - { - }; - - VULKAN_HPP_INLINE std::string to_string( DisplaySurfaceCreateFlagBitsKHR ) - { - return "(void)"; - } - using DisplaySurfaceCreateFlagsKHR = Flags; VULKAN_HPP_INLINE std::string to_string( DisplaySurfaceCreateFlagsKHR ) @@ -16869,15 +17204,6 @@ namespace VULKAN_HPP_NAMESPACE #if defined( VK_USE_PLATFORM_XLIB_KHR ) //=== VK_KHR_xlib_surface === - enum class XlibSurfaceCreateFlagBitsKHR : VkFlags - { - }; - - VULKAN_HPP_INLINE std::string to_string( XlibSurfaceCreateFlagBitsKHR ) - { - return "(void)"; - } - using XlibSurfaceCreateFlagsKHR = Flags; VULKAN_HPP_INLINE std::string to_string( XlibSurfaceCreateFlagsKHR ) @@ -16889,15 +17215,6 @@ namespace VULKAN_HPP_NAMESPACE #if defined( VK_USE_PLATFORM_XCB_KHR ) //=== VK_KHR_xcb_surface === - enum class XcbSurfaceCreateFlagBitsKHR : VkFlags - { - }; - - VULKAN_HPP_INLINE std::string to_string( XcbSurfaceCreateFlagBitsKHR ) - { - return "(void)"; - } - using XcbSurfaceCreateFlagsKHR = Flags; VULKAN_HPP_INLINE std::string to_string( XcbSurfaceCreateFlagsKHR ) @@ -16909,15 +17226,6 @@ namespace VULKAN_HPP_NAMESPACE #if defined( VK_USE_PLATFORM_WAYLAND_KHR ) //=== VK_KHR_wayland_surface === - enum class WaylandSurfaceCreateFlagBitsKHR : VkFlags - { - }; - - VULKAN_HPP_INLINE std::string to_string( WaylandSurfaceCreateFlagBitsKHR ) - { - return "(void)"; - } - using WaylandSurfaceCreateFlagsKHR = Flags; VULKAN_HPP_INLINE std::string to_string( WaylandSurfaceCreateFlagsKHR ) @@ -16929,15 +17237,6 @@ namespace VULKAN_HPP_NAMESPACE #if defined( VK_USE_PLATFORM_ANDROID_KHR ) //=== VK_KHR_android_surface === - enum class AndroidSurfaceCreateFlagBitsKHR : VkFlags - { - }; - - VULKAN_HPP_INLINE std::string to_string( AndroidSurfaceCreateFlagBitsKHR ) - { - return "(void)"; - } - using AndroidSurfaceCreateFlagsKHR = Flags; VULKAN_HPP_INLINE std::string to_string( AndroidSurfaceCreateFlagsKHR ) @@ -16949,15 +17248,6 @@ namespace VULKAN_HPP_NAMESPACE #if defined( VK_USE_PLATFORM_WIN32_KHR ) //=== VK_KHR_win32_surface === - enum class Win32SurfaceCreateFlagBitsKHR : VkFlags - { - }; - - VULKAN_HPP_INLINE std::string to_string( Win32SurfaceCreateFlagBitsKHR ) - { - return "(void)"; - } - using Win32SurfaceCreateFlagsKHR = Flags; VULKAN_HPP_INLINE std::string to_string( Win32SurfaceCreateFlagsKHR ) @@ -17291,15 +17581,6 @@ namespace VULKAN_HPP_NAMESPACE return "{ " + result.substr( 0, result.size() - 3 ) + " }"; } - enum class VideoBeginCodingFlagBitsKHR : VkFlags - { - }; - - VULKAN_HPP_INLINE std::string to_string( VideoBeginCodingFlagBitsKHR ) - { - return "(void)"; - } - using VideoBeginCodingFlagsKHR = Flags; VULKAN_HPP_INLINE std::string to_string( VideoBeginCodingFlagsKHR ) @@ -17307,15 +17588,6 @@ namespace VULKAN_HPP_NAMESPACE return "{}"; } - enum class VideoEndCodingFlagBitsKHR : VkFlags - { - }; - - VULKAN_HPP_INLINE std::string to_string( VideoEndCodingFlagBitsKHR ) - { - return "(void)"; - } - using VideoEndCodingFlagsKHR = Flags; VULKAN_HPP_INLINE std::string to_string( VideoEndCodingFlagsKHR ) @@ -17475,15 +17747,6 @@ namespace VULKAN_HPP_NAMESPACE //=== VK_EXT_transform_feedback === - enum class PipelineRasterizationStateStreamCreateFlagBitsEXT : VkFlags - { - }; - - VULKAN_HPP_INLINE std::string to_string( PipelineRasterizationStateStreamCreateFlagBitsEXT ) - { - return "(void)"; - } - using PipelineRasterizationStateStreamCreateFlagsEXT = Flags; VULKAN_HPP_INLINE std::string to_string( PipelineRasterizationStateStreamCreateFlagsEXT ) @@ -17776,15 +18039,6 @@ namespace VULKAN_HPP_NAMESPACE return "{ " + result.substr( 0, result.size() - 3 ) + " }"; } - enum class VideoDecodeH264CreateFlagBitsEXT : VkFlags - { - }; - - VULKAN_HPP_INLINE std::string to_string( VideoDecodeH264CreateFlagBitsEXT ) - { - return "(void)"; - } - using VideoDecodeH264CreateFlagsEXT = Flags; VULKAN_HPP_INLINE std::string to_string( VideoDecodeH264CreateFlagsEXT ) @@ -17796,15 +18050,6 @@ namespace VULKAN_HPP_NAMESPACE #if defined( VK_USE_PLATFORM_GGP ) //=== VK_GGP_stream_descriptor_surface === - enum class StreamDescriptorSurfaceCreateFlagBitsGGP : VkFlags - { - }; - - VULKAN_HPP_INLINE std::string to_string( StreamDescriptorSurfaceCreateFlagBitsGGP ) - { - return "(void)"; - } - using StreamDescriptorSurfaceCreateFlagsGGP = Flags; VULKAN_HPP_INLINE std::string to_string( StreamDescriptorSurfaceCreateFlagsGGP ) @@ -17925,15 +18170,6 @@ namespace VULKAN_HPP_NAMESPACE #if defined( VK_USE_PLATFORM_VI_NN ) //=== VK_NN_vi_surface === - enum class ViSurfaceCreateFlagBitsNN : VkFlags - { - }; - - VULKAN_HPP_INLINE std::string to_string( ViSurfaceCreateFlagBitsNN ) - { - return "(void)"; - } - using ViSurfaceCreateFlagsNN = Flags; VULKAN_HPP_INLINE std::string to_string( ViSurfaceCreateFlagsNN ) @@ -18040,15 +18276,6 @@ namespace VULKAN_HPP_NAMESPACE //=== VK_NV_viewport_swizzle === - enum class PipelineViewportSwizzleStateCreateFlagBitsNV : VkFlags - { - }; - - VULKAN_HPP_INLINE std::string to_string( PipelineViewportSwizzleStateCreateFlagBitsNV ) - { - return "(void)"; - } - using PipelineViewportSwizzleStateCreateFlagsNV = Flags; VULKAN_HPP_INLINE std::string to_string( PipelineViewportSwizzleStateCreateFlagsNV ) @@ -18058,15 +18285,6 @@ namespace VULKAN_HPP_NAMESPACE //=== VK_EXT_discard_rectangles === - enum class PipelineDiscardRectangleStateCreateFlagBitsEXT : VkFlags - { - }; - - VULKAN_HPP_INLINE std::string to_string( PipelineDiscardRectangleStateCreateFlagBitsEXT ) - { - return "(void)"; - } - using PipelineDiscardRectangleStateCreateFlagsEXT = Flags; VULKAN_HPP_INLINE std::string to_string( PipelineDiscardRectangleStateCreateFlagsEXT ) @@ -18076,15 +18294,6 @@ namespace VULKAN_HPP_NAMESPACE //=== VK_EXT_conservative_rasterization === - enum class PipelineRasterizationConservativeStateCreateFlagBitsEXT : VkFlags - { - }; - - VULKAN_HPP_INLINE std::string to_string( PipelineRasterizationConservativeStateCreateFlagBitsEXT ) - { - return "(void)"; - } - using PipelineRasterizationConservativeStateCreateFlagsEXT = Flags; @@ -18095,15 +18304,6 @@ namespace VULKAN_HPP_NAMESPACE //=== VK_EXT_depth_clip_enable === - enum class PipelineRasterizationDepthClipStateCreateFlagBitsEXT : VkFlags - { - }; - - VULKAN_HPP_INLINE std::string to_string( PipelineRasterizationDepthClipStateCreateFlagBitsEXT ) - { - return "(void)"; - } - using PipelineRasterizationDepthClipStateCreateFlagsEXT = Flags; VULKAN_HPP_INLINE std::string to_string( PipelineRasterizationDepthClipStateCreateFlagsEXT ) @@ -18172,15 +18372,6 @@ namespace VULKAN_HPP_NAMESPACE #if defined( VK_USE_PLATFORM_IOS_MVK ) //=== VK_MVK_ios_surface === - enum class IOSSurfaceCreateFlagBitsMVK : VkFlags - { - }; - - VULKAN_HPP_INLINE std::string to_string( IOSSurfaceCreateFlagBitsMVK ) - { - return "(void)"; - } - using IOSSurfaceCreateFlagsMVK = Flags; VULKAN_HPP_INLINE std::string to_string( IOSSurfaceCreateFlagsMVK ) @@ -18192,15 +18383,6 @@ namespace VULKAN_HPP_NAMESPACE #if defined( VK_USE_PLATFORM_MACOS_MVK ) //=== VK_MVK_macos_surface === - enum class MacOSSurfaceCreateFlagBitsMVK : VkFlags - { - }; - - VULKAN_HPP_INLINE std::string to_string( MacOSSurfaceCreateFlagBitsMVK ) - { - return "(void)"; - } - using MacOSSurfaceCreateFlagsMVK = Flags; VULKAN_HPP_INLINE std::string to_string( MacOSSurfaceCreateFlagsMVK ) @@ -18318,15 +18500,6 @@ namespace VULKAN_HPP_NAMESPACE return "{ " + result.substr( 0, result.size() - 3 ) + " }"; } - enum class DebugUtilsMessengerCallbackDataFlagBitsEXT : VkFlags - { - }; - - VULKAN_HPP_INLINE std::string to_string( DebugUtilsMessengerCallbackDataFlagBitsEXT ) - { - return "(void)"; - } - using DebugUtilsMessengerCallbackDataFlagsEXT = Flags; VULKAN_HPP_INLINE std::string to_string( DebugUtilsMessengerCallbackDataFlagsEXT ) @@ -18334,15 +18507,6 @@ namespace VULKAN_HPP_NAMESPACE return "{}"; } - enum class DebugUtilsMessengerCreateFlagBitsEXT : VkFlags - { - }; - - VULKAN_HPP_INLINE std::string to_string( DebugUtilsMessengerCreateFlagBitsEXT ) - { - return "(void)"; - } - using DebugUtilsMessengerCreateFlagsEXT = Flags; VULKAN_HPP_INLINE std::string to_string( DebugUtilsMessengerCreateFlagsEXT ) @@ -18352,15 +18516,6 @@ namespace VULKAN_HPP_NAMESPACE //=== VK_NV_fragment_coverage_to_color === - enum class PipelineCoverageToColorStateCreateFlagBitsNV : VkFlags - { - }; - - VULKAN_HPP_INLINE std::string to_string( PipelineCoverageToColorStateCreateFlagBitsNV ) - { - return "(void)"; - } - using PipelineCoverageToColorStateCreateFlagsNV = Flags; VULKAN_HPP_INLINE std::string to_string( PipelineCoverageToColorStateCreateFlagsNV ) @@ -18584,15 +18739,6 @@ namespace VULKAN_HPP_NAMESPACE //=== VK_NV_framebuffer_mixed_samples === - enum class PipelineCoverageModulationStateCreateFlagBitsNV : VkFlags - { - }; - - VULKAN_HPP_INLINE std::string to_string( PipelineCoverageModulationStateCreateFlagBitsNV ) - { - return "(void)"; - } - using PipelineCoverageModulationStateCreateFlagsNV = Flags; VULKAN_HPP_INLINE std::string to_string( PipelineCoverageModulationStateCreateFlagsNV ) @@ -18602,15 +18748,6 @@ namespace VULKAN_HPP_NAMESPACE //=== VK_EXT_validation_cache === - enum class ValidationCacheCreateFlagBitsEXT : VkFlags - { - }; - - VULKAN_HPP_INLINE std::string to_string( ValidationCacheCreateFlagBitsEXT ) - { - return "(void)"; - } - using ValidationCacheCreateFlagsEXT = Flags; VULKAN_HPP_INLINE std::string to_string( ValidationCacheCreateFlagsEXT ) @@ -18630,15 +18767,6 @@ namespace VULKAN_HPP_NAMESPACE #if defined( VK_ENABLE_BETA_EXTENSIONS ) //=== VK_EXT_video_decode_h265 === - enum class VideoDecodeH265CreateFlagBitsEXT : VkFlags - { - }; - - VULKAN_HPP_INLINE std::string to_string( VideoDecodeH265CreateFlagBitsEXT ) - { - return "(void)"; - } - using VideoDecodeH265CreateFlagsEXT = Flags; VULKAN_HPP_INLINE std::string to_string( VideoDecodeH265CreateFlagsEXT ) @@ -18704,15 +18832,6 @@ namespace VULKAN_HPP_NAMESPACE #if defined( VK_USE_PLATFORM_FUCHSIA ) //=== VK_FUCHSIA_imagepipe_surface === - enum class ImagePipeSurfaceCreateFlagBitsFUCHSIA : VkFlags - { - }; - - VULKAN_HPP_INLINE std::string to_string( ImagePipeSurfaceCreateFlagBitsFUCHSIA ) - { - return "(void)"; - } - using ImagePipeSurfaceCreateFlagsFUCHSIA = Flags; VULKAN_HPP_INLINE std::string to_string( ImagePipeSurfaceCreateFlagsFUCHSIA ) @@ -18724,15 +18843,6 @@ namespace VULKAN_HPP_NAMESPACE #if defined( VK_USE_PLATFORM_METAL_EXT ) //=== VK_EXT_metal_surface === - enum class MetalSurfaceCreateFlagBitsEXT : VkFlags - { - }; - - VULKAN_HPP_INLINE std::string to_string( MetalSurfaceCreateFlagBitsEXT ) - { - return "(void)"; - } - using MetalSurfaceCreateFlagsEXT = Flags; VULKAN_HPP_INLINE std::string to_string( MetalSurfaceCreateFlagsEXT ) @@ -18815,15 +18925,6 @@ namespace VULKAN_HPP_NAMESPACE //=== VK_NV_coverage_reduction_mode === - enum class PipelineCoverageReductionStateCreateFlagBitsNV : VkFlags - { - }; - - VULKAN_HPP_INLINE std::string to_string( PipelineCoverageReductionStateCreateFlagBitsNV ) - { - return "(void)"; - } - using PipelineCoverageReductionStateCreateFlagsNV = Flags; VULKAN_HPP_INLINE std::string to_string( PipelineCoverageReductionStateCreateFlagsNV ) @@ -18833,15 +18934,6 @@ namespace VULKAN_HPP_NAMESPACE //=== VK_EXT_headless_surface === - enum class HeadlessSurfaceCreateFlagBitsEXT : VkFlags - { - }; - - VULKAN_HPP_INLINE std::string to_string( HeadlessSurfaceCreateFlagBitsEXT ) - { - return "(void)"; - } - using HeadlessSurfaceCreateFlagsEXT = Flags; VULKAN_HPP_INLINE std::string to_string( HeadlessSurfaceCreateFlagsEXT ) @@ -18951,15 +19043,6 @@ namespace VULKAN_HPP_NAMESPACE //=== VK_EXT_device_memory_report === - enum class DeviceMemoryReportFlagBitsEXT : VkFlags - { - }; - - VULKAN_HPP_INLINE std::string to_string( DeviceMemoryReportFlagBitsEXT ) - { - return "(void)"; - } - using DeviceMemoryReportFlagsEXT = Flags; VULKAN_HPP_INLINE std::string to_string( DeviceMemoryReportFlagsEXT ) @@ -19517,15 +19600,6 @@ namespace VULKAN_HPP_NAMESPACE #if defined( VK_USE_PLATFORM_DIRECTFB_EXT ) //=== VK_EXT_directfb_surface === - enum class DirectFBSurfaceCreateFlagBitsEXT : VkFlags - { - }; - - VULKAN_HPP_INLINE std::string to_string( DirectFBSurfaceCreateFlagBitsEXT ) - { - return "(void)"; - } - using DirectFBSurfaceCreateFlagsEXT = Flags; VULKAN_HPP_INLINE std::string to_string( DirectFBSurfaceCreateFlagsEXT ) @@ -19537,15 +19611,6 @@ namespace VULKAN_HPP_NAMESPACE #if defined( VK_USE_PLATFORM_SCREEN_QNX ) //=== VK_QNX_screen_surface === - enum class ScreenSurfaceCreateFlagBitsQNX : VkFlags - { - }; - - VULKAN_HPP_INLINE std::string to_string( ScreenSurfaceCreateFlagBitsQNX ) - { - return "(void)"; - } - using ScreenSurfaceCreateFlagsQNX = Flags; VULKAN_HPP_INLINE std::string to_string( ScreenSurfaceCreateFlagsQNX )