diff --git a/VulkanHppGenerator.cpp b/VulkanHppGenerator.cpp index 30ba6dc..6212277 100644 --- a/VulkanHppGenerator.cpp +++ b/VulkanHppGenerator.cpp @@ -1807,6 +1807,14 @@ void VulkanHppGenerator::appendEnums( std::string & str ) const appendPlatformEnter( str, !e.second.alias.empty(), e.second.platform ); appendEnum( str, e ); appendEnumToString( str, e ); + if ( e.first == "VkObjectType" ) + { + str += R"( + template + struct [[deprecated("vk::cpp_type is deprecated. Use vk::CppType instead.")]] cpp_type + {}; +)"; + } if ( e.second.alias.empty() ) // enums with an alias are not protected anymore ! { appendPlatformLeave( str, !e.second.alias.empty(), e.second.platform ); @@ -3259,10 +3267,16 @@ ${commands} static_assert( sizeof( ${className} ) == sizeof( Vk${className} ), "handle and wrapper have different size!" ); template <> - struct cpp_type + struct [[deprecated("vk::cpp_type is deprecated. Use vk::CppType instead.")]] cpp_type { using type = ${className}; }; + + template <> + struct CppType + { + using Type = ${className}; + }; )"; std::string enter, leave; @@ -3610,10 +3624,11 @@ void VulkanHppGenerator::appendStructCopyConstructors( std::string & str, std::s str += replaceWithMap( templateString, { { "name", name } } ); } -void VulkanHppGenerator::appendStructMembers( std::string & str, - std::pair const & structData, - std::string const & prefix ) const +std::string VulkanHppGenerator::appendStructMembers( std::string & str, + std::pair const & structData, + std::string const & prefix ) const { + std::string sTypeValue; for ( auto const & member : structData.second.members ) { str += prefix; @@ -3651,7 +3666,8 @@ void VulkanHppGenerator::appendStructMembers( std::string & enumIt->second.values.end(), [&member]( EnumValueData const & evd ) { return member.values == evd.vulkanValue; } ); assert( nameIt != enumIt->second.values.end() ); - str += " = StructureType::" + nameIt->vkValue; + sTypeValue = nameIt->vkValue; + str += " = StructureType::" + sTypeValue; } else { @@ -3684,6 +3700,7 @@ void VulkanHppGenerator::appendStructMembers( std::string & } str += ";\n"; } + return sTypeValue; } void VulkanHppGenerator::appendStructs( std::string & str ) const @@ -3695,7 +3712,10 @@ void VulkanHppGenerator::appendStructs( std::string & str ) const } } -void VulkanHppGenerator::appendStructSetter(std::string & str, std::string const& structureName, bool isUnion, MemberData const& memberData) const +void VulkanHppGenerator::appendStructSetter( std::string & str, + std::string const & structureName, + bool isUnion, + MemberData const & memberData ) const { if ( memberData.type.type != "VkStructureType" ) // filter out StructureType, which is supposed to be immutable ! { @@ -3707,13 +3727,16 @@ void VulkanHppGenerator::appendStructSetter(std::string & str, std::string const } )"; - std::string memberType = memberData.arraySizes.empty() ? memberData.type.compose() : constructStandardArray(memberData.type.compose(), memberData.arraySizes); + std::string memberType = memberData.arraySizes.empty() + ? memberData.type.compose() + : constructStandardArray( memberData.type.compose(), memberData.arraySizes ); std::string assignment; if ( !memberData.bitCount.empty() && beginsWith( memberData.type.type, "Vk" ) ) { - assignment = memberData.name + " = " + "*reinterpret_cast<" + memberData.type.type + "*>(&" + memberData.name + "_)"; + assignment = + memberData.name + " = " + "*reinterpret_cast<" + memberData.type.type + "*>(&" + memberData.name + "_)"; } - else if (isUnion && holdsSType(memberData.type.type) ) + else if ( isUnion && holdsSType( memberData.type.type ) ) { assignment = "memcpy( &" + memberData.name + ", &" + memberData.name + "_, sizeof(" + memberType + "))"; } @@ -3722,15 +3745,17 @@ void VulkanHppGenerator::appendStructSetter(std::string & str, std::string const assignment = memberData.name + " = " + memberData.name + "_"; } - str += replaceWithMap(templateString, - { - { "assignment", assignment }, + str += replaceWithMap( + templateString, + { { "assignment", assignment }, { "memberName", memberData.name }, - { "MemberName", startUpperCase(memberData.name) }, + { "MemberName", startUpperCase( memberData.name ) }, { "memberType", memberType }, - { "reference", (memberData.type.postfix.empty() && (m_structures.find(memberData.type.type) != m_structures.end())) ? "const & " : "" }, - { "structureName", structureName } - }); + { "reference", + ( memberData.type.postfix.empty() && ( m_structures.find( memberData.type.type ) != m_structures.end() ) ) + ? "const & " + : "" }, + { "structureName", structureName } } ); } } @@ -3793,7 +3818,7 @@ void VulkanHppGenerator::appendStructure( std::string & // only structs that are not returnedOnly get setters! for ( auto const & member : structure.second.members ) { - appendStructSetter(constructorAndSetters, stripPrefix(structure.first, "Vk"), false, member); + appendStructSetter( constructorAndSetters, stripPrefix( structure.first, "Vk" ), false, member ); } } @@ -3806,11 +3831,12 @@ void VulkanHppGenerator::appendStructure( std::string & } // the member variables - std::string members = "\n public:\n"; - appendStructMembers( members, structure, " " ); + std::string members = "\n public:\n"; + std::string sTypeValue = appendStructMembers( members, structure, " " ); - static const std::string structureTemplate = R"( struct ${name} + static const std::string structureTemplate = R"( struct ${structureName} { +${structureType} ${constructorAndSetters} operator ${vkName} const&() const VULKAN_HPP_NOEXCEPT @@ -3827,16 +3853,37 @@ ${compareOperators} ${members} }; - static_assert( sizeof( ${name} ) == sizeof( ${vkName} ), "struct and wrapper have different size!" ); - static_assert( std::is_standard_layout<${name}>::value, "struct wrapper is not a standard layout!" ); + static_assert( sizeof( ${structureName} ) == sizeof( ${vkName} ), "struct and wrapper have different size!" ); + static_assert( std::is_standard_layout<${structureName}>::value, "struct wrapper is not a standard layout!" ); )"; + std::string structureName = stripPrefix( structure.first, "Vk" ); + std::string structureType; + if ( !sTypeValue.empty() ) + { + structureType = + " static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::" + sTypeValue + ";\n"; + } str += replaceWithMap( structureTemplate, - { { "name", stripPrefix( structure.first, "Vk" ) }, + { { "structureName", structureName }, + { "structureType", structureType }, { "constructorAndSetters", constructorAndSetters }, { "vkName", structure.first }, { "compareOperators", compareOperators }, { "members", members } } ); + + if ( !sTypeValue.empty() ) + { + std::string cppTypeTemplate = R"( + template <> + struct CppType + { + using Type = ${structureName}; + }; +)"; + str += replaceWithMap( cppTypeTemplate, { { "sTypeValue", sTypeValue }, { "structureName", structureName } } ); + } + appendPlatformLeave( str, !structure.second.aliases.empty(), structure.second.platform ); } @@ -3961,21 +4008,22 @@ void VulkanHppGenerator::appendUnion( std::string & str, std::pair VulkanHppGenerator::determineVectorParamIndices( std::v return vectorParamIndices; } +void VulkanHppGenerator::appendIndexTypeTraits( std::string & str ) const +{ + auto indexType = m_enums.find( "VkIndexType" ); + assert( indexType != m_enums.end() ); + + str += R"( + template + struct IndexTypeValue + {}; +)"; + + std::set seenCppTypes; + for ( auto const & value : indexType->second.values ) + { + std::string cppType; + if ( beginsWith( value.vkValue, "eUint8" ) ) + { + cppType = "uint8_t"; + } + else if ( beginsWith( value.vkValue, "eUint16" ) ) + { + cppType = "uint16_t"; + } + else if ( beginsWith( value.vkValue, "eUint32" ) ) + { + cppType = "uint32_t"; + } + else if ( beginsWith( value.vkValue, "eUint64" ) ) + { + cppType = "uint64_t"; // No extension for this currently + } + else + { + assert( value.vkValue == "eNoneKHR" ); + } + + if ( !cppType.empty() ) + { + if ( seenCppTypes.insert( cppType ).second ) + { + // IndexType traits aren't necessarily invertible. + // The Type -> Enum translation will only occur for the first prefixed enum value. + // A hypothetical extension to this enum with a conflicting prefix will use the core spec value. + str += + "\n" + " template <>\n" + " struct IndexTypeValue<" + + cppType + + ">\n" + " {\n" + " static VULKAN_HPP_CONST_OR_CONSTEXPR IndexType value = IndexType::" + + value.vkValue + + ";\n" + " };\n"; + } + // Enum -> Type translations are always able to occur. + str += + "\n" + " template <>\n" + " struct CppType\n" + " {\n" + " using Type = " + + cppType + + ";\n" + " };\n"; + } + } +} + std::string const & VulkanHppGenerator::getTypesafeCheck() const { return m_typesafeCheck; @@ -4503,18 +4622,18 @@ std::string const & VulkanHppGenerator::getVulkanLicenseHeader() const return m_vulkanLicenseHeader; } -bool VulkanHppGenerator::holdsSType(std::string const& type) const +bool VulkanHppGenerator::holdsSType( std::string const & type ) const { - auto it = m_structures.find(type); - if (it != m_structures.end()) + auto it = m_structures.find( type ); + if ( it != m_structures.end() ) { - assert(!it->second.members.empty()); - return (it->second.members.front().name == "sType"); + assert( !it->second.members.empty() ); + return ( it->second.members.front().name == "sType" ); } return false; } -bool VulkanHppGenerator::isTwoStepAlgorithm(std::vector const& params) const +bool VulkanHppGenerator::isTwoStepAlgorithm( std::vector const & params ) const { // we generate a two-step algorithm for functions returning a vector of stuff, where the length is specified as a // pointer as well for those functions, the size can be queried first, and then used @@ -7823,10 +7942,9 @@ namespace std )"; static const std::string typeTraits = R"( - template - struct cpp_type - { - }; + template + struct CppType + {}; )"; try @@ -7859,8 +7977,9 @@ namespace std generator.appendDispatchLoaderDefault( str ); str += classObjectDestroy + classObjectFree + classPoolFree + "\n"; generator.appendBaseTypes( str ); - generator.appendEnums( str ); str += typeTraits; + generator.appendEnums( str ); + generator.appendIndexTypeTraits( str ); generator.appendBitmasks( str ); str += "} // namespace VULKAN_HPP_NAMESPACE\n" + is_error_code_enum + "\n" + "namespace VULKAN_HPP_NAMESPACE\n" + "{\n" + "#ifndef VULKAN_HPP_NO_EXCEPTIONS" + exceptions; diff --git a/VulkanHppGenerator.hpp b/VulkanHppGenerator.hpp index bcae7d2..5a30cf6 100644 --- a/VulkanHppGenerator.hpp +++ b/VulkanHppGenerator.hpp @@ -40,6 +40,7 @@ public: void appendStructs( std::string & str ) const; void appendStructureChainValidation( std::string & str ); void appendThrowExceptions( std::string & str ) const; + void appendIndexTypeTraits( std::string & str ) const; std::string const & getTypesafeCheck() const; std::string const & getVersion() const; std::string const & getVulkanLicenseHeader() const; @@ -461,39 +462,39 @@ private: std::string const & indentation, MemberData const & memberData ) const; void appendStructCopyConstructors( std::string & str, std::string const & vkName ) const; - void appendStructMembers( std::string & str, - std::pair const & structData, - std::string const & prefix ) const; - void appendStructSetter( std::string & str, - std::string const & structureName, - bool isUnion, - MemberData const & memberData ) const; - void appendStructSubConstructor( std::string & str, + std::string appendStructMembers( std::string & str, std::pair const & structData, std::string const & prefix ) const; - void appendStructure( std::string & str, std::pair const & structure ) const; - void appendUnion( std::string & str, std::pair const & structure ) const; - void appendUniqueTypes( std::string & str, - std::string const & parentType, - std::set const & childrenTypes ) const; - std::string constructConstexprString( std::pair const & structData ) const; - void checkCorrectness(); - bool checkLenAttribute( std::string const & len, std::vector const & params ); - bool containsArray( std::string const & type ) const; - bool containsUnion( std::string const & type ) const; - std::string determineEnhancedReturnType( CommandData const & commandData, - size_t returnParamIndex, - std::map const & vectorParamIndices, - bool isStructureChain ) const; - size_t determineReturnParamIndex( CommandData const & commandData, - std::map const & vectorParamIndices, - bool twoStep ) const; - std::string determineSubStruct( std::pair const & structure ) const; - size_t determineTemplateParamIndex( std::vector const & params, - std::map const & vectorParamIndices ) const; + void appendStructSetter( std::string & str, + std::string const & structureName, + bool isUnion, + MemberData const & memberData ) const; + void appendStructSubConstructor( std::string & str, + std::pair const & structData, + std::string const & prefix ) const; + void appendStructure( std::string & str, std::pair const & structure ) const; + void appendUnion( std::string & str, std::pair const & structure ) const; + void appendUniqueTypes( std::string & str, + std::string const & parentType, + std::set const & childrenTypes ) const; + std::string constructConstexprString( std::pair const & structData ) const; + void checkCorrectness(); + bool checkLenAttribute( std::string const & len, std::vector const & params ); + bool containsArray( std::string const & type ) const; + bool containsUnion( std::string const & type ) const; + std::string determineEnhancedReturnType( CommandData const & commandData, + size_t returnParamIndex, + std::map const & vectorParamIndices, + bool isStructureChain ) const; + size_t determineReturnParamIndex( CommandData const & commandData, + std::map const & vectorParamIndices, + bool twoStep ) const; + std::string determineSubStruct( std::pair const & structure ) const; + size_t determineTemplateParamIndex( std::vector const & params, + std::map const & vectorParamIndices ) const; std::map determineVectorParamIndices( std::vector const & params ) const; bool holdsSType( std::string const & type ) const; - bool isTwoStepAlgorithm( std::vector const & params ) const; + bool isTwoStepAlgorithm( std::vector const & params ) const; void linkCommandToHandle( int line, std::string const & name, CommandData const & commandData ); void readBaseType( tinyxml2::XMLElement const * element, std::map const & attributes ); void readBitmask( tinyxml2::XMLElement const * element, std::map const & attributes ); @@ -575,27 +576,27 @@ private: void setVulkanLicenseHeader( int line, std::string const & comment ); std::string toString( TypeCategory category ); - private: - std::map m_baseTypes; - std::map m_bitmasks; - std::map m_commandToHandle; - std::set m_constants; - std::set m_defines; - std::map m_enums; - std::set m_extendedStructs; // structs which are referenced by the structextends tag - std::map m_extensions; - std::map m_features; - std::map m_funcPointers; - std::map m_handles; - std::set m_includes; - std::map m_platforms; - std::map m_structureAliases; - std::map m_structures; - std::set m_tags; - std::map m_types; - std::string m_typesafeCheck; - std::string m_version; - std::string m_vulkanLicenseHeader; +private: + std::map m_baseTypes; + std::map m_bitmasks; + std::map m_commandToHandle; + std::set m_constants; + std::set m_defines; + std::map m_enums; + std::set m_extendedStructs; // structs which are referenced by the structextends tag + std::map m_extensions; + std::map m_features; + std::map m_funcPointers; + std::map m_handles; + std::set m_includes; + std::map m_platforms; + std::map m_structureAliases; + std::map m_structures; + std::set m_tags; + std::map m_types; + std::string m_typesafeCheck; + std::string m_version; + std::string m_vulkanLicenseHeader; }; const size_t INVALID_INDEX = (size_t)~0; diff --git a/vulkan/vulkan.hpp b/vulkan/vulkan.hpp index 3f76b9d..ce7c4de 100644 --- a/vulkan/vulkan.hpp +++ b/vulkan/vulkan.hpp @@ -4531,6 +4531,10 @@ namespace VULKAN_HPP_NAMESPACE using DeviceSize = uint64_t; using SampleMask = uint32_t; + template + struct CppType + {}; + #ifdef VK_ENABLE_BETA_EXTENSIONS enum class AccelerationStructureBuildTypeKHR { @@ -7459,6 +7463,9 @@ namespace VULKAN_HPP_NAMESPACE } } + template + struct [[deprecated( "vk::cpp_type is deprecated. Use vk::CppType instead." )]] cpp_type{}; + enum class PeerMemoryFeatureFlagBits : VkPeerMemoryFeatureFlags { eCopySrc = VK_PEER_MEMORY_FEATURE_COPY_SRC_BIT, @@ -10368,10 +10375,46 @@ namespace VULKAN_HPP_NAMESPACE } } - template - struct cpp_type + template + struct IndexTypeValue {}; + template <> + struct IndexTypeValue + { + static VULKAN_HPP_CONST_OR_CONSTEXPR IndexType value = IndexType::eUint16; + }; + + template <> + struct CppType + { + using Type = uint16_t; + }; + + template <> + struct IndexTypeValue + { + static VULKAN_HPP_CONST_OR_CONSTEXPR IndexType value = IndexType::eUint32; + }; + + template <> + struct CppType + { + using Type = uint32_t; + }; + + template <> + struct IndexTypeValue + { + static VULKAN_HPP_CONST_OR_CONSTEXPR IndexType value = IndexType::eUint8EXT; + }; + + template <> + struct CppType + { + using Type = uint8_t; + }; + using AccessFlags = Flags; template <> @@ -16705,11 +16748,17 @@ namespace VULKAN_HPP_NAMESPACE static_assert( sizeof( SurfaceKHR ) == sizeof( VkSurfaceKHR ), "handle and wrapper have different size!" ); template <> - struct cpp_type + struct [[deprecated( "vk::cpp_type is deprecated. Use vk::CppType instead." )]] cpp_type { using type = SurfaceKHR; }; + template <> + struct CppType + { + using Type = SurfaceKHR; + }; + class DebugReportCallbackEXT { public: @@ -16784,11 +16833,18 @@ namespace VULKAN_HPP_NAMESPACE "handle and wrapper have different size!" ); template <> - struct cpp_type + struct [[deprecated( + "vk::cpp_type is deprecated. Use vk::CppType instead." )]] cpp_type { using type = DebugReportCallbackEXT; }; + template <> + struct CppType + { + using Type = DebugReportCallbackEXT; + }; + class DebugUtilsMessengerEXT { public: @@ -16863,11 +16919,18 @@ namespace VULKAN_HPP_NAMESPACE "handle and wrapper have different size!" ); template <> - struct cpp_type + struct [[deprecated( + "vk::cpp_type is deprecated. Use vk::CppType instead." )]] cpp_type { using type = DebugUtilsMessengerEXT; }; + template <> + struct CppType + { + using Type = DebugUtilsMessengerEXT; + }; + class DisplayKHR { public: @@ -16937,11 +17000,17 @@ namespace VULKAN_HPP_NAMESPACE static_assert( sizeof( DisplayKHR ) == sizeof( VkDisplayKHR ), "handle and wrapper have different size!" ); template <> - struct cpp_type + struct [[deprecated( "vk::cpp_type is deprecated. Use vk::CppType instead." )]] cpp_type { using type = DisplayKHR; }; + template <> + struct CppType + { + using Type = DisplayKHR; + }; + class SwapchainKHR { public: @@ -17012,11 +17081,17 @@ namespace VULKAN_HPP_NAMESPACE static_assert( sizeof( SwapchainKHR ) == sizeof( VkSwapchainKHR ), "handle and wrapper have different size!" ); template <> - struct cpp_type + struct [[deprecated( "vk::cpp_type is deprecated. Use vk::CppType instead." )]] cpp_type { using type = SwapchainKHR; }; + template <> + struct CppType + { + using Type = SwapchainKHR; + }; + class Semaphore { public: @@ -17085,11 +17160,17 @@ namespace VULKAN_HPP_NAMESPACE static_assert( sizeof( Semaphore ) == sizeof( VkSemaphore ), "handle and wrapper have different size!" ); template <> - struct cpp_type + struct [[deprecated( "vk::cpp_type is deprecated. Use vk::CppType instead." )]] cpp_type { using type = Semaphore; }; + template <> + struct CppType + { + using Type = Semaphore; + }; + class Fence { public: @@ -17158,11 +17239,17 @@ namespace VULKAN_HPP_NAMESPACE static_assert( sizeof( Fence ) == sizeof( VkFence ), "handle and wrapper have different size!" ); template <> - struct cpp_type + struct [[deprecated( "vk::cpp_type is deprecated. Use vk::CppType instead." )]] cpp_type { using type = Fence; }; + template <> + struct CppType + { + using Type = Fence; + }; + class PerformanceConfigurationINTEL { public: @@ -17240,11 +17327,18 @@ namespace VULKAN_HPP_NAMESPACE "handle and wrapper have different size!" ); template <> - struct cpp_type + struct [[deprecated( + "vk::cpp_type is deprecated. Use vk::CppType instead." )]] cpp_type { using type = PerformanceConfigurationINTEL; }; + template <> + struct CppType + { + using Type = PerformanceConfigurationINTEL; + }; + class QueryPool { public: @@ -17313,11 +17407,17 @@ namespace VULKAN_HPP_NAMESPACE static_assert( sizeof( QueryPool ) == sizeof( VkQueryPool ), "handle and wrapper have different size!" ); template <> - struct cpp_type + struct [[deprecated( "vk::cpp_type is deprecated. Use vk::CppType instead." )]] cpp_type { using type = QueryPool; }; + template <> + struct CppType + { + using Type = QueryPool; + }; + class Buffer { public: @@ -17386,11 +17486,17 @@ namespace VULKAN_HPP_NAMESPACE static_assert( sizeof( Buffer ) == sizeof( VkBuffer ), "handle and wrapper have different size!" ); template <> - struct cpp_type + struct [[deprecated( "vk::cpp_type is deprecated. Use vk::CppType instead." )]] cpp_type { using type = Buffer; }; + template <> + struct CppType + { + using Type = Buffer; + }; + class PipelineLayout { public: @@ -17461,11 +17567,17 @@ namespace VULKAN_HPP_NAMESPACE static_assert( sizeof( PipelineLayout ) == sizeof( VkPipelineLayout ), "handle and wrapper have different size!" ); template <> - struct cpp_type + struct [[deprecated( "vk::cpp_type is deprecated. Use vk::CppType instead." )]] cpp_type { using type = PipelineLayout; }; + template <> + struct CppType + { + using Type = PipelineLayout; + }; + class DescriptorSet { public: @@ -17536,11 +17648,17 @@ namespace VULKAN_HPP_NAMESPACE static_assert( sizeof( DescriptorSet ) == sizeof( VkDescriptorSet ), "handle and wrapper have different size!" ); template <> - struct cpp_type + struct [[deprecated( "vk::cpp_type is deprecated. Use vk::CppType instead." )]] cpp_type { using type = DescriptorSet; }; + template <> + struct CppType + { + using Type = DescriptorSet; + }; + class Pipeline { public: @@ -17609,11 +17727,17 @@ namespace VULKAN_HPP_NAMESPACE static_assert( sizeof( Pipeline ) == sizeof( VkPipeline ), "handle and wrapper have different size!" ); template <> - struct cpp_type + struct [[deprecated( "vk::cpp_type is deprecated. Use vk::CppType instead." )]] cpp_type { using type = Pipeline; }; + template <> + struct CppType + { + using Type = Pipeline; + }; + class ImageView { public: @@ -17682,11 +17806,17 @@ namespace VULKAN_HPP_NAMESPACE static_assert( sizeof( ImageView ) == sizeof( VkImageView ), "handle and wrapper have different size!" ); template <> - struct cpp_type + struct [[deprecated( "vk::cpp_type is deprecated. Use vk::CppType instead." )]] cpp_type { using type = ImageView; }; + template <> + struct CppType + { + using Type = ImageView; + }; + class Image { public: @@ -17755,11 +17885,17 @@ namespace VULKAN_HPP_NAMESPACE static_assert( sizeof( Image ) == sizeof( VkImage ), "handle and wrapper have different size!" ); template <> - struct cpp_type + struct [[deprecated( "vk::cpp_type is deprecated. Use vk::CppType instead." )]] cpp_type { using type = Image; }; + template <> + struct CppType + { + using Type = Image; + }; + class AccelerationStructureKHR { public: @@ -17835,10 +17971,17 @@ namespace VULKAN_HPP_NAMESPACE "handle and wrapper have different size!" ); template <> - struct cpp_type + struct [[deprecated( + "vk::cpp_type is deprecated. Use vk::CppType instead." )]] cpp_type { using type = AccelerationStructureKHR; }; + + template <> + struct CppType + { + using Type = AccelerationStructureKHR; + }; using AccelerationStructureNV = AccelerationStructureKHR; class DescriptorUpdateTemplate @@ -17916,10 +18059,17 @@ namespace VULKAN_HPP_NAMESPACE "handle and wrapper have different size!" ); template <> - struct cpp_type + struct [[deprecated( + "vk::cpp_type is deprecated. Use vk::CppType instead." )]] cpp_type { using type = DescriptorUpdateTemplate; }; + + template <> + struct CppType + { + using Type = DescriptorUpdateTemplate; + }; using DescriptorUpdateTemplateKHR = DescriptorUpdateTemplate; class Event @@ -17990,11 +18140,17 @@ namespace VULKAN_HPP_NAMESPACE static_assert( sizeof( Event ) == sizeof( VkEvent ), "handle and wrapper have different size!" ); template <> - struct cpp_type + struct [[deprecated( "vk::cpp_type is deprecated. Use vk::CppType instead." )]] cpp_type { using type = Event; }; + template <> + struct CppType + { + using Type = Event; + }; + class CommandBuffer { public: @@ -19189,11 +19345,17 @@ namespace VULKAN_HPP_NAMESPACE static_assert( sizeof( CommandBuffer ) == sizeof( VkCommandBuffer ), "handle and wrapper have different size!" ); template <> - struct cpp_type + struct [[deprecated( "vk::cpp_type is deprecated. Use vk::CppType instead." )]] cpp_type { using type = CommandBuffer; }; + template <> + struct CppType + { + using Type = CommandBuffer; + }; + class DeviceMemory { public: @@ -19264,11 +19426,17 @@ namespace VULKAN_HPP_NAMESPACE static_assert( sizeof( DeviceMemory ) == sizeof( VkDeviceMemory ), "handle and wrapper have different size!" ); template <> - struct cpp_type + struct [[deprecated( "vk::cpp_type is deprecated. Use vk::CppType instead." )]] cpp_type { using type = DeviceMemory; }; + template <> + struct CppType + { + using Type = DeviceMemory; + }; + class BufferView { public: @@ -19338,11 +19506,17 @@ namespace VULKAN_HPP_NAMESPACE static_assert( sizeof( BufferView ) == sizeof( VkBufferView ), "handle and wrapper have different size!" ); template <> - struct cpp_type + struct [[deprecated( "vk::cpp_type is deprecated. Use vk::CppType instead." )]] cpp_type { using type = BufferView; }; + template <> + struct CppType + { + using Type = BufferView; + }; + class CommandPool { public: @@ -19413,11 +19587,17 @@ namespace VULKAN_HPP_NAMESPACE static_assert( sizeof( CommandPool ) == sizeof( VkCommandPool ), "handle and wrapper have different size!" ); template <> - struct cpp_type + struct [[deprecated( "vk::cpp_type is deprecated. Use vk::CppType instead." )]] cpp_type { using type = CommandPool; }; + template <> + struct CppType + { + using Type = CommandPool; + }; + class PipelineCache { public: @@ -19488,11 +19668,17 @@ namespace VULKAN_HPP_NAMESPACE static_assert( sizeof( PipelineCache ) == sizeof( VkPipelineCache ), "handle and wrapper have different size!" ); template <> - struct cpp_type + struct [[deprecated( "vk::cpp_type is deprecated. Use vk::CppType instead." )]] cpp_type { using type = PipelineCache; }; + template <> + struct CppType + { + using Type = PipelineCache; + }; + #ifdef VK_ENABLE_BETA_EXTENSIONS class DeferredOperationKHR { @@ -19567,10 +19753,17 @@ namespace VULKAN_HPP_NAMESPACE "handle and wrapper have different size!" ); template <> - struct cpp_type + struct [ + [deprecated( "vk::cpp_type is deprecated. Use vk::CppType instead." )]] cpp_type { using type = DeferredOperationKHR; }; + + template <> + struct CppType + { + using Type = DeferredOperationKHR; + }; #endif /*VK_ENABLE_BETA_EXTENSIONS*/ class DescriptorPool @@ -19643,11 +19836,17 @@ namespace VULKAN_HPP_NAMESPACE static_assert( sizeof( DescriptorPool ) == sizeof( VkDescriptorPool ), "handle and wrapper have different size!" ); template <> - struct cpp_type + struct [[deprecated( "vk::cpp_type is deprecated. Use vk::CppType instead." )]] cpp_type { using type = DescriptorPool; }; + template <> + struct CppType + { + using Type = DescriptorPool; + }; + class DescriptorSetLayout { public: @@ -19721,11 +19920,18 @@ namespace VULKAN_HPP_NAMESPACE "handle and wrapper have different size!" ); template <> - struct cpp_type + struct [ + [deprecated( "vk::cpp_type is deprecated. Use vk::CppType instead." )]] cpp_type { using type = DescriptorSetLayout; }; + template <> + struct CppType + { + using Type = DescriptorSetLayout; + }; + class Framebuffer { public: @@ -19796,11 +20002,17 @@ namespace VULKAN_HPP_NAMESPACE static_assert( sizeof( Framebuffer ) == sizeof( VkFramebuffer ), "handle and wrapper have different size!" ); template <> - struct cpp_type + struct [[deprecated( "vk::cpp_type is deprecated. Use vk::CppType instead." )]] cpp_type { using type = Framebuffer; }; + template <> + struct CppType + { + using Type = Framebuffer; + }; + class IndirectCommandsLayoutNV { public: @@ -19876,11 +20088,18 @@ namespace VULKAN_HPP_NAMESPACE "handle and wrapper have different size!" ); template <> - struct cpp_type + struct [[deprecated( + "vk::cpp_type is deprecated. Use vk::CppType instead." )]] cpp_type { using type = IndirectCommandsLayoutNV; }; + template <> + struct CppType + { + using Type = IndirectCommandsLayoutNV; + }; + class RenderPass { public: @@ -19950,11 +20169,17 @@ namespace VULKAN_HPP_NAMESPACE static_assert( sizeof( RenderPass ) == sizeof( VkRenderPass ), "handle and wrapper have different size!" ); template <> - struct cpp_type + struct [[deprecated( "vk::cpp_type is deprecated. Use vk::CppType instead." )]] cpp_type { using type = RenderPass; }; + template <> + struct CppType + { + using Type = RenderPass; + }; + class Sampler { public: @@ -20023,11 +20248,17 @@ namespace VULKAN_HPP_NAMESPACE static_assert( sizeof( Sampler ) == sizeof( VkSampler ), "handle and wrapper have different size!" ); template <> - struct cpp_type + struct [[deprecated( "vk::cpp_type is deprecated. Use vk::CppType instead." )]] cpp_type { using type = Sampler; }; + template <> + struct CppType + { + using Type = Sampler; + }; + class SamplerYcbcrConversion { public: @@ -20102,10 +20333,17 @@ namespace VULKAN_HPP_NAMESPACE "handle and wrapper have different size!" ); template <> - struct cpp_type + struct [[deprecated( + "vk::cpp_type is deprecated. Use vk::CppType instead." )]] cpp_type { using type = SamplerYcbcrConversion; }; + + template <> + struct CppType + { + using Type = SamplerYcbcrConversion; + }; using SamplerYcbcrConversionKHR = SamplerYcbcrConversion; class ShaderModule @@ -20178,11 +20416,17 @@ namespace VULKAN_HPP_NAMESPACE static_assert( sizeof( ShaderModule ) == sizeof( VkShaderModule ), "handle and wrapper have different size!" ); template <> - struct cpp_type + struct [[deprecated( "vk::cpp_type is deprecated. Use vk::CppType instead." )]] cpp_type { using type = ShaderModule; }; + template <> + struct CppType + { + using Type = ShaderModule; + }; + class ValidationCacheEXT { public: @@ -20256,11 +20500,18 @@ namespace VULKAN_HPP_NAMESPACE "handle and wrapper have different size!" ); template <> - struct cpp_type + struct [ + [deprecated( "vk::cpp_type is deprecated. Use vk::CppType instead." )]] cpp_type { using type = ValidationCacheEXT; }; + template <> + struct CppType + { + using Type = ValidationCacheEXT; + }; + class Queue { public: @@ -20417,11 +20668,17 @@ namespace VULKAN_HPP_NAMESPACE static_assert( sizeof( Queue ) == sizeof( VkQueue ), "handle and wrapper have different size!" ); template <> - struct cpp_type + struct [[deprecated( "vk::cpp_type is deprecated. Use vk::CppType instead." )]] cpp_type { using type = Queue; }; + template <> + struct CppType + { + using Type = Queue; + }; + #ifndef VULKAN_HPP_NO_SMART_HANDLE class Device; template @@ -23977,11 +24234,17 @@ namespace VULKAN_HPP_NAMESPACE static_assert( sizeof( Device ) == sizeof( VkDevice ), "handle and wrapper have different size!" ); template <> - struct cpp_type + struct [[deprecated( "vk::cpp_type is deprecated. Use vk::CppType instead." )]] cpp_type { using type = Device; }; + template <> + struct CppType + { + using Type = Device; + }; + class DisplayModeKHR { public: @@ -24052,11 +24315,17 @@ namespace VULKAN_HPP_NAMESPACE static_assert( sizeof( DisplayModeKHR ) == sizeof( VkDisplayModeKHR ), "handle and wrapper have different size!" ); template <> - struct cpp_type + struct [[deprecated( "vk::cpp_type is deprecated. Use vk::CppType instead." )]] cpp_type { using type = DisplayModeKHR; }; + template <> + struct CppType + { + using Type = DisplayModeKHR; + }; + #ifndef VULKAN_HPP_NO_SMART_HANDLE template class UniqueHandleTraits @@ -25095,11 +25364,17 @@ namespace VULKAN_HPP_NAMESPACE static_assert( sizeof( PhysicalDevice ) == sizeof( VkPhysicalDevice ), "handle and wrapper have different size!" ); template <> - struct cpp_type + struct [[deprecated( "vk::cpp_type is deprecated. Use vk::CppType instead." )]] cpp_type { using type = PhysicalDevice; }; + template <> + struct CppType + { + using Type = PhysicalDevice; + }; + #ifndef VULKAN_HPP_NO_SMART_HANDLE class Instance; template @@ -25682,11 +25957,17 @@ namespace VULKAN_HPP_NAMESPACE static_assert( sizeof( Instance ) == sizeof( VkInstance ), "handle and wrapper have different size!" ); template <> - struct cpp_type + struct [[deprecated( "vk::cpp_type is deprecated. Use vk::CppType instead." )]] cpp_type { using type = Instance; }; + template <> + struct CppType + { + using Type = Instance; + }; + #ifndef VULKAN_HPP_NO_SMART_HANDLE template class UniqueHandleTraits @@ -25915,6 +26196,9 @@ namespace VULKAN_HPP_NAMESPACE #ifdef VK_ENABLE_BETA_EXTENSIONS struct AccelerationStructureGeometryTrianglesDataKHR { + static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = + StructureType::eAccelerationStructureGeometryTrianglesDataKHR; + AccelerationStructureGeometryTrianglesDataKHR( VULKAN_HPP_NAMESPACE::Format vertexFormat_ = VULKAN_HPP_NAMESPACE::Format::eUndefined, VULKAN_HPP_NAMESPACE::DeviceOrHostAddressConstKHR vertexData_ = {}, @@ -26026,11 +26310,20 @@ namespace VULKAN_HPP_NAMESPACE "struct and wrapper have different size!" ); static_assert( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); + + template <> + struct CppType + { + using Type = AccelerationStructureGeometryTrianglesDataKHR; + }; #endif /*VK_ENABLE_BETA_EXTENSIONS*/ #ifdef VK_ENABLE_BETA_EXTENSIONS struct AccelerationStructureGeometryAabbsDataKHR { + static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = + StructureType::eAccelerationStructureGeometryAabbsDataKHR; + AccelerationStructureGeometryAabbsDataKHR( VULKAN_HPP_NAMESPACE::DeviceOrHostAddressConstKHR data_ = {}, VULKAN_HPP_NAMESPACE::DeviceSize stride_ = {} ) VULKAN_HPP_NOEXCEPT : data( data_ ) @@ -26101,11 +26394,20 @@ namespace VULKAN_HPP_NAMESPACE "struct and wrapper have different size!" ); static_assert( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); + + template <> + struct CppType + { + using Type = AccelerationStructureGeometryAabbsDataKHR; + }; #endif /*VK_ENABLE_BETA_EXTENSIONS*/ #ifdef VK_ENABLE_BETA_EXTENSIONS struct AccelerationStructureGeometryInstancesDataKHR { + static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = + StructureType::eAccelerationStructureGeometryInstancesDataKHR; + AccelerationStructureGeometryInstancesDataKHR( VULKAN_HPP_NAMESPACE::Bool32 arrayOfPointers_ = {}, VULKAN_HPP_NAMESPACE::DeviceOrHostAddressConstKHR data_ = {} ) VULKAN_HPP_NOEXCEPT @@ -26177,6 +26479,12 @@ namespace VULKAN_HPP_NAMESPACE "struct and wrapper have different size!" ); static_assert( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); + + template <> + struct CppType + { + using Type = AccelerationStructureGeometryInstancesDataKHR; + }; #endif /*VK_ENABLE_BETA_EXTENSIONS*/ #ifdef VK_ENABLE_BETA_EXTENSIONS @@ -26255,6 +26563,8 @@ namespace VULKAN_HPP_NAMESPACE #ifdef VK_ENABLE_BETA_EXTENSIONS struct AccelerationStructureGeometryKHR { + static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::eAccelerationStructureGeometryKHR; + AccelerationStructureGeometryKHR( VULKAN_HPP_NAMESPACE::GeometryTypeKHR geometryType_ = VULKAN_HPP_NAMESPACE::GeometryTypeKHR::eTriangles, VULKAN_HPP_NAMESPACE::AccelerationStructureGeometryDataKHR geometry_ = {}, @@ -26330,6 +26640,12 @@ namespace VULKAN_HPP_NAMESPACE "struct and wrapper have different size!" ); static_assert( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); + + template <> + struct CppType + { + using Type = AccelerationStructureGeometryKHR; + }; #endif /*VK_ENABLE_BETA_EXTENSIONS*/ #ifdef VK_ENABLE_BETA_EXTENSIONS @@ -26387,6 +26703,9 @@ namespace VULKAN_HPP_NAMESPACE #ifdef VK_ENABLE_BETA_EXTENSIONS struct AccelerationStructureBuildGeometryInfoKHR { + static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = + StructureType::eAccelerationStructureBuildGeometryInfoKHR; + AccelerationStructureBuildGeometryInfoKHR( VULKAN_HPP_NAMESPACE::AccelerationStructureTypeKHR type_ = VULKAN_HPP_NAMESPACE::AccelerationStructureTypeKHR::eTopLevel, @@ -26528,6 +26847,12 @@ namespace VULKAN_HPP_NAMESPACE "struct and wrapper have different size!" ); static_assert( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); + + template <> + struct CppType + { + using Type = AccelerationStructureBuildGeometryInfoKHR; + }; #endif /*VK_ENABLE_BETA_EXTENSIONS*/ #ifdef VK_ENABLE_BETA_EXTENSIONS @@ -26620,6 +26945,9 @@ namespace VULKAN_HPP_NAMESPACE #ifdef VK_ENABLE_BETA_EXTENSIONS struct AccelerationStructureCreateGeometryTypeInfoKHR { + static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = + StructureType::eAccelerationStructureCreateGeometryTypeInfoKHR; + VULKAN_HPP_CONSTEXPR AccelerationStructureCreateGeometryTypeInfoKHR( VULKAN_HPP_NAMESPACE::GeometryTypeKHR geometryType_ = VULKAN_HPP_NAMESPACE::GeometryTypeKHR::eTriangles, uint32_t maxPrimitiveCount_ = {}, @@ -26747,11 +27075,20 @@ namespace VULKAN_HPP_NAMESPACE "struct and wrapper have different size!" ); static_assert( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); + + template <> + struct CppType + { + using Type = AccelerationStructureCreateGeometryTypeInfoKHR; + }; #endif /*VK_ENABLE_BETA_EXTENSIONS*/ #ifdef VK_ENABLE_BETA_EXTENSIONS struct AccelerationStructureCreateInfoKHR { + static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = + StructureType::eAccelerationStructureCreateInfoKHR; + VULKAN_HPP_CONSTEXPR AccelerationStructureCreateInfoKHR( VULKAN_HPP_NAMESPACE::DeviceSize compactedSize_ = {}, VULKAN_HPP_NAMESPACE::AccelerationStructureTypeKHR type_ = @@ -26876,10 +27213,18 @@ namespace VULKAN_HPP_NAMESPACE "struct and wrapper have different size!" ); static_assert( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); + + template <> + struct CppType + { + using Type = AccelerationStructureCreateInfoKHR; + }; #endif /*VK_ENABLE_BETA_EXTENSIONS*/ struct GeometryTrianglesNV { + static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::eGeometryTrianglesNV; + VULKAN_HPP_CONSTEXPR GeometryTrianglesNV( VULKAN_HPP_NAMESPACE::Buffer vertexData_ = {}, VULKAN_HPP_NAMESPACE::DeviceSize vertexOffset_ = {}, @@ -27042,8 +27387,16 @@ namespace VULKAN_HPP_NAMESPACE "struct and wrapper have different size!" ); static_assert( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); + template <> + struct CppType + { + using Type = GeometryTrianglesNV; + }; + struct GeometryAABBNV { + static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::eGeometryAabbNV; + VULKAN_HPP_CONSTEXPR GeometryAABBNV( VULKAN_HPP_NAMESPACE::Buffer aabbData_ = {}, uint32_t numAABBs_ = {}, uint32_t stride_ = {}, @@ -27137,6 +27490,12 @@ namespace VULKAN_HPP_NAMESPACE static_assert( sizeof( GeometryAABBNV ) == sizeof( VkGeometryAABBNV ), "struct and wrapper have different size!" ); static_assert( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); + template <> + struct CppType + { + using Type = GeometryAABBNV; + }; + struct GeometryDataNV { VULKAN_HPP_CONSTEXPR GeometryDataNV( VULKAN_HPP_NAMESPACE::GeometryTrianglesNV triangles_ = {}, @@ -27201,6 +27560,8 @@ namespace VULKAN_HPP_NAMESPACE struct GeometryNV { + static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::eGeometryNV; + VULKAN_HPP_CONSTEXPR GeometryNV( VULKAN_HPP_NAMESPACE::GeometryTypeKHR geometryType_ = VULKAN_HPP_NAMESPACE::GeometryTypeKHR::eTriangles, VULKAN_HPP_NAMESPACE::GeometryDataNV geometry_ = {}, @@ -27286,8 +27647,16 @@ namespace VULKAN_HPP_NAMESPACE static_assert( sizeof( GeometryNV ) == sizeof( VkGeometryNV ), "struct and wrapper have different size!" ); static_assert( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); + template <> + struct CppType + { + using Type = GeometryNV; + }; + struct AccelerationStructureInfoNV { + static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::eAccelerationStructureInfoNV; + VULKAN_HPP_CONSTEXPR AccelerationStructureInfoNV( VULKAN_HPP_NAMESPACE::AccelerationStructureTypeNV type_ = {}, VULKAN_HPP_NAMESPACE::BuildAccelerationStructureFlagsNV flags_ = {}, @@ -27397,8 +27766,17 @@ namespace VULKAN_HPP_NAMESPACE static_assert( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); + template <> + struct CppType + { + using Type = AccelerationStructureInfoNV; + }; + struct AccelerationStructureCreateInfoNV { + static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = + StructureType::eAccelerationStructureCreateInfoNV; + VULKAN_HPP_CONSTEXPR AccelerationStructureCreateInfoNV( VULKAN_HPP_NAMESPACE::DeviceSize compactedSize_ = {}, VULKAN_HPP_NAMESPACE::AccelerationStructureInfoNV info_ = {} ) VULKAN_HPP_NOEXCEPT @@ -27481,9 +27859,18 @@ namespace VULKAN_HPP_NAMESPACE static_assert( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); + template <> + struct CppType + { + using Type = AccelerationStructureCreateInfoNV; + }; + #ifdef VK_ENABLE_BETA_EXTENSIONS struct AccelerationStructureDeviceAddressInfoKHR { + static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = + StructureType::eAccelerationStructureDeviceAddressInfoKHR; + VULKAN_HPP_CONSTEXPR AccelerationStructureDeviceAddressInfoKHR( VULKAN_HPP_NAMESPACE::AccelerationStructureKHR accelerationStructure_ = {} ) VULKAN_HPP_NOEXCEPT : accelerationStructure( accelerationStructure_ ) @@ -27559,6 +27946,12 @@ namespace VULKAN_HPP_NAMESPACE "struct and wrapper have different size!" ); static_assert( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); + + template <> + struct CppType + { + using Type = AccelerationStructureDeviceAddressInfoKHR; + }; #endif /*VK_ENABLE_BETA_EXTENSIONS*/ struct TransformMatrixKHR @@ -27727,6 +28120,9 @@ namespace VULKAN_HPP_NAMESPACE #ifdef VK_ENABLE_BETA_EXTENSIONS struct AccelerationStructureMemoryRequirementsInfoKHR { + static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = + StructureType::eAccelerationStructureMemoryRequirementsInfoKHR; + VULKAN_HPP_CONSTEXPR AccelerationStructureMemoryRequirementsInfoKHR( VULKAN_HPP_NAMESPACE::AccelerationStructureMemoryRequirementsTypeKHR type_ = VULKAN_HPP_NAMESPACE::AccelerationStructureMemoryRequirementsTypeKHR::eObject, @@ -27827,10 +28223,19 @@ namespace VULKAN_HPP_NAMESPACE "struct and wrapper have different size!" ); static_assert( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); + + template <> + struct CppType + { + using Type = AccelerationStructureMemoryRequirementsInfoKHR; + }; #endif /*VK_ENABLE_BETA_EXTENSIONS*/ struct AccelerationStructureMemoryRequirementsInfoNV { + static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = + StructureType::eAccelerationStructureMemoryRequirementsInfoNV; + VULKAN_HPP_CONSTEXPR AccelerationStructureMemoryRequirementsInfoNV( VULKAN_HPP_NAMESPACE::AccelerationStructureMemoryRequirementsTypeNV type_ = {}, VULKAN_HPP_NAMESPACE::AccelerationStructureNV accelerationStructure_ = {} ) VULKAN_HPP_NOEXCEPT @@ -27918,9 +28323,17 @@ namespace VULKAN_HPP_NAMESPACE static_assert( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); + template <> + struct CppType + { + using Type = AccelerationStructureMemoryRequirementsInfoNV; + }; + #ifdef VK_ENABLE_BETA_EXTENSIONS struct AccelerationStructureVersionKHR { + static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::eAccelerationStructureVersionKHR; + VULKAN_HPP_CONSTEXPR AccelerationStructureVersionKHR( const uint8_t * versionData_ = {} ) VULKAN_HPP_NOEXCEPT : versionData( versionData_ ) {} @@ -27989,10 +28402,18 @@ namespace VULKAN_HPP_NAMESPACE "struct and wrapper have different size!" ); static_assert( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); + + template <> + struct CppType + { + using Type = AccelerationStructureVersionKHR; + }; #endif /*VK_ENABLE_BETA_EXTENSIONS*/ struct AcquireNextImageInfoKHR { + static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::eAcquireNextImageInfoKHR; + VULKAN_HPP_CONSTEXPR AcquireNextImageInfoKHR( VULKAN_HPP_NAMESPACE::SwapchainKHR swapchain_ = {}, uint64_t timeout_ = {}, VULKAN_HPP_NAMESPACE::Semaphore semaphore_ = {}, @@ -28097,8 +28518,16 @@ namespace VULKAN_HPP_NAMESPACE "struct and wrapper have different size!" ); static_assert( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); + template <> + struct CppType + { + using Type = AcquireNextImageInfoKHR; + }; + struct AcquireProfilingLockInfoKHR { + static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::eAcquireProfilingLockInfoKHR; + VULKAN_HPP_CONSTEXPR AcquireProfilingLockInfoKHR( VULKAN_HPP_NAMESPACE::AcquireProfilingLockFlagsKHR flags_ = {}, uint64_t timeout_ = {} ) VULKAN_HPP_NOEXCEPT : flags( flags_ ) @@ -28177,6 +28606,12 @@ namespace VULKAN_HPP_NAMESPACE static_assert( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); + template <> + struct CppType + { + using Type = AcquireProfilingLockInfoKHR; + }; + struct AllocationCallbacks { VULKAN_HPP_CONSTEXPR AllocationCallbacks( void * pUserData_ = {}, @@ -28365,6 +28800,9 @@ namespace VULKAN_HPP_NAMESPACE #ifdef VK_USE_PLATFORM_ANDROID_KHR struct AndroidHardwareBufferFormatPropertiesANDROID { + static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = + StructureType::eAndroidHardwareBufferFormatPropertiesANDROID; + VULKAN_HPP_CONSTEXPR AndroidHardwareBufferFormatPropertiesANDROID( VULKAN_HPP_NAMESPACE::Format format_ = VULKAN_HPP_NAMESPACE::Format::eUndefined, uint64_t externalFormat_ = {}, @@ -28456,11 +28894,20 @@ namespace VULKAN_HPP_NAMESPACE "struct and wrapper have different size!" ); static_assert( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); + + template <> + struct CppType + { + using Type = AndroidHardwareBufferFormatPropertiesANDROID; + }; #endif /*VK_USE_PLATFORM_ANDROID_KHR*/ #ifdef VK_USE_PLATFORM_ANDROID_KHR struct AndroidHardwareBufferPropertiesANDROID { + static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = + StructureType::eAndroidHardwareBufferPropertiesANDROID; + VULKAN_HPP_CONSTEXPR AndroidHardwareBufferPropertiesANDROID( VULKAN_HPP_NAMESPACE::DeviceSize allocationSize_ = {}, uint32_t memoryTypeBits_ = {} ) VULKAN_HPP_NOEXCEPT : allocationSize( allocationSize_ ) @@ -28524,11 +28971,20 @@ namespace VULKAN_HPP_NAMESPACE "struct and wrapper have different size!" ); static_assert( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); + + template <> + struct CppType + { + using Type = AndroidHardwareBufferPropertiesANDROID; + }; #endif /*VK_USE_PLATFORM_ANDROID_KHR*/ #ifdef VK_USE_PLATFORM_ANDROID_KHR struct AndroidHardwareBufferUsageANDROID { + static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = + StructureType::eAndroidHardwareBufferUsageANDROID; + VULKAN_HPP_CONSTEXPR AndroidHardwareBufferUsageANDROID( uint64_t androidHardwareBufferUsage_ = {} ) VULKAN_HPP_NOEXCEPT : androidHardwareBufferUsage( androidHardwareBufferUsage_ ) @@ -28587,11 +29043,19 @@ namespace VULKAN_HPP_NAMESPACE "struct and wrapper have different size!" ); static_assert( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); + + template <> + struct CppType + { + using Type = AndroidHardwareBufferUsageANDROID; + }; #endif /*VK_USE_PLATFORM_ANDROID_KHR*/ #ifdef VK_USE_PLATFORM_ANDROID_KHR struct AndroidSurfaceCreateInfoKHR { + static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::eAndroidSurfaceCreateInfoKHR; + VULKAN_HPP_CONSTEXPR AndroidSurfaceCreateInfoKHR( VULKAN_HPP_NAMESPACE::AndroidSurfaceCreateFlagsKHR flags_ = {}, struct ANativeWindow * window_ = {} ) VULKAN_HPP_NOEXCEPT : flags( flags_ ) @@ -28669,10 +29133,18 @@ namespace VULKAN_HPP_NAMESPACE "struct and wrapper have different size!" ); static_assert( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); + + template <> + struct CppType + { + using Type = AndroidSurfaceCreateInfoKHR; + }; #endif /*VK_USE_PLATFORM_ANDROID_KHR*/ struct ApplicationInfo { + static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::eApplicationInfo; + VULKAN_HPP_CONSTEXPR ApplicationInfo( const char * pApplicationName_ = {}, uint32_t applicationVersion_ = {}, const char * pEngineName_ = {}, @@ -28776,6 +29248,12 @@ namespace VULKAN_HPP_NAMESPACE static_assert( sizeof( ApplicationInfo ) == sizeof( VkApplicationInfo ), "struct and wrapper have different size!" ); static_assert( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); + template <> + struct CppType + { + using Type = ApplicationInfo; + }; + struct AttachmentDescription { VULKAN_HPP_CONSTEXPR AttachmentDescription( @@ -28911,6 +29389,8 @@ namespace VULKAN_HPP_NAMESPACE struct AttachmentDescription2 { + static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::eAttachmentDescription2; + VULKAN_HPP_CONSTEXPR AttachmentDescription2( VULKAN_HPP_NAMESPACE::AttachmentDescriptionFlags flags_ = {}, VULKAN_HPP_NAMESPACE::Format format_ = VULKAN_HPP_NAMESPACE::Format::eUndefined, @@ -29056,8 +29536,17 @@ namespace VULKAN_HPP_NAMESPACE "struct and wrapper have different size!" ); static_assert( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); + template <> + struct CppType + { + using Type = AttachmentDescription2; + }; + struct AttachmentDescriptionStencilLayout { + static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = + StructureType::eAttachmentDescriptionStencilLayout; + VULKAN_HPP_CONSTEXPR AttachmentDescriptionStencilLayout( VULKAN_HPP_NAMESPACE::ImageLayout stencilInitialLayout_ = VULKAN_HPP_NAMESPACE::ImageLayout::eUndefined, VULKAN_HPP_NAMESPACE::ImageLayout stencilFinalLayout_ = VULKAN_HPP_NAMESPACE::ImageLayout::eUndefined ) @@ -29142,6 +29631,12 @@ namespace VULKAN_HPP_NAMESPACE static_assert( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); + template <> + struct CppType + { + using Type = AttachmentDescriptionStencilLayout; + }; + struct AttachmentReference { VULKAN_HPP_CONSTEXPR AttachmentReference( @@ -29208,6 +29703,8 @@ namespace VULKAN_HPP_NAMESPACE struct AttachmentReference2 { + static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::eAttachmentReference2; + VULKAN_HPP_CONSTEXPR AttachmentReference2( uint32_t attachment_ = {}, VULKAN_HPP_NAMESPACE::ImageLayout layout_ = VULKAN_HPP_NAMESPACE::ImageLayout::eUndefined, @@ -29294,8 +29791,16 @@ namespace VULKAN_HPP_NAMESPACE "struct and wrapper have different size!" ); static_assert( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); + template <> + struct CppType + { + using Type = AttachmentReference2; + }; + struct AttachmentReferenceStencilLayout { + static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::eAttachmentReferenceStencilLayout; + VULKAN_HPP_CONSTEXPR AttachmentReferenceStencilLayout( VULKAN_HPP_NAMESPACE::ImageLayout stencilLayout_ = VULKAN_HPP_NAMESPACE::ImageLayout::eUndefined ) VULKAN_HPP_NOEXCEPT @@ -29368,6 +29873,12 @@ namespace VULKAN_HPP_NAMESPACE static_assert( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); + template <> + struct CppType + { + using Type = AttachmentReferenceStencilLayout; + }; + struct Extent2D { VULKAN_HPP_CONSTEXPR Extent2D( uint32_t width_ = {}, uint32_t height_ = {} ) VULKAN_HPP_NOEXCEPT @@ -29493,6 +30004,8 @@ namespace VULKAN_HPP_NAMESPACE struct SampleLocationsInfoEXT { + static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::eSampleLocationsInfoEXT; + VULKAN_HPP_CONSTEXPR SampleLocationsInfoEXT( VULKAN_HPP_NAMESPACE::SampleCountFlagBits sampleLocationsPerPixel_ = VULKAN_HPP_NAMESPACE::SampleCountFlagBits::e1, @@ -29594,6 +30107,12 @@ namespace VULKAN_HPP_NAMESPACE "struct and wrapper have different size!" ); static_assert( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); + template <> + struct CppType + { + using Type = SampleLocationsInfoEXT; + }; + struct AttachmentSampleLocationsEXT { VULKAN_HPP_CONSTEXPR AttachmentSampleLocationsEXT( @@ -29767,6 +30286,9 @@ namespace VULKAN_HPP_NAMESPACE struct BindAccelerationStructureMemoryInfoKHR { + static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = + StructureType::eBindAccelerationStructureMemoryInfoKHR; + VULKAN_HPP_CONSTEXPR BindAccelerationStructureMemoryInfoKHR( VULKAN_HPP_NAMESPACE::AccelerationStructureKHR accelerationStructure_ = {}, VULKAN_HPP_NAMESPACE::DeviceMemory memory_ = {}, @@ -29881,8 +30403,16 @@ namespace VULKAN_HPP_NAMESPACE static_assert( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); + template <> + struct CppType + { + using Type = BindAccelerationStructureMemoryInfoKHR; + }; + struct BindBufferMemoryDeviceGroupInfo { + static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::eBindBufferMemoryDeviceGroupInfo; + VULKAN_HPP_CONSTEXPR BindBufferMemoryDeviceGroupInfo( uint32_t deviceIndexCount_ = {}, const uint32_t * pDeviceIndices_ = {} ) VULKAN_HPP_NOEXCEPT : deviceIndexCount( deviceIndexCount_ ) @@ -29962,8 +30492,16 @@ namespace VULKAN_HPP_NAMESPACE static_assert( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); + template <> + struct CppType + { + using Type = BindBufferMemoryDeviceGroupInfo; + }; + struct BindBufferMemoryInfo { + static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::eBindBufferMemoryInfo; + VULKAN_HPP_CONSTEXPR BindBufferMemoryInfo( VULKAN_HPP_NAMESPACE::Buffer buffer_ = {}, VULKAN_HPP_NAMESPACE::DeviceMemory memory_ = {}, VULKAN_HPP_NAMESPACE::DeviceSize memoryOffset_ = {} ) VULKAN_HPP_NOEXCEPT @@ -30049,6 +30587,12 @@ namespace VULKAN_HPP_NAMESPACE "struct and wrapper have different size!" ); static_assert( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); + template <> + struct CppType + { + using Type = BindBufferMemoryInfo; + }; + struct Offset2D { VULKAN_HPP_CONSTEXPR Offset2D( int32_t x_ = {}, int32_t y_ = {} ) VULKAN_HPP_NOEXCEPT @@ -30174,6 +30718,8 @@ namespace VULKAN_HPP_NAMESPACE struct BindImageMemoryDeviceGroupInfo { + static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::eBindImageMemoryDeviceGroupInfo; + VULKAN_HPP_CONSTEXPR BindImageMemoryDeviceGroupInfo( uint32_t deviceIndexCount_ = {}, const uint32_t * pDeviceIndices_ = {}, @@ -30276,8 +30822,16 @@ namespace VULKAN_HPP_NAMESPACE static_assert( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); + template <> + struct CppType + { + using Type = BindImageMemoryDeviceGroupInfo; + }; + struct BindImageMemoryInfo { + static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::eBindImageMemoryInfo; + VULKAN_HPP_CONSTEXPR BindImageMemoryInfo( VULKAN_HPP_NAMESPACE::Image image_ = {}, VULKAN_HPP_NAMESPACE::DeviceMemory memory_ = {}, VULKAN_HPP_NAMESPACE::DeviceSize memoryOffset_ = {} ) VULKAN_HPP_NOEXCEPT @@ -30363,8 +30917,16 @@ namespace VULKAN_HPP_NAMESPACE "struct and wrapper have different size!" ); static_assert( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); + template <> + struct CppType + { + using Type = BindImageMemoryInfo; + }; + struct BindImageMemorySwapchainInfoKHR { + static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::eBindImageMemorySwapchainInfoKHR; + VULKAN_HPP_CONSTEXPR BindImageMemorySwapchainInfoKHR( VULKAN_HPP_NAMESPACE::SwapchainKHR swapchain_ = {}, uint32_t imageIndex_ = {} ) VULKAN_HPP_NOEXCEPT : swapchain( swapchain_ ) @@ -30444,8 +31006,16 @@ namespace VULKAN_HPP_NAMESPACE static_assert( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); + template <> + struct CppType + { + using Type = BindImageMemorySwapchainInfoKHR; + }; + struct BindImagePlaneMemoryInfo { + static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::eBindImagePlaneMemoryInfo; + VULKAN_HPP_CONSTEXPR BindImagePlaneMemoryInfo( VULKAN_HPP_NAMESPACE::ImageAspectFlagBits planeAspect_ = VULKAN_HPP_NAMESPACE::ImageAspectFlagBits::eColor ) VULKAN_HPP_NOEXCEPT @@ -30515,6 +31085,12 @@ namespace VULKAN_HPP_NAMESPACE "struct and wrapper have different size!" ); static_assert( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); + template <> + struct CppType + { + using Type = BindImagePlaneMemoryInfo; + }; + struct BindIndexBufferIndirectCommandNV { VULKAN_HPP_CONSTEXPR BindIndexBufferIndirectCommandNV( @@ -31281,6 +31857,8 @@ namespace VULKAN_HPP_NAMESPACE struct BindSparseInfo { + static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::eBindSparseInfo; + VULKAN_HPP_CONSTEXPR BindSparseInfo( uint32_t waitSemaphoreCount_ = {}, const VULKAN_HPP_NAMESPACE::Semaphore * pWaitSemaphores_ = {}, @@ -31437,6 +32015,12 @@ namespace VULKAN_HPP_NAMESPACE static_assert( sizeof( BindSparseInfo ) == sizeof( VkBindSparseInfo ), "struct and wrapper have different size!" ); static_assert( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); + template <> + struct CppType + { + using Type = BindSparseInfo; + }; + struct BindVertexBufferIndirectCommandNV { VULKAN_HPP_CONSTEXPR BindVertexBufferIndirectCommandNV( VULKAN_HPP_NAMESPACE::DeviceAddress bufferAddress_ = {}, @@ -31584,6 +32168,8 @@ namespace VULKAN_HPP_NAMESPACE struct BufferCreateInfo { + static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::eBufferCreateInfo; + VULKAN_HPP_CONSTEXPR BufferCreateInfo( VULKAN_HPP_NAMESPACE::BufferCreateFlags flags_ = {}, VULKAN_HPP_NAMESPACE::DeviceSize size_ = {}, @@ -31699,8 +32285,16 @@ namespace VULKAN_HPP_NAMESPACE "struct and wrapper have different size!" ); static_assert( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); + template <> + struct CppType + { + using Type = BufferCreateInfo; + }; + struct BufferDeviceAddressCreateInfoEXT { + static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::eBufferDeviceAddressCreateInfoEXT; + VULKAN_HPP_CONSTEXPR BufferDeviceAddressCreateInfoEXT( VULKAN_HPP_NAMESPACE::DeviceAddress deviceAddress_ = {} ) VULKAN_HPP_NOEXCEPT : deviceAddress( deviceAddress_ ) @@ -31772,8 +32366,16 @@ namespace VULKAN_HPP_NAMESPACE static_assert( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); + template <> + struct CppType + { + using Type = BufferDeviceAddressCreateInfoEXT; + }; + struct BufferDeviceAddressInfo { + static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::eBufferDeviceAddressInfo; + VULKAN_HPP_CONSTEXPR BufferDeviceAddressInfo( VULKAN_HPP_NAMESPACE::Buffer buffer_ = {} ) VULKAN_HPP_NOEXCEPT : buffer( buffer_ ) {} @@ -31840,6 +32442,12 @@ namespace VULKAN_HPP_NAMESPACE "struct and wrapper have different size!" ); static_assert( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); + template <> + struct CppType + { + using Type = BufferDeviceAddressInfo; + }; + struct ImageSubresourceLayers { VULKAN_HPP_CONSTEXPR ImageSubresourceLayers( VULKAN_HPP_NAMESPACE::ImageAspectFlags aspectMask_ = {}, @@ -32025,6 +32633,8 @@ namespace VULKAN_HPP_NAMESPACE struct BufferMemoryBarrier { + static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::eBufferMemoryBarrier; + VULKAN_HPP_CONSTEXPR BufferMemoryBarrier( VULKAN_HPP_NAMESPACE::AccessFlags srcAccessMask_ = {}, VULKAN_HPP_NAMESPACE::AccessFlags dstAccessMask_ = {}, uint32_t srcQueueFamilyIndex_ = {}, @@ -32148,8 +32758,16 @@ namespace VULKAN_HPP_NAMESPACE "struct and wrapper have different size!" ); static_assert( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); + template <> + struct CppType + { + using Type = BufferMemoryBarrier; + }; + struct BufferMemoryRequirementsInfo2 { + static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::eBufferMemoryRequirementsInfo2; + VULKAN_HPP_CONSTEXPR BufferMemoryRequirementsInfo2( VULKAN_HPP_NAMESPACE::Buffer buffer_ = {} ) VULKAN_HPP_NOEXCEPT : buffer( buffer_ ) {} @@ -32219,8 +32837,17 @@ namespace VULKAN_HPP_NAMESPACE static_assert( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); + template <> + struct CppType + { + using Type = BufferMemoryRequirementsInfo2; + }; + struct BufferOpaqueCaptureAddressCreateInfo { + static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = + StructureType::eBufferOpaqueCaptureAddressCreateInfo; + VULKAN_HPP_CONSTEXPR BufferOpaqueCaptureAddressCreateInfo( uint64_t opaqueCaptureAddress_ = {} ) VULKAN_HPP_NOEXCEPT : opaqueCaptureAddress( opaqueCaptureAddress_ ) {} @@ -32293,8 +32920,16 @@ namespace VULKAN_HPP_NAMESPACE static_assert( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); + template <> + struct CppType + { + using Type = BufferOpaqueCaptureAddressCreateInfo; + }; + struct BufferViewCreateInfo { + static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::eBufferViewCreateInfo; + VULKAN_HPP_CONSTEXPR BufferViewCreateInfo( VULKAN_HPP_NAMESPACE::BufferViewCreateFlags flags_ = {}, VULKAN_HPP_NAMESPACE::Buffer buffer_ = {}, @@ -32399,8 +33034,16 @@ namespace VULKAN_HPP_NAMESPACE "struct and wrapper have different size!" ); static_assert( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); + template <> + struct CppType + { + using Type = BufferViewCreateInfo; + }; + struct CalibratedTimestampInfoEXT { + static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::eCalibratedTimestampInfoEXT; + VULKAN_HPP_CONSTEXPR CalibratedTimestampInfoEXT( VULKAN_HPP_NAMESPACE::TimeDomainEXT timeDomain_ = VULKAN_HPP_NAMESPACE::TimeDomainEXT::eDevice ) VULKAN_HPP_NOEXCEPT @@ -32471,8 +33114,16 @@ namespace VULKAN_HPP_NAMESPACE static_assert( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); + template <> + struct CppType + { + using Type = CalibratedTimestampInfoEXT; + }; + struct CheckpointDataNV { + static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::eCheckpointDataNV; + VULKAN_HPP_CONSTEXPR CheckpointDataNV( VULKAN_HPP_NAMESPACE::PipelineStageFlagBits stage_ = VULKAN_HPP_NAMESPACE::PipelineStageFlagBits::eTopOfPipe, void * pCheckpointMarker_ = {} ) VULKAN_HPP_NOEXCEPT @@ -32532,6 +33183,12 @@ namespace VULKAN_HPP_NAMESPACE "struct and wrapper have different size!" ); static_assert( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); + template <> + struct CppType + { + using Type = CheckpointDataNV; + }; + union ClearColorValue { ClearColorValue( VULKAN_HPP_NAMESPACE::ClearColorValue const & rhs ) VULKAN_HPP_NOEXCEPT @@ -32985,6 +33642,8 @@ namespace VULKAN_HPP_NAMESPACE struct CommandBufferAllocateInfo { + static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::eCommandBufferAllocateInfo; + VULKAN_HPP_CONSTEXPR CommandBufferAllocateInfo( VULKAN_HPP_NAMESPACE::CommandPool commandPool_ = {}, VULKAN_HPP_NAMESPACE::CommandBufferLevel level_ = VULKAN_HPP_NAMESPACE::CommandBufferLevel::ePrimary, @@ -33072,8 +33731,16 @@ namespace VULKAN_HPP_NAMESPACE static_assert( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); + template <> + struct CppType + { + using Type = CommandBufferAllocateInfo; + }; + struct CommandBufferInheritanceInfo { + static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::eCommandBufferInheritanceInfo; + VULKAN_HPP_CONSTEXPR CommandBufferInheritanceInfo( VULKAN_HPP_NAMESPACE::RenderPass renderPass_ = {}, uint32_t subpass_ = {}, @@ -33194,8 +33861,16 @@ namespace VULKAN_HPP_NAMESPACE static_assert( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); + template <> + struct CppType + { + using Type = CommandBufferInheritanceInfo; + }; + struct CommandBufferBeginInfo { + static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::eCommandBufferBeginInfo; + VULKAN_HPP_CONSTEXPR CommandBufferBeginInfo( VULKAN_HPP_NAMESPACE::CommandBufferUsageFlags flags_ = {}, const VULKAN_HPP_NAMESPACE::CommandBufferInheritanceInfo * pInheritanceInfo_ = {} ) VULKAN_HPP_NOEXCEPT @@ -33274,8 +33949,17 @@ namespace VULKAN_HPP_NAMESPACE "struct and wrapper have different size!" ); static_assert( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); + template <> + struct CppType + { + using Type = CommandBufferBeginInfo; + }; + struct CommandBufferInheritanceConditionalRenderingInfoEXT { + static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = + StructureType::eCommandBufferInheritanceConditionalRenderingInfoEXT; + VULKAN_HPP_CONSTEXPR CommandBufferInheritanceConditionalRenderingInfoEXT( VULKAN_HPP_NAMESPACE::Bool32 conditionalRenderingEnable_ = {} ) VULKAN_HPP_NOEXCEPT : conditionalRenderingEnable( conditionalRenderingEnable_ ) @@ -33355,8 +34039,17 @@ namespace VULKAN_HPP_NAMESPACE static_assert( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); + template <> + struct CppType + { + using Type = CommandBufferInheritanceConditionalRenderingInfoEXT; + }; + struct CommandBufferInheritanceRenderPassTransformInfoQCOM { + static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = + StructureType::eCommandBufferInheritanceRenderPassTransformInfoQCOM; + VULKAN_HPP_CONSTEXPR CommandBufferInheritanceRenderPassTransformInfoQCOM( VULKAN_HPP_NAMESPACE::SurfaceTransformFlagBitsKHR transform_ = VULKAN_HPP_NAMESPACE::SurfaceTransformFlagBitsKHR::eIdentity, @@ -33448,8 +34141,16 @@ namespace VULKAN_HPP_NAMESPACE static_assert( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); + template <> + struct CppType + { + using Type = CommandBufferInheritanceRenderPassTransformInfoQCOM; + }; + struct CommandPoolCreateInfo { + static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::eCommandPoolCreateInfo; + VULKAN_HPP_CONSTEXPR CommandPoolCreateInfo( VULKAN_HPP_NAMESPACE::CommandPoolCreateFlags flags_ = {}, uint32_t queueFamilyIndex_ = {} ) VULKAN_HPP_NOEXCEPT : flags( flags_ ) @@ -33526,6 +34227,12 @@ namespace VULKAN_HPP_NAMESPACE "struct and wrapper have different size!" ); static_assert( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); + template <> + struct CppType + { + using Type = CommandPoolCreateInfo; + }; + struct SpecializationMapEntry { VULKAN_HPP_CONSTEXPR @@ -33682,6 +34389,8 @@ namespace VULKAN_HPP_NAMESPACE struct PipelineShaderStageCreateInfo { + static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::ePipelineShaderStageCreateInfo; + VULKAN_HPP_CONSTEXPR PipelineShaderStageCreateInfo( VULKAN_HPP_NAMESPACE::PipelineShaderStageCreateFlags flags_ = {}, VULKAN_HPP_NAMESPACE::ShaderStageFlagBits stage_ = VULKAN_HPP_NAMESPACE::ShaderStageFlagBits::eVertex, @@ -33791,8 +34500,16 @@ namespace VULKAN_HPP_NAMESPACE static_assert( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); + template <> + struct CppType + { + using Type = PipelineShaderStageCreateInfo; + }; + struct ComputePipelineCreateInfo { + static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::eComputePipelineCreateInfo; + VULKAN_HPP_CONSTEXPR ComputePipelineCreateInfo( VULKAN_HPP_NAMESPACE::PipelineCreateFlags flags_ = {}, VULKAN_HPP_NAMESPACE::PipelineShaderStageCreateInfo stage_ = {}, VULKAN_HPP_NAMESPACE::PipelineLayout layout_ = {}, @@ -33900,8 +34617,16 @@ namespace VULKAN_HPP_NAMESPACE static_assert( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); + template <> + struct CppType + { + using Type = ComputePipelineCreateInfo; + }; + struct ConditionalRenderingBeginInfoEXT { + static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::eConditionalRenderingBeginInfoEXT; + VULKAN_HPP_CONSTEXPR ConditionalRenderingBeginInfoEXT( VULKAN_HPP_NAMESPACE::Buffer buffer_ = {}, VULKAN_HPP_NAMESPACE::DeviceSize offset_ = {}, @@ -33992,6 +34717,12 @@ namespace VULKAN_HPP_NAMESPACE static_assert( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); + template <> + struct CppType + { + using Type = ConditionalRenderingBeginInfoEXT; + }; + struct ConformanceVersion { VULKAN_HPP_CONSTEXPR ConformanceVersion( uint8_t major_ = {}, @@ -34075,6 +34806,8 @@ namespace VULKAN_HPP_NAMESPACE struct CooperativeMatrixPropertiesNV { + static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::eCooperativeMatrixPropertiesNV; + VULKAN_HPP_CONSTEXPR CooperativeMatrixPropertiesNV( uint32_t MSize_ = {}, uint32_t NSize_ = {}, @@ -34210,9 +34943,17 @@ namespace VULKAN_HPP_NAMESPACE static_assert( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); + template <> + struct CppType + { + using Type = CooperativeMatrixPropertiesNV; + }; + #ifdef VK_ENABLE_BETA_EXTENSIONS struct CopyAccelerationStructureInfoKHR { + static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::eCopyAccelerationStructureInfoKHR; + VULKAN_HPP_CONSTEXPR CopyAccelerationStructureInfoKHR( VULKAN_HPP_NAMESPACE::AccelerationStructureKHR src_ = {}, VULKAN_HPP_NAMESPACE::AccelerationStructureKHR dst_ = {}, @@ -34304,11 +35045,20 @@ namespace VULKAN_HPP_NAMESPACE "struct and wrapper have different size!" ); static_assert( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); + + template <> + struct CppType + { + using Type = CopyAccelerationStructureInfoKHR; + }; #endif /*VK_ENABLE_BETA_EXTENSIONS*/ #ifdef VK_ENABLE_BETA_EXTENSIONS struct CopyAccelerationStructureToMemoryInfoKHR { + static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = + StructureType::eCopyAccelerationStructureToMemoryInfoKHR; + CopyAccelerationStructureToMemoryInfoKHR( VULKAN_HPP_NAMESPACE::AccelerationStructureKHR src_ = {}, VULKAN_HPP_NAMESPACE::DeviceOrHostAddressKHR dst_ = {}, VULKAN_HPP_NAMESPACE::CopyAccelerationStructureModeKHR mode_ = @@ -34392,10 +35142,18 @@ namespace VULKAN_HPP_NAMESPACE "struct and wrapper have different size!" ); static_assert( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); + + template <> + struct CppType + { + using Type = CopyAccelerationStructureToMemoryInfoKHR; + }; #endif /*VK_ENABLE_BETA_EXTENSIONS*/ struct CopyDescriptorSet { + static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::eCopyDescriptorSet; + VULKAN_HPP_CONSTEXPR CopyDescriptorSet( VULKAN_HPP_NAMESPACE::DescriptorSet srcSet_ = {}, uint32_t srcBinding_ = {}, uint32_t srcArrayElement_ = {}, @@ -34519,9 +35277,18 @@ namespace VULKAN_HPP_NAMESPACE "struct and wrapper have different size!" ); static_assert( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); + template <> + struct CppType + { + using Type = CopyDescriptorSet; + }; + #ifdef VK_ENABLE_BETA_EXTENSIONS struct CopyMemoryToAccelerationStructureInfoKHR { + static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = + StructureType::eCopyMemoryToAccelerationStructureInfoKHR; + CopyMemoryToAccelerationStructureInfoKHR( VULKAN_HPP_NAMESPACE::DeviceOrHostAddressConstKHR src_ = {}, VULKAN_HPP_NAMESPACE::AccelerationStructureKHR dst_ = {}, VULKAN_HPP_NAMESPACE::CopyAccelerationStructureModeKHR mode_ = @@ -34605,11 +35372,19 @@ namespace VULKAN_HPP_NAMESPACE "struct and wrapper have different size!" ); static_assert( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); + + template <> + struct CppType + { + using Type = CopyMemoryToAccelerationStructureInfoKHR; + }; #endif /*VK_ENABLE_BETA_EXTENSIONS*/ #ifdef VK_USE_PLATFORM_WIN32_KHR struct D3D12FenceSubmitInfoKHR { + static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::eD3D12FenceSubmitInfoKHR; + VULKAN_HPP_CONSTEXPR D3D12FenceSubmitInfoKHR( uint32_t waitSemaphoreValuesCount_ = {}, const uint64_t * pWaitSemaphoreValues_ = {}, uint32_t signalSemaphoreValuesCount_ = {}, @@ -34706,10 +35481,18 @@ namespace VULKAN_HPP_NAMESPACE static_assert( sizeof( D3D12FenceSubmitInfoKHR ) == sizeof( VkD3D12FenceSubmitInfoKHR ), "struct and wrapper have different size!" ); static_assert( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); + + template <> + struct CppType + { + using Type = D3D12FenceSubmitInfoKHR; + }; #endif /*VK_USE_PLATFORM_WIN32_KHR*/ struct DebugMarkerMarkerInfoEXT { + static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::eDebugMarkerMarkerInfoEXT; + VULKAN_HPP_CONSTEXPR_14 DebugMarkerMarkerInfoEXT( const char * pMarkerName_ = {}, std::array const & color_ = {} ) VULKAN_HPP_NOEXCEPT : pMarkerName( pMarkerName_ ) @@ -34786,8 +35569,16 @@ namespace VULKAN_HPP_NAMESPACE "struct and wrapper have different size!" ); static_assert( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); + template <> + struct CppType + { + using Type = DebugMarkerMarkerInfoEXT; + }; + struct DebugMarkerObjectNameInfoEXT { + static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::eDebugMarkerObjectNameInfoEXT; + VULKAN_HPP_CONSTEXPR DebugMarkerObjectNameInfoEXT( VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT objectType_ = VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT::eUnknown, uint64_t object_ = {}, @@ -34878,8 +35669,16 @@ namespace VULKAN_HPP_NAMESPACE static_assert( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); + template <> + struct CppType + { + using Type = DebugMarkerObjectNameInfoEXT; + }; + struct DebugMarkerObjectTagInfoEXT { + static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::eDebugMarkerObjectTagInfoEXT; + VULKAN_HPP_CONSTEXPR DebugMarkerObjectTagInfoEXT( VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT objectType_ = VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT::eUnknown, uint64_t object_ = {}, @@ -34989,8 +35788,16 @@ namespace VULKAN_HPP_NAMESPACE static_assert( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); + template <> + struct CppType + { + using Type = DebugMarkerObjectTagInfoEXT; + }; + struct DebugReportCallbackCreateInfoEXT { + static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::eDebugReportCallbackCreateInfoEXT; + VULKAN_HPP_CONSTEXPR DebugReportCallbackCreateInfoEXT( VULKAN_HPP_NAMESPACE::DebugReportFlagsEXT flags_ = {}, PFN_vkDebugReportCallbackEXT pfnCallback_ = {}, void * pUserData_ = {} ) VULKAN_HPP_NOEXCEPT @@ -35079,8 +35886,16 @@ namespace VULKAN_HPP_NAMESPACE static_assert( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); + template <> + struct CppType + { + using Type = DebugReportCallbackCreateInfoEXT; + }; + struct DebugUtilsLabelEXT { + static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::eDebugUtilsLabelEXT; + VULKAN_HPP_CONSTEXPR_14 DebugUtilsLabelEXT( const char * pLabelName_ = {}, std::array const & color_ = {} ) VULKAN_HPP_NOEXCEPT : pLabelName( pLabelName_ ) @@ -35157,8 +35972,16 @@ namespace VULKAN_HPP_NAMESPACE "struct and wrapper have different size!" ); static_assert( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); + template <> + struct CppType + { + using Type = DebugUtilsLabelEXT; + }; + struct DebugUtilsObjectNameInfoEXT { + static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::eDebugUtilsObjectNameInfoEXT; + VULKAN_HPP_CONSTEXPR DebugUtilsObjectNameInfoEXT( VULKAN_HPP_NAMESPACE::ObjectType objectType_ = VULKAN_HPP_NAMESPACE::ObjectType::eUnknown, uint64_t objectHandle_ = {}, @@ -35247,8 +36070,17 @@ namespace VULKAN_HPP_NAMESPACE static_assert( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); + template <> + struct CppType + { + using Type = DebugUtilsObjectNameInfoEXT; + }; + struct DebugUtilsMessengerCallbackDataEXT { + static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = + StructureType::eDebugUtilsMessengerCallbackDataEXT; + VULKAN_HPP_CONSTEXPR_14 DebugUtilsMessengerCallbackDataEXT( VULKAN_HPP_NAMESPACE::DebugUtilsMessengerCallbackDataFlagsEXT flags_ = {}, const char * pMessageIdName_ = {}, @@ -35410,8 +36242,16 @@ namespace VULKAN_HPP_NAMESPACE static_assert( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); + template <> + struct CppType + { + using Type = DebugUtilsMessengerCallbackDataEXT; + }; + struct DebugUtilsMessengerCreateInfoEXT { + static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::eDebugUtilsMessengerCreateInfoEXT; + VULKAN_HPP_CONSTEXPR DebugUtilsMessengerCreateInfoEXT( VULKAN_HPP_NAMESPACE::DebugUtilsMessengerCreateFlagsEXT flags_ = {}, VULKAN_HPP_NAMESPACE::DebugUtilsMessageSeverityFlagsEXT messageSeverity_ = {}, @@ -35524,8 +36364,16 @@ namespace VULKAN_HPP_NAMESPACE static_assert( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); + template <> + struct CppType + { + using Type = DebugUtilsMessengerCreateInfoEXT; + }; + struct DebugUtilsObjectTagInfoEXT { + static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::eDebugUtilsObjectTagInfoEXT; + VULKAN_HPP_CONSTEXPR DebugUtilsObjectTagInfoEXT( VULKAN_HPP_NAMESPACE::ObjectType objectType_ = VULKAN_HPP_NAMESPACE::ObjectType::eUnknown, uint64_t objectHandle_ = {}, @@ -35633,8 +36481,17 @@ namespace VULKAN_HPP_NAMESPACE static_assert( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); + template <> + struct CppType + { + using Type = DebugUtilsObjectTagInfoEXT; + }; + struct DedicatedAllocationBufferCreateInfoNV { + static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = + StructureType::eDedicatedAllocationBufferCreateInfoNV; + VULKAN_HPP_CONSTEXPR DedicatedAllocationBufferCreateInfoNV( VULKAN_HPP_NAMESPACE::Bool32 dedicatedAllocation_ = {} ) VULKAN_HPP_NOEXCEPT : dedicatedAllocation( dedicatedAllocation_ ) {} @@ -35708,8 +36565,17 @@ namespace VULKAN_HPP_NAMESPACE static_assert( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); + template <> + struct CppType + { + using Type = DedicatedAllocationBufferCreateInfoNV; + }; + struct DedicatedAllocationImageCreateInfoNV { + static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = + StructureType::eDedicatedAllocationImageCreateInfoNV; + VULKAN_HPP_CONSTEXPR DedicatedAllocationImageCreateInfoNV( VULKAN_HPP_NAMESPACE::Bool32 dedicatedAllocation_ = {} ) VULKAN_HPP_NOEXCEPT : dedicatedAllocation( dedicatedAllocation_ ) @@ -35784,8 +36650,17 @@ namespace VULKAN_HPP_NAMESPACE static_assert( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); + template <> + struct CppType + { + using Type = DedicatedAllocationImageCreateInfoNV; + }; + struct DedicatedAllocationMemoryAllocateInfoNV { + static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = + StructureType::eDedicatedAllocationMemoryAllocateInfoNV; + VULKAN_HPP_CONSTEXPR DedicatedAllocationMemoryAllocateInfoNV( VULKAN_HPP_NAMESPACE::Image image_ = {}, VULKAN_HPP_NAMESPACE::Buffer buffer_ = {} ) VULKAN_HPP_NOEXCEPT @@ -35869,9 +36744,17 @@ namespace VULKAN_HPP_NAMESPACE static_assert( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); + template <> + struct CppType + { + using Type = DedicatedAllocationMemoryAllocateInfoNV; + }; + #ifdef VK_ENABLE_BETA_EXTENSIONS struct DeferredOperationInfoKHR { + static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::eDeferredOperationInfoKHR; + VULKAN_HPP_CONSTEXPR DeferredOperationInfoKHR( VULKAN_HPP_NAMESPACE::DeferredOperationKHR operationHandle_ = {} ) VULKAN_HPP_NOEXCEPT : operationHandle( operationHandle_ ) @@ -35939,6 +36822,12 @@ namespace VULKAN_HPP_NAMESPACE static_assert( sizeof( DeferredOperationInfoKHR ) == sizeof( VkDeferredOperationInfoKHR ), "struct and wrapper have different size!" ); static_assert( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); + + template <> + struct CppType + { + using Type = DeferredOperationInfoKHR; + }; #endif /*VK_ENABLE_BETA_EXTENSIONS*/ struct DescriptorBufferInfo @@ -36152,6 +37041,8 @@ namespace VULKAN_HPP_NAMESPACE struct DescriptorPoolCreateInfo { + static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::eDescriptorPoolCreateInfo; + VULKAN_HPP_CONSTEXPR DescriptorPoolCreateInfo( VULKAN_HPP_NAMESPACE::DescriptorPoolCreateFlags flags_ = {}, uint32_t maxSets_ = {}, @@ -36248,8 +37139,17 @@ namespace VULKAN_HPP_NAMESPACE "struct and wrapper have different size!" ); static_assert( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); + template <> + struct CppType + { + using Type = DescriptorPoolCreateInfo; + }; + struct DescriptorPoolInlineUniformBlockCreateInfoEXT { + static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = + StructureType::eDescriptorPoolInlineUniformBlockCreateInfoEXT; + VULKAN_HPP_CONSTEXPR DescriptorPoolInlineUniformBlockCreateInfoEXT( uint32_t maxInlineUniformBlockBindings_ = {} ) VULKAN_HPP_NOEXCEPT : maxInlineUniformBlockBindings( maxInlineUniformBlockBindings_ ) @@ -36327,8 +37227,16 @@ namespace VULKAN_HPP_NAMESPACE static_assert( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); + template <> + struct CppType + { + using Type = DescriptorPoolInlineUniformBlockCreateInfoEXT; + }; + struct DescriptorSetAllocateInfo { + static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::eDescriptorSetAllocateInfo; + VULKAN_HPP_CONSTEXPR DescriptorSetAllocateInfo( VULKAN_HPP_NAMESPACE::DescriptorPool descriptorPool_ = {}, uint32_t descriptorSetCount_ = {}, @@ -36418,6 +37326,12 @@ namespace VULKAN_HPP_NAMESPACE static_assert( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); + template <> + struct CppType + { + using Type = DescriptorSetAllocateInfo; + }; + struct DescriptorSetLayoutBinding { VULKAN_HPP_CONSTEXPR DescriptorSetLayoutBinding( @@ -36516,6 +37430,9 @@ namespace VULKAN_HPP_NAMESPACE struct DescriptorSetLayoutBindingFlagsCreateInfo { + static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = + StructureType::eDescriptorSetLayoutBindingFlagsCreateInfo; + VULKAN_HPP_CONSTEXPR DescriptorSetLayoutBindingFlagsCreateInfo( uint32_t bindingCount_ = {}, const VULKAN_HPP_NAMESPACE::DescriptorBindingFlags * pBindingFlags_ = {} ) VULKAN_HPP_NOEXCEPT @@ -36602,8 +37519,16 @@ namespace VULKAN_HPP_NAMESPACE static_assert( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); + template <> + struct CppType + { + using Type = DescriptorSetLayoutBindingFlagsCreateInfo; + }; + struct DescriptorSetLayoutCreateInfo { + static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::eDescriptorSetLayoutCreateInfo; + VULKAN_HPP_CONSTEXPR DescriptorSetLayoutCreateInfo( VULKAN_HPP_NAMESPACE::DescriptorSetLayoutCreateFlags flags_ = {}, uint32_t bindingCount_ = {}, @@ -36695,8 +37620,16 @@ namespace VULKAN_HPP_NAMESPACE static_assert( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); + template <> + struct CppType + { + using Type = DescriptorSetLayoutCreateInfo; + }; + struct DescriptorSetLayoutSupport { + static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::eDescriptorSetLayoutSupport; + VULKAN_HPP_CONSTEXPR DescriptorSetLayoutSupport( VULKAN_HPP_NAMESPACE::Bool32 supported_ = {} ) VULKAN_HPP_NOEXCEPT : supported( supported_ ) {} @@ -36753,8 +37686,17 @@ namespace VULKAN_HPP_NAMESPACE static_assert( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); + template <> + struct CppType + { + using Type = DescriptorSetLayoutSupport; + }; + struct DescriptorSetVariableDescriptorCountAllocateInfo { + static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = + StructureType::eDescriptorSetVariableDescriptorCountAllocateInfo; + VULKAN_HPP_CONSTEXPR DescriptorSetVariableDescriptorCountAllocateInfo( uint32_t descriptorSetCount_ = {}, const uint32_t * pDescriptorCounts_ = {} ) VULKAN_HPP_NOEXCEPT @@ -36842,8 +37784,17 @@ namespace VULKAN_HPP_NAMESPACE static_assert( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); + template <> + struct CppType + { + using Type = DescriptorSetVariableDescriptorCountAllocateInfo; + }; + struct DescriptorSetVariableDescriptorCountLayoutSupport { + static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = + StructureType::eDescriptorSetVariableDescriptorCountLayoutSupport; + VULKAN_HPP_CONSTEXPR DescriptorSetVariableDescriptorCountLayoutSupport( uint32_t maxVariableDescriptorCount_ = {} ) VULKAN_HPP_NOEXCEPT : maxVariableDescriptorCount( maxVariableDescriptorCount_ ) @@ -36909,6 +37860,12 @@ namespace VULKAN_HPP_NAMESPACE static_assert( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); + template <> + struct CppType + { + using Type = DescriptorSetVariableDescriptorCountLayoutSupport; + }; + struct DescriptorUpdateTemplateEntry { VULKAN_HPP_CONSTEXPR DescriptorUpdateTemplateEntry( @@ -37015,6 +37972,9 @@ namespace VULKAN_HPP_NAMESPACE struct DescriptorUpdateTemplateCreateInfo { + static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = + StructureType::eDescriptorUpdateTemplateCreateInfo; + VULKAN_HPP_CONSTEXPR DescriptorUpdateTemplateCreateInfo( VULKAN_HPP_NAMESPACE::DescriptorUpdateTemplateCreateFlags flags_ = {}, uint32_t descriptorUpdateEntryCount_ = {}, @@ -37162,8 +38122,16 @@ namespace VULKAN_HPP_NAMESPACE static_assert( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); + template <> + struct CppType + { + using Type = DescriptorUpdateTemplateCreateInfo; + }; + struct DeviceQueueCreateInfo { + static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::eDeviceQueueCreateInfo; + VULKAN_HPP_CONSTEXPR DeviceQueueCreateInfo( VULKAN_HPP_NAMESPACE::DeviceQueueCreateFlags flags_ = {}, uint32_t queueFamilyIndex_ = {}, uint32_t queueCount_ = {}, @@ -37259,6 +38227,12 @@ namespace VULKAN_HPP_NAMESPACE "struct and wrapper have different size!" ); static_assert( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); + template <> + struct CppType + { + using Type = DeviceQueueCreateInfo; + }; + struct PhysicalDeviceFeatures { VULKAN_HPP_CONSTEXPR @@ -37875,6 +38849,8 @@ namespace VULKAN_HPP_NAMESPACE struct DeviceCreateInfo { + static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::eDeviceCreateInfo; + VULKAN_HPP_CONSTEXPR DeviceCreateInfo( VULKAN_HPP_NAMESPACE::DeviceCreateFlags flags_ = {}, uint32_t queueCreateInfoCount_ = {}, const VULKAN_HPP_NAMESPACE::DeviceQueueCreateInfo * pQueueCreateInfos_ = {}, @@ -38011,8 +38987,17 @@ namespace VULKAN_HPP_NAMESPACE "struct and wrapper have different size!" ); static_assert( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); + template <> + struct CppType + { + using Type = DeviceCreateInfo; + }; + struct DeviceDiagnosticsConfigCreateInfoNV { + static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = + StructureType::eDeviceDiagnosticsConfigCreateInfoNV; + VULKAN_HPP_CONSTEXPR DeviceDiagnosticsConfigCreateInfoNV( VULKAN_HPP_NAMESPACE::DeviceDiagnosticsConfigFlagsNV flags_ = {} ) VULKAN_HPP_NOEXCEPT : flags( flags_ ) {} @@ -38085,8 +39070,16 @@ namespace VULKAN_HPP_NAMESPACE static_assert( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); + template <> + struct CppType + { + using Type = DeviceDiagnosticsConfigCreateInfoNV; + }; + struct DeviceEventInfoEXT { + static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::eDeviceEventInfoEXT; + VULKAN_HPP_CONSTEXPR DeviceEventInfoEXT( VULKAN_HPP_NAMESPACE::DeviceEventTypeEXT deviceEvent_ = VULKAN_HPP_NAMESPACE::DeviceEventTypeEXT::eDisplayHotplug ) VULKAN_HPP_NOEXCEPT @@ -38155,8 +39148,16 @@ namespace VULKAN_HPP_NAMESPACE "struct and wrapper have different size!" ); static_assert( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); + template <> + struct CppType + { + using Type = DeviceEventInfoEXT; + }; + struct DeviceGroupBindSparseInfo { + static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::eDeviceGroupBindSparseInfo; + VULKAN_HPP_CONSTEXPR DeviceGroupBindSparseInfo( uint32_t resourceDeviceIndex_ = {}, uint32_t memoryDeviceIndex_ = {} ) VULKAN_HPP_NOEXCEPT : resourceDeviceIndex( resourceDeviceIndex_ ) @@ -38234,8 +39235,17 @@ namespace VULKAN_HPP_NAMESPACE static_assert( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); + template <> + struct CppType + { + using Type = DeviceGroupBindSparseInfo; + }; + struct DeviceGroupCommandBufferBeginInfo { + static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = + StructureType::eDeviceGroupCommandBufferBeginInfo; + VULKAN_HPP_CONSTEXPR DeviceGroupCommandBufferBeginInfo( uint32_t deviceMask_ = {} ) VULKAN_HPP_NOEXCEPT : deviceMask( deviceMask_ ) {} @@ -38305,8 +39315,16 @@ namespace VULKAN_HPP_NAMESPACE static_assert( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); + template <> + struct CppType + { + using Type = DeviceGroupCommandBufferBeginInfo; + }; + struct DeviceGroupDeviceCreateInfo { + static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::eDeviceGroupDeviceCreateInfo; + VULKAN_HPP_CONSTEXPR DeviceGroupDeviceCreateInfo( uint32_t physicalDeviceCount_ = {}, const VULKAN_HPP_NAMESPACE::PhysicalDevice * pPhysicalDevices_ = {} ) VULKAN_HPP_NOEXCEPT @@ -38387,8 +39405,17 @@ namespace VULKAN_HPP_NAMESPACE static_assert( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); + template <> + struct CppType + { + using Type = DeviceGroupDeviceCreateInfo; + }; + struct DeviceGroupPresentCapabilitiesKHR { + static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = + StructureType::eDeviceGroupPresentCapabilitiesKHR; + VULKAN_HPP_CONSTEXPR_14 DeviceGroupPresentCapabilitiesKHR( std::array const & presentMask_ = {}, VULKAN_HPP_NAMESPACE::DeviceGroupPresentModeFlagsKHR modes_ = {} ) VULKAN_HPP_NOEXCEPT @@ -38451,8 +39478,16 @@ namespace VULKAN_HPP_NAMESPACE static_assert( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); + template <> + struct CppType + { + using Type = DeviceGroupPresentCapabilitiesKHR; + }; + struct DeviceGroupPresentInfoKHR { + static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::eDeviceGroupPresentInfoKHR; + VULKAN_HPP_CONSTEXPR DeviceGroupPresentInfoKHR( uint32_t swapchainCount_ = {}, const uint32_t * pDeviceMasks_ = {}, @@ -38543,8 +39578,16 @@ namespace VULKAN_HPP_NAMESPACE static_assert( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); + template <> + struct CppType + { + using Type = DeviceGroupPresentInfoKHR; + }; + struct DeviceGroupRenderPassBeginInfo { + static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::eDeviceGroupRenderPassBeginInfo; + VULKAN_HPP_CONSTEXPR DeviceGroupRenderPassBeginInfo( uint32_t deviceMask_ = {}, uint32_t deviceRenderAreaCount_ = {}, const VULKAN_HPP_NAMESPACE::Rect2D * pDeviceRenderAreas_ = {} ) @@ -38635,8 +39678,16 @@ namespace VULKAN_HPP_NAMESPACE static_assert( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); + template <> + struct CppType + { + using Type = DeviceGroupRenderPassBeginInfo; + }; + struct DeviceGroupSubmitInfo { + static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::eDeviceGroupSubmitInfo; + VULKAN_HPP_CONSTEXPR DeviceGroupSubmitInfo( uint32_t waitSemaphoreCount_ = {}, const uint32_t * pWaitSemaphoreDeviceIndices_ = {}, @@ -38757,8 +39808,17 @@ namespace VULKAN_HPP_NAMESPACE "struct and wrapper have different size!" ); static_assert( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); + template <> + struct CppType + { + using Type = DeviceGroupSubmitInfo; + }; + struct DeviceGroupSwapchainCreateInfoKHR { + static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = + StructureType::eDeviceGroupSwapchainCreateInfoKHR; + VULKAN_HPP_CONSTEXPR DeviceGroupSwapchainCreateInfoKHR( VULKAN_HPP_NAMESPACE::DeviceGroupPresentModeFlagsKHR modes_ = {} ) VULKAN_HPP_NOEXCEPT : modes( modes_ ) {} @@ -38829,8 +39889,17 @@ namespace VULKAN_HPP_NAMESPACE static_assert( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); + template <> + struct CppType + { + using Type = DeviceGroupSwapchainCreateInfoKHR; + }; + struct DeviceMemoryOpaqueCaptureAddressInfo { + static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = + StructureType::eDeviceMemoryOpaqueCaptureAddressInfo; + VULKAN_HPP_CONSTEXPR DeviceMemoryOpaqueCaptureAddressInfo( VULKAN_HPP_NAMESPACE::DeviceMemory memory_ = {} ) VULKAN_HPP_NOEXCEPT : memory( memory_ ) @@ -38904,8 +39973,17 @@ namespace VULKAN_HPP_NAMESPACE static_assert( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); + template <> + struct CppType + { + using Type = DeviceMemoryOpaqueCaptureAddressInfo; + }; + struct DeviceMemoryOverallocationCreateInfoAMD { + static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = + StructureType::eDeviceMemoryOverallocationCreateInfoAMD; + VULKAN_HPP_CONSTEXPR DeviceMemoryOverallocationCreateInfoAMD( VULKAN_HPP_NAMESPACE::MemoryOverallocationBehaviorAMD overallocationBehavior_ = VULKAN_HPP_NAMESPACE::MemoryOverallocationBehaviorAMD::eDefault ) VULKAN_HPP_NOEXCEPT @@ -38984,8 +40062,17 @@ namespace VULKAN_HPP_NAMESPACE static_assert( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); + template <> + struct CppType + { + using Type = DeviceMemoryOverallocationCreateInfoAMD; + }; + struct DeviceQueueGlobalPriorityCreateInfoEXT { + static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = + StructureType::eDeviceQueueGlobalPriorityCreateInfoEXT; + VULKAN_HPP_CONSTEXPR DeviceQueueGlobalPriorityCreateInfoEXT( VULKAN_HPP_NAMESPACE::QueueGlobalPriorityEXT globalPriority_ = VULKAN_HPP_NAMESPACE::QueueGlobalPriorityEXT::eLow ) VULKAN_HPP_NOEXCEPT @@ -39061,8 +40148,16 @@ namespace VULKAN_HPP_NAMESPACE static_assert( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); + template <> + struct CppType + { + using Type = DeviceQueueGlobalPriorityCreateInfoEXT; + }; + struct DeviceQueueInfo2 { + static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::eDeviceQueueInfo2; + VULKAN_HPP_CONSTEXPR DeviceQueueInfo2( VULKAN_HPP_NAMESPACE::DeviceQueueCreateFlags flags_ = {}, uint32_t queueFamilyIndex_ = {}, uint32_t queueIndex_ = {} ) VULKAN_HPP_NOEXCEPT @@ -39148,6 +40243,12 @@ namespace VULKAN_HPP_NAMESPACE "struct and wrapper have different size!" ); static_assert( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); + template <> + struct CppType + { + using Type = DeviceQueueInfo2; + }; + struct DispatchIndirectCommand { VULKAN_HPP_CONSTEXPR @@ -39221,6 +40322,8 @@ namespace VULKAN_HPP_NAMESPACE struct DisplayEventInfoEXT { + static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::eDisplayEventInfoEXT; + VULKAN_HPP_CONSTEXPR DisplayEventInfoEXT( VULKAN_HPP_NAMESPACE::DisplayEventTypeEXT displayEvent_ = VULKAN_HPP_NAMESPACE::DisplayEventTypeEXT::eFirstPixelOut ) VULKAN_HPP_NOEXCEPT @@ -39289,6 +40392,12 @@ namespace VULKAN_HPP_NAMESPACE "struct and wrapper have different size!" ); static_assert( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); + template <> + struct CppType + { + using Type = DisplayEventInfoEXT; + }; + struct DisplayModeParametersKHR { VULKAN_HPP_CONSTEXPR DisplayModeParametersKHR( VULKAN_HPP_NAMESPACE::Extent2D visibleRegion_ = {}, @@ -39355,6 +40464,8 @@ namespace VULKAN_HPP_NAMESPACE struct DisplayModeCreateInfoKHR { + static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::eDisplayModeCreateInfoKHR; + VULKAN_HPP_CONSTEXPR DisplayModeCreateInfoKHR( VULKAN_HPP_NAMESPACE::DisplayModeCreateFlagsKHR flags_ = {}, VULKAN_HPP_NAMESPACE::DisplayModeParametersKHR parameters_ = {} ) VULKAN_HPP_NOEXCEPT @@ -39433,6 +40544,12 @@ namespace VULKAN_HPP_NAMESPACE "struct and wrapper have different size!" ); static_assert( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); + template <> + struct CppType + { + using Type = DisplayModeCreateInfoKHR; + }; + struct DisplayModePropertiesKHR { VULKAN_HPP_CONSTEXPR @@ -39487,6 +40604,8 @@ namespace VULKAN_HPP_NAMESPACE struct DisplayModeProperties2KHR { + static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::eDisplayModeProperties2KHR; + VULKAN_HPP_CONSTEXPR DisplayModeProperties2KHR( VULKAN_HPP_NAMESPACE::DisplayModePropertiesKHR displayModeProperties_ = {} ) VULKAN_HPP_NOEXCEPT : displayModeProperties( displayModeProperties_ ) @@ -39543,8 +40662,17 @@ namespace VULKAN_HPP_NAMESPACE static_assert( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); + template <> + struct CppType + { + using Type = DisplayModeProperties2KHR; + }; + struct DisplayNativeHdrSurfaceCapabilitiesAMD { + static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = + StructureType::eDisplayNativeHdrSurfaceCapabilitiesAMD; + VULKAN_HPP_CONSTEXPR DisplayNativeHdrSurfaceCapabilitiesAMD( VULKAN_HPP_NAMESPACE::Bool32 localDimmingSupport_ = {} ) VULKAN_HPP_NOEXCEPT : localDimmingSupport( localDimmingSupport_ ) @@ -39606,6 +40734,12 @@ namespace VULKAN_HPP_NAMESPACE static_assert( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); + template <> + struct CppType + { + using Type = DisplayNativeHdrSurfaceCapabilitiesAMD; + }; + struct DisplayPlaneCapabilitiesKHR { VULKAN_HPP_CONSTEXPR @@ -39686,6 +40820,8 @@ namespace VULKAN_HPP_NAMESPACE struct DisplayPlaneCapabilities2KHR { + static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::eDisplayPlaneCapabilities2KHR; + VULKAN_HPP_CONSTEXPR DisplayPlaneCapabilities2KHR( VULKAN_HPP_NAMESPACE::DisplayPlaneCapabilitiesKHR capabilities_ = {} ) VULKAN_HPP_NOEXCEPT : capabilities( capabilities_ ) @@ -39743,8 +40879,16 @@ namespace VULKAN_HPP_NAMESPACE static_assert( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); + template <> + struct CppType + { + using Type = DisplayPlaneCapabilities2KHR; + }; + struct DisplayPlaneInfo2KHR { + static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::eDisplayPlaneInfo2KHR; + VULKAN_HPP_CONSTEXPR DisplayPlaneInfo2KHR( VULKAN_HPP_NAMESPACE::DisplayModeKHR mode_ = {}, uint32_t planeIndex_ = {} ) VULKAN_HPP_NOEXCEPT : mode( mode_ ) @@ -39821,6 +40965,12 @@ namespace VULKAN_HPP_NAMESPACE "struct and wrapper have different size!" ); static_assert( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); + template <> + struct CppType + { + using Type = DisplayPlaneInfo2KHR; + }; + struct DisplayPlanePropertiesKHR { VULKAN_HPP_CONSTEXPR DisplayPlanePropertiesKHR( VULKAN_HPP_NAMESPACE::DisplayKHR currentDisplay_ = {}, @@ -39875,6 +41025,8 @@ namespace VULKAN_HPP_NAMESPACE struct DisplayPlaneProperties2KHR { + static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::eDisplayPlaneProperties2KHR; + VULKAN_HPP_CONSTEXPR DisplayPlaneProperties2KHR( VULKAN_HPP_NAMESPACE::DisplayPlanePropertiesKHR displayPlaneProperties_ = {} ) VULKAN_HPP_NOEXCEPT : displayPlaneProperties( displayPlaneProperties_ ) @@ -39933,8 +41085,16 @@ namespace VULKAN_HPP_NAMESPACE static_assert( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); + template <> + struct CppType + { + using Type = DisplayPlaneProperties2KHR; + }; + struct DisplayPowerInfoEXT { + static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::eDisplayPowerInfoEXT; + VULKAN_HPP_CONSTEXPR DisplayPowerInfoEXT( VULKAN_HPP_NAMESPACE::DisplayPowerStateEXT powerState_ = VULKAN_HPP_NAMESPACE::DisplayPowerStateEXT::eOff ) VULKAN_HPP_NOEXCEPT : powerState( powerState_ ) @@ -40002,8 +41162,16 @@ namespace VULKAN_HPP_NAMESPACE "struct and wrapper have different size!" ); static_assert( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); + template <> + struct CppType + { + using Type = DisplayPowerInfoEXT; + }; + struct DisplayPresentInfoKHR { + static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::eDisplayPresentInfoKHR; + VULKAN_HPP_CONSTEXPR DisplayPresentInfoKHR( VULKAN_HPP_NAMESPACE::Rect2D srcRect_ = {}, VULKAN_HPP_NAMESPACE::Rect2D dstRect_ = {}, VULKAN_HPP_NAMESPACE::Bool32 persistent_ = {} ) VULKAN_HPP_NOEXCEPT @@ -40089,6 +41257,12 @@ namespace VULKAN_HPP_NAMESPACE "struct and wrapper have different size!" ); static_assert( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); + template <> + struct CppType + { + using Type = DisplayPresentInfoKHR; + }; + struct DisplayPropertiesKHR { VULKAN_HPP_CONSTEXPR @@ -40161,6 +41335,8 @@ namespace VULKAN_HPP_NAMESPACE struct DisplayProperties2KHR { + static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::eDisplayProperties2KHR; + VULKAN_HPP_CONSTEXPR DisplayProperties2KHR( VULKAN_HPP_NAMESPACE::DisplayPropertiesKHR displayProperties_ = {} ) VULKAN_HPP_NOEXCEPT : displayProperties( displayProperties_ ) @@ -40216,8 +41392,16 @@ namespace VULKAN_HPP_NAMESPACE "struct and wrapper have different size!" ); static_assert( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); + template <> + struct CppType + { + using Type = DisplayProperties2KHR; + }; + struct DisplaySurfaceCreateInfoKHR { + static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::eDisplaySurfaceCreateInfoKHR; + VULKAN_HPP_CONSTEXPR DisplaySurfaceCreateInfoKHR( VULKAN_HPP_NAMESPACE::DisplaySurfaceCreateFlagsKHR flags_ = {}, VULKAN_HPP_NAMESPACE::DisplayModeKHR displayMode_ = {}, @@ -40362,6 +41546,12 @@ namespace VULKAN_HPP_NAMESPACE static_assert( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); + template <> + struct CppType + { + using Type = DisplaySurfaceCreateInfoKHR; + }; + struct DrawIndexedIndirectCommand { VULKAN_HPP_CONSTEXPR DrawIndexedIndirectCommand( uint32_t indexCount_ = {}, @@ -40661,6 +41851,9 @@ namespace VULKAN_HPP_NAMESPACE struct DrmFormatModifierPropertiesListEXT { + static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = + StructureType::eDrmFormatModifierPropertiesListEXT; + VULKAN_HPP_CONSTEXPR DrmFormatModifierPropertiesListEXT( uint32_t drmFormatModifierCount_ = {}, VULKAN_HPP_NAMESPACE::DrmFormatModifierPropertiesEXT * pDrmFormatModifierProperties_ = {} ) VULKAN_HPP_NOEXCEPT @@ -40725,8 +41918,16 @@ namespace VULKAN_HPP_NAMESPACE static_assert( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); + template <> + struct CppType + { + using Type = DrmFormatModifierPropertiesListEXT; + }; + struct EventCreateInfo { + static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::eEventCreateInfo; + VULKAN_HPP_CONSTEXPR EventCreateInfo( VULKAN_HPP_NAMESPACE::EventCreateFlags flags_ = {} ) VULKAN_HPP_NOEXCEPT : flags( flags_ ) {} @@ -40792,8 +41993,16 @@ namespace VULKAN_HPP_NAMESPACE static_assert( sizeof( EventCreateInfo ) == sizeof( VkEventCreateInfo ), "struct and wrapper have different size!" ); static_assert( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); + template <> + struct CppType + { + using Type = EventCreateInfo; + }; + struct ExportFenceCreateInfo { + static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::eExportFenceCreateInfo; + VULKAN_HPP_CONSTEXPR ExportFenceCreateInfo( VULKAN_HPP_NAMESPACE::ExternalFenceHandleTypeFlags handleTypes_ = {} ) VULKAN_HPP_NOEXCEPT : handleTypes( handleTypes_ ) @@ -40862,9 +42071,17 @@ namespace VULKAN_HPP_NAMESPACE "struct and wrapper have different size!" ); static_assert( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); + template <> + struct CppType + { + using Type = ExportFenceCreateInfo; + }; + #ifdef VK_USE_PLATFORM_WIN32_KHR struct ExportFenceWin32HandleInfoKHR { + static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::eExportFenceWin32HandleInfoKHR; + VULKAN_HPP_CONSTEXPR ExportFenceWin32HandleInfoKHR( const SECURITY_ATTRIBUTES * pAttributes_ = {}, DWORD dwAccess_ = {}, LPCWSTR name_ = {} ) VULKAN_HPP_NOEXCEPT @@ -40952,10 +42169,18 @@ namespace VULKAN_HPP_NAMESPACE "struct and wrapper have different size!" ); static_assert( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); + + template <> + struct CppType + { + using Type = ExportFenceWin32HandleInfoKHR; + }; #endif /*VK_USE_PLATFORM_WIN32_KHR*/ struct ExportMemoryAllocateInfo { + static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::eExportMemoryAllocateInfo; + VULKAN_HPP_CONSTEXPR ExportMemoryAllocateInfo( VULKAN_HPP_NAMESPACE::ExternalMemoryHandleTypeFlags handleTypes_ = {} ) VULKAN_HPP_NOEXCEPT : handleTypes( handleTypes_ ) @@ -41024,8 +42249,16 @@ namespace VULKAN_HPP_NAMESPACE "struct and wrapper have different size!" ); static_assert( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); + template <> + struct CppType + { + using Type = ExportMemoryAllocateInfo; + }; + struct ExportMemoryAllocateInfoNV { + static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::eExportMemoryAllocateInfoNV; + VULKAN_HPP_CONSTEXPR ExportMemoryAllocateInfoNV( VULKAN_HPP_NAMESPACE::ExternalMemoryHandleTypeFlagsNV handleTypes_ = {} ) VULKAN_HPP_NOEXCEPT : handleTypes( handleTypes_ ) @@ -41096,9 +42329,17 @@ namespace VULKAN_HPP_NAMESPACE static_assert( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); + template <> + struct CppType + { + using Type = ExportMemoryAllocateInfoNV; + }; + #ifdef VK_USE_PLATFORM_WIN32_KHR struct ExportMemoryWin32HandleInfoKHR { + static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::eExportMemoryWin32HandleInfoKHR; + VULKAN_HPP_CONSTEXPR ExportMemoryWin32HandleInfoKHR( const SECURITY_ATTRIBUTES * pAttributes_ = {}, DWORD dwAccess_ = {}, LPCWSTR name_ = {} ) VULKAN_HPP_NOEXCEPT @@ -41186,11 +42427,19 @@ namespace VULKAN_HPP_NAMESPACE "struct and wrapper have different size!" ); static_assert( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); + + template <> + struct CppType + { + using Type = ExportMemoryWin32HandleInfoKHR; + }; #endif /*VK_USE_PLATFORM_WIN32_KHR*/ #ifdef VK_USE_PLATFORM_WIN32_KHR struct ExportMemoryWin32HandleInfoNV { + static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::eExportMemoryWin32HandleInfoNV; + VULKAN_HPP_CONSTEXPR ExportMemoryWin32HandleInfoNV( const SECURITY_ATTRIBUTES * pAttributes_ = {}, DWORD dwAccess_ = {} ) VULKAN_HPP_NOEXCEPT : pAttributes( pAttributes_ ) @@ -41269,10 +42518,18 @@ namespace VULKAN_HPP_NAMESPACE "struct and wrapper have different size!" ); static_assert( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); + + template <> + struct CppType + { + using Type = ExportMemoryWin32HandleInfoNV; + }; #endif /*VK_USE_PLATFORM_WIN32_KHR*/ struct ExportSemaphoreCreateInfo { + static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::eExportSemaphoreCreateInfo; + VULKAN_HPP_CONSTEXPR ExportSemaphoreCreateInfo( VULKAN_HPP_NAMESPACE::ExternalSemaphoreHandleTypeFlags handleTypes_ = {} ) VULKAN_HPP_NOEXCEPT : handleTypes( handleTypes_ ) @@ -41342,9 +42599,18 @@ namespace VULKAN_HPP_NAMESPACE static_assert( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); + template <> + struct CppType + { + using Type = ExportSemaphoreCreateInfo; + }; + #ifdef VK_USE_PLATFORM_WIN32_KHR struct ExportSemaphoreWin32HandleInfoKHR { + static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = + StructureType::eExportSemaphoreWin32HandleInfoKHR; + VULKAN_HPP_CONSTEXPR ExportSemaphoreWin32HandleInfoKHR( const SECURITY_ATTRIBUTES * pAttributes_ = {}, DWORD dwAccess_ = {}, LPCWSTR name_ = {} ) VULKAN_HPP_NOEXCEPT @@ -41432,6 +42698,12 @@ namespace VULKAN_HPP_NAMESPACE "struct and wrapper have different size!" ); static_assert( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); + + template <> + struct CppType + { + using Type = ExportSemaphoreWin32HandleInfoKHR; + }; #endif /*VK_USE_PLATFORM_WIN32_KHR*/ struct ExtensionProperties @@ -41545,6 +42817,8 @@ namespace VULKAN_HPP_NAMESPACE struct ExternalBufferProperties { + static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::eExternalBufferProperties; + VULKAN_HPP_CONSTEXPR ExternalBufferProperties( VULKAN_HPP_NAMESPACE::ExternalMemoryProperties externalMemoryProperties_ = {} ) VULKAN_HPP_NOEXCEPT : externalMemoryProperties( externalMemoryProperties_ ) @@ -41601,8 +42875,16 @@ namespace VULKAN_HPP_NAMESPACE "struct and wrapper have different size!" ); static_assert( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); + template <> + struct CppType + { + using Type = ExternalBufferProperties; + }; + struct ExternalFenceProperties { + static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::eExternalFenceProperties; + VULKAN_HPP_CONSTEXPR ExternalFenceProperties( VULKAN_HPP_NAMESPACE::ExternalFenceHandleTypeFlags exportFromImportedHandleTypes_ = {}, VULKAN_HPP_NAMESPACE::ExternalFenceHandleTypeFlags compatibleHandleTypes_ = {}, @@ -41667,9 +42949,17 @@ namespace VULKAN_HPP_NAMESPACE "struct and wrapper have different size!" ); static_assert( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); + template <> + struct CppType + { + using Type = ExternalFenceProperties; + }; + #ifdef VK_USE_PLATFORM_ANDROID_KHR struct ExternalFormatANDROID { + static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::eExternalFormatANDROID; + VULKAN_HPP_CONSTEXPR ExternalFormatANDROID( uint64_t externalFormat_ = {} ) VULKAN_HPP_NOEXCEPT : externalFormat( externalFormat_ ) {} @@ -41735,10 +43025,18 @@ namespace VULKAN_HPP_NAMESPACE static_assert( sizeof( ExternalFormatANDROID ) == sizeof( VkExternalFormatANDROID ), "struct and wrapper have different size!" ); static_assert( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); + + template <> + struct CppType + { + using Type = ExternalFormatANDROID; + }; #endif /*VK_USE_PLATFORM_ANDROID_KHR*/ struct ExternalImageFormatProperties { + static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::eExternalImageFormatProperties; + VULKAN_HPP_CONSTEXPR ExternalImageFormatProperties( VULKAN_HPP_NAMESPACE::ExternalMemoryProperties externalMemoryProperties_ = {} ) VULKAN_HPP_NOEXCEPT : externalMemoryProperties( externalMemoryProperties_ ) @@ -41798,6 +43096,12 @@ namespace VULKAN_HPP_NAMESPACE static_assert( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); + template <> + struct CppType + { + using Type = ExternalImageFormatProperties; + }; + struct ImageFormatProperties { VULKAN_HPP_CONSTEXPR @@ -41925,6 +43229,8 @@ namespace VULKAN_HPP_NAMESPACE struct ExternalMemoryBufferCreateInfo { + static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::eExternalMemoryBufferCreateInfo; + VULKAN_HPP_CONSTEXPR ExternalMemoryBufferCreateInfo( VULKAN_HPP_NAMESPACE::ExternalMemoryHandleTypeFlags handleTypes_ = {} ) VULKAN_HPP_NOEXCEPT : handleTypes( handleTypes_ ) @@ -41996,8 +43302,16 @@ namespace VULKAN_HPP_NAMESPACE static_assert( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); + template <> + struct CppType + { + using Type = ExternalMemoryBufferCreateInfo; + }; + struct ExternalMemoryImageCreateInfo { + static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::eExternalMemoryImageCreateInfo; + VULKAN_HPP_CONSTEXPR ExternalMemoryImageCreateInfo( VULKAN_HPP_NAMESPACE::ExternalMemoryHandleTypeFlags handleTypes_ = {} ) VULKAN_HPP_NOEXCEPT : handleTypes( handleTypes_ ) @@ -42069,8 +43383,16 @@ namespace VULKAN_HPP_NAMESPACE static_assert( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); + template <> + struct CppType + { + using Type = ExternalMemoryImageCreateInfo; + }; + struct ExternalMemoryImageCreateInfoNV { + static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::eExternalMemoryImageCreateInfoNV; + VULKAN_HPP_CONSTEXPR ExternalMemoryImageCreateInfoNV( VULKAN_HPP_NAMESPACE::ExternalMemoryHandleTypeFlagsNV handleTypes_ = {} ) VULKAN_HPP_NOEXCEPT : handleTypes( handleTypes_ ) @@ -42142,8 +43464,16 @@ namespace VULKAN_HPP_NAMESPACE static_assert( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); + template <> + struct CppType + { + using Type = ExternalMemoryImageCreateInfoNV; + }; + struct ExternalSemaphoreProperties { + static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::eExternalSemaphoreProperties; + VULKAN_HPP_CONSTEXPR ExternalSemaphoreProperties( VULKAN_HPP_NAMESPACE::ExternalSemaphoreHandleTypeFlags exportFromImportedHandleTypes_ = {}, VULKAN_HPP_NAMESPACE::ExternalSemaphoreHandleTypeFlags compatibleHandleTypes_ = {}, @@ -42210,8 +43540,16 @@ namespace VULKAN_HPP_NAMESPACE static_assert( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); + template <> + struct CppType + { + using Type = ExternalSemaphoreProperties; + }; + struct FenceCreateInfo { + static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::eFenceCreateInfo; + VULKAN_HPP_CONSTEXPR FenceCreateInfo( VULKAN_HPP_NAMESPACE::FenceCreateFlags flags_ = {} ) VULKAN_HPP_NOEXCEPT : flags( flags_ ) {} @@ -42277,8 +43615,16 @@ namespace VULKAN_HPP_NAMESPACE static_assert( sizeof( FenceCreateInfo ) == sizeof( VkFenceCreateInfo ), "struct and wrapper have different size!" ); static_assert( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); + template <> + struct CppType + { + using Type = FenceCreateInfo; + }; + struct FenceGetFdInfoKHR { + static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::eFenceGetFdInfoKHR; + VULKAN_HPP_CONSTEXPR FenceGetFdInfoKHR( VULKAN_HPP_NAMESPACE::Fence fence_ = {}, VULKAN_HPP_NAMESPACE::ExternalFenceHandleTypeFlagBits handleType_ = @@ -42359,9 +43705,17 @@ namespace VULKAN_HPP_NAMESPACE "struct and wrapper have different size!" ); static_assert( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); + template <> + struct CppType + { + using Type = FenceGetFdInfoKHR; + }; + #ifdef VK_USE_PLATFORM_WIN32_KHR struct FenceGetWin32HandleInfoKHR { + static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::eFenceGetWin32HandleInfoKHR; + VULKAN_HPP_CONSTEXPR FenceGetWin32HandleInfoKHR( VULKAN_HPP_NAMESPACE::Fence fence_ = {}, VULKAN_HPP_NAMESPACE::ExternalFenceHandleTypeFlagBits handleType_ = @@ -42443,10 +43797,19 @@ namespace VULKAN_HPP_NAMESPACE "struct and wrapper have different size!" ); static_assert( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); + + template <> + struct CppType + { + using Type = FenceGetWin32HandleInfoKHR; + }; #endif /*VK_USE_PLATFORM_WIN32_KHR*/ struct FilterCubicImageViewImageFormatPropertiesEXT { + static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = + StructureType::eFilterCubicImageViewImageFormatPropertiesEXT; + VULKAN_HPP_CONSTEXPR FilterCubicImageViewImageFormatPropertiesEXT( VULKAN_HPP_NAMESPACE::Bool32 filterCubic_ = {}, VULKAN_HPP_NAMESPACE::Bool32 filterCubicMinmax_ = {} ) VULKAN_HPP_NOEXCEPT @@ -42514,6 +43877,12 @@ namespace VULKAN_HPP_NAMESPACE static_assert( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); + template <> + struct CppType + { + using Type = FilterCubicImageViewImageFormatPropertiesEXT; + }; + struct FormatProperties { VULKAN_HPP_CONSTEXPR @@ -42572,6 +43941,8 @@ namespace VULKAN_HPP_NAMESPACE struct FormatProperties2 { + static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::eFormatProperties2; + VULKAN_HPP_CONSTEXPR FormatProperties2( VULKAN_HPP_NAMESPACE::FormatProperties formatProperties_ = {} ) VULKAN_HPP_NOEXCEPT : formatProperties( formatProperties_ ) @@ -42627,8 +43998,16 @@ namespace VULKAN_HPP_NAMESPACE "struct and wrapper have different size!" ); static_assert( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); + template <> + struct CppType + { + using Type = FormatProperties2; + }; + struct FramebufferAttachmentImageInfo { + static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::eFramebufferAttachmentImageInfo; + VULKAN_HPP_CONSTEXPR FramebufferAttachmentImageInfo( VULKAN_HPP_NAMESPACE::ImageCreateFlags flags_ = {}, VULKAN_HPP_NAMESPACE::ImageUsageFlags usage_ = {}, @@ -42756,8 +44135,16 @@ namespace VULKAN_HPP_NAMESPACE static_assert( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); + template <> + struct CppType + { + using Type = FramebufferAttachmentImageInfo; + }; + struct FramebufferAttachmentsCreateInfo { + static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::eFramebufferAttachmentsCreateInfo; + VULKAN_HPP_CONSTEXPR FramebufferAttachmentsCreateInfo( uint32_t attachmentImageInfoCount_ = {}, const VULKAN_HPP_NAMESPACE::FramebufferAttachmentImageInfo * pAttachmentImageInfos_ = {} ) VULKAN_HPP_NOEXCEPT @@ -42841,8 +44228,16 @@ namespace VULKAN_HPP_NAMESPACE static_assert( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); + template <> + struct CppType + { + using Type = FramebufferAttachmentsCreateInfo; + }; + struct FramebufferCreateInfo { + static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::eFramebufferCreateInfo; + VULKAN_HPP_CONSTEXPR FramebufferCreateInfo( VULKAN_HPP_NAMESPACE::FramebufferCreateFlags flags_ = {}, VULKAN_HPP_NAMESPACE::RenderPass renderPass_ = {}, uint32_t attachmentCount_ = {}, @@ -42966,8 +44361,17 @@ namespace VULKAN_HPP_NAMESPACE "struct and wrapper have different size!" ); static_assert( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); + template <> + struct CppType + { + using Type = FramebufferCreateInfo; + }; + struct FramebufferMixedSamplesCombinationNV { + static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = + StructureType::eFramebufferMixedSamplesCombinationNV; + VULKAN_HPP_CONSTEXPR FramebufferMixedSamplesCombinationNV( VULKAN_HPP_NAMESPACE::CoverageReductionModeNV coverageReductionMode_ = VULKAN_HPP_NAMESPACE::CoverageReductionModeNV::eMerge, @@ -43043,6 +44447,12 @@ namespace VULKAN_HPP_NAMESPACE static_assert( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); + template <> + struct CppType + { + using Type = FramebufferMixedSamplesCombinationNV; + }; + struct IndirectCommandsStreamNV { VULKAN_HPP_CONSTEXPR IndirectCommandsStreamNV( VULKAN_HPP_NAMESPACE::Buffer buffer_ = {}, @@ -43108,6 +44518,8 @@ namespace VULKAN_HPP_NAMESPACE struct GeneratedCommandsInfoNV { + static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::eGeneratedCommandsInfoNV; + VULKAN_HPP_CONSTEXPR GeneratedCommandsInfoNV( VULKAN_HPP_NAMESPACE::PipelineBindPoint pipelineBindPoint_ = VULKAN_HPP_NAMESPACE::PipelineBindPoint::eGraphics, VULKAN_HPP_NAMESPACE::Pipeline pipeline_ = {}, @@ -43299,8 +44711,17 @@ namespace VULKAN_HPP_NAMESPACE "struct and wrapper have different size!" ); static_assert( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); + template <> + struct CppType + { + using Type = GeneratedCommandsInfoNV; + }; + struct GeneratedCommandsMemoryRequirementsInfoNV { + static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = + StructureType::eGeneratedCommandsMemoryRequirementsInfoNV; + VULKAN_HPP_CONSTEXPR GeneratedCommandsMemoryRequirementsInfoNV( VULKAN_HPP_NAMESPACE::PipelineBindPoint pipelineBindPoint_ = VULKAN_HPP_NAMESPACE::PipelineBindPoint::eGraphics, VULKAN_HPP_NAMESPACE::Pipeline pipeline_ = {}, @@ -43408,6 +44829,12 @@ namespace VULKAN_HPP_NAMESPACE static_assert( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); + template <> + struct CppType + { + using Type = GeneratedCommandsMemoryRequirementsInfoNV; + }; + struct VertexInputBindingDescription { VULKAN_HPP_CONSTEXPR @@ -43569,6 +44996,9 @@ namespace VULKAN_HPP_NAMESPACE struct PipelineVertexInputStateCreateInfo { + static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = + StructureType::ePipelineVertexInputStateCreateInfo; + VULKAN_HPP_CONSTEXPR PipelineVertexInputStateCreateInfo( VULKAN_HPP_NAMESPACE::PipelineVertexInputStateCreateFlags flags_ = {}, uint32_t vertexBindingDescriptionCount_ = {}, @@ -43686,8 +45116,17 @@ namespace VULKAN_HPP_NAMESPACE static_assert( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); + template <> + struct CppType + { + using Type = PipelineVertexInputStateCreateInfo; + }; + struct PipelineInputAssemblyStateCreateInfo { + static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = + StructureType::ePipelineInputAssemblyStateCreateInfo; + VULKAN_HPP_CONSTEXPR PipelineInputAssemblyStateCreateInfo( VULKAN_HPP_NAMESPACE::PipelineInputAssemblyStateCreateFlags flags_ = {}, VULKAN_HPP_NAMESPACE::PrimitiveTopology topology_ = VULKAN_HPP_NAMESPACE::PrimitiveTopology::ePointList, @@ -43783,8 +45222,17 @@ namespace VULKAN_HPP_NAMESPACE static_assert( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); + template <> + struct CppType + { + using Type = PipelineInputAssemblyStateCreateInfo; + }; + struct PipelineTessellationStateCreateInfo { + static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = + StructureType::ePipelineTessellationStateCreateInfo; + VULKAN_HPP_CONSTEXPR PipelineTessellationStateCreateInfo( VULKAN_HPP_NAMESPACE::PipelineTessellationStateCreateFlags flags_ = {}, uint32_t patchControlPoints_ = {} ) VULKAN_HPP_NOEXCEPT @@ -43868,6 +45316,12 @@ namespace VULKAN_HPP_NAMESPACE static_assert( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); + template <> + struct CppType + { + using Type = PipelineTessellationStateCreateInfo; + }; + struct Viewport { VULKAN_HPP_CONSTEXPR Viewport( float x_ = {}, @@ -43969,6 +45423,8 @@ namespace VULKAN_HPP_NAMESPACE struct PipelineViewportStateCreateInfo { + static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::ePipelineViewportStateCreateInfo; + VULKAN_HPP_CONSTEXPR PipelineViewportStateCreateInfo( VULKAN_HPP_NAMESPACE::PipelineViewportStateCreateFlags flags_ = {}, uint32_t viewportCount_ = {}, @@ -44080,8 +45536,17 @@ namespace VULKAN_HPP_NAMESPACE static_assert( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); + template <> + struct CppType + { + using Type = PipelineViewportStateCreateInfo; + }; + struct PipelineRasterizationStateCreateInfo { + static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = + StructureType::ePipelineRasterizationStateCreateInfo; + VULKAN_HPP_CONSTEXPR PipelineRasterizationStateCreateInfo( VULKAN_HPP_NAMESPACE::PipelineRasterizationStateCreateFlags flags_ = {}, VULKAN_HPP_NAMESPACE::Bool32 depthClampEnable_ = {}, @@ -44259,8 +45724,17 @@ namespace VULKAN_HPP_NAMESPACE static_assert( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); + template <> + struct CppType + { + using Type = PipelineRasterizationStateCreateInfo; + }; + struct PipelineMultisampleStateCreateInfo { + static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = + StructureType::ePipelineMultisampleStateCreateInfo; + VULKAN_HPP_CONSTEXPR PipelineMultisampleStateCreateInfo( VULKAN_HPP_NAMESPACE::PipelineMultisampleStateCreateFlags flags_ = {}, VULKAN_HPP_NAMESPACE::SampleCountFlagBits rasterizationSamples_ = VULKAN_HPP_NAMESPACE::SampleCountFlagBits::e1, @@ -44396,6 +45870,12 @@ namespace VULKAN_HPP_NAMESPACE static_assert( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); + template <> + struct CppType + { + using Type = PipelineMultisampleStateCreateInfo; + }; + struct StencilOpState { VULKAN_HPP_CONSTEXPR @@ -44508,6 +45988,9 @@ namespace VULKAN_HPP_NAMESPACE struct PipelineDepthStencilStateCreateInfo { + static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = + StructureType::ePipelineDepthStencilStateCreateInfo; + VULKAN_HPP_CONSTEXPR PipelineDepthStencilStateCreateInfo( VULKAN_HPP_NAMESPACE::PipelineDepthStencilStateCreateFlags flags_ = {}, VULKAN_HPP_NAMESPACE::Bool32 depthTestEnable_ = {}, @@ -44673,6 +46156,12 @@ namespace VULKAN_HPP_NAMESPACE static_assert( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); + template <> + struct CppType + { + using Type = PipelineDepthStencilStateCreateInfo; + }; + struct PipelineColorBlendAttachmentState { VULKAN_HPP_CONSTEXPR PipelineColorBlendAttachmentState( @@ -44804,6 +46293,9 @@ namespace VULKAN_HPP_NAMESPACE struct PipelineColorBlendStateCreateInfo { + static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = + StructureType::ePipelineColorBlendStateCreateInfo; + VULKAN_HPP_CONSTEXPR_14 PipelineColorBlendStateCreateInfo( VULKAN_HPP_NAMESPACE::PipelineColorBlendStateCreateFlags flags_ = {}, VULKAN_HPP_NAMESPACE::Bool32 logicOpEnable_ = {}, @@ -44925,8 +46417,16 @@ namespace VULKAN_HPP_NAMESPACE static_assert( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); + template <> + struct CppType + { + using Type = PipelineColorBlendStateCreateInfo; + }; + struct PipelineDynamicStateCreateInfo { + static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::ePipelineDynamicStateCreateInfo; + VULKAN_HPP_CONSTEXPR PipelineDynamicStateCreateInfo( VULKAN_HPP_NAMESPACE::PipelineDynamicStateCreateFlags flags_ = {}, uint32_t dynamicStateCount_ = {}, @@ -45018,8 +46518,16 @@ namespace VULKAN_HPP_NAMESPACE static_assert( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); + template <> + struct CppType + { + using Type = PipelineDynamicStateCreateInfo; + }; + struct GraphicsPipelineCreateInfo { + static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::eGraphicsPipelineCreateInfo; + VULKAN_HPP_CONSTEXPR_14 GraphicsPipelineCreateInfo( VULKAN_HPP_NAMESPACE::PipelineCreateFlags flags_ = {}, uint32_t stageCount_ = {}, @@ -45252,8 +46760,16 @@ namespace VULKAN_HPP_NAMESPACE static_assert( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); + template <> + struct CppType + { + using Type = GraphicsPipelineCreateInfo; + }; + struct GraphicsShaderGroupCreateInfoNV { + static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::eGraphicsShaderGroupCreateInfoNV; + VULKAN_HPP_CONSTEXPR GraphicsShaderGroupCreateInfoNV( uint32_t stageCount_ = {}, const VULKAN_HPP_NAMESPACE::PipelineShaderStageCreateInfo * pStages_ = {}, @@ -45356,8 +46872,17 @@ namespace VULKAN_HPP_NAMESPACE static_assert( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); + template <> + struct CppType + { + using Type = GraphicsShaderGroupCreateInfoNV; + }; + struct GraphicsPipelineShaderGroupsCreateInfoNV { + static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = + StructureType::eGraphicsPipelineShaderGroupsCreateInfoNV; + VULKAN_HPP_CONSTEXPR GraphicsPipelineShaderGroupsCreateInfoNV( uint32_t groupCount_ = {}, const VULKAN_HPP_NAMESPACE::GraphicsShaderGroupCreateInfoNV * pGroups_ = {}, @@ -45463,6 +46988,12 @@ namespace VULKAN_HPP_NAMESPACE static_assert( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); + template <> + struct CppType + { + using Type = GraphicsPipelineShaderGroupsCreateInfoNV; + }; + struct XYColorEXT { VULKAN_HPP_CONSTEXPR XYColorEXT( float x_ = {}, float y_ = {} ) VULKAN_HPP_NOEXCEPT @@ -45526,6 +47057,8 @@ namespace VULKAN_HPP_NAMESPACE struct HdrMetadataEXT { + static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::eHdrMetadataEXT; + VULKAN_HPP_CONSTEXPR HdrMetadataEXT( VULKAN_HPP_NAMESPACE::XYColorEXT displayPrimaryRed_ = {}, VULKAN_HPP_NAMESPACE::XYColorEXT displayPrimaryGreen_ = {}, VULKAN_HPP_NAMESPACE::XYColorEXT displayPrimaryBlue_ = {}, @@ -45661,8 +47194,16 @@ namespace VULKAN_HPP_NAMESPACE static_assert( sizeof( HdrMetadataEXT ) == sizeof( VkHdrMetadataEXT ), "struct and wrapper have different size!" ); static_assert( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); + template <> + struct CppType + { + using Type = HdrMetadataEXT; + }; + struct HeadlessSurfaceCreateInfoEXT { + static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::eHeadlessSurfaceCreateInfoEXT; + VULKAN_HPP_CONSTEXPR HeadlessSurfaceCreateInfoEXT( VULKAN_HPP_NAMESPACE::HeadlessSurfaceCreateFlagsEXT flags_ = {} ) VULKAN_HPP_NOEXCEPT : flags( flags_ ) {} @@ -45732,9 +47273,17 @@ namespace VULKAN_HPP_NAMESPACE static_assert( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); + template <> + struct CppType + { + using Type = HeadlessSurfaceCreateInfoEXT; + }; + #ifdef VK_USE_PLATFORM_IOS_MVK struct IOSSurfaceCreateInfoMVK { + static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::eIosSurfaceCreateInfoMVK; + VULKAN_HPP_CONSTEXPR IOSSurfaceCreateInfoMVK( VULKAN_HPP_NAMESPACE::IOSSurfaceCreateFlagsMVK flags_ = {}, const void * pView_ = {} ) VULKAN_HPP_NOEXCEPT : flags( flags_ ) @@ -45809,6 +47358,12 @@ namespace VULKAN_HPP_NAMESPACE static_assert( sizeof( IOSSurfaceCreateInfoMVK ) == sizeof( VkIOSSurfaceCreateInfoMVK ), "struct and wrapper have different size!" ); static_assert( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); + + template <> + struct CppType + { + using Type = IOSSurfaceCreateInfoMVK; + }; #endif /*VK_USE_PLATFORM_IOS_MVK*/ struct ImageBlit @@ -45989,6 +47544,8 @@ namespace VULKAN_HPP_NAMESPACE struct ImageCreateInfo { + static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::eImageCreateInfo; + VULKAN_HPP_CONSTEXPR ImageCreateInfo( VULKAN_HPP_NAMESPACE::ImageCreateFlags flags_ = {}, VULKAN_HPP_NAMESPACE::ImageType imageType_ = VULKAN_HPP_NAMESPACE::ImageType::e1D, @@ -46169,6 +47726,12 @@ namespace VULKAN_HPP_NAMESPACE static_assert( sizeof( ImageCreateInfo ) == sizeof( VkImageCreateInfo ), "struct and wrapper have different size!" ); static_assert( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); + template <> + struct CppType + { + using Type = ImageCreateInfo; + }; + struct SubresourceLayout { VULKAN_HPP_CONSTEXPR SubresourceLayout( VULKAN_HPP_NAMESPACE::DeviceSize offset_ = {}, @@ -46232,6 +47795,9 @@ namespace VULKAN_HPP_NAMESPACE struct ImageDrmFormatModifierExplicitCreateInfoEXT { + static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = + StructureType::eImageDrmFormatModifierExplicitCreateInfoEXT; + VULKAN_HPP_CONSTEXPR ImageDrmFormatModifierExplicitCreateInfoEXT( uint64_t drmFormatModifier_ = {}, uint32_t drmFormatModifierPlaneCount_ = {}, @@ -46330,8 +47896,17 @@ namespace VULKAN_HPP_NAMESPACE static_assert( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); + template <> + struct CppType + { + using Type = ImageDrmFormatModifierExplicitCreateInfoEXT; + }; + struct ImageDrmFormatModifierListCreateInfoEXT { + static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = + StructureType::eImageDrmFormatModifierListCreateInfoEXT; + VULKAN_HPP_CONSTEXPR ImageDrmFormatModifierListCreateInfoEXT( uint32_t drmFormatModifierCount_ = {}, const uint64_t * pDrmFormatModifiers_ = {} ) VULKAN_HPP_NOEXCEPT @@ -46419,8 +47994,17 @@ namespace VULKAN_HPP_NAMESPACE static_assert( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); + template <> + struct CppType + { + using Type = ImageDrmFormatModifierListCreateInfoEXT; + }; + struct ImageDrmFormatModifierPropertiesEXT { + static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = + StructureType::eImageDrmFormatModifierPropertiesEXT; + VULKAN_HPP_CONSTEXPR ImageDrmFormatModifierPropertiesEXT( uint64_t drmFormatModifier_ = {} ) VULKAN_HPP_NOEXCEPT : drmFormatModifier( drmFormatModifier_ ) {} @@ -46480,8 +48064,16 @@ namespace VULKAN_HPP_NAMESPACE static_assert( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); + template <> + struct CppType + { + using Type = ImageDrmFormatModifierPropertiesEXT; + }; + struct ImageFormatListCreateInfo { + static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::eImageFormatListCreateInfo; + VULKAN_HPP_CONSTEXPR ImageFormatListCreateInfo( uint32_t viewFormatCount_ = {}, const VULKAN_HPP_NAMESPACE::Format * pViewFormats_ = {} ) VULKAN_HPP_NOEXCEPT @@ -46561,8 +48153,16 @@ namespace VULKAN_HPP_NAMESPACE static_assert( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); + template <> + struct CppType + { + using Type = ImageFormatListCreateInfo; + }; + struct ImageFormatProperties2 { + static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::eImageFormatProperties2; + VULKAN_HPP_CONSTEXPR ImageFormatProperties2( VULKAN_HPP_NAMESPACE::ImageFormatProperties imageFormatProperties_ = {} ) VULKAN_HPP_NOEXCEPT : imageFormatProperties( imageFormatProperties_ ) @@ -46618,6 +48218,12 @@ namespace VULKAN_HPP_NAMESPACE "struct and wrapper have different size!" ); static_assert( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); + template <> + struct CppType + { + using Type = ImageFormatProperties2; + }; + struct ImageSubresourceRange { VULKAN_HPP_CONSTEXPR ImageSubresourceRange( VULKAN_HPP_NAMESPACE::ImageAspectFlags aspectMask_ = {}, @@ -46712,6 +48318,8 @@ namespace VULKAN_HPP_NAMESPACE struct ImageMemoryBarrier { + static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::eImageMemoryBarrier; + VULKAN_HPP_CONSTEXPR ImageMemoryBarrier( VULKAN_HPP_NAMESPACE::AccessFlags srcAccessMask_ = {}, VULKAN_HPP_NAMESPACE::AccessFlags dstAccessMask_ = {}, @@ -46847,8 +48455,16 @@ namespace VULKAN_HPP_NAMESPACE "struct and wrapper have different size!" ); static_assert( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); + template <> + struct CppType + { + using Type = ImageMemoryBarrier; + }; + struct ImageMemoryRequirementsInfo2 { + static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::eImageMemoryRequirementsInfo2; + VULKAN_HPP_CONSTEXPR ImageMemoryRequirementsInfo2( VULKAN_HPP_NAMESPACE::Image image_ = {} ) VULKAN_HPP_NOEXCEPT : image( image_ ) {} @@ -46917,9 +48533,18 @@ namespace VULKAN_HPP_NAMESPACE static_assert( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); + template <> + struct CppType + { + using Type = ImageMemoryRequirementsInfo2; + }; + #ifdef VK_USE_PLATFORM_FUCHSIA struct ImagePipeSurfaceCreateInfoFUCHSIA { + static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = + StructureType::eImagepipeSurfaceCreateInfoFUCHSIA; + VULKAN_HPP_CONSTEXPR ImagePipeSurfaceCreateInfoFUCHSIA( VULKAN_HPP_NAMESPACE::ImagePipeSurfaceCreateFlagsFUCHSIA flags_ = {}, zx_handle_t imagePipeHandle_ = {} ) VULKAN_HPP_NOEXCEPT @@ -47000,10 +48625,18 @@ namespace VULKAN_HPP_NAMESPACE "struct and wrapper have different size!" ); static_assert( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); + + template <> + struct CppType + { + using Type = ImagePipeSurfaceCreateInfoFUCHSIA; + }; #endif /*VK_USE_PLATFORM_FUCHSIA*/ struct ImagePlaneMemoryRequirementsInfo { + static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::eImagePlaneMemoryRequirementsInfo; + VULKAN_HPP_CONSTEXPR ImagePlaneMemoryRequirementsInfo( VULKAN_HPP_NAMESPACE::ImageAspectFlagBits planeAspect_ = VULKAN_HPP_NAMESPACE::ImageAspectFlagBits::eColor ) VULKAN_HPP_NOEXCEPT @@ -47076,6 +48709,12 @@ namespace VULKAN_HPP_NAMESPACE static_assert( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); + template <> + struct CppType + { + using Type = ImagePlaneMemoryRequirementsInfo; + }; + struct ImageResolve { VULKAN_HPP_CONSTEXPR ImageResolve( VULKAN_HPP_NAMESPACE::ImageSubresourceLayers srcSubresource_ = {}, @@ -47170,6 +48809,9 @@ namespace VULKAN_HPP_NAMESPACE struct ImageSparseMemoryRequirementsInfo2 { + static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = + StructureType::eImageSparseMemoryRequirementsInfo2; + VULKAN_HPP_CONSTEXPR ImageSparseMemoryRequirementsInfo2( VULKAN_HPP_NAMESPACE::Image image_ = {} ) VULKAN_HPP_NOEXCEPT : image( image_ ) @@ -47241,8 +48883,16 @@ namespace VULKAN_HPP_NAMESPACE static_assert( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); + template <> + struct CppType + { + using Type = ImageSparseMemoryRequirementsInfo2; + }; + struct ImageStencilUsageCreateInfo { + static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::eImageStencilUsageCreateInfo; + VULKAN_HPP_CONSTEXPR ImageStencilUsageCreateInfo( VULKAN_HPP_NAMESPACE::ImageUsageFlags stencilUsage_ = {} ) VULKAN_HPP_NOEXCEPT : stencilUsage( stencilUsage_ ) @@ -47313,8 +48963,16 @@ namespace VULKAN_HPP_NAMESPACE static_assert( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); + template <> + struct CppType + { + using Type = ImageStencilUsageCreateInfo; + }; + struct ImageSwapchainCreateInfoKHR { + static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::eImageSwapchainCreateInfoKHR; + VULKAN_HPP_CONSTEXPR ImageSwapchainCreateInfoKHR( VULKAN_HPP_NAMESPACE::SwapchainKHR swapchain_ = {} ) VULKAN_HPP_NOEXCEPT : swapchain( swapchain_ ) @@ -47384,8 +49042,16 @@ namespace VULKAN_HPP_NAMESPACE static_assert( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); + template <> + struct CppType + { + using Type = ImageSwapchainCreateInfoKHR; + }; + struct ImageViewASTCDecodeModeEXT { + static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::eImageViewAstcDecodeModeEXT; + VULKAN_HPP_CONSTEXPR ImageViewASTCDecodeModeEXT( VULKAN_HPP_NAMESPACE::Format decodeMode_ = VULKAN_HPP_NAMESPACE::Format::eUndefined ) VULKAN_HPP_NOEXCEPT : decodeMode( decodeMode_ ) @@ -47455,8 +49121,16 @@ namespace VULKAN_HPP_NAMESPACE static_assert( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); + template <> + struct CppType + { + using Type = ImageViewASTCDecodeModeEXT; + }; + struct ImageViewAddressPropertiesNVX { + static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::eImageViewAddressPropertiesNVX; + VULKAN_HPP_CONSTEXPR ImageViewAddressPropertiesNVX( VULKAN_HPP_NAMESPACE::DeviceAddress deviceAddress_ = {}, VULKAN_HPP_NAMESPACE::DeviceSize size_ = {} ) VULKAN_HPP_NOEXCEPT @@ -47519,8 +49193,16 @@ namespace VULKAN_HPP_NAMESPACE static_assert( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); + template <> + struct CppType + { + using Type = ImageViewAddressPropertiesNVX; + }; + struct ImageViewCreateInfo { + static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::eImageViewCreateInfo; + VULKAN_HPP_CONSTEXPR ImageViewCreateInfo( VULKAN_HPP_NAMESPACE::ImageViewCreateFlags flags_ = {}, VULKAN_HPP_NAMESPACE::Image image_ = {}, @@ -47637,8 +49319,16 @@ namespace VULKAN_HPP_NAMESPACE "struct and wrapper have different size!" ); static_assert( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); + template <> + struct CppType + { + using Type = ImageViewCreateInfo; + }; + struct ImageViewHandleInfoNVX { + static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::eImageViewHandleInfoNVX; + VULKAN_HPP_CONSTEXPR ImageViewHandleInfoNVX( VULKAN_HPP_NAMESPACE::ImageView imageView_ = {}, VULKAN_HPP_NAMESPACE::DescriptorType descriptorType_ = VULKAN_HPP_NAMESPACE::DescriptorType::eSampler, @@ -47726,8 +49416,16 @@ namespace VULKAN_HPP_NAMESPACE "struct and wrapper have different size!" ); static_assert( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); + template <> + struct CppType + { + using Type = ImageViewHandleInfoNVX; + }; + struct ImageViewUsageCreateInfo { + static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::eImageViewUsageCreateInfo; + VULKAN_HPP_CONSTEXPR ImageViewUsageCreateInfo( VULKAN_HPP_NAMESPACE::ImageUsageFlags usage_ = {} ) VULKAN_HPP_NOEXCEPT : usage( usage_ ) @@ -47795,9 +49493,18 @@ namespace VULKAN_HPP_NAMESPACE "struct and wrapper have different size!" ); static_assert( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); + template <> + struct CppType + { + using Type = ImageViewUsageCreateInfo; + }; + #ifdef VK_USE_PLATFORM_ANDROID_KHR struct ImportAndroidHardwareBufferInfoANDROID { + static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = + StructureType::eImportAndroidHardwareBufferInfoANDROID; + VULKAN_HPP_CONSTEXPR ImportAndroidHardwareBufferInfoANDROID( struct AHardwareBuffer * buffer_ = {} ) VULKAN_HPP_NOEXCEPT : buffer( buffer_ ) @@ -47870,10 +49577,18 @@ namespace VULKAN_HPP_NAMESPACE "struct and wrapper have different size!" ); static_assert( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); + + template <> + struct CppType + { + using Type = ImportAndroidHardwareBufferInfoANDROID; + }; #endif /*VK_USE_PLATFORM_ANDROID_KHR*/ struct ImportFenceFdInfoKHR { + static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::eImportFenceFdInfoKHR; + VULKAN_HPP_CONSTEXPR ImportFenceFdInfoKHR( VULKAN_HPP_NAMESPACE::Fence fence_ = {}, VULKAN_HPP_NAMESPACE::FenceImportFlags flags_ = {}, VULKAN_HPP_NAMESPACE::ExternalFenceHandleTypeFlagBits handleType_ = @@ -47971,9 +49686,17 @@ namespace VULKAN_HPP_NAMESPACE "struct and wrapper have different size!" ); static_assert( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); + template <> + struct CppType + { + using Type = ImportFenceFdInfoKHR; + }; + #ifdef VK_USE_PLATFORM_WIN32_KHR struct ImportFenceWin32HandleInfoKHR { + static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::eImportFenceWin32HandleInfoKHR; + VULKAN_HPP_CONSTEXPR ImportFenceWin32HandleInfoKHR( VULKAN_HPP_NAMESPACE::Fence fence_ = {}, VULKAN_HPP_NAMESPACE::FenceImportFlags flags_ = {}, @@ -48083,10 +49806,18 @@ namespace VULKAN_HPP_NAMESPACE "struct and wrapper have different size!" ); static_assert( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); + + template <> + struct CppType + { + using Type = ImportFenceWin32HandleInfoKHR; + }; #endif /*VK_USE_PLATFORM_WIN32_KHR*/ struct ImportMemoryFdInfoKHR { + static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::eImportMemoryFdInfoKHR; + VULKAN_HPP_CONSTEXPR ImportMemoryFdInfoKHR( VULKAN_HPP_NAMESPACE::ExternalMemoryHandleTypeFlagBits handleType_ = VULKAN_HPP_NAMESPACE::ExternalMemoryHandleTypeFlagBits::eOpaqueFd, int fd_ = {} ) VULKAN_HPP_NOEXCEPT @@ -48165,8 +49896,16 @@ namespace VULKAN_HPP_NAMESPACE "struct and wrapper have different size!" ); static_assert( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); + template <> + struct CppType + { + using Type = ImportMemoryFdInfoKHR; + }; + struct ImportMemoryHostPointerInfoEXT { + static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::eImportMemoryHostPointerInfoEXT; + VULKAN_HPP_CONSTEXPR ImportMemoryHostPointerInfoEXT( VULKAN_HPP_NAMESPACE::ExternalMemoryHandleTypeFlagBits handleType_ = VULKAN_HPP_NAMESPACE::ExternalMemoryHandleTypeFlagBits::eOpaqueFd, @@ -48250,9 +49989,17 @@ namespace VULKAN_HPP_NAMESPACE static_assert( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); + template <> + struct CppType + { + using Type = ImportMemoryHostPointerInfoEXT; + }; + #ifdef VK_USE_PLATFORM_WIN32_KHR struct ImportMemoryWin32HandleInfoKHR { + static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::eImportMemoryWin32HandleInfoKHR; + VULKAN_HPP_CONSTEXPR ImportMemoryWin32HandleInfoKHR( VULKAN_HPP_NAMESPACE::ExternalMemoryHandleTypeFlagBits handleType_ = VULKAN_HPP_NAMESPACE::ExternalMemoryHandleTypeFlagBits::eOpaqueFd, @@ -48344,11 +50091,19 @@ namespace VULKAN_HPP_NAMESPACE "struct and wrapper have different size!" ); static_assert( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); + + template <> + struct CppType + { + using Type = ImportMemoryWin32HandleInfoKHR; + }; #endif /*VK_USE_PLATFORM_WIN32_KHR*/ #ifdef VK_USE_PLATFORM_WIN32_KHR struct ImportMemoryWin32HandleInfoNV { + static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::eImportMemoryWin32HandleInfoNV; + VULKAN_HPP_CONSTEXPR ImportMemoryWin32HandleInfoNV( VULKAN_HPP_NAMESPACE::ExternalMemoryHandleTypeFlagsNV handleType_ = {}, HANDLE handle_ = {} ) VULKAN_HPP_NOEXCEPT @@ -48429,10 +50184,18 @@ namespace VULKAN_HPP_NAMESPACE "struct and wrapper have different size!" ); static_assert( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); + + template <> + struct CppType + { + using Type = ImportMemoryWin32HandleInfoNV; + }; #endif /*VK_USE_PLATFORM_WIN32_KHR*/ struct ImportSemaphoreFdInfoKHR { + static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::eImportSemaphoreFdInfoKHR; + VULKAN_HPP_CONSTEXPR ImportSemaphoreFdInfoKHR( VULKAN_HPP_NAMESPACE::Semaphore semaphore_ = {}, VULKAN_HPP_NAMESPACE::SemaphoreImportFlags flags_ = {}, @@ -48531,9 +50294,18 @@ namespace VULKAN_HPP_NAMESPACE "struct and wrapper have different size!" ); static_assert( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); + template <> + struct CppType + { + using Type = ImportSemaphoreFdInfoKHR; + }; + #ifdef VK_USE_PLATFORM_WIN32_KHR struct ImportSemaphoreWin32HandleInfoKHR { + static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = + StructureType::eImportSemaphoreWin32HandleInfoKHR; + VULKAN_HPP_CONSTEXPR ImportSemaphoreWin32HandleInfoKHR( VULKAN_HPP_NAMESPACE::Semaphore semaphore_ = {}, VULKAN_HPP_NAMESPACE::SemaphoreImportFlags flags_ = {}, @@ -48645,10 +50417,18 @@ namespace VULKAN_HPP_NAMESPACE "struct and wrapper have different size!" ); static_assert( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); + + template <> + struct CppType + { + using Type = ImportSemaphoreWin32HandleInfoKHR; + }; #endif /*VK_USE_PLATFORM_WIN32_KHR*/ struct IndirectCommandsLayoutTokenNV { + static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::eIndirectCommandsLayoutTokenNV; + VULKAN_HPP_CONSTEXPR IndirectCommandsLayoutTokenNV( VULKAN_HPP_NAMESPACE::IndirectCommandsTokenTypeNV tokenType_ = VULKAN_HPP_NAMESPACE::IndirectCommandsTokenTypeNV::eShaderGroup, @@ -48842,8 +50622,17 @@ namespace VULKAN_HPP_NAMESPACE static_assert( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); + template <> + struct CppType + { + using Type = IndirectCommandsLayoutTokenNV; + }; + struct IndirectCommandsLayoutCreateInfoNV { + static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = + StructureType::eIndirectCommandsLayoutCreateInfoNV; + VULKAN_HPP_CONSTEXPR IndirectCommandsLayoutCreateInfoNV( VULKAN_HPP_NAMESPACE::IndirectCommandsLayoutUsageFlagsNV flags_ = {}, VULKAN_HPP_NAMESPACE::PipelineBindPoint pipelineBindPoint_ = VULKAN_HPP_NAMESPACE::PipelineBindPoint::eGraphics, @@ -48966,8 +50755,17 @@ namespace VULKAN_HPP_NAMESPACE static_assert( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); + template <> + struct CppType + { + using Type = IndirectCommandsLayoutCreateInfoNV; + }; + struct InitializePerformanceApiInfoINTEL { + static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = + StructureType::eInitializePerformanceApiInfoINTEL; + VULKAN_HPP_CONSTEXPR InitializePerformanceApiInfoINTEL( void * pUserData_ = {} ) VULKAN_HPP_NOEXCEPT : pUserData( pUserData_ ) {} @@ -49037,6 +50835,12 @@ namespace VULKAN_HPP_NAMESPACE static_assert( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); + template <> + struct CppType + { + using Type = InitializePerformanceApiInfoINTEL; + }; + struct InputAttachmentAspectReference { VULKAN_HPP_CONSTEXPR @@ -49115,6 +50919,8 @@ namespace VULKAN_HPP_NAMESPACE struct InstanceCreateInfo { + static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::eInstanceCreateInfo; + VULKAN_HPP_CONSTEXPR InstanceCreateInfo( VULKAN_HPP_NAMESPACE::InstanceCreateFlags flags_ = {}, const VULKAN_HPP_NAMESPACE::ApplicationInfo * pApplicationInfo_ = {}, uint32_t enabledLayerCount_ = {}, @@ -49231,6 +51037,12 @@ namespace VULKAN_HPP_NAMESPACE "struct and wrapper have different size!" ); static_assert( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); + template <> + struct CppType + { + using Type = InstanceCreateInfo; + }; + struct LayerProperties { VULKAN_HPP_CONSTEXPR_14 @@ -49292,6 +51104,8 @@ namespace VULKAN_HPP_NAMESPACE #ifdef VK_USE_PLATFORM_MACOS_MVK struct MacOSSurfaceCreateInfoMVK { + static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::eMacosSurfaceCreateInfoMVK; + VULKAN_HPP_CONSTEXPR MacOSSurfaceCreateInfoMVK( VULKAN_HPP_NAMESPACE::MacOSSurfaceCreateFlagsMVK flags_ = {}, const void * pView_ = {} ) VULKAN_HPP_NOEXCEPT : flags( flags_ ) @@ -49367,10 +51181,18 @@ namespace VULKAN_HPP_NAMESPACE "struct and wrapper have different size!" ); static_assert( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); + + template <> + struct CppType + { + using Type = MacOSSurfaceCreateInfoMVK; + }; #endif /*VK_USE_PLATFORM_MACOS_MVK*/ struct MappedMemoryRange { + static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::eMappedMemoryRange; + VULKAN_HPP_CONSTEXPR MappedMemoryRange( VULKAN_HPP_NAMESPACE::DeviceMemory memory_ = {}, VULKAN_HPP_NAMESPACE::DeviceSize offset_ = {}, VULKAN_HPP_NAMESPACE::DeviceSize size_ = {} ) VULKAN_HPP_NOEXCEPT @@ -49456,8 +51278,16 @@ namespace VULKAN_HPP_NAMESPACE "struct and wrapper have different size!" ); static_assert( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); + template <> + struct CppType + { + using Type = MappedMemoryRange; + }; + struct MemoryAllocateFlagsInfo { + static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::eMemoryAllocateFlagsInfo; + VULKAN_HPP_CONSTEXPR MemoryAllocateFlagsInfo( VULKAN_HPP_NAMESPACE::MemoryAllocateFlags flags_ = {}, uint32_t deviceMask_ = {} ) VULKAN_HPP_NOEXCEPT : flags( flags_ ) @@ -49534,8 +51364,16 @@ namespace VULKAN_HPP_NAMESPACE "struct and wrapper have different size!" ); static_assert( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); + template <> + struct CppType + { + using Type = MemoryAllocateFlagsInfo; + }; + struct MemoryAllocateInfo { + static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::eMemoryAllocateInfo; + VULKAN_HPP_CONSTEXPR MemoryAllocateInfo( VULKAN_HPP_NAMESPACE::DeviceSize allocationSize_ = {}, uint32_t memoryTypeIndex_ = {} ) VULKAN_HPP_NOEXCEPT : allocationSize( allocationSize_ ) @@ -49612,8 +51450,16 @@ namespace VULKAN_HPP_NAMESPACE "struct and wrapper have different size!" ); static_assert( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); + template <> + struct CppType + { + using Type = MemoryAllocateInfo; + }; + struct MemoryBarrier { + static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::eMemoryBarrier; + VULKAN_HPP_CONSTEXPR MemoryBarrier( VULKAN_HPP_NAMESPACE::AccessFlags srcAccessMask_ = {}, VULKAN_HPP_NAMESPACE::AccessFlags dstAccessMask_ = {} ) VULKAN_HPP_NOEXCEPT : srcAccessMask( srcAccessMask_ ) @@ -49689,8 +51535,16 @@ namespace VULKAN_HPP_NAMESPACE static_assert( sizeof( MemoryBarrier ) == sizeof( VkMemoryBarrier ), "struct and wrapper have different size!" ); static_assert( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); + template <> + struct CppType + { + using Type = MemoryBarrier; + }; + struct MemoryDedicatedAllocateInfo { + static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::eMemoryDedicatedAllocateInfo; + VULKAN_HPP_CONSTEXPR MemoryDedicatedAllocateInfo( VULKAN_HPP_NAMESPACE::Image image_ = {}, VULKAN_HPP_NAMESPACE::Buffer buffer_ = {} ) VULKAN_HPP_NOEXCEPT : image( image_ ) @@ -49768,8 +51622,16 @@ namespace VULKAN_HPP_NAMESPACE static_assert( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); + template <> + struct CppType + { + using Type = MemoryDedicatedAllocateInfo; + }; + struct MemoryDedicatedRequirements { + static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::eMemoryDedicatedRequirements; + VULKAN_HPP_CONSTEXPR MemoryDedicatedRequirements( VULKAN_HPP_NAMESPACE::Bool32 prefersDedicatedAllocation_ = {}, VULKAN_HPP_NAMESPACE::Bool32 requiresDedicatedAllocation_ = {} ) VULKAN_HPP_NOEXCEPT @@ -49832,8 +51694,16 @@ namespace VULKAN_HPP_NAMESPACE static_assert( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); + template <> + struct CppType + { + using Type = MemoryDedicatedRequirements; + }; + struct MemoryFdPropertiesKHR { + static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::eMemoryFdPropertiesKHR; + VULKAN_HPP_CONSTEXPR MemoryFdPropertiesKHR( uint32_t memoryTypeBits_ = {} ) VULKAN_HPP_NOEXCEPT : memoryTypeBits( memoryTypeBits_ ) {} @@ -49888,9 +51758,18 @@ namespace VULKAN_HPP_NAMESPACE "struct and wrapper have different size!" ); static_assert( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); + template <> + struct CppType + { + using Type = MemoryFdPropertiesKHR; + }; + #ifdef VK_USE_PLATFORM_ANDROID_KHR struct MemoryGetAndroidHardwareBufferInfoANDROID { + static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = + StructureType::eMemoryGetAndroidHardwareBufferInfoANDROID; + VULKAN_HPP_CONSTEXPR MemoryGetAndroidHardwareBufferInfoANDROID( VULKAN_HPP_NAMESPACE::DeviceMemory memory_ = {} ) VULKAN_HPP_NOEXCEPT : memory( memory_ ) @@ -49966,10 +51845,18 @@ namespace VULKAN_HPP_NAMESPACE "struct and wrapper have different size!" ); static_assert( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); + + template <> + struct CppType + { + using Type = MemoryGetAndroidHardwareBufferInfoANDROID; + }; #endif /*VK_USE_PLATFORM_ANDROID_KHR*/ struct MemoryGetFdInfoKHR { + static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::eMemoryGetFdInfoKHR; + VULKAN_HPP_CONSTEXPR MemoryGetFdInfoKHR( VULKAN_HPP_NAMESPACE::DeviceMemory memory_ = {}, VULKAN_HPP_NAMESPACE::ExternalMemoryHandleTypeFlagBits handleType_ = @@ -50050,9 +51937,17 @@ namespace VULKAN_HPP_NAMESPACE "struct and wrapper have different size!" ); static_assert( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); + template <> + struct CppType + { + using Type = MemoryGetFdInfoKHR; + }; + #ifdef VK_USE_PLATFORM_WIN32_KHR struct MemoryGetWin32HandleInfoKHR { + static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::eMemoryGetWin32HandleInfoKHR; + VULKAN_HPP_CONSTEXPR MemoryGetWin32HandleInfoKHR( VULKAN_HPP_NAMESPACE::DeviceMemory memory_ = {}, VULKAN_HPP_NAMESPACE::ExternalMemoryHandleTypeFlagBits handleType_ = @@ -50134,6 +52029,12 @@ namespace VULKAN_HPP_NAMESPACE "struct and wrapper have different size!" ); static_assert( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); + + template <> + struct CppType + { + using Type = MemoryGetWin32HandleInfoKHR; + }; #endif /*VK_USE_PLATFORM_WIN32_KHR*/ struct MemoryHeap @@ -50188,6 +52089,8 @@ namespace VULKAN_HPP_NAMESPACE struct MemoryHostPointerPropertiesEXT { + static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::eMemoryHostPointerPropertiesEXT; + VULKAN_HPP_CONSTEXPR MemoryHostPointerPropertiesEXT( uint32_t memoryTypeBits_ = {} ) VULKAN_HPP_NOEXCEPT : memoryTypeBits( memoryTypeBits_ ) {} @@ -50245,8 +52148,17 @@ namespace VULKAN_HPP_NAMESPACE static_assert( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); + template <> + struct CppType + { + using Type = MemoryHostPointerPropertiesEXT; + }; + struct MemoryOpaqueCaptureAddressAllocateInfo { + static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = + StructureType::eMemoryOpaqueCaptureAddressAllocateInfo; + VULKAN_HPP_CONSTEXPR MemoryOpaqueCaptureAddressAllocateInfo( uint64_t opaqueCaptureAddress_ = {} ) VULKAN_HPP_NOEXCEPT : opaqueCaptureAddress( opaqueCaptureAddress_ ) @@ -50321,8 +52233,16 @@ namespace VULKAN_HPP_NAMESPACE static_assert( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); + template <> + struct CppType + { + using Type = MemoryOpaqueCaptureAddressAllocateInfo; + }; + struct MemoryPriorityAllocateInfoEXT { + static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::eMemoryPriorityAllocateInfoEXT; + VULKAN_HPP_CONSTEXPR MemoryPriorityAllocateInfoEXT( float priority_ = {} ) VULKAN_HPP_NOEXCEPT : priority( priority_ ) {} @@ -50392,6 +52312,12 @@ namespace VULKAN_HPP_NAMESPACE static_assert( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); + template <> + struct CppType + { + using Type = MemoryPriorityAllocateInfoEXT; + }; + struct MemoryRequirements { VULKAN_HPP_CONSTEXPR MemoryRequirements( VULKAN_HPP_NAMESPACE::DeviceSize size_ = {}, @@ -50448,6 +52374,8 @@ namespace VULKAN_HPP_NAMESPACE struct MemoryRequirements2 { + static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::eMemoryRequirements2; + VULKAN_HPP_CONSTEXPR MemoryRequirements2( VULKAN_HPP_NAMESPACE::MemoryRequirements memoryRequirements_ = {} ) VULKAN_HPP_NOEXCEPT : memoryRequirements( memoryRequirements_ ) @@ -50503,6 +52431,12 @@ namespace VULKAN_HPP_NAMESPACE "struct and wrapper have different size!" ); static_assert( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); + template <> + struct CppType + { + using Type = MemoryRequirements2; + }; + struct MemoryType { VULKAN_HPP_CONSTEXPR MemoryType( VULKAN_HPP_NAMESPACE::MemoryPropertyFlags propertyFlags_ = {}, @@ -50556,6 +52490,8 @@ namespace VULKAN_HPP_NAMESPACE #ifdef VK_USE_PLATFORM_WIN32_KHR struct MemoryWin32HandlePropertiesKHR { + static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::eMemoryWin32HandlePropertiesKHR; + VULKAN_HPP_CONSTEXPR MemoryWin32HandlePropertiesKHR( uint32_t memoryTypeBits_ = {} ) VULKAN_HPP_NOEXCEPT : memoryTypeBits( memoryTypeBits_ ) {} @@ -50612,11 +52548,19 @@ namespace VULKAN_HPP_NAMESPACE "struct and wrapper have different size!" ); static_assert( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); + + template <> + struct CppType + { + using Type = MemoryWin32HandlePropertiesKHR; + }; #endif /*VK_USE_PLATFORM_WIN32_KHR*/ #ifdef VK_USE_PLATFORM_METAL_EXT struct MetalSurfaceCreateInfoEXT { + static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::eMetalSurfaceCreateInfoEXT; + VULKAN_HPP_CONSTEXPR MetalSurfaceCreateInfoEXT( VULKAN_HPP_NAMESPACE::MetalSurfaceCreateFlagsEXT flags_ = {}, const CAMetalLayer * pLayer_ = {} ) VULKAN_HPP_NOEXCEPT : flags( flags_ ) @@ -50692,10 +52636,18 @@ namespace VULKAN_HPP_NAMESPACE "struct and wrapper have different size!" ); static_assert( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); + + template <> + struct CppType + { + using Type = MetalSurfaceCreateInfoEXT; + }; #endif /*VK_USE_PLATFORM_METAL_EXT*/ struct MultisamplePropertiesEXT { + static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::eMultisamplePropertiesEXT; + VULKAN_HPP_CONSTEXPR MultisamplePropertiesEXT( VULKAN_HPP_NAMESPACE::Extent2D maxSampleLocationGridSize_ = {} ) VULKAN_HPP_NOEXCEPT : maxSampleLocationGridSize( maxSampleLocationGridSize_ ) @@ -50752,6 +52704,12 @@ namespace VULKAN_HPP_NAMESPACE "struct and wrapper have different size!" ); static_assert( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); + template <> + struct CppType + { + using Type = MultisamplePropertiesEXT; + }; + struct PastPresentationTimingGOOGLE { VULKAN_HPP_CONSTEXPR PastPresentationTimingGOOGLE( uint32_t presentID_ = {}, @@ -50817,6 +52775,9 @@ namespace VULKAN_HPP_NAMESPACE struct PerformanceConfigurationAcquireInfoINTEL { + static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = + StructureType::ePerformanceConfigurationAcquireInfoINTEL; + VULKAN_HPP_CONSTEXPR PerformanceConfigurationAcquireInfoINTEL( VULKAN_HPP_NAMESPACE::PerformanceConfigurationTypeINTEL type_ = VULKAN_HPP_NAMESPACE::PerformanceConfigurationTypeINTEL::eCommandQueueMetricsDiscoveryActivated ) @@ -50895,8 +52856,16 @@ namespace VULKAN_HPP_NAMESPACE static_assert( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); + template <> + struct CppType + { + using Type = PerformanceConfigurationAcquireInfoINTEL; + }; + struct PerformanceCounterDescriptionKHR { + static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::ePerformanceCounterDescriptionKHR; + VULKAN_HPP_CONSTEXPR_14 PerformanceCounterDescriptionKHR( VULKAN_HPP_NAMESPACE::PerformanceCounterDescriptionFlagsKHR flags_ = {}, std::array const & name_ = {}, @@ -50965,8 +52934,16 @@ namespace VULKAN_HPP_NAMESPACE static_assert( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); + template <> + struct CppType + { + using Type = PerformanceCounterDescriptionKHR; + }; + struct PerformanceCounterKHR { + static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::ePerformanceCounterKHR; + VULKAN_HPP_CONSTEXPR_14 PerformanceCounterKHR( VULKAN_HPP_NAMESPACE::PerformanceCounterUnitKHR unit_ = VULKAN_HPP_NAMESPACE::PerformanceCounterUnitKHR::eGeneric, VULKAN_HPP_NAMESPACE::PerformanceCounterScopeKHR scope_ = @@ -51036,6 +53013,12 @@ namespace VULKAN_HPP_NAMESPACE "struct and wrapper have different size!" ); static_assert( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); + template <> + struct CppType + { + using Type = PerformanceCounterKHR; + }; + union PerformanceCounterResultKHR { PerformanceCounterResultKHR( VULKAN_HPP_NAMESPACE::PerformanceCounterResultKHR const & rhs ) VULKAN_HPP_NOEXCEPT @@ -51118,6 +53101,8 @@ namespace VULKAN_HPP_NAMESPACE struct PerformanceMarkerInfoINTEL { + static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::ePerformanceMarkerInfoINTEL; + VULKAN_HPP_CONSTEXPR PerformanceMarkerInfoINTEL( uint64_t marker_ = {} ) VULKAN_HPP_NOEXCEPT : marker( marker_ ) {} PerformanceMarkerInfoINTEL & operator=( PerformanceMarkerInfoINTEL const & rhs ) VULKAN_HPP_NOEXCEPT @@ -51184,8 +53169,16 @@ namespace VULKAN_HPP_NAMESPACE static_assert( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); + template <> + struct CppType + { + using Type = PerformanceMarkerInfoINTEL; + }; + struct PerformanceOverrideInfoINTEL { + static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::ePerformanceOverrideInfoINTEL; + VULKAN_HPP_CONSTEXPR PerformanceOverrideInfoINTEL( VULKAN_HPP_NAMESPACE::PerformanceOverrideTypeINTEL type_ = VULKAN_HPP_NAMESPACE::PerformanceOverrideTypeINTEL::eNullHardware, @@ -51277,8 +53270,16 @@ namespace VULKAN_HPP_NAMESPACE static_assert( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); + template <> + struct CppType + { + using Type = PerformanceOverrideInfoINTEL; + }; + struct PerformanceQuerySubmitInfoKHR { + static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::ePerformanceQuerySubmitInfoKHR; + VULKAN_HPP_CONSTEXPR PerformanceQuerySubmitInfoKHR( uint32_t counterPassIndex_ = {} ) VULKAN_HPP_NOEXCEPT : counterPassIndex( counterPassIndex_ ) {} @@ -51348,8 +53349,16 @@ namespace VULKAN_HPP_NAMESPACE static_assert( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); + template <> + struct CppType + { + using Type = PerformanceQuerySubmitInfoKHR; + }; + struct PerformanceStreamMarkerInfoINTEL { + static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::ePerformanceStreamMarkerInfoINTEL; + VULKAN_HPP_CONSTEXPR PerformanceStreamMarkerInfoINTEL( uint32_t marker_ = {} ) VULKAN_HPP_NOEXCEPT : marker( marker_ ) {} @@ -51419,6 +53428,12 @@ namespace VULKAN_HPP_NAMESPACE static_assert( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); + template <> + struct CppType + { + using Type = PerformanceStreamMarkerInfoINTEL; + }; + union PerformanceValueDataINTEL { PerformanceValueDataINTEL( VULKAN_HPP_NAMESPACE::PerformanceValueDataINTEL const & rhs ) VULKAN_HPP_NOEXCEPT @@ -51548,6 +53563,9 @@ namespace VULKAN_HPP_NAMESPACE struct PhysicalDevice16BitStorageFeatures { + static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = + StructureType::ePhysicalDevice16BitStorageFeatures; + VULKAN_HPP_CONSTEXPR PhysicalDevice16BitStorageFeatures( VULKAN_HPP_NAMESPACE::Bool32 storageBuffer16BitAccess_ = {}, VULKAN_HPP_NAMESPACE::Bool32 uniformAndStorageBuffer16BitAccess_ = {}, @@ -51654,8 +53672,17 @@ namespace VULKAN_HPP_NAMESPACE static_assert( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); + template <> + struct CppType + { + using Type = PhysicalDevice16BitStorageFeatures; + }; + struct PhysicalDevice8BitStorageFeatures { + static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = + StructureType::ePhysicalDevice8BitStorageFeatures; + VULKAN_HPP_CONSTEXPR PhysicalDevice8BitStorageFeatures( VULKAN_HPP_NAMESPACE::Bool32 storageBuffer8BitAccess_ = {}, VULKAN_HPP_NAMESPACE::Bool32 uniformAndStorageBuffer8BitAccess_ = {}, @@ -51750,8 +53777,17 @@ namespace VULKAN_HPP_NAMESPACE static_assert( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); + template <> + struct CppType + { + using Type = PhysicalDevice8BitStorageFeatures; + }; + struct PhysicalDeviceASTCDecodeFeaturesEXT { + static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = + StructureType::ePhysicalDeviceAstcDecodeFeaturesEXT; + VULKAN_HPP_CONSTEXPR PhysicalDeviceASTCDecodeFeaturesEXT( VULKAN_HPP_NAMESPACE::Bool32 decodeModeSharedExponent_ = {} ) VULKAN_HPP_NOEXCEPT : decodeModeSharedExponent( decodeModeSharedExponent_ ) @@ -51826,8 +53862,17 @@ namespace VULKAN_HPP_NAMESPACE static_assert( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); + template <> + struct CppType + { + using Type = PhysicalDeviceASTCDecodeFeaturesEXT; + }; + struct PhysicalDeviceBlendOperationAdvancedFeaturesEXT { + static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = + StructureType::ePhysicalDeviceBlendOperationAdvancedFeaturesEXT; + VULKAN_HPP_CONSTEXPR PhysicalDeviceBlendOperationAdvancedFeaturesEXT( VULKAN_HPP_NAMESPACE::Bool32 advancedBlendCoherentOperations_ = {} ) VULKAN_HPP_NOEXCEPT : advancedBlendCoherentOperations( advancedBlendCoherentOperations_ ) @@ -51905,8 +53950,17 @@ namespace VULKAN_HPP_NAMESPACE static_assert( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); + template <> + struct CppType + { + using Type = PhysicalDeviceBlendOperationAdvancedFeaturesEXT; + }; + struct PhysicalDeviceBlendOperationAdvancedPropertiesEXT { + static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = + StructureType::ePhysicalDeviceBlendOperationAdvancedPropertiesEXT; + VULKAN_HPP_CONSTEXPR PhysicalDeviceBlendOperationAdvancedPropertiesEXT( uint32_t advancedBlendMaxColorAttachments_ = {}, VULKAN_HPP_NAMESPACE::Bool32 advancedBlendIndependentBlend_ = {}, @@ -51992,8 +54046,17 @@ namespace VULKAN_HPP_NAMESPACE static_assert( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); + template <> + struct CppType + { + using Type = PhysicalDeviceBlendOperationAdvancedPropertiesEXT; + }; + struct PhysicalDeviceBufferDeviceAddressFeatures { + static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = + StructureType::ePhysicalDeviceBufferDeviceAddressFeatures; + VULKAN_HPP_CONSTEXPR PhysicalDeviceBufferDeviceAddressFeatures( VULKAN_HPP_NAMESPACE::Bool32 bufferDeviceAddress_ = {}, VULKAN_HPP_NAMESPACE::Bool32 bufferDeviceAddressCaptureReplay_ = {}, @@ -52092,8 +54155,17 @@ namespace VULKAN_HPP_NAMESPACE static_assert( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); + template <> + struct CppType + { + using Type = PhysicalDeviceBufferDeviceAddressFeatures; + }; + struct PhysicalDeviceBufferDeviceAddressFeaturesEXT { + static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = + StructureType::ePhysicalDeviceBufferDeviceAddressFeaturesEXT; + VULKAN_HPP_CONSTEXPR PhysicalDeviceBufferDeviceAddressFeaturesEXT( VULKAN_HPP_NAMESPACE::Bool32 bufferDeviceAddress_ = {}, VULKAN_HPP_NAMESPACE::Bool32 bufferDeviceAddressCaptureReplay_ = {}, @@ -52192,8 +54264,17 @@ namespace VULKAN_HPP_NAMESPACE static_assert( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); + template <> + struct CppType + { + using Type = PhysicalDeviceBufferDeviceAddressFeaturesEXT; + }; + struct PhysicalDeviceCoherentMemoryFeaturesAMD { + static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = + StructureType::ePhysicalDeviceCoherentMemoryFeaturesAMD; + VULKAN_HPP_CONSTEXPR PhysicalDeviceCoherentMemoryFeaturesAMD( VULKAN_HPP_NAMESPACE::Bool32 deviceCoherentMemory_ = {} ) VULKAN_HPP_NOEXCEPT : deviceCoherentMemory( deviceCoherentMemory_ ) @@ -52269,8 +54350,17 @@ namespace VULKAN_HPP_NAMESPACE static_assert( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); + template <> + struct CppType + { + using Type = PhysicalDeviceCoherentMemoryFeaturesAMD; + }; + struct PhysicalDeviceComputeShaderDerivativesFeaturesNV { + static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = + StructureType::ePhysicalDeviceComputeShaderDerivativesFeaturesNV; + VULKAN_HPP_CONSTEXPR PhysicalDeviceComputeShaderDerivativesFeaturesNV( VULKAN_HPP_NAMESPACE::Bool32 computeDerivativeGroupQuads_ = {}, VULKAN_HPP_NAMESPACE::Bool32 computeDerivativeGroupLinear_ = {} ) VULKAN_HPP_NOEXCEPT @@ -52359,8 +54449,17 @@ namespace VULKAN_HPP_NAMESPACE static_assert( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); + template <> + struct CppType + { + using Type = PhysicalDeviceComputeShaderDerivativesFeaturesNV; + }; + struct PhysicalDeviceConditionalRenderingFeaturesEXT { + static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = + StructureType::ePhysicalDeviceConditionalRenderingFeaturesEXT; + VULKAN_HPP_CONSTEXPR PhysicalDeviceConditionalRenderingFeaturesEXT( VULKAN_HPP_NAMESPACE::Bool32 conditionalRendering_ = {}, VULKAN_HPP_NAMESPACE::Bool32 inheritedConditionalRendering_ = {} ) VULKAN_HPP_NOEXCEPT @@ -52448,8 +54547,17 @@ namespace VULKAN_HPP_NAMESPACE static_assert( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); + template <> + struct CppType + { + using Type = PhysicalDeviceConditionalRenderingFeaturesEXT; + }; + struct PhysicalDeviceConservativeRasterizationPropertiesEXT { + static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = + StructureType::ePhysicalDeviceConservativeRasterizationPropertiesEXT; + VULKAN_HPP_CONSTEXPR PhysicalDeviceConservativeRasterizationPropertiesEXT( float primitiveOverestimationSize_ = {}, float maxExtraPrimitiveOverestimationSize_ = {}, @@ -52548,8 +54656,17 @@ namespace VULKAN_HPP_NAMESPACE static_assert( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); + template <> + struct CppType + { + using Type = PhysicalDeviceConservativeRasterizationPropertiesEXT; + }; + struct PhysicalDeviceCooperativeMatrixFeaturesNV { + static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = + StructureType::ePhysicalDeviceCooperativeMatrixFeaturesNV; + VULKAN_HPP_CONSTEXPR PhysicalDeviceCooperativeMatrixFeaturesNV( VULKAN_HPP_NAMESPACE::Bool32 cooperativeMatrix_ = {}, VULKAN_HPP_NAMESPACE::Bool32 cooperativeMatrixRobustBufferAccess_ = {} ) VULKAN_HPP_NOEXCEPT @@ -52637,8 +54754,17 @@ namespace VULKAN_HPP_NAMESPACE static_assert( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); + template <> + struct CppType + { + using Type = PhysicalDeviceCooperativeMatrixFeaturesNV; + }; + struct PhysicalDeviceCooperativeMatrixPropertiesNV { + static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = + StructureType::ePhysicalDeviceCooperativeMatrixPropertiesNV; + VULKAN_HPP_CONSTEXPR PhysicalDeviceCooperativeMatrixPropertiesNV( VULKAN_HPP_NAMESPACE::ShaderStageFlags cooperativeMatrixSupportedStages_ = {} ) VULKAN_HPP_NOEXCEPT : cooperativeMatrixSupportedStages( cooperativeMatrixSupportedStages_ ) @@ -52703,8 +54829,17 @@ namespace VULKAN_HPP_NAMESPACE static_assert( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); + template <> + struct CppType + { + using Type = PhysicalDeviceCooperativeMatrixPropertiesNV; + }; + struct PhysicalDeviceCornerSampledImageFeaturesNV { + static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = + StructureType::ePhysicalDeviceCornerSampledImageFeaturesNV; + VULKAN_HPP_CONSTEXPR PhysicalDeviceCornerSampledImageFeaturesNV( VULKAN_HPP_NAMESPACE::Bool32 cornerSampledImage_ = {} ) VULKAN_HPP_NOEXCEPT : cornerSampledImage( cornerSampledImage_ ) @@ -52781,8 +54916,17 @@ namespace VULKAN_HPP_NAMESPACE static_assert( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); + template <> + struct CppType + { + using Type = PhysicalDeviceCornerSampledImageFeaturesNV; + }; + struct PhysicalDeviceCoverageReductionModeFeaturesNV { + static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = + StructureType::ePhysicalDeviceCoverageReductionModeFeaturesNV; + VULKAN_HPP_CONSTEXPR PhysicalDeviceCoverageReductionModeFeaturesNV( VULKAN_HPP_NAMESPACE::Bool32 coverageReductionMode_ = {} ) VULKAN_HPP_NOEXCEPT : coverageReductionMode( coverageReductionMode_ ) @@ -52859,8 +55003,17 @@ namespace VULKAN_HPP_NAMESPACE static_assert( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); + template <> + struct CppType + { + using Type = PhysicalDeviceCoverageReductionModeFeaturesNV; + }; + struct PhysicalDeviceDedicatedAllocationImageAliasingFeaturesNV { + static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = + StructureType::ePhysicalDeviceDedicatedAllocationImageAliasingFeaturesNV; + VULKAN_HPP_CONSTEXPR PhysicalDeviceDedicatedAllocationImageAliasingFeaturesNV( VULKAN_HPP_NAMESPACE::Bool32 dedicatedAllocationImageAliasing_ = {} ) VULKAN_HPP_NOEXCEPT : dedicatedAllocationImageAliasing( dedicatedAllocationImageAliasing_ ) @@ -52940,8 +55093,17 @@ namespace VULKAN_HPP_NAMESPACE static_assert( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); + template <> + struct CppType + { + using Type = PhysicalDeviceDedicatedAllocationImageAliasingFeaturesNV; + }; + struct PhysicalDeviceDepthClipEnableFeaturesEXT { + static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = + StructureType::ePhysicalDeviceDepthClipEnableFeaturesEXT; + VULKAN_HPP_CONSTEXPR PhysicalDeviceDepthClipEnableFeaturesEXT( VULKAN_HPP_NAMESPACE::Bool32 depthClipEnable_ = {} ) VULKAN_HPP_NOEXCEPT : depthClipEnable( depthClipEnable_ ) @@ -53018,8 +55180,17 @@ namespace VULKAN_HPP_NAMESPACE static_assert( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); + template <> + struct CppType + { + using Type = PhysicalDeviceDepthClipEnableFeaturesEXT; + }; + struct PhysicalDeviceDepthStencilResolveProperties { + static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = + StructureType::ePhysicalDeviceDepthStencilResolveProperties; + VULKAN_HPP_CONSTEXPR PhysicalDeviceDepthStencilResolveProperties( VULKAN_HPP_NAMESPACE::ResolveModeFlags supportedDepthResolveModes_ = {}, VULKAN_HPP_NAMESPACE::ResolveModeFlags supportedStencilResolveModes_ = {}, @@ -53096,8 +55267,17 @@ namespace VULKAN_HPP_NAMESPACE static_assert( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); + template <> + struct CppType + { + using Type = PhysicalDeviceDepthStencilResolveProperties; + }; + struct PhysicalDeviceDescriptorIndexingFeatures { + static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = + StructureType::ePhysicalDeviceDescriptorIndexingFeatures; + VULKAN_HPP_CONSTEXPR PhysicalDeviceDescriptorIndexingFeatures( VULKAN_HPP_NAMESPACE::Bool32 shaderInputAttachmentArrayDynamicIndexing_ = {}, VULKAN_HPP_NAMESPACE::Bool32 shaderUniformTexelBufferArrayDynamicIndexing_ = {}, @@ -53388,8 +55568,17 @@ namespace VULKAN_HPP_NAMESPACE static_assert( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); + template <> + struct CppType + { + using Type = PhysicalDeviceDescriptorIndexingFeatures; + }; + struct PhysicalDeviceDescriptorIndexingProperties { + static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = + StructureType::ePhysicalDeviceDescriptorIndexingProperties; + VULKAN_HPP_CONSTEXPR PhysicalDeviceDescriptorIndexingProperties( uint32_t maxUpdateAfterBindDescriptorsInAllPools_ = {}, VULKAN_HPP_NAMESPACE::Bool32 shaderUniformBufferArrayNonUniformIndexingNative_ = {}, @@ -53554,8 +55743,17 @@ namespace VULKAN_HPP_NAMESPACE static_assert( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); + template <> + struct CppType + { + using Type = PhysicalDeviceDescriptorIndexingProperties; + }; + struct PhysicalDeviceDeviceGeneratedCommandsFeaturesNV { + static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = + StructureType::ePhysicalDeviceDeviceGeneratedCommandsFeaturesNV; + VULKAN_HPP_CONSTEXPR PhysicalDeviceDeviceGeneratedCommandsFeaturesNV( VULKAN_HPP_NAMESPACE::Bool32 deviceGeneratedCommands_ = {} ) VULKAN_HPP_NOEXCEPT : deviceGeneratedCommands( deviceGeneratedCommands_ ) @@ -53633,8 +55831,17 @@ namespace VULKAN_HPP_NAMESPACE static_assert( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); + template <> + struct CppType + { + using Type = PhysicalDeviceDeviceGeneratedCommandsFeaturesNV; + }; + struct PhysicalDeviceDeviceGeneratedCommandsPropertiesNV { + static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = + StructureType::ePhysicalDeviceDeviceGeneratedCommandsPropertiesNV; + VULKAN_HPP_CONSTEXPR PhysicalDeviceDeviceGeneratedCommandsPropertiesNV( uint32_t maxGraphicsShaderGroupCount_ = {}, uint32_t maxIndirectSequenceCount_ = {}, @@ -53732,8 +55939,17 @@ namespace VULKAN_HPP_NAMESPACE static_assert( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); + template <> + struct CppType + { + using Type = PhysicalDeviceDeviceGeneratedCommandsPropertiesNV; + }; + struct PhysicalDeviceDiagnosticsConfigFeaturesNV { + static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = + StructureType::ePhysicalDeviceDiagnosticsConfigFeaturesNV; + VULKAN_HPP_CONSTEXPR PhysicalDeviceDiagnosticsConfigFeaturesNV( VULKAN_HPP_NAMESPACE::Bool32 diagnosticsConfig_ = {} ) VULKAN_HPP_NOEXCEPT : diagnosticsConfig( diagnosticsConfig_ ) @@ -53810,8 +56026,17 @@ namespace VULKAN_HPP_NAMESPACE static_assert( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); + template <> + struct CppType + { + using Type = PhysicalDeviceDiagnosticsConfigFeaturesNV; + }; + struct PhysicalDeviceDiscardRectanglePropertiesEXT { + static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = + StructureType::ePhysicalDeviceDiscardRectanglePropertiesEXT; + VULKAN_HPP_CONSTEXPR PhysicalDeviceDiscardRectanglePropertiesEXT( uint32_t maxDiscardRectangles_ = {} ) VULKAN_HPP_NOEXCEPT : maxDiscardRectangles( maxDiscardRectangles_ ) @@ -53875,8 +56100,16 @@ namespace VULKAN_HPP_NAMESPACE static_assert( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); + template <> + struct CppType + { + using Type = PhysicalDeviceDiscardRectanglePropertiesEXT; + }; + struct PhysicalDeviceDriverProperties { + static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::ePhysicalDeviceDriverProperties; + VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceDriverProperties( VULKAN_HPP_NAMESPACE::DriverId driverID_ = VULKAN_HPP_NAMESPACE::DriverId::eAmdProprietary, std::array const & driverName_ = {}, @@ -53946,8 +56179,17 @@ namespace VULKAN_HPP_NAMESPACE static_assert( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); + template <> + struct CppType + { + using Type = PhysicalDeviceDriverProperties; + }; + struct PhysicalDeviceExclusiveScissorFeaturesNV { + static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = + StructureType::ePhysicalDeviceExclusiveScissorFeaturesNV; + VULKAN_HPP_CONSTEXPR PhysicalDeviceExclusiveScissorFeaturesNV( VULKAN_HPP_NAMESPACE::Bool32 exclusiveScissor_ = {} ) VULKAN_HPP_NOEXCEPT : exclusiveScissor( exclusiveScissor_ ) {} @@ -54023,8 +56265,16 @@ namespace VULKAN_HPP_NAMESPACE static_assert( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); + template <> + struct CppType + { + using Type = PhysicalDeviceExclusiveScissorFeaturesNV; + }; + struct PhysicalDeviceExternalBufferInfo { + static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::ePhysicalDeviceExternalBufferInfo; + VULKAN_HPP_CONSTEXPR PhysicalDeviceExternalBufferInfo( VULKAN_HPP_NAMESPACE::BufferCreateFlags flags_ = {}, VULKAN_HPP_NAMESPACE::BufferUsageFlags usage_ = {}, @@ -54117,8 +56367,16 @@ namespace VULKAN_HPP_NAMESPACE static_assert( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); + template <> + struct CppType + { + using Type = PhysicalDeviceExternalBufferInfo; + }; + struct PhysicalDeviceExternalFenceInfo { + static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::ePhysicalDeviceExternalFenceInfo; + VULKAN_HPP_CONSTEXPR PhysicalDeviceExternalFenceInfo( VULKAN_HPP_NAMESPACE::ExternalFenceHandleTypeFlagBits handleType_ = VULKAN_HPP_NAMESPACE::ExternalFenceHandleTypeFlagBits::eOpaqueFd ) VULKAN_HPP_NOEXCEPT @@ -54192,8 +56450,17 @@ namespace VULKAN_HPP_NAMESPACE static_assert( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); + template <> + struct CppType + { + using Type = PhysicalDeviceExternalFenceInfo; + }; + struct PhysicalDeviceExternalImageFormatInfo { + static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = + StructureType::ePhysicalDeviceExternalImageFormatInfo; + VULKAN_HPP_CONSTEXPR PhysicalDeviceExternalImageFormatInfo( VULKAN_HPP_NAMESPACE::ExternalMemoryHandleTypeFlagBits handleType_ = VULKAN_HPP_NAMESPACE::ExternalMemoryHandleTypeFlagBits::eOpaqueFd ) VULKAN_HPP_NOEXCEPT @@ -54270,8 +56537,17 @@ namespace VULKAN_HPP_NAMESPACE static_assert( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); + template <> + struct CppType + { + using Type = PhysicalDeviceExternalImageFormatInfo; + }; + struct PhysicalDeviceExternalMemoryHostPropertiesEXT { + static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = + StructureType::ePhysicalDeviceExternalMemoryHostPropertiesEXT; + VULKAN_HPP_CONSTEXPR PhysicalDeviceExternalMemoryHostPropertiesEXT( VULKAN_HPP_NAMESPACE::DeviceSize minImportedHostPointerAlignment_ = {} ) VULKAN_HPP_NOEXCEPT : minImportedHostPointerAlignment( minImportedHostPointerAlignment_ ) @@ -54336,8 +56612,17 @@ namespace VULKAN_HPP_NAMESPACE static_assert( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); + template <> + struct CppType + { + using Type = PhysicalDeviceExternalMemoryHostPropertiesEXT; + }; + struct PhysicalDeviceExternalSemaphoreInfo { + static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = + StructureType::ePhysicalDeviceExternalSemaphoreInfo; + VULKAN_HPP_CONSTEXPR PhysicalDeviceExternalSemaphoreInfo( VULKAN_HPP_NAMESPACE::ExternalSemaphoreHandleTypeFlagBits handleType_ = VULKAN_HPP_NAMESPACE::ExternalSemaphoreHandleTypeFlagBits::eOpaqueFd ) VULKAN_HPP_NOEXCEPT @@ -54413,8 +56698,16 @@ namespace VULKAN_HPP_NAMESPACE static_assert( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); + template <> + struct CppType + { + using Type = PhysicalDeviceExternalSemaphoreInfo; + }; + struct PhysicalDeviceFeatures2 { + static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::ePhysicalDeviceFeatures2; + VULKAN_HPP_CONSTEXPR PhysicalDeviceFeatures2( VULKAN_HPP_NAMESPACE::PhysicalDeviceFeatures features_ = {} ) VULKAN_HPP_NOEXCEPT : features( features_ ) @@ -54483,8 +56776,17 @@ namespace VULKAN_HPP_NAMESPACE "struct and wrapper have different size!" ); static_assert( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); + template <> + struct CppType + { + using Type = PhysicalDeviceFeatures2; + }; + struct PhysicalDeviceFloatControlsProperties { + static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = + StructureType::ePhysicalDeviceFloatControlsProperties; + VULKAN_HPP_CONSTEXPR PhysicalDeviceFloatControlsProperties( VULKAN_HPP_NAMESPACE::ShaderFloatControlsIndependence denormBehaviorIndependence_ = VULKAN_HPP_NAMESPACE::ShaderFloatControlsIndependence::e32BitOnly, @@ -54615,8 +56917,17 @@ namespace VULKAN_HPP_NAMESPACE static_assert( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); + template <> + struct CppType + { + using Type = PhysicalDeviceFloatControlsProperties; + }; + struct PhysicalDeviceFragmentDensityMapFeaturesEXT { + static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = + StructureType::ePhysicalDeviceFragmentDensityMapFeaturesEXT; + VULKAN_HPP_CONSTEXPR PhysicalDeviceFragmentDensityMapFeaturesEXT( VULKAN_HPP_NAMESPACE::Bool32 fragmentDensityMap_ = {}, VULKAN_HPP_NAMESPACE::Bool32 fragmentDensityMapDynamic_ = {}, @@ -54688,8 +56999,17 @@ namespace VULKAN_HPP_NAMESPACE static_assert( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); + template <> + struct CppType + { + using Type = PhysicalDeviceFragmentDensityMapFeaturesEXT; + }; + struct PhysicalDeviceFragmentDensityMapPropertiesEXT { + static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = + StructureType::ePhysicalDeviceFragmentDensityMapPropertiesEXT; + VULKAN_HPP_CONSTEXPR PhysicalDeviceFragmentDensityMapPropertiesEXT( VULKAN_HPP_NAMESPACE::Extent2D minFragmentDensityTexelSize_ = {}, VULKAN_HPP_NAMESPACE::Extent2D maxFragmentDensityTexelSize_ = {}, @@ -54762,8 +57082,17 @@ namespace VULKAN_HPP_NAMESPACE static_assert( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); + template <> + struct CppType + { + using Type = PhysicalDeviceFragmentDensityMapPropertiesEXT; + }; + struct PhysicalDeviceFragmentShaderBarycentricFeaturesNV { + static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = + StructureType::ePhysicalDeviceFragmentShaderBarycentricFeaturesNV; + VULKAN_HPP_CONSTEXPR PhysicalDeviceFragmentShaderBarycentricFeaturesNV( VULKAN_HPP_NAMESPACE::Bool32 fragmentShaderBarycentric_ = {} ) VULKAN_HPP_NOEXCEPT : fragmentShaderBarycentric( fragmentShaderBarycentric_ ) @@ -54842,8 +57171,17 @@ namespace VULKAN_HPP_NAMESPACE static_assert( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); + template <> + struct CppType + { + using Type = PhysicalDeviceFragmentShaderBarycentricFeaturesNV; + }; + struct PhysicalDeviceFragmentShaderInterlockFeaturesEXT { + static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = + StructureType::ePhysicalDeviceFragmentShaderInterlockFeaturesEXT; + VULKAN_HPP_CONSTEXPR PhysicalDeviceFragmentShaderInterlockFeaturesEXT( VULKAN_HPP_NAMESPACE::Bool32 fragmentShaderSampleInterlock_ = {}, VULKAN_HPP_NAMESPACE::Bool32 fragmentShaderPixelInterlock_ = {}, @@ -54943,8 +57281,16 @@ namespace VULKAN_HPP_NAMESPACE static_assert( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); + template <> + struct CppType + { + using Type = PhysicalDeviceFragmentShaderInterlockFeaturesEXT; + }; + struct PhysicalDeviceGroupProperties { + static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::ePhysicalDeviceGroupProperties; + VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceGroupProperties( uint32_t physicalDeviceCount_ = {}, std::array const & physicalDevices_ = {}, @@ -55011,8 +57357,17 @@ namespace VULKAN_HPP_NAMESPACE static_assert( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); + template <> + struct CppType + { + using Type = PhysicalDeviceGroupProperties; + }; + struct PhysicalDeviceHostQueryResetFeatures { + static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = + StructureType::ePhysicalDeviceHostQueryResetFeatures; + VULKAN_HPP_CONSTEXPR PhysicalDeviceHostQueryResetFeatures( VULKAN_HPP_NAMESPACE::Bool32 hostQueryReset_ = {} ) VULKAN_HPP_NOEXCEPT : hostQueryReset( hostQueryReset_ ) @@ -55087,8 +57442,16 @@ namespace VULKAN_HPP_NAMESPACE static_assert( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); + template <> + struct CppType + { + using Type = PhysicalDeviceHostQueryResetFeatures; + }; + struct PhysicalDeviceIDProperties { + static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::ePhysicalDeviceIdProperties; + VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceIDProperties( std::array const & deviceUUID_ = {}, std::array const & driverUUID_ = {}, @@ -55160,8 +57523,17 @@ namespace VULKAN_HPP_NAMESPACE static_assert( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); + template <> + struct CppType + { + using Type = PhysicalDeviceIDProperties; + }; + struct PhysicalDeviceImageDrmFormatModifierInfoEXT { + static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = + StructureType::ePhysicalDeviceImageDrmFormatModifierInfoEXT; + VULKAN_HPP_CONSTEXPR PhysicalDeviceImageDrmFormatModifierInfoEXT( uint64_t drmFormatModifier_ = {}, VULKAN_HPP_NAMESPACE::SharingMode sharingMode_ = VULKAN_HPP_NAMESPACE::SharingMode::eExclusive, @@ -55270,8 +57642,16 @@ namespace VULKAN_HPP_NAMESPACE static_assert( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); + template <> + struct CppType + { + using Type = PhysicalDeviceImageDrmFormatModifierInfoEXT; + }; + struct PhysicalDeviceImageFormatInfo2 { + static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::ePhysicalDeviceImageFormatInfo2; + VULKAN_HPP_CONSTEXPR PhysicalDeviceImageFormatInfo2( VULKAN_HPP_NAMESPACE::Format format_ = VULKAN_HPP_NAMESPACE::Format::eUndefined, VULKAN_HPP_NAMESPACE::ImageType type_ = VULKAN_HPP_NAMESPACE::ImageType::e1D, @@ -55379,8 +57759,17 @@ namespace VULKAN_HPP_NAMESPACE static_assert( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); + template <> + struct CppType + { + using Type = PhysicalDeviceImageFormatInfo2; + }; + struct PhysicalDeviceImageViewImageFormatInfoEXT { + static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = + StructureType::ePhysicalDeviceImageViewImageFormatInfoEXT; + VULKAN_HPP_CONSTEXPR PhysicalDeviceImageViewImageFormatInfoEXT( VULKAN_HPP_NAMESPACE::ImageViewType imageViewType_ = VULKAN_HPP_NAMESPACE::ImageViewType::e1D ) VULKAN_HPP_NOEXCEPT @@ -55458,8 +57847,17 @@ namespace VULKAN_HPP_NAMESPACE static_assert( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); + template <> + struct CppType + { + using Type = PhysicalDeviceImageViewImageFormatInfoEXT; + }; + struct PhysicalDeviceImagelessFramebufferFeatures { + static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = + StructureType::ePhysicalDeviceImagelessFramebufferFeatures; + VULKAN_HPP_CONSTEXPR PhysicalDeviceImagelessFramebufferFeatures( VULKAN_HPP_NAMESPACE::Bool32 imagelessFramebuffer_ = {} ) VULKAN_HPP_NOEXCEPT : imagelessFramebuffer( imagelessFramebuffer_ ) @@ -55536,8 +57934,17 @@ namespace VULKAN_HPP_NAMESPACE static_assert( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); + template <> + struct CppType + { + using Type = PhysicalDeviceImagelessFramebufferFeatures; + }; + struct PhysicalDeviceIndexTypeUint8FeaturesEXT { + static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = + StructureType::ePhysicalDeviceIndexTypeUint8FeaturesEXT; + VULKAN_HPP_CONSTEXPR PhysicalDeviceIndexTypeUint8FeaturesEXT( VULKAN_HPP_NAMESPACE::Bool32 indexTypeUint8_ = {} ) VULKAN_HPP_NOEXCEPT : indexTypeUint8( indexTypeUint8_ ) @@ -55613,8 +58020,17 @@ namespace VULKAN_HPP_NAMESPACE static_assert( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); + template <> + struct CppType + { + using Type = PhysicalDeviceIndexTypeUint8FeaturesEXT; + }; + struct PhysicalDeviceInlineUniformBlockFeaturesEXT { + static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = + StructureType::ePhysicalDeviceInlineUniformBlockFeaturesEXT; + VULKAN_HPP_CONSTEXPR PhysicalDeviceInlineUniformBlockFeaturesEXT( VULKAN_HPP_NAMESPACE::Bool32 inlineUniformBlock_ = {}, VULKAN_HPP_NAMESPACE::Bool32 descriptorBindingInlineUniformBlockUpdateAfterBind_ = {} ) VULKAN_HPP_NOEXCEPT @@ -55703,8 +58119,17 @@ namespace VULKAN_HPP_NAMESPACE static_assert( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); + template <> + struct CppType + { + using Type = PhysicalDeviceInlineUniformBlockFeaturesEXT; + }; + struct PhysicalDeviceInlineUniformBlockPropertiesEXT { + static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = + StructureType::ePhysicalDeviceInlineUniformBlockPropertiesEXT; + VULKAN_HPP_CONSTEXPR PhysicalDeviceInlineUniformBlockPropertiesEXT( uint32_t maxInlineUniformBlockSize_ = {}, uint32_t maxPerStageDescriptorInlineUniformBlocks_ = {}, @@ -55788,6 +58213,12 @@ namespace VULKAN_HPP_NAMESPACE static_assert( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); + template <> + struct CppType + { + using Type = PhysicalDeviceInlineUniformBlockPropertiesEXT; + }; + struct PhysicalDeviceLimits { VULKAN_HPP_CONSTEXPR_14 @@ -56252,6 +58683,9 @@ namespace VULKAN_HPP_NAMESPACE struct PhysicalDeviceLineRasterizationFeaturesEXT { + static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = + StructureType::ePhysicalDeviceLineRasterizationFeaturesEXT; + VULKAN_HPP_CONSTEXPR PhysicalDeviceLineRasterizationFeaturesEXT( VULKAN_HPP_NAMESPACE::Bool32 rectangularLines_ = {}, VULKAN_HPP_NAMESPACE::Bool32 bresenhamLines_ = {}, @@ -56382,8 +58816,17 @@ namespace VULKAN_HPP_NAMESPACE static_assert( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); + template <> + struct CppType + { + using Type = PhysicalDeviceLineRasterizationFeaturesEXT; + }; + struct PhysicalDeviceLineRasterizationPropertiesEXT { + static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = + StructureType::ePhysicalDeviceLineRasterizationPropertiesEXT; + VULKAN_HPP_CONSTEXPR PhysicalDeviceLineRasterizationPropertiesEXT( uint32_t lineSubPixelPrecisionBits_ = {} ) VULKAN_HPP_NOEXCEPT : lineSubPixelPrecisionBits( lineSubPixelPrecisionBits_ ) @@ -56448,8 +58891,17 @@ namespace VULKAN_HPP_NAMESPACE static_assert( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); + template <> + struct CppType + { + using Type = PhysicalDeviceLineRasterizationPropertiesEXT; + }; + struct PhysicalDeviceMaintenance3Properties { + static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = + StructureType::ePhysicalDeviceMaintenance3Properties; + VULKAN_HPP_CONSTEXPR PhysicalDeviceMaintenance3Properties( uint32_t maxPerSetDescriptors_ = {}, VULKAN_HPP_NAMESPACE::DeviceSize maxMemoryAllocationSize_ = {} ) VULKAN_HPP_NOEXCEPT @@ -56515,8 +58967,17 @@ namespace VULKAN_HPP_NAMESPACE static_assert( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); + template <> + struct CppType + { + using Type = PhysicalDeviceMaintenance3Properties; + }; + struct PhysicalDeviceMemoryBudgetPropertiesEXT { + static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = + StructureType::ePhysicalDeviceMemoryBudgetPropertiesEXT; + VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceMemoryBudgetPropertiesEXT( std::array const & heapBudget_ = {}, std::array const & heapUsage_ = {} ) VULKAN_HPP_NOEXCEPT @@ -56583,8 +59044,17 @@ namespace VULKAN_HPP_NAMESPACE static_assert( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); + template <> + struct CppType + { + using Type = PhysicalDeviceMemoryBudgetPropertiesEXT; + }; + struct PhysicalDeviceMemoryPriorityFeaturesEXT { + static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = + StructureType::ePhysicalDeviceMemoryPriorityFeaturesEXT; + VULKAN_HPP_CONSTEXPR PhysicalDeviceMemoryPriorityFeaturesEXT( VULKAN_HPP_NAMESPACE::Bool32 memoryPriority_ = {} ) VULKAN_HPP_NOEXCEPT : memoryPriority( memoryPriority_ ) @@ -56660,6 +59130,12 @@ namespace VULKAN_HPP_NAMESPACE static_assert( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); + template <> + struct CppType + { + using Type = PhysicalDeviceMemoryPriorityFeaturesEXT; + }; + struct PhysicalDeviceMemoryProperties { VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceMemoryProperties( @@ -56722,6 +59198,8 @@ namespace VULKAN_HPP_NAMESPACE struct PhysicalDeviceMemoryProperties2 { + static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::ePhysicalDeviceMemoryProperties2; + VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceMemoryProperties2( VULKAN_HPP_NAMESPACE::PhysicalDeviceMemoryProperties memoryProperties_ = {} ) VULKAN_HPP_NOEXCEPT : memoryProperties( memoryProperties_ ) @@ -56780,8 +59258,17 @@ namespace VULKAN_HPP_NAMESPACE static_assert( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); + template <> + struct CppType + { + using Type = PhysicalDeviceMemoryProperties2; + }; + struct PhysicalDeviceMeshShaderFeaturesNV { + static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = + StructureType::ePhysicalDeviceMeshShaderFeaturesNV; + VULKAN_HPP_CONSTEXPR PhysicalDeviceMeshShaderFeaturesNV( VULKAN_HPP_NAMESPACE::Bool32 taskShader_ = {}, VULKAN_HPP_NAMESPACE::Bool32 meshShader_ = {} ) VULKAN_HPP_NOEXCEPT @@ -56863,8 +59350,17 @@ namespace VULKAN_HPP_NAMESPACE static_assert( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); + template <> + struct CppType + { + using Type = PhysicalDeviceMeshShaderFeaturesNV; + }; + struct PhysicalDeviceMeshShaderPropertiesNV { + static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = + StructureType::ePhysicalDeviceMeshShaderPropertiesNV; + VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceMeshShaderPropertiesNV( uint32_t maxDrawMeshTasksCount_ = {}, uint32_t maxTaskWorkGroupInvocations_ = {}, @@ -56975,8 +59471,16 @@ namespace VULKAN_HPP_NAMESPACE static_assert( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); + template <> + struct CppType + { + using Type = PhysicalDeviceMeshShaderPropertiesNV; + }; + struct PhysicalDeviceMultiviewFeatures { + static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::ePhysicalDeviceMultiviewFeatures; + VULKAN_HPP_CONSTEXPR PhysicalDeviceMultiviewFeatures( VULKAN_HPP_NAMESPACE::Bool32 multiview_ = {}, VULKAN_HPP_NAMESPACE::Bool32 multiviewGeometryShader_ = {}, @@ -57069,8 +59573,17 @@ namespace VULKAN_HPP_NAMESPACE static_assert( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); + template <> + struct CppType + { + using Type = PhysicalDeviceMultiviewFeatures; + }; + struct PhysicalDeviceMultiviewPerViewAttributesPropertiesNVX { + static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = + StructureType::ePhysicalDeviceMultiviewPerViewAttributesPropertiesNVX; + VULKAN_HPP_CONSTEXPR PhysicalDeviceMultiviewPerViewAttributesPropertiesNVX( VULKAN_HPP_NAMESPACE::Bool32 perViewPositionAllComponents_ = {} ) VULKAN_HPP_NOEXCEPT : perViewPositionAllComponents( perViewPositionAllComponents_ ) @@ -57137,8 +59650,17 @@ namespace VULKAN_HPP_NAMESPACE static_assert( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); + template <> + struct CppType + { + using Type = PhysicalDeviceMultiviewPerViewAttributesPropertiesNVX; + }; + struct PhysicalDeviceMultiviewProperties { + static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = + StructureType::ePhysicalDeviceMultiviewProperties; + VULKAN_HPP_CONSTEXPR PhysicalDeviceMultiviewProperties( uint32_t maxMultiviewViewCount_ = {}, uint32_t maxMultiviewInstanceIndex_ = {} ) VULKAN_HPP_NOEXCEPT @@ -57202,8 +59724,17 @@ namespace VULKAN_HPP_NAMESPACE static_assert( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); + template <> + struct CppType + { + using Type = PhysicalDeviceMultiviewProperties; + }; + struct PhysicalDevicePCIBusInfoPropertiesEXT { + static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = + StructureType::ePhysicalDevicePciBusInfoPropertiesEXT; + VULKAN_HPP_CONSTEXPR PhysicalDevicePCIBusInfoPropertiesEXT( uint32_t pciDomain_ = {}, uint32_t pciBus_ = {}, uint32_t pciDevice_ = {}, @@ -57274,8 +59805,17 @@ namespace VULKAN_HPP_NAMESPACE static_assert( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); + template <> + struct CppType + { + using Type = PhysicalDevicePCIBusInfoPropertiesEXT; + }; + struct PhysicalDevicePerformanceQueryFeaturesKHR { + static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = + StructureType::ePhysicalDevicePerformanceQueryFeaturesKHR; + VULKAN_HPP_CONSTEXPR PhysicalDevicePerformanceQueryFeaturesKHR( VULKAN_HPP_NAMESPACE::Bool32 performanceCounterQueryPools_ = {}, VULKAN_HPP_NAMESPACE::Bool32 performanceCounterMultipleQueryPools_ = {} ) VULKAN_HPP_NOEXCEPT @@ -57364,8 +59904,17 @@ namespace VULKAN_HPP_NAMESPACE static_assert( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); + template <> + struct CppType + { + using Type = PhysicalDevicePerformanceQueryFeaturesKHR; + }; + struct PhysicalDevicePerformanceQueryPropertiesKHR { + static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = + StructureType::ePhysicalDevicePerformanceQueryPropertiesKHR; + VULKAN_HPP_CONSTEXPR PhysicalDevicePerformanceQueryPropertiesKHR( VULKAN_HPP_NAMESPACE::Bool32 allowCommandBufferQueryCopies_ = {} ) VULKAN_HPP_NOEXCEPT : allowCommandBufferQueryCopies( allowCommandBufferQueryCopies_ ) @@ -57430,8 +59979,17 @@ namespace VULKAN_HPP_NAMESPACE static_assert( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); + template <> + struct CppType + { + using Type = PhysicalDevicePerformanceQueryPropertiesKHR; + }; + struct PhysicalDevicePipelineCreationCacheControlFeaturesEXT { + static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = + StructureType::ePhysicalDevicePipelineCreationCacheControlFeaturesEXT; + VULKAN_HPP_CONSTEXPR PhysicalDevicePipelineCreationCacheControlFeaturesEXT( VULKAN_HPP_NAMESPACE::Bool32 pipelineCreationCacheControl_ = {} ) VULKAN_HPP_NOEXCEPT : pipelineCreationCacheControl( pipelineCreationCacheControl_ ) @@ -57511,8 +60069,17 @@ namespace VULKAN_HPP_NAMESPACE static_assert( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); + template <> + struct CppType + { + using Type = PhysicalDevicePipelineCreationCacheControlFeaturesEXT; + }; + struct PhysicalDevicePipelineExecutablePropertiesFeaturesKHR { + static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = + StructureType::ePhysicalDevicePipelineExecutablePropertiesFeaturesKHR; + VULKAN_HPP_CONSTEXPR PhysicalDevicePipelineExecutablePropertiesFeaturesKHR( VULKAN_HPP_NAMESPACE::Bool32 pipelineExecutableInfo_ = {} ) VULKAN_HPP_NOEXCEPT : pipelineExecutableInfo( pipelineExecutableInfo_ ) @@ -57592,8 +60159,17 @@ namespace VULKAN_HPP_NAMESPACE static_assert( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); + template <> + struct CppType + { + using Type = PhysicalDevicePipelineExecutablePropertiesFeaturesKHR; + }; + struct PhysicalDevicePointClippingProperties { + static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = + StructureType::ePhysicalDevicePointClippingProperties; + VULKAN_HPP_CONSTEXPR PhysicalDevicePointClippingProperties( VULKAN_HPP_NAMESPACE::PointClippingBehavior pointClippingBehavior_ = VULKAN_HPP_NAMESPACE::PointClippingBehavior::eAllClipPlanes ) VULKAN_HPP_NOEXCEPT @@ -57657,6 +60233,12 @@ namespace VULKAN_HPP_NAMESPACE static_assert( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); + template <> + struct CppType + { + using Type = PhysicalDevicePointClippingProperties; + }; + struct PhysicalDeviceSparseProperties { VULKAN_HPP_CONSTEXPR PhysicalDeviceSparseProperties( @@ -57801,6 +60383,8 @@ namespace VULKAN_HPP_NAMESPACE struct PhysicalDeviceProperties2 { + static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::ePhysicalDeviceProperties2; + VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceProperties2( VULKAN_HPP_NAMESPACE::PhysicalDeviceProperties properties_ = {} ) VULKAN_HPP_NOEXCEPT : properties( properties_ ) @@ -57857,8 +60441,17 @@ namespace VULKAN_HPP_NAMESPACE static_assert( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); + template <> + struct CppType + { + using Type = PhysicalDeviceProperties2; + }; + struct PhysicalDeviceProtectedMemoryFeatures { + static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = + StructureType::ePhysicalDeviceProtectedMemoryFeatures; + VULKAN_HPP_CONSTEXPR PhysicalDeviceProtectedMemoryFeatures( VULKAN_HPP_NAMESPACE::Bool32 protectedMemory_ = {} ) VULKAN_HPP_NOEXCEPT : protectedMemory( protectedMemory_ ) @@ -57933,8 +60526,17 @@ namespace VULKAN_HPP_NAMESPACE static_assert( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); + template <> + struct CppType + { + using Type = PhysicalDeviceProtectedMemoryFeatures; + }; + struct PhysicalDeviceProtectedMemoryProperties { + static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = + StructureType::ePhysicalDeviceProtectedMemoryProperties; + VULKAN_HPP_CONSTEXPR PhysicalDeviceProtectedMemoryProperties( VULKAN_HPP_NAMESPACE::Bool32 protectedNoFault_ = {} ) VULKAN_HPP_NOEXCEPT : protectedNoFault( protectedNoFault_ ) @@ -57997,8 +60599,17 @@ namespace VULKAN_HPP_NAMESPACE static_assert( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); + template <> + struct CppType + { + using Type = PhysicalDeviceProtectedMemoryProperties; + }; + struct PhysicalDevicePushDescriptorPropertiesKHR { + static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = + StructureType::ePhysicalDevicePushDescriptorPropertiesKHR; + VULKAN_HPP_CONSTEXPR PhysicalDevicePushDescriptorPropertiesKHR( uint32_t maxPushDescriptors_ = {} ) VULKAN_HPP_NOEXCEPT : maxPushDescriptors( maxPushDescriptors_ ) @@ -58062,9 +60673,18 @@ namespace VULKAN_HPP_NAMESPACE static_assert( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); + template <> + struct CppType + { + using Type = PhysicalDevicePushDescriptorPropertiesKHR; + }; + #ifdef VK_ENABLE_BETA_EXTENSIONS struct PhysicalDeviceRayTracingFeaturesKHR { + static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = + StructureType::ePhysicalDeviceRayTracingFeaturesKHR; + VULKAN_HPP_CONSTEXPR PhysicalDeviceRayTracingFeaturesKHR( VULKAN_HPP_NAMESPACE::Bool32 rayTracing_ = {}, VULKAN_HPP_NAMESPACE::Bool32 rayTracingShaderGroupHandleCaptureReplay_ = {}, @@ -58222,11 +60842,20 @@ namespace VULKAN_HPP_NAMESPACE "struct and wrapper have different size!" ); static_assert( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); + + template <> + struct CppType + { + using Type = PhysicalDeviceRayTracingFeaturesKHR; + }; #endif /*VK_ENABLE_BETA_EXTENSIONS*/ #ifdef VK_ENABLE_BETA_EXTENSIONS struct PhysicalDeviceRayTracingPropertiesKHR { + static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = + StructureType::ePhysicalDeviceRayTracingPropertiesKHR; + VULKAN_HPP_CONSTEXPR PhysicalDeviceRayTracingPropertiesKHR( uint32_t shaderGroupHandleSize_ = {}, uint32_t maxRecursionDepth_ = {}, @@ -58318,10 +60947,19 @@ namespace VULKAN_HPP_NAMESPACE "struct and wrapper have different size!" ); static_assert( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); + + template <> + struct CppType + { + using Type = PhysicalDeviceRayTracingPropertiesKHR; + }; #endif /*VK_ENABLE_BETA_EXTENSIONS*/ struct PhysicalDeviceRayTracingPropertiesNV { + static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = + StructureType::ePhysicalDeviceRayTracingPropertiesNV; + VULKAN_HPP_CONSTEXPR PhysicalDeviceRayTracingPropertiesNV( uint32_t shaderGroupHandleSize_ = {}, uint32_t maxRecursionDepth_ = {}, @@ -58410,8 +61048,17 @@ namespace VULKAN_HPP_NAMESPACE static_assert( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); + template <> + struct CppType + { + using Type = PhysicalDeviceRayTracingPropertiesNV; + }; + struct PhysicalDeviceRepresentativeFragmentTestFeaturesNV { + static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = + StructureType::ePhysicalDeviceRepresentativeFragmentTestFeaturesNV; + VULKAN_HPP_CONSTEXPR PhysicalDeviceRepresentativeFragmentTestFeaturesNV( VULKAN_HPP_NAMESPACE::Bool32 representativeFragmentTest_ = {} ) VULKAN_HPP_NOEXCEPT : representativeFragmentTest( representativeFragmentTest_ ) @@ -58491,8 +61138,17 @@ namespace VULKAN_HPP_NAMESPACE static_assert( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); + template <> + struct CppType + { + using Type = PhysicalDeviceRepresentativeFragmentTestFeaturesNV; + }; + struct PhysicalDeviceSampleLocationsPropertiesEXT { + static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = + StructureType::ePhysicalDeviceSampleLocationsPropertiesEXT; + VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceSampleLocationsPropertiesEXT( VULKAN_HPP_NAMESPACE::SampleCountFlags sampleLocationSampleCounts_ = {}, VULKAN_HPP_NAMESPACE::Extent2D maxSampleLocationGridSize_ = {}, @@ -58573,8 +61229,17 @@ namespace VULKAN_HPP_NAMESPACE static_assert( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); + template <> + struct CppType + { + using Type = PhysicalDeviceSampleLocationsPropertiesEXT; + }; + struct PhysicalDeviceSamplerFilterMinmaxProperties { + static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = + StructureType::ePhysicalDeviceSamplerFilterMinmaxProperties; + VULKAN_HPP_CONSTEXPR PhysicalDeviceSamplerFilterMinmaxProperties( VULKAN_HPP_NAMESPACE::Bool32 filterMinmaxSingleComponentFormats_ = {}, VULKAN_HPP_NAMESPACE::Bool32 filterMinmaxImageComponentMapping_ = {} ) VULKAN_HPP_NOEXCEPT @@ -58643,8 +61308,17 @@ namespace VULKAN_HPP_NAMESPACE static_assert( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); + template <> + struct CppType + { + using Type = PhysicalDeviceSamplerFilterMinmaxProperties; + }; + struct PhysicalDeviceSamplerYcbcrConversionFeatures { + static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = + StructureType::ePhysicalDeviceSamplerYcbcrConversionFeatures; + VULKAN_HPP_CONSTEXPR PhysicalDeviceSamplerYcbcrConversionFeatures( VULKAN_HPP_NAMESPACE::Bool32 samplerYcbcrConversion_ = {} ) VULKAN_HPP_NOEXCEPT : samplerYcbcrConversion( samplerYcbcrConversion_ ) @@ -58722,8 +61396,17 @@ namespace VULKAN_HPP_NAMESPACE static_assert( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); + template <> + struct CppType + { + using Type = PhysicalDeviceSamplerYcbcrConversionFeatures; + }; + struct PhysicalDeviceScalarBlockLayoutFeatures { + static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = + StructureType::ePhysicalDeviceScalarBlockLayoutFeatures; + VULKAN_HPP_CONSTEXPR PhysicalDeviceScalarBlockLayoutFeatures( VULKAN_HPP_NAMESPACE::Bool32 scalarBlockLayout_ = {} ) VULKAN_HPP_NOEXCEPT : scalarBlockLayout( scalarBlockLayout_ ) {} @@ -58798,8 +61481,17 @@ namespace VULKAN_HPP_NAMESPACE static_assert( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); + template <> + struct CppType + { + using Type = PhysicalDeviceScalarBlockLayoutFeatures; + }; + struct PhysicalDeviceSeparateDepthStencilLayoutsFeatures { + static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = + StructureType::ePhysicalDeviceSeparateDepthStencilLayoutsFeatures; + VULKAN_HPP_CONSTEXPR PhysicalDeviceSeparateDepthStencilLayoutsFeatures( VULKAN_HPP_NAMESPACE::Bool32 separateDepthStencilLayouts_ = {} ) VULKAN_HPP_NOEXCEPT : separateDepthStencilLayouts( separateDepthStencilLayouts_ ) @@ -58878,8 +61570,17 @@ namespace VULKAN_HPP_NAMESPACE static_assert( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); + template <> + struct CppType + { + using Type = PhysicalDeviceSeparateDepthStencilLayoutsFeatures; + }; + struct PhysicalDeviceShaderAtomicInt64Features { + static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = + StructureType::ePhysicalDeviceShaderAtomicInt64Features; + VULKAN_HPP_CONSTEXPR PhysicalDeviceShaderAtomicInt64Features( VULKAN_HPP_NAMESPACE::Bool32 shaderBufferInt64Atomics_ = {}, VULKAN_HPP_NAMESPACE::Bool32 shaderSharedInt64Atomics_ = {} ) VULKAN_HPP_NOEXCEPT @@ -58967,8 +61668,17 @@ namespace VULKAN_HPP_NAMESPACE static_assert( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); + template <> + struct CppType + { + using Type = PhysicalDeviceShaderAtomicInt64Features; + }; + struct PhysicalDeviceShaderClockFeaturesKHR { + static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = + StructureType::ePhysicalDeviceShaderClockFeaturesKHR; + VULKAN_HPP_CONSTEXPR PhysicalDeviceShaderClockFeaturesKHR( VULKAN_HPP_NAMESPACE::Bool32 shaderSubgroupClock_ = {}, VULKAN_HPP_NAMESPACE::Bool32 shaderDeviceClock_ = {} ) VULKAN_HPP_NOEXCEPT @@ -59054,8 +61764,17 @@ namespace VULKAN_HPP_NAMESPACE static_assert( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); + template <> + struct CppType + { + using Type = PhysicalDeviceShaderClockFeaturesKHR; + }; + struct PhysicalDeviceShaderCoreProperties2AMD { + static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = + StructureType::ePhysicalDeviceShaderCoreProperties2AMD; + VULKAN_HPP_CONSTEXPR PhysicalDeviceShaderCoreProperties2AMD( VULKAN_HPP_NAMESPACE::ShaderCorePropertiesFlagsAMD shaderCoreFeatures_ = {}, uint32_t activeComputeUnitCount_ = {} ) VULKAN_HPP_NOEXCEPT @@ -59121,8 +61840,17 @@ namespace VULKAN_HPP_NAMESPACE static_assert( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); + template <> + struct CppType + { + using Type = PhysicalDeviceShaderCoreProperties2AMD; + }; + struct PhysicalDeviceShaderCorePropertiesAMD { + static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = + StructureType::ePhysicalDeviceShaderCorePropertiesAMD; + VULKAN_HPP_CONSTEXPR PhysicalDeviceShaderCorePropertiesAMD( uint32_t shaderEngineCount_ = {}, uint32_t shaderArraysPerEngineCount_ = {}, @@ -59231,8 +61959,17 @@ namespace VULKAN_HPP_NAMESPACE static_assert( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); + template <> + struct CppType + { + using Type = PhysicalDeviceShaderCorePropertiesAMD; + }; + struct PhysicalDeviceShaderDemoteToHelperInvocationFeaturesEXT { + static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = + StructureType::ePhysicalDeviceShaderDemoteToHelperInvocationFeaturesEXT; + VULKAN_HPP_CONSTEXPR PhysicalDeviceShaderDemoteToHelperInvocationFeaturesEXT( VULKAN_HPP_NAMESPACE::Bool32 shaderDemoteToHelperInvocation_ = {} ) VULKAN_HPP_NOEXCEPT : shaderDemoteToHelperInvocation( shaderDemoteToHelperInvocation_ ) @@ -59312,8 +62049,17 @@ namespace VULKAN_HPP_NAMESPACE static_assert( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); + template <> + struct CppType + { + using Type = PhysicalDeviceShaderDemoteToHelperInvocationFeaturesEXT; + }; + struct PhysicalDeviceShaderDrawParametersFeatures { + static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = + StructureType::ePhysicalDeviceShaderDrawParametersFeatures; + VULKAN_HPP_CONSTEXPR PhysicalDeviceShaderDrawParametersFeatures( VULKAN_HPP_NAMESPACE::Bool32 shaderDrawParameters_ = {} ) VULKAN_HPP_NOEXCEPT : shaderDrawParameters( shaderDrawParameters_ ) @@ -59390,8 +62136,17 @@ namespace VULKAN_HPP_NAMESPACE static_assert( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); + template <> + struct CppType + { + using Type = PhysicalDeviceShaderDrawParametersFeatures; + }; + struct PhysicalDeviceShaderFloat16Int8Features { + static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = + StructureType::ePhysicalDeviceShaderFloat16Int8Features; + VULKAN_HPP_CONSTEXPR PhysicalDeviceShaderFloat16Int8Features( VULKAN_HPP_NAMESPACE::Bool32 shaderFloat16_ = {}, VULKAN_HPP_NAMESPACE::Bool32 shaderInt8_ = {} ) VULKAN_HPP_NOEXCEPT @@ -59478,8 +62233,17 @@ namespace VULKAN_HPP_NAMESPACE static_assert( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); + template <> + struct CppType + { + using Type = PhysicalDeviceShaderFloat16Int8Features; + }; + struct PhysicalDeviceShaderImageFootprintFeaturesNV { + static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = + StructureType::ePhysicalDeviceShaderImageFootprintFeaturesNV; + VULKAN_HPP_CONSTEXPR PhysicalDeviceShaderImageFootprintFeaturesNV( VULKAN_HPP_NAMESPACE::Bool32 imageFootprint_ = {} ) VULKAN_HPP_NOEXCEPT : imageFootprint( imageFootprint_ ) {} @@ -59555,8 +62319,17 @@ namespace VULKAN_HPP_NAMESPACE static_assert( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); + template <> + struct CppType + { + using Type = PhysicalDeviceShaderImageFootprintFeaturesNV; + }; + struct PhysicalDeviceShaderIntegerFunctions2FeaturesINTEL { + static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = + StructureType::ePhysicalDeviceShaderIntegerFunctions2FeaturesINTEL; + VULKAN_HPP_CONSTEXPR PhysicalDeviceShaderIntegerFunctions2FeaturesINTEL( VULKAN_HPP_NAMESPACE::Bool32 shaderIntegerFunctions2_ = {} ) VULKAN_HPP_NOEXCEPT : shaderIntegerFunctions2( shaderIntegerFunctions2_ ) @@ -59636,8 +62409,17 @@ namespace VULKAN_HPP_NAMESPACE static_assert( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); + template <> + struct CppType + { + using Type = PhysicalDeviceShaderIntegerFunctions2FeaturesINTEL; + }; + struct PhysicalDeviceShaderSMBuiltinsFeaturesNV { + static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = + StructureType::ePhysicalDeviceShaderSmBuiltinsFeaturesNV; + VULKAN_HPP_CONSTEXPR PhysicalDeviceShaderSMBuiltinsFeaturesNV( VULKAN_HPP_NAMESPACE::Bool32 shaderSMBuiltins_ = {} ) VULKAN_HPP_NOEXCEPT : shaderSMBuiltins( shaderSMBuiltins_ ) {} @@ -59713,8 +62495,17 @@ namespace VULKAN_HPP_NAMESPACE static_assert( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); + template <> + struct CppType + { + using Type = PhysicalDeviceShaderSMBuiltinsFeaturesNV; + }; + struct PhysicalDeviceShaderSMBuiltinsPropertiesNV { + static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = + StructureType::ePhysicalDeviceShaderSmBuiltinsPropertiesNV; + VULKAN_HPP_CONSTEXPR PhysicalDeviceShaderSMBuiltinsPropertiesNV( uint32_t shaderSMCount_ = {}, uint32_t shaderWarpsPerSM_ = {} ) VULKAN_HPP_NOEXCEPT @@ -59782,8 +62573,17 @@ namespace VULKAN_HPP_NAMESPACE static_assert( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); + template <> + struct CppType + { + using Type = PhysicalDeviceShaderSMBuiltinsPropertiesNV; + }; + struct PhysicalDeviceShaderSubgroupExtendedTypesFeatures { + static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = + StructureType::ePhysicalDeviceShaderSubgroupExtendedTypesFeatures; + VULKAN_HPP_CONSTEXPR PhysicalDeviceShaderSubgroupExtendedTypesFeatures( VULKAN_HPP_NAMESPACE::Bool32 shaderSubgroupExtendedTypes_ = {} ) VULKAN_HPP_NOEXCEPT : shaderSubgroupExtendedTypes( shaderSubgroupExtendedTypes_ ) @@ -59862,8 +62662,17 @@ namespace VULKAN_HPP_NAMESPACE static_assert( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); + template <> + struct CppType + { + using Type = PhysicalDeviceShaderSubgroupExtendedTypesFeatures; + }; + struct PhysicalDeviceShadingRateImageFeaturesNV { + static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = + StructureType::ePhysicalDeviceShadingRateImageFeaturesNV; + VULKAN_HPP_CONSTEXPR PhysicalDeviceShadingRateImageFeaturesNV( VULKAN_HPP_NAMESPACE::Bool32 shadingRateImage_ = {}, VULKAN_HPP_NAMESPACE::Bool32 shadingRateCoarseSampleOrder_ = {} ) VULKAN_HPP_NOEXCEPT @@ -59951,8 +62760,17 @@ namespace VULKAN_HPP_NAMESPACE static_assert( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); + template <> + struct CppType + { + using Type = PhysicalDeviceShadingRateImageFeaturesNV; + }; + struct PhysicalDeviceShadingRateImagePropertiesNV { + static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = + StructureType::ePhysicalDeviceShadingRateImagePropertiesNV; + VULKAN_HPP_CONSTEXPR PhysicalDeviceShadingRateImagePropertiesNV( VULKAN_HPP_NAMESPACE::Extent2D shadingRateTexelSize_ = {}, uint32_t shadingRatePaletteSize_ = {}, @@ -60024,8 +62842,17 @@ namespace VULKAN_HPP_NAMESPACE static_assert( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); + template <> + struct CppType + { + using Type = PhysicalDeviceShadingRateImagePropertiesNV; + }; + struct PhysicalDeviceSparseImageFormatInfo2 { + static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = + StructureType::ePhysicalDeviceSparseImageFormatInfo2; + VULKAN_HPP_CONSTEXPR PhysicalDeviceSparseImageFormatInfo2( VULKAN_HPP_NAMESPACE::Format format_ = VULKAN_HPP_NAMESPACE::Format::eUndefined, VULKAN_HPP_NAMESPACE::ImageType type_ = VULKAN_HPP_NAMESPACE::ImageType::e1D, @@ -60137,8 +62964,16 @@ namespace VULKAN_HPP_NAMESPACE static_assert( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); + template <> + struct CppType + { + using Type = PhysicalDeviceSparseImageFormatInfo2; + }; + struct PhysicalDeviceSubgroupProperties { + static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::ePhysicalDeviceSubgroupProperties; + VULKAN_HPP_CONSTEXPR PhysicalDeviceSubgroupProperties( uint32_t subgroupSize_ = {}, VULKAN_HPP_NAMESPACE::ShaderStageFlags supportedStages_ = {}, @@ -60208,8 +63043,17 @@ namespace VULKAN_HPP_NAMESPACE static_assert( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); + template <> + struct CppType + { + using Type = PhysicalDeviceSubgroupProperties; + }; + struct PhysicalDeviceSubgroupSizeControlFeaturesEXT { + static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = + StructureType::ePhysicalDeviceSubgroupSizeControlFeaturesEXT; + VULKAN_HPP_CONSTEXPR PhysicalDeviceSubgroupSizeControlFeaturesEXT( VULKAN_HPP_NAMESPACE::Bool32 subgroupSizeControl_ = {}, VULKAN_HPP_NAMESPACE::Bool32 computeFullSubgroups_ = {} ) VULKAN_HPP_NOEXCEPT @@ -60297,8 +63141,17 @@ namespace VULKAN_HPP_NAMESPACE static_assert( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); + template <> + struct CppType + { + using Type = PhysicalDeviceSubgroupSizeControlFeaturesEXT; + }; + struct PhysicalDeviceSubgroupSizeControlPropertiesEXT { + static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = + StructureType::ePhysicalDeviceSubgroupSizeControlPropertiesEXT; + VULKAN_HPP_CONSTEXPR PhysicalDeviceSubgroupSizeControlPropertiesEXT( uint32_t minSubgroupSize_ = {}, uint32_t maxSubgroupSize_ = {}, @@ -60374,8 +63227,16 @@ namespace VULKAN_HPP_NAMESPACE static_assert( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); + template <> + struct CppType + { + using Type = PhysicalDeviceSubgroupSizeControlPropertiesEXT; + }; + struct PhysicalDeviceSurfaceInfo2KHR { + static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::ePhysicalDeviceSurfaceInfo2KHR; + VULKAN_HPP_CONSTEXPR PhysicalDeviceSurfaceInfo2KHR( VULKAN_HPP_NAMESPACE::SurfaceKHR surface_ = {} ) VULKAN_HPP_NOEXCEPT : surface( surface_ ) @@ -60446,8 +63307,17 @@ namespace VULKAN_HPP_NAMESPACE static_assert( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); + template <> + struct CppType + { + using Type = PhysicalDeviceSurfaceInfo2KHR; + }; + struct PhysicalDeviceTexelBufferAlignmentFeaturesEXT { + static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = + StructureType::ePhysicalDeviceTexelBufferAlignmentFeaturesEXT; + VULKAN_HPP_CONSTEXPR PhysicalDeviceTexelBufferAlignmentFeaturesEXT( VULKAN_HPP_NAMESPACE::Bool32 texelBufferAlignment_ = {} ) VULKAN_HPP_NOEXCEPT : texelBufferAlignment( texelBufferAlignment_ ) @@ -60524,8 +63394,17 @@ namespace VULKAN_HPP_NAMESPACE static_assert( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); + template <> + struct CppType + { + using Type = PhysicalDeviceTexelBufferAlignmentFeaturesEXT; + }; + struct PhysicalDeviceTexelBufferAlignmentPropertiesEXT { + static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = + StructureType::ePhysicalDeviceTexelBufferAlignmentPropertiesEXT; + VULKAN_HPP_CONSTEXPR PhysicalDeviceTexelBufferAlignmentPropertiesEXT( VULKAN_HPP_NAMESPACE::DeviceSize storageTexelBufferOffsetAlignmentBytes_ = {}, VULKAN_HPP_NAMESPACE::Bool32 storageTexelBufferOffsetSingleTexelAlignment_ = {}, @@ -60602,8 +63481,17 @@ namespace VULKAN_HPP_NAMESPACE static_assert( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); + template <> + struct CppType + { + using Type = PhysicalDeviceTexelBufferAlignmentPropertiesEXT; + }; + struct PhysicalDeviceTextureCompressionASTCHDRFeaturesEXT { + static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = + StructureType::ePhysicalDeviceTextureCompressionAstcHdrFeaturesEXT; + VULKAN_HPP_CONSTEXPR PhysicalDeviceTextureCompressionASTCHDRFeaturesEXT( VULKAN_HPP_NAMESPACE::Bool32 textureCompressionASTC_HDR_ = {} ) VULKAN_HPP_NOEXCEPT : textureCompressionASTC_HDR( textureCompressionASTC_HDR_ ) @@ -60683,8 +63571,17 @@ namespace VULKAN_HPP_NAMESPACE static_assert( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); + template <> + struct CppType + { + using Type = PhysicalDeviceTextureCompressionASTCHDRFeaturesEXT; + }; + struct PhysicalDeviceTimelineSemaphoreFeatures { + static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = + StructureType::ePhysicalDeviceTimelineSemaphoreFeatures; + VULKAN_HPP_CONSTEXPR PhysicalDeviceTimelineSemaphoreFeatures( VULKAN_HPP_NAMESPACE::Bool32 timelineSemaphore_ = {} ) VULKAN_HPP_NOEXCEPT : timelineSemaphore( timelineSemaphore_ ) {} @@ -60759,8 +63656,17 @@ namespace VULKAN_HPP_NAMESPACE static_assert( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); + template <> + struct CppType + { + using Type = PhysicalDeviceTimelineSemaphoreFeatures; + }; + struct PhysicalDeviceTimelineSemaphoreProperties { + static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = + StructureType::ePhysicalDeviceTimelineSemaphoreProperties; + VULKAN_HPP_CONSTEXPR PhysicalDeviceTimelineSemaphoreProperties( uint64_t maxTimelineSemaphoreValueDifference_ = {} ) VULKAN_HPP_NOEXCEPT : maxTimelineSemaphoreValueDifference( maxTimelineSemaphoreValueDifference_ ) {} @@ -60824,8 +63730,16 @@ namespace VULKAN_HPP_NAMESPACE static_assert( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); + template <> + struct CppType + { + using Type = PhysicalDeviceTimelineSemaphoreProperties; + }; + struct PhysicalDeviceToolPropertiesEXT { + static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::ePhysicalDeviceToolPropertiesEXT; + VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceToolPropertiesEXT( std::array const & name_ = {}, std::array const & version_ = {}, @@ -60897,8 +63811,17 @@ namespace VULKAN_HPP_NAMESPACE static_assert( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); + template <> + struct CppType + { + using Type = PhysicalDeviceToolPropertiesEXT; + }; + struct PhysicalDeviceTransformFeedbackFeaturesEXT { + static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = + StructureType::ePhysicalDeviceTransformFeedbackFeaturesEXT; + VULKAN_HPP_CONSTEXPR PhysicalDeviceTransformFeedbackFeaturesEXT( VULKAN_HPP_NAMESPACE::Bool32 transformFeedback_ = {}, VULKAN_HPP_NAMESPACE::Bool32 geometryStreams_ = {} ) VULKAN_HPP_NOEXCEPT @@ -60986,8 +63909,17 @@ namespace VULKAN_HPP_NAMESPACE static_assert( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); + template <> + struct CppType + { + using Type = PhysicalDeviceTransformFeedbackFeaturesEXT; + }; + struct PhysicalDeviceTransformFeedbackPropertiesEXT { + static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = + StructureType::ePhysicalDeviceTransformFeedbackPropertiesEXT; + VULKAN_HPP_CONSTEXPR PhysicalDeviceTransformFeedbackPropertiesEXT( uint32_t maxTransformFeedbackStreams_ = {}, uint32_t maxTransformFeedbackBuffers_ = {}, @@ -61088,8 +64020,17 @@ namespace VULKAN_HPP_NAMESPACE static_assert( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); + template <> + struct CppType + { + using Type = PhysicalDeviceTransformFeedbackPropertiesEXT; + }; + struct PhysicalDeviceUniformBufferStandardLayoutFeatures { + static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = + StructureType::ePhysicalDeviceUniformBufferStandardLayoutFeatures; + VULKAN_HPP_CONSTEXPR PhysicalDeviceUniformBufferStandardLayoutFeatures( VULKAN_HPP_NAMESPACE::Bool32 uniformBufferStandardLayout_ = {} ) VULKAN_HPP_NOEXCEPT : uniformBufferStandardLayout( uniformBufferStandardLayout_ ) @@ -61168,8 +64109,17 @@ namespace VULKAN_HPP_NAMESPACE static_assert( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); + template <> + struct CppType + { + using Type = PhysicalDeviceUniformBufferStandardLayoutFeatures; + }; + struct PhysicalDeviceVariablePointersFeatures { + static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = + StructureType::ePhysicalDeviceVariablePointersFeatures; + VULKAN_HPP_CONSTEXPR PhysicalDeviceVariablePointersFeatures( VULKAN_HPP_NAMESPACE::Bool32 variablePointersStorageBuffer_ = {}, VULKAN_HPP_NAMESPACE::Bool32 variablePointers_ = {} ) VULKAN_HPP_NOEXCEPT @@ -61256,8 +64206,17 @@ namespace VULKAN_HPP_NAMESPACE static_assert( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); + template <> + struct CppType + { + using Type = PhysicalDeviceVariablePointersFeatures; + }; + struct PhysicalDeviceVertexAttributeDivisorFeaturesEXT { + static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = + StructureType::ePhysicalDeviceVertexAttributeDivisorFeaturesEXT; + VULKAN_HPP_CONSTEXPR PhysicalDeviceVertexAttributeDivisorFeaturesEXT( VULKAN_HPP_NAMESPACE::Bool32 vertexAttributeInstanceRateDivisor_ = {}, VULKAN_HPP_NAMESPACE::Bool32 vertexAttributeInstanceRateZeroDivisor_ = {} ) VULKAN_HPP_NOEXCEPT @@ -61346,8 +64305,17 @@ namespace VULKAN_HPP_NAMESPACE static_assert( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); + template <> + struct CppType + { + using Type = PhysicalDeviceVertexAttributeDivisorFeaturesEXT; + }; + struct PhysicalDeviceVertexAttributeDivisorPropertiesEXT { + static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = + StructureType::ePhysicalDeviceVertexAttributeDivisorPropertiesEXT; + VULKAN_HPP_CONSTEXPR PhysicalDeviceVertexAttributeDivisorPropertiesEXT( uint32_t maxVertexAttribDivisor_ = {} ) VULKAN_HPP_NOEXCEPT : maxVertexAttribDivisor( maxVertexAttribDivisor_ ) @@ -61413,8 +64381,16 @@ namespace VULKAN_HPP_NAMESPACE static_assert( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); + template <> + struct CppType + { + using Type = PhysicalDeviceVertexAttributeDivisorPropertiesEXT; + }; + struct PhysicalDeviceVulkan11Features { + static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::ePhysicalDeviceVulkan11Features; + VULKAN_HPP_CONSTEXPR PhysicalDeviceVulkan11Features( VULKAN_HPP_NAMESPACE::Bool32 storageBuffer16BitAccess_ = {}, VULKAN_HPP_NAMESPACE::Bool32 uniformAndStorageBuffer16BitAccess_ = {}, @@ -61605,8 +64581,16 @@ namespace VULKAN_HPP_NAMESPACE static_assert( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); + template <> + struct CppType + { + using Type = PhysicalDeviceVulkan11Features; + }; + struct PhysicalDeviceVulkan11Properties { + static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::ePhysicalDeviceVulkan11Properties; + VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceVulkan11Properties( std::array const & deviceUUID_ = {}, std::array const & driverUUID_ = {}, @@ -61719,8 +64703,16 @@ namespace VULKAN_HPP_NAMESPACE static_assert( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); + template <> + struct CppType + { + using Type = PhysicalDeviceVulkan11Properties; + }; + struct PhysicalDeviceVulkan12Features { + static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::ePhysicalDeviceVulkan12Features; + VULKAN_HPP_CONSTEXPR PhysicalDeviceVulkan12Features( VULKAN_HPP_NAMESPACE::Bool32 samplerMirrorClampToEdge_ = {}, VULKAN_HPP_NAMESPACE::Bool32 drawIndirectCount_ = {}, @@ -62297,8 +65289,16 @@ namespace VULKAN_HPP_NAMESPACE static_assert( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); + template <> + struct CppType + { + using Type = PhysicalDeviceVulkan12Features; + }; + struct PhysicalDeviceVulkan12Properties { + static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::ePhysicalDeviceVulkan12Properties; + VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceVulkan12Properties( VULKAN_HPP_NAMESPACE::DriverId driverID_ = VULKAN_HPP_NAMESPACE::DriverId::eAmdProprietary, std::array const & driverName_ = {}, @@ -62577,8 +65577,17 @@ namespace VULKAN_HPP_NAMESPACE static_assert( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); + template <> + struct CppType + { + using Type = PhysicalDeviceVulkan12Properties; + }; + struct PhysicalDeviceVulkanMemoryModelFeatures { + static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = + StructureType::ePhysicalDeviceVulkanMemoryModelFeatures; + VULKAN_HPP_CONSTEXPR PhysicalDeviceVulkanMemoryModelFeatures( VULKAN_HPP_NAMESPACE::Bool32 vulkanMemoryModel_ = {}, VULKAN_HPP_NAMESPACE::Bool32 vulkanMemoryModelDeviceScope_ = {}, @@ -62676,8 +65685,17 @@ namespace VULKAN_HPP_NAMESPACE static_assert( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); + template <> + struct CppType + { + using Type = PhysicalDeviceVulkanMemoryModelFeatures; + }; + struct PhysicalDeviceYcbcrImageArraysFeaturesEXT { + static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = + StructureType::ePhysicalDeviceYcbcrImageArraysFeaturesEXT; + VULKAN_HPP_CONSTEXPR PhysicalDeviceYcbcrImageArraysFeaturesEXT( VULKAN_HPP_NAMESPACE::Bool32 ycbcrImageArrays_ = {} ) VULKAN_HPP_NOEXCEPT : ycbcrImageArrays( ycbcrImageArrays_ ) {} @@ -62753,8 +65771,16 @@ namespace VULKAN_HPP_NAMESPACE static_assert( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); + template <> + struct CppType + { + using Type = PhysicalDeviceYcbcrImageArraysFeaturesEXT; + }; + struct PipelineCacheCreateInfo { + static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::ePipelineCacheCreateInfo; + VULKAN_HPP_CONSTEXPR PipelineCacheCreateInfo( VULKAN_HPP_NAMESPACE::PipelineCacheCreateFlags flags_ = {}, size_t initialDataSize_ = {}, const void * pInitialData_ = {} ) VULKAN_HPP_NOEXCEPT @@ -62840,8 +65866,17 @@ namespace VULKAN_HPP_NAMESPACE "struct and wrapper have different size!" ); static_assert( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); + template <> + struct CppType + { + using Type = PipelineCacheCreateInfo; + }; + struct PipelineColorBlendAdvancedStateCreateInfoEXT { + static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = + StructureType::ePipelineColorBlendAdvancedStateCreateInfoEXT; + VULKAN_HPP_CONSTEXPR PipelineColorBlendAdvancedStateCreateInfoEXT( VULKAN_HPP_NAMESPACE::Bool32 srcPremultiplied_ = {}, VULKAN_HPP_NAMESPACE::Bool32 dstPremultiplied_ = {}, @@ -62940,8 +65975,17 @@ namespace VULKAN_HPP_NAMESPACE static_assert( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); + template <> + struct CppType + { + using Type = PipelineColorBlendAdvancedStateCreateInfoEXT; + }; + struct PipelineCompilerControlCreateInfoAMD { + static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = + StructureType::ePipelineCompilerControlCreateInfoAMD; + VULKAN_HPP_CONSTEXPR PipelineCompilerControlCreateInfoAMD( VULKAN_HPP_NAMESPACE::PipelineCompilerControlFlagsAMD compilerControlFlags_ = {} ) VULKAN_HPP_NOEXCEPT : compilerControlFlags( compilerControlFlags_ ) @@ -63016,8 +66060,17 @@ namespace VULKAN_HPP_NAMESPACE static_assert( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); + template <> + struct CppType + { + using Type = PipelineCompilerControlCreateInfoAMD; + }; + struct PipelineCoverageModulationStateCreateInfoNV { + static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = + StructureType::ePipelineCoverageModulationStateCreateInfoNV; + VULKAN_HPP_CONSTEXPR PipelineCoverageModulationStateCreateInfoNV( VULKAN_HPP_NAMESPACE::PipelineCoverageModulationStateCreateFlagsNV flags_ = {}, VULKAN_HPP_NAMESPACE::CoverageModulationModeNV coverageModulationMode_ = @@ -63140,8 +66193,17 @@ namespace VULKAN_HPP_NAMESPACE static_assert( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); + template <> + struct CppType + { + using Type = PipelineCoverageModulationStateCreateInfoNV; + }; + struct PipelineCoverageReductionStateCreateInfoNV { + static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = + StructureType::ePipelineCoverageReductionStateCreateInfoNV; + VULKAN_HPP_CONSTEXPR PipelineCoverageReductionStateCreateInfoNV( VULKAN_HPP_NAMESPACE::PipelineCoverageReductionStateCreateFlagsNV flags_ = {}, VULKAN_HPP_NAMESPACE::CoverageReductionModeNV coverageReductionMode_ = @@ -63231,8 +66293,17 @@ namespace VULKAN_HPP_NAMESPACE static_assert( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); + template <> + struct CppType + { + using Type = PipelineCoverageReductionStateCreateInfoNV; + }; + struct PipelineCoverageToColorStateCreateInfoNV { + static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = + StructureType::ePipelineCoverageToColorStateCreateInfoNV; + VULKAN_HPP_CONSTEXPR PipelineCoverageToColorStateCreateInfoNV( VULKAN_HPP_NAMESPACE::PipelineCoverageToColorStateCreateFlagsNV flags_ = {}, VULKAN_HPP_NAMESPACE::Bool32 coverageToColorEnable_ = {}, @@ -63331,6 +66402,12 @@ namespace VULKAN_HPP_NAMESPACE static_assert( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); + template <> + struct CppType + { + using Type = PipelineCoverageToColorStateCreateInfoNV; + }; + struct PipelineCreationFeedbackEXT { VULKAN_HPP_CONSTEXPR @@ -63386,6 +66463,9 @@ namespace VULKAN_HPP_NAMESPACE struct PipelineCreationFeedbackCreateInfoEXT { + static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = + StructureType::ePipelineCreationFeedbackCreateInfoEXT; + VULKAN_HPP_CONSTEXPR PipelineCreationFeedbackCreateInfoEXT( VULKAN_HPP_NAMESPACE::PipelineCreationFeedbackEXT * pPipelineCreationFeedback_ = {}, uint32_t pipelineStageCreationFeedbackCount_ = {}, @@ -63483,8 +66563,17 @@ namespace VULKAN_HPP_NAMESPACE static_assert( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); + template <> + struct CppType + { + using Type = PipelineCreationFeedbackCreateInfoEXT; + }; + struct PipelineDiscardRectangleStateCreateInfoEXT { + static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = + StructureType::ePipelineDiscardRectangleStateCreateInfoEXT; + VULKAN_HPP_CONSTEXPR PipelineDiscardRectangleStateCreateInfoEXT( VULKAN_HPP_NAMESPACE::PipelineDiscardRectangleStateCreateFlagsEXT flags_ = {}, VULKAN_HPP_NAMESPACE::DiscardRectangleModeEXT discardRectangleMode_ = @@ -63595,8 +66684,16 @@ namespace VULKAN_HPP_NAMESPACE static_assert( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); + template <> + struct CppType + { + using Type = PipelineDiscardRectangleStateCreateInfoEXT; + }; + struct PipelineExecutableInfoKHR { + static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::ePipelineExecutableInfoKHR; + VULKAN_HPP_CONSTEXPR PipelineExecutableInfoKHR( VULKAN_HPP_NAMESPACE::Pipeline pipeline_ = {}, uint32_t executableIndex_ = {} ) VULKAN_HPP_NOEXCEPT : pipeline( pipeline_ ) @@ -63674,8 +66771,17 @@ namespace VULKAN_HPP_NAMESPACE static_assert( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); + template <> + struct CppType + { + using Type = PipelineExecutableInfoKHR; + }; + struct PipelineExecutableInternalRepresentationKHR { + static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = + StructureType::ePipelineExecutableInternalRepresentationKHR; + VULKAN_HPP_CONSTEXPR_14 PipelineExecutableInternalRepresentationKHR( std::array const & name_ = {}, std::array const & description_ = {}, @@ -63753,8 +66859,16 @@ namespace VULKAN_HPP_NAMESPACE static_assert( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); + template <> + struct CppType + { + using Type = PipelineExecutableInternalRepresentationKHR; + }; + struct PipelineExecutablePropertiesKHR { + static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::ePipelineExecutablePropertiesKHR; + VULKAN_HPP_CONSTEXPR_14 PipelineExecutablePropertiesKHR( VULKAN_HPP_NAMESPACE::ShaderStageFlags stages_ = {}, std::array const & name_ = {}, @@ -63823,6 +66937,12 @@ namespace VULKAN_HPP_NAMESPACE static_assert( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); + template <> + struct CppType + { + using Type = PipelineExecutablePropertiesKHR; + }; + union PipelineExecutableStatisticValueKHR { PipelineExecutableStatisticValueKHR( VULKAN_HPP_NAMESPACE::PipelineExecutableStatisticValueKHR const & rhs ) @@ -63895,6 +67015,8 @@ namespace VULKAN_HPP_NAMESPACE struct PipelineExecutableStatisticKHR { + static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::ePipelineExecutableStatisticKHR; + PipelineExecutableStatisticKHR( std::array const & name_ = {}, std::array const & description_ = {}, VULKAN_HPP_NAMESPACE::PipelineExecutableStatisticFormatKHR format_ = @@ -63950,8 +67072,16 @@ namespace VULKAN_HPP_NAMESPACE static_assert( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); + template <> + struct CppType + { + using Type = PipelineExecutableStatisticKHR; + }; + struct PipelineInfoKHR { + static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::ePipelineInfoKHR; + VULKAN_HPP_CONSTEXPR PipelineInfoKHR( VULKAN_HPP_NAMESPACE::Pipeline pipeline_ = {} ) VULKAN_HPP_NOEXCEPT : pipeline( pipeline_ ) {} @@ -64017,6 +67147,12 @@ namespace VULKAN_HPP_NAMESPACE static_assert( sizeof( PipelineInfoKHR ) == sizeof( VkPipelineInfoKHR ), "struct and wrapper have different size!" ); static_assert( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); + template <> + struct CppType + { + using Type = PipelineInfoKHR; + }; + struct PushConstantRange { VULKAN_HPP_CONSTEXPR PushConstantRange( VULKAN_HPP_NAMESPACE::ShaderStageFlags stageFlags_ = {}, @@ -64091,6 +67227,8 @@ namespace VULKAN_HPP_NAMESPACE struct PipelineLayoutCreateInfo { + static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::ePipelineLayoutCreateInfo; + VULKAN_HPP_CONSTEXPR PipelineLayoutCreateInfo( VULKAN_HPP_NAMESPACE::PipelineLayoutCreateFlags flags_ = {}, uint32_t setLayoutCount_ = {}, @@ -64199,9 +67337,17 @@ namespace VULKAN_HPP_NAMESPACE "struct and wrapper have different size!" ); static_assert( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); + template <> + struct CppType + { + using Type = PipelineLayoutCreateInfo; + }; + #ifdef VK_ENABLE_BETA_EXTENSIONS struct PipelineLibraryCreateInfoKHR { + static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::ePipelineLibraryCreateInfoKHR; + VULKAN_HPP_CONSTEXPR PipelineLibraryCreateInfoKHR( uint32_t libraryCount_ = {}, const VULKAN_HPP_NAMESPACE::Pipeline * pLibraries_ = {} ) VULKAN_HPP_NOEXCEPT @@ -64281,10 +67427,19 @@ namespace VULKAN_HPP_NAMESPACE "struct and wrapper have different size!" ); static_assert( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); + + template <> + struct CppType + { + using Type = PipelineLibraryCreateInfoKHR; + }; #endif /*VK_ENABLE_BETA_EXTENSIONS*/ struct PipelineRasterizationConservativeStateCreateInfoEXT { + static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = + StructureType::ePipelineRasterizationConservativeStateCreateInfoEXT; + VULKAN_HPP_CONSTEXPR PipelineRasterizationConservativeStateCreateInfoEXT( VULKAN_HPP_NAMESPACE::PipelineRasterizationConservativeStateCreateFlagsEXT flags_ = {}, VULKAN_HPP_NAMESPACE::ConservativeRasterizationModeEXT conservativeRasterizationMode_ = @@ -64387,8 +67542,17 @@ namespace VULKAN_HPP_NAMESPACE static_assert( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); + template <> + struct CppType + { + using Type = PipelineRasterizationConservativeStateCreateInfoEXT; + }; + struct PipelineRasterizationDepthClipStateCreateInfoEXT { + static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = + StructureType::ePipelineRasterizationDepthClipStateCreateInfoEXT; + VULKAN_HPP_CONSTEXPR PipelineRasterizationDepthClipStateCreateInfoEXT( VULKAN_HPP_NAMESPACE::PipelineRasterizationDepthClipStateCreateFlagsEXT flags_ = {}, VULKAN_HPP_NAMESPACE::Bool32 depthClipEnable_ = {} ) VULKAN_HPP_NOEXCEPT @@ -64476,8 +67640,17 @@ namespace VULKAN_HPP_NAMESPACE static_assert( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); + template <> + struct CppType + { + using Type = PipelineRasterizationDepthClipStateCreateInfoEXT; + }; + struct PipelineRasterizationLineStateCreateInfoEXT { + static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = + StructureType::ePipelineRasterizationLineStateCreateInfoEXT; + VULKAN_HPP_CONSTEXPR PipelineRasterizationLineStateCreateInfoEXT( VULKAN_HPP_NAMESPACE::LineRasterizationModeEXT lineRasterizationMode_ = VULKAN_HPP_NAMESPACE::LineRasterizationModeEXT::eDefault, @@ -64589,8 +67762,17 @@ namespace VULKAN_HPP_NAMESPACE static_assert( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); + template <> + struct CppType + { + using Type = PipelineRasterizationLineStateCreateInfoEXT; + }; + struct PipelineRasterizationStateRasterizationOrderAMD { + static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = + StructureType::ePipelineRasterizationStateRasterizationOrderAMD; + VULKAN_HPP_CONSTEXPR PipelineRasterizationStateRasterizationOrderAMD( VULKAN_HPP_NAMESPACE::RasterizationOrderAMD rasterizationOrder_ = VULKAN_HPP_NAMESPACE::RasterizationOrderAMD::eStrict ) VULKAN_HPP_NOEXCEPT @@ -64669,8 +67851,17 @@ namespace VULKAN_HPP_NAMESPACE static_assert( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); + template <> + struct CppType + { + using Type = PipelineRasterizationStateRasterizationOrderAMD; + }; + struct PipelineRasterizationStateStreamCreateInfoEXT { + static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = + StructureType::ePipelineRasterizationStateStreamCreateInfoEXT; + VULKAN_HPP_CONSTEXPR PipelineRasterizationStateStreamCreateInfoEXT( VULKAN_HPP_NAMESPACE::PipelineRasterizationStateStreamCreateFlagsEXT flags_ = {}, uint32_t rasterizationStream_ = {} ) VULKAN_HPP_NOEXCEPT @@ -64758,8 +67949,17 @@ namespace VULKAN_HPP_NAMESPACE static_assert( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); + template <> + struct CppType + { + using Type = PipelineRasterizationStateStreamCreateInfoEXT; + }; + struct PipelineRepresentativeFragmentTestStateCreateInfoNV { + static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = + StructureType::ePipelineRepresentativeFragmentTestStateCreateInfoNV; + VULKAN_HPP_CONSTEXPR PipelineRepresentativeFragmentTestStateCreateInfoNV( VULKAN_HPP_NAMESPACE::Bool32 representativeFragmentTestEnable_ = {} ) VULKAN_HPP_NOEXCEPT : representativeFragmentTestEnable( representativeFragmentTestEnable_ ) @@ -64839,8 +68039,17 @@ namespace VULKAN_HPP_NAMESPACE static_assert( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); + template <> + struct CppType + { + using Type = PipelineRepresentativeFragmentTestStateCreateInfoNV; + }; + struct PipelineSampleLocationsStateCreateInfoEXT { + static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = + StructureType::ePipelineSampleLocationsStateCreateInfoEXT; + VULKAN_HPP_CONSTEXPR PipelineSampleLocationsStateCreateInfoEXT( VULKAN_HPP_NAMESPACE::Bool32 sampleLocationsEnable_ = {}, VULKAN_HPP_NAMESPACE::SampleLocationsInfoEXT sampleLocationsInfo_ = {} ) VULKAN_HPP_NOEXCEPT @@ -64929,8 +68138,17 @@ namespace VULKAN_HPP_NAMESPACE static_assert( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); + template <> + struct CppType + { + using Type = PipelineSampleLocationsStateCreateInfoEXT; + }; + struct PipelineShaderStageRequiredSubgroupSizeCreateInfoEXT { + static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = + StructureType::ePipelineShaderStageRequiredSubgroupSizeCreateInfoEXT; + VULKAN_HPP_CONSTEXPR PipelineShaderStageRequiredSubgroupSizeCreateInfoEXT( uint32_t requiredSubgroupSize_ = {} ) VULKAN_HPP_NOEXCEPT : requiredSubgroupSize( requiredSubgroupSize_ ) @@ -64996,8 +68214,17 @@ namespace VULKAN_HPP_NAMESPACE static_assert( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); + template <> + struct CppType + { + using Type = PipelineShaderStageRequiredSubgroupSizeCreateInfoEXT; + }; + struct PipelineTessellationDomainOriginStateCreateInfo { + static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = + StructureType::ePipelineTessellationDomainOriginStateCreateInfo; + VULKAN_HPP_CONSTEXPR PipelineTessellationDomainOriginStateCreateInfo( VULKAN_HPP_NAMESPACE::TessellationDomainOrigin domainOrigin_ = VULKAN_HPP_NAMESPACE::TessellationDomainOrigin::eUpperLeft ) VULKAN_HPP_NOEXCEPT : domainOrigin( domainOrigin_ ) @@ -65075,6 +68302,12 @@ namespace VULKAN_HPP_NAMESPACE static_assert( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); + template <> + struct CppType + { + using Type = PipelineTessellationDomainOriginStateCreateInfo; + }; + struct VertexInputBindingDivisorDescriptionEXT { VULKAN_HPP_CONSTEXPR VertexInputBindingDivisorDescriptionEXT( uint32_t binding_ = {}, @@ -65143,6 +68376,9 @@ namespace VULKAN_HPP_NAMESPACE struct PipelineVertexInputDivisorStateCreateInfoEXT { + static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = + StructureType::ePipelineVertexInputDivisorStateCreateInfoEXT; + VULKAN_HPP_CONSTEXPR PipelineVertexInputDivisorStateCreateInfoEXT( uint32_t vertexBindingDivisorCount_ = {}, const VULKAN_HPP_NAMESPACE::VertexInputBindingDivisorDescriptionEXT * pVertexBindingDivisors_ = {} ) @@ -65233,8 +68469,17 @@ namespace VULKAN_HPP_NAMESPACE static_assert( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); + template <> + struct CppType + { + using Type = PipelineVertexInputDivisorStateCreateInfoEXT; + }; + struct PipelineViewportCoarseSampleOrderStateCreateInfoNV { + static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = + StructureType::ePipelineViewportCoarseSampleOrderStateCreateInfoNV; + VULKAN_HPP_CONSTEXPR PipelineViewportCoarseSampleOrderStateCreateInfoNV( VULKAN_HPP_NAMESPACE::CoarseSampleOrderTypeNV sampleOrderType_ = VULKAN_HPP_NAMESPACE::CoarseSampleOrderTypeNV::eDefault, @@ -65337,8 +68582,17 @@ namespace VULKAN_HPP_NAMESPACE static_assert( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); + template <> + struct CppType + { + using Type = PipelineViewportCoarseSampleOrderStateCreateInfoNV; + }; + struct PipelineViewportExclusiveScissorStateCreateInfoNV { + static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = + StructureType::ePipelineViewportExclusiveScissorStateCreateInfoNV; + VULKAN_HPP_CONSTEXPR PipelineViewportExclusiveScissorStateCreateInfoNV( uint32_t exclusiveScissorCount_ = {}, const VULKAN_HPP_NAMESPACE::Rect2D * pExclusiveScissors_ = {} ) VULKAN_HPP_NOEXCEPT @@ -65427,6 +68681,12 @@ namespace VULKAN_HPP_NAMESPACE static_assert( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); + template <> + struct CppType + { + using Type = PipelineViewportExclusiveScissorStateCreateInfoNV; + }; + struct ShadingRatePaletteNV { VULKAN_HPP_CONSTEXPR ShadingRatePaletteNV( @@ -65495,6 +68755,9 @@ namespace VULKAN_HPP_NAMESPACE struct PipelineViewportShadingRateImageStateCreateInfoNV { + static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = + StructureType::ePipelineViewportShadingRateImageStateCreateInfoNV; + VULKAN_HPP_CONSTEXPR PipelineViewportShadingRateImageStateCreateInfoNV( VULKAN_HPP_NAMESPACE::Bool32 shadingRateImageEnable_ = {}, uint32_t viewportCount_ = {}, @@ -65593,6 +68856,12 @@ namespace VULKAN_HPP_NAMESPACE static_assert( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); + template <> + struct CppType + { + using Type = PipelineViewportShadingRateImageStateCreateInfoNV; + }; + struct ViewportSwizzleNV { VULKAN_HPP_CONSTEXPR @@ -65681,6 +68950,9 @@ namespace VULKAN_HPP_NAMESPACE struct PipelineViewportSwizzleStateCreateInfoNV { + static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = + StructureType::ePipelineViewportSwizzleStateCreateInfoNV; + VULKAN_HPP_CONSTEXPR PipelineViewportSwizzleStateCreateInfoNV( VULKAN_HPP_NAMESPACE::PipelineViewportSwizzleStateCreateFlagsNV flags_ = {}, uint32_t viewportCount_ = {}, @@ -65777,6 +69049,12 @@ namespace VULKAN_HPP_NAMESPACE static_assert( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); + template <> + struct CppType + { + using Type = PipelineViewportSwizzleStateCreateInfoNV; + }; + struct ViewportWScalingNV { VULKAN_HPP_CONSTEXPR ViewportWScalingNV( float xcoeff_ = {}, float ycoeff_ = {} ) VULKAN_HPP_NOEXCEPT @@ -65841,6 +69119,9 @@ namespace VULKAN_HPP_NAMESPACE struct PipelineViewportWScalingStateCreateInfoNV { + static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = + StructureType::ePipelineViewportWScalingStateCreateInfoNV; + VULKAN_HPP_CONSTEXPR PipelineViewportWScalingStateCreateInfoNV( VULKAN_HPP_NAMESPACE::Bool32 viewportWScalingEnable_ = {}, uint32_t viewportCount_ = {}, @@ -65938,9 +69219,17 @@ namespace VULKAN_HPP_NAMESPACE static_assert( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); + template <> + struct CppType + { + using Type = PipelineViewportWScalingStateCreateInfoNV; + }; + #ifdef VK_USE_PLATFORM_GGP struct PresentFrameTokenGGP { + static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::ePresentFrameTokenGGP; + VULKAN_HPP_CONSTEXPR PresentFrameTokenGGP( GgpFrameToken frameToken_ = {} ) VULKAN_HPP_NOEXCEPT : frameToken( frameToken_ ) {} @@ -66006,10 +69295,18 @@ namespace VULKAN_HPP_NAMESPACE static_assert( sizeof( PresentFrameTokenGGP ) == sizeof( VkPresentFrameTokenGGP ), "struct and wrapper have different size!" ); static_assert( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); + + template <> + struct CppType + { + using Type = PresentFrameTokenGGP; + }; #endif /*VK_USE_PLATFORM_GGP*/ struct PresentInfoKHR { + static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::ePresentInfoKHR; + VULKAN_HPP_CONSTEXPR PresentInfoKHR( uint32_t waitSemaphoreCount_ = {}, const VULKAN_HPP_NAMESPACE::Semaphore * pWaitSemaphores_ = {}, uint32_t swapchainCount_ = {}, @@ -66123,6 +69420,12 @@ namespace VULKAN_HPP_NAMESPACE static_assert( sizeof( PresentInfoKHR ) == sizeof( VkPresentInfoKHR ), "struct and wrapper have different size!" ); static_assert( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); + template <> + struct CppType + { + using Type = PresentInfoKHR; + }; + struct RectLayerKHR { VULKAN_HPP_CONSTEXPR RectLayerKHR( VULKAN_HPP_NAMESPACE::Offset2D offset_ = {}, @@ -66264,6 +69567,8 @@ namespace VULKAN_HPP_NAMESPACE struct PresentRegionsKHR { + static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::ePresentRegionsKHR; + VULKAN_HPP_CONSTEXPR PresentRegionsKHR( uint32_t swapchainCount_ = {}, const VULKAN_HPP_NAMESPACE::PresentRegionKHR * pRegions_ = {} ) VULKAN_HPP_NOEXCEPT @@ -66341,6 +69646,12 @@ namespace VULKAN_HPP_NAMESPACE "struct and wrapper have different size!" ); static_assert( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); + template <> + struct CppType + { + using Type = PresentRegionsKHR; + }; + struct PresentTimeGOOGLE { VULKAN_HPP_CONSTEXPR PresentTimeGOOGLE( uint32_t presentID_ = {}, @@ -66406,6 +69717,8 @@ namespace VULKAN_HPP_NAMESPACE struct PresentTimesInfoGOOGLE { + static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::ePresentTimesInfoGOOGLE; + VULKAN_HPP_CONSTEXPR PresentTimesInfoGOOGLE( uint32_t swapchainCount_ = {}, const VULKAN_HPP_NAMESPACE::PresentTimeGOOGLE * pTimes_ = {} ) VULKAN_HPP_NOEXCEPT @@ -66483,8 +69796,16 @@ namespace VULKAN_HPP_NAMESPACE "struct and wrapper have different size!" ); static_assert( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); + template <> + struct CppType + { + using Type = PresentTimesInfoGOOGLE; + }; + struct ProtectedSubmitInfo { + static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::eProtectedSubmitInfo; + VULKAN_HPP_CONSTEXPR ProtectedSubmitInfo( VULKAN_HPP_NAMESPACE::Bool32 protectedSubmit_ = {} ) VULKAN_HPP_NOEXCEPT : protectedSubmit( protectedSubmit_ ) {} @@ -66551,8 +69872,16 @@ namespace VULKAN_HPP_NAMESPACE "struct and wrapper have different size!" ); static_assert( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); + template <> + struct CppType + { + using Type = ProtectedSubmitInfo; + }; + struct QueryPoolCreateInfo { + static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::eQueryPoolCreateInfo; + VULKAN_HPP_CONSTEXPR QueryPoolCreateInfo( VULKAN_HPP_NAMESPACE::QueryPoolCreateFlags flags_ = {}, VULKAN_HPP_NAMESPACE::QueryType queryType_ = VULKAN_HPP_NAMESPACE::QueryType::eOcclusion, @@ -66650,8 +69979,17 @@ namespace VULKAN_HPP_NAMESPACE "struct and wrapper have different size!" ); static_assert( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); + template <> + struct CppType + { + using Type = QueryPoolCreateInfo; + }; + struct QueryPoolPerformanceCreateInfoKHR { + static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = + StructureType::eQueryPoolPerformanceCreateInfoKHR; + VULKAN_HPP_CONSTEXPR QueryPoolPerformanceCreateInfoKHR( uint32_t queueFamilyIndex_ = {}, uint32_t counterIndexCount_ = {}, const uint32_t * pCounterIndices_ = {} ) VULKAN_HPP_NOEXCEPT @@ -66740,8 +70078,17 @@ namespace VULKAN_HPP_NAMESPACE static_assert( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); + template <> + struct CppType + { + using Type = QueryPoolPerformanceCreateInfoKHR; + }; + struct QueryPoolPerformanceQueryCreateInfoINTEL { + static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = + StructureType::eQueryPoolPerformanceQueryCreateInfoINTEL; + VULKAN_HPP_CONSTEXPR QueryPoolPerformanceQueryCreateInfoINTEL( VULKAN_HPP_NAMESPACE::QueryPoolSamplingModeINTEL performanceCountersSampling_ = VULKAN_HPP_NAMESPACE::QueryPoolSamplingModeINTEL::eManual ) VULKAN_HPP_NOEXCEPT @@ -66821,8 +70168,17 @@ namespace VULKAN_HPP_NAMESPACE static_assert( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); + template <> + struct CppType + { + using Type = QueryPoolPerformanceQueryCreateInfoINTEL; + }; + struct QueueFamilyCheckpointPropertiesNV { + static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = + StructureType::eQueueFamilyCheckpointPropertiesNV; + VULKAN_HPP_CONSTEXPR QueueFamilyCheckpointPropertiesNV( VULKAN_HPP_NAMESPACE::PipelineStageFlags checkpointExecutionStageMask_ = {} ) VULKAN_HPP_NOEXCEPT : checkpointExecutionStageMask( checkpointExecutionStageMask_ ) @@ -66882,6 +70238,12 @@ namespace VULKAN_HPP_NAMESPACE static_assert( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); + template <> + struct CppType + { + using Type = QueueFamilyCheckpointPropertiesNV; + }; + struct QueueFamilyProperties { VULKAN_HPP_CONSTEXPR @@ -66944,6 +70306,8 @@ namespace VULKAN_HPP_NAMESPACE struct QueueFamilyProperties2 { + static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::eQueueFamilyProperties2; + VULKAN_HPP_CONSTEXPR QueueFamilyProperties2( VULKAN_HPP_NAMESPACE::QueueFamilyProperties queueFamilyProperties_ = {} ) VULKAN_HPP_NOEXCEPT : queueFamilyProperties( queueFamilyProperties_ ) @@ -66999,9 +70363,18 @@ namespace VULKAN_HPP_NAMESPACE "struct and wrapper have different size!" ); static_assert( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); + template <> + struct CppType + { + using Type = QueueFamilyProperties2; + }; + #ifdef VK_ENABLE_BETA_EXTENSIONS struct RayTracingShaderGroupCreateInfoKHR { + static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = + StructureType::eRayTracingShaderGroupCreateInfoKHR; + VULKAN_HPP_CONSTEXPR RayTracingShaderGroupCreateInfoKHR( VULKAN_HPP_NAMESPACE::RayTracingShaderGroupTypeKHR type_ = VULKAN_HPP_NAMESPACE::RayTracingShaderGroupTypeKHR::eGeneral, @@ -67124,11 +70497,20 @@ namespace VULKAN_HPP_NAMESPACE "struct and wrapper have different size!" ); static_assert( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); + + template <> + struct CppType + { + using Type = RayTracingShaderGroupCreateInfoKHR; + }; #endif /*VK_ENABLE_BETA_EXTENSIONS*/ #ifdef VK_ENABLE_BETA_EXTENSIONS struct RayTracingPipelineInterfaceCreateInfoKHR { + static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = + StructureType::eRayTracingPipelineInterfaceCreateInfoKHR; + VULKAN_HPP_CONSTEXPR RayTracingPipelineInterfaceCreateInfoKHR( uint32_t maxPayloadSize_ = {}, uint32_t maxAttributeSize_ = {}, uint32_t maxCallableSize_ = {} ) VULKAN_HPP_NOEXCEPT @@ -67221,11 +70603,19 @@ namespace VULKAN_HPP_NAMESPACE "struct and wrapper have different size!" ); static_assert( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); + + template <> + struct CppType + { + using Type = RayTracingPipelineInterfaceCreateInfoKHR; + }; #endif /*VK_ENABLE_BETA_EXTENSIONS*/ #ifdef VK_ENABLE_BETA_EXTENSIONS struct RayTracingPipelineCreateInfoKHR { + static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::eRayTracingPipelineCreateInfoKHR; + VULKAN_HPP_CONSTEXPR RayTracingPipelineCreateInfoKHR( VULKAN_HPP_NAMESPACE::PipelineCreateFlags flags_ = {}, uint32_t stageCount_ = {}, @@ -67395,10 +70785,19 @@ namespace VULKAN_HPP_NAMESPACE "struct and wrapper have different size!" ); static_assert( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); + + template <> + struct CppType + { + using Type = RayTracingPipelineCreateInfoKHR; + }; #endif /*VK_ENABLE_BETA_EXTENSIONS*/ struct RayTracingShaderGroupCreateInfoNV { + static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = + StructureType::eRayTracingShaderGroupCreateInfoNV; + VULKAN_HPP_CONSTEXPR RayTracingShaderGroupCreateInfoNV( VULKAN_HPP_NAMESPACE::RayTracingShaderGroupTypeKHR type_ = VULKAN_HPP_NAMESPACE::RayTracingShaderGroupTypeKHR::eGeneral, @@ -67510,8 +70909,16 @@ namespace VULKAN_HPP_NAMESPACE static_assert( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); + template <> + struct CppType + { + using Type = RayTracingShaderGroupCreateInfoNV; + }; + struct RayTracingPipelineCreateInfoNV { + static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::eRayTracingPipelineCreateInfoNV; + VULKAN_HPP_CONSTEXPR RayTracingPipelineCreateInfoNV( VULKAN_HPP_NAMESPACE::PipelineCreateFlags flags_ = {}, uint32_t stageCount_ = {}, @@ -67660,6 +71067,12 @@ namespace VULKAN_HPP_NAMESPACE static_assert( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); + template <> + struct CppType + { + using Type = RayTracingPipelineCreateInfoNV; + }; + struct RefreshCycleDurationGOOGLE { VULKAN_HPP_CONSTEXPR RefreshCycleDurationGOOGLE( uint64_t refreshDuration_ = {} ) VULKAN_HPP_NOEXCEPT @@ -67711,6 +71124,8 @@ namespace VULKAN_HPP_NAMESPACE struct RenderPassAttachmentBeginInfo { + static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::eRenderPassAttachmentBeginInfo; + VULKAN_HPP_CONSTEXPR RenderPassAttachmentBeginInfo( uint32_t attachmentCount_ = {}, const VULKAN_HPP_NAMESPACE::ImageView * pAttachments_ = {} ) VULKAN_HPP_NOEXCEPT @@ -67792,8 +71207,16 @@ namespace VULKAN_HPP_NAMESPACE static_assert( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); + template <> + struct CppType + { + using Type = RenderPassAttachmentBeginInfo; + }; + struct RenderPassBeginInfo { + static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::eRenderPassBeginInfo; + VULKAN_HPP_CONSTEXPR_14 RenderPassBeginInfo( VULKAN_HPP_NAMESPACE::RenderPass renderPass_ = {}, VULKAN_HPP_NAMESPACE::Framebuffer framebuffer_ = {}, @@ -67899,6 +71322,12 @@ namespace VULKAN_HPP_NAMESPACE "struct and wrapper have different size!" ); static_assert( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); + template <> + struct CppType + { + using Type = RenderPassBeginInfo; + }; + struct SubpassDescription { VULKAN_HPP_CONSTEXPR SubpassDescription( @@ -68160,6 +71589,8 @@ namespace VULKAN_HPP_NAMESPACE struct RenderPassCreateInfo { + static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::eRenderPassCreateInfo; + VULKAN_HPP_CONSTEXPR RenderPassCreateInfo( VULKAN_HPP_NAMESPACE::RenderPassCreateFlags flags_ = {}, uint32_t attachmentCount_ = {}, @@ -68287,8 +71718,16 @@ namespace VULKAN_HPP_NAMESPACE "struct and wrapper have different size!" ); static_assert( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); + template <> + struct CppType + { + using Type = RenderPassCreateInfo; + }; + struct SubpassDescription2 { + static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::eSubpassDescription2; + VULKAN_HPP_CONSTEXPR SubpassDescription2( VULKAN_HPP_NAMESPACE::SubpassDescriptionFlags flags_ = {}, VULKAN_HPP_NAMESPACE::PipelineBindPoint pipelineBindPoint_ = VULKAN_HPP_NAMESPACE::PipelineBindPoint::eGraphics, @@ -68458,8 +71897,16 @@ namespace VULKAN_HPP_NAMESPACE "struct and wrapper have different size!" ); static_assert( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); + template <> + struct CppType + { + using Type = SubpassDescription2; + }; + struct SubpassDependency2 { + static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::eSubpassDependency2; + VULKAN_HPP_CONSTEXPR SubpassDependency2( uint32_t srcSubpass_ = {}, uint32_t dstSubpass_ = {}, VULKAN_HPP_NAMESPACE::PipelineStageFlags srcStageMask_ = {}, @@ -68594,8 +72041,16 @@ namespace VULKAN_HPP_NAMESPACE "struct and wrapper have different size!" ); static_assert( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); + template <> + struct CppType + { + using Type = SubpassDependency2; + }; + struct RenderPassCreateInfo2 { + static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::eRenderPassCreateInfo2; + VULKAN_HPP_CONSTEXPR RenderPassCreateInfo2( VULKAN_HPP_NAMESPACE::RenderPassCreateFlags flags_ = {}, uint32_t attachmentCount_ = {}, const VULKAN_HPP_NAMESPACE::AttachmentDescription2 * pAttachments_ = {}, @@ -68742,8 +72197,17 @@ namespace VULKAN_HPP_NAMESPACE "struct and wrapper have different size!" ); static_assert( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); + template <> + struct CppType + { + using Type = RenderPassCreateInfo2; + }; + struct RenderPassFragmentDensityMapCreateInfoEXT { + static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = + StructureType::eRenderPassFragmentDensityMapCreateInfoEXT; + VULKAN_HPP_CONSTEXPR RenderPassFragmentDensityMapCreateInfoEXT( VULKAN_HPP_NAMESPACE::AttachmentReference fragmentDensityMapAttachment_ = {} ) VULKAN_HPP_NOEXCEPT : fragmentDensityMapAttachment( fragmentDensityMapAttachment_ ) @@ -68821,8 +72285,17 @@ namespace VULKAN_HPP_NAMESPACE static_assert( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); + template <> + struct CppType + { + using Type = RenderPassFragmentDensityMapCreateInfoEXT; + }; + struct RenderPassInputAttachmentAspectCreateInfo { + static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = + StructureType::eRenderPassInputAttachmentAspectCreateInfo; + VULKAN_HPP_CONSTEXPR RenderPassInputAttachmentAspectCreateInfo( uint32_t aspectReferenceCount_ = {}, const VULKAN_HPP_NAMESPACE::InputAttachmentAspectReference * pAspectReferences_ = {} ) VULKAN_HPP_NOEXCEPT @@ -68910,8 +72383,16 @@ namespace VULKAN_HPP_NAMESPACE static_assert( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); + template <> + struct CppType + { + using Type = RenderPassInputAttachmentAspectCreateInfo; + }; + struct RenderPassMultiviewCreateInfo { + static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::eRenderPassMultiviewCreateInfo; + VULKAN_HPP_CONSTEXPR RenderPassMultiviewCreateInfo( uint32_t subpassCount_ = {}, const uint32_t * pViewMasks_ = {}, uint32_t dependencyCount_ = {}, @@ -69029,6 +72510,12 @@ namespace VULKAN_HPP_NAMESPACE static_assert( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); + template <> + struct CppType + { + using Type = RenderPassMultiviewCreateInfo; + }; + struct SubpassSampleLocationsEXT { VULKAN_HPP_CONSTEXPR SubpassSampleLocationsEXT( @@ -69097,6 +72584,9 @@ namespace VULKAN_HPP_NAMESPACE struct RenderPassSampleLocationsBeginInfoEXT { + static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = + StructureType::eRenderPassSampleLocationsBeginInfoEXT; + VULKAN_HPP_CONSTEXPR RenderPassSampleLocationsBeginInfoEXT( uint32_t attachmentInitialSampleLocationsCount_ = {}, const VULKAN_HPP_NAMESPACE::AttachmentSampleLocationsEXT * pAttachmentInitialSampleLocations_ = {}, @@ -69206,8 +72696,16 @@ namespace VULKAN_HPP_NAMESPACE static_assert( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); + template <> + struct CppType + { + using Type = RenderPassSampleLocationsBeginInfoEXT; + }; + struct RenderPassTransformBeginInfoQCOM { + static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::eRenderPassTransformBeginInfoQCOM; + VULKAN_HPP_CONSTEXPR RenderPassTransformBeginInfoQCOM( VULKAN_HPP_NAMESPACE::SurfaceTransformFlagBitsKHR transform_ = VULKAN_HPP_NAMESPACE::SurfaceTransformFlagBitsKHR::eIdentity ) VULKAN_HPP_NOEXCEPT : transform( transform_ ) @@ -69280,8 +72778,16 @@ namespace VULKAN_HPP_NAMESPACE static_assert( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); + template <> + struct CppType + { + using Type = RenderPassTransformBeginInfoQCOM; + }; + struct SamplerCreateInfo { + static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::eSamplerCreateInfo; + VULKAN_HPP_CONSTEXPR SamplerCreateInfo( VULKAN_HPP_NAMESPACE::SamplerCreateFlags flags_ = {}, VULKAN_HPP_NAMESPACE::Filter magFilter_ = VULKAN_HPP_NAMESPACE::Filter::eNearest, @@ -69492,8 +72998,16 @@ namespace VULKAN_HPP_NAMESPACE "struct and wrapper have different size!" ); static_assert( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); + template <> + struct CppType + { + using Type = SamplerCreateInfo; + }; + struct SamplerReductionModeCreateInfo { + static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::eSamplerReductionModeCreateInfo; + VULKAN_HPP_CONSTEXPR SamplerReductionModeCreateInfo( VULKAN_HPP_NAMESPACE::SamplerReductionMode reductionMode_ = VULKAN_HPP_NAMESPACE::SamplerReductionMode::eWeightedAverage ) VULKAN_HPP_NOEXCEPT @@ -69567,8 +73081,16 @@ namespace VULKAN_HPP_NAMESPACE static_assert( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); + template <> + struct CppType + { + using Type = SamplerReductionModeCreateInfo; + }; + struct SamplerYcbcrConversionCreateInfo { + static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::eSamplerYcbcrConversionCreateInfo; + VULKAN_HPP_CONSTEXPR SamplerYcbcrConversionCreateInfo( VULKAN_HPP_NAMESPACE::Format format_ = VULKAN_HPP_NAMESPACE::Format::eUndefined, VULKAN_HPP_NAMESPACE::SamplerYcbcrModelConversion ycbcrModel_ = @@ -69713,8 +73235,17 @@ namespace VULKAN_HPP_NAMESPACE static_assert( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); + template <> + struct CppType + { + using Type = SamplerYcbcrConversionCreateInfo; + }; + struct SamplerYcbcrConversionImageFormatProperties { + static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = + StructureType::eSamplerYcbcrConversionImageFormatProperties; + VULKAN_HPP_CONSTEXPR SamplerYcbcrConversionImageFormatProperties( uint32_t combinedImageSamplerDescriptorCount_ = {} ) VULKAN_HPP_NOEXCEPT : combinedImageSamplerDescriptorCount( combinedImageSamplerDescriptorCount_ ) @@ -69779,8 +73310,16 @@ namespace VULKAN_HPP_NAMESPACE static_assert( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); + template <> + struct CppType + { + using Type = SamplerYcbcrConversionImageFormatProperties; + }; + struct SamplerYcbcrConversionInfo { + static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::eSamplerYcbcrConversionInfo; + VULKAN_HPP_CONSTEXPR SamplerYcbcrConversionInfo( VULKAN_HPP_NAMESPACE::SamplerYcbcrConversion conversion_ = {} ) VULKAN_HPP_NOEXCEPT : conversion( conversion_ ) @@ -69851,8 +73390,16 @@ namespace VULKAN_HPP_NAMESPACE static_assert( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); + template <> + struct CppType + { + using Type = SamplerYcbcrConversionInfo; + }; + struct SemaphoreCreateInfo { + static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::eSemaphoreCreateInfo; + VULKAN_HPP_CONSTEXPR SemaphoreCreateInfo( VULKAN_HPP_NAMESPACE::SemaphoreCreateFlags flags_ = {} ) VULKAN_HPP_NOEXCEPT : flags( flags_ ) @@ -69920,8 +73467,16 @@ namespace VULKAN_HPP_NAMESPACE "struct and wrapper have different size!" ); static_assert( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); + template <> + struct CppType + { + using Type = SemaphoreCreateInfo; + }; + struct SemaphoreGetFdInfoKHR { + static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::eSemaphoreGetFdInfoKHR; + VULKAN_HPP_CONSTEXPR SemaphoreGetFdInfoKHR( VULKAN_HPP_NAMESPACE::Semaphore semaphore_ = {}, VULKAN_HPP_NAMESPACE::ExternalSemaphoreHandleTypeFlagBits handleType_ = VULKAN_HPP_NAMESPACE::ExternalSemaphoreHandleTypeFlagBits::eOpaqueFd ) @@ -70002,9 +73557,17 @@ namespace VULKAN_HPP_NAMESPACE "struct and wrapper have different size!" ); static_assert( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); + template <> + struct CppType + { + using Type = SemaphoreGetFdInfoKHR; + }; + #ifdef VK_USE_PLATFORM_WIN32_KHR struct SemaphoreGetWin32HandleInfoKHR { + static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::eSemaphoreGetWin32HandleInfoKHR; + VULKAN_HPP_CONSTEXPR SemaphoreGetWin32HandleInfoKHR( VULKAN_HPP_NAMESPACE::Semaphore semaphore_ = {}, VULKAN_HPP_NAMESPACE::ExternalSemaphoreHandleTypeFlagBits handleType_ = @@ -70087,10 +73650,18 @@ namespace VULKAN_HPP_NAMESPACE "struct and wrapper have different size!" ); static_assert( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); + + template <> + struct CppType + { + using Type = SemaphoreGetWin32HandleInfoKHR; + }; #endif /*VK_USE_PLATFORM_WIN32_KHR*/ struct SemaphoreSignalInfo { + static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::eSemaphoreSignalInfo; + VULKAN_HPP_CONSTEXPR SemaphoreSignalInfo( VULKAN_HPP_NAMESPACE::Semaphore semaphore_ = {}, uint64_t value_ = {} ) VULKAN_HPP_NOEXCEPT : semaphore( semaphore_ ) @@ -70167,8 +73738,16 @@ namespace VULKAN_HPP_NAMESPACE "struct and wrapper have different size!" ); static_assert( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); + template <> + struct CppType + { + using Type = SemaphoreSignalInfo; + }; + struct SemaphoreTypeCreateInfo { + static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::eSemaphoreTypeCreateInfo; + VULKAN_HPP_CONSTEXPR SemaphoreTypeCreateInfo( VULKAN_HPP_NAMESPACE::SemaphoreType semaphoreType_ = VULKAN_HPP_NAMESPACE::SemaphoreType::eBinary, uint64_t initialValue_ = {} ) VULKAN_HPP_NOEXCEPT @@ -70246,8 +73825,16 @@ namespace VULKAN_HPP_NAMESPACE "struct and wrapper have different size!" ); static_assert( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); + template <> + struct CppType + { + using Type = SemaphoreTypeCreateInfo; + }; + struct SemaphoreWaitInfo { + static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::eSemaphoreWaitInfo; + VULKAN_HPP_CONSTEXPR SemaphoreWaitInfo( VULKAN_HPP_NAMESPACE::SemaphoreWaitFlags flags_ = {}, uint32_t semaphoreCount_ = {}, const VULKAN_HPP_NAMESPACE::Semaphore * pSemaphores_ = {}, @@ -70343,6 +73930,12 @@ namespace VULKAN_HPP_NAMESPACE "struct and wrapper have different size!" ); static_assert( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); + template <> + struct CppType + { + using Type = SemaphoreWaitInfo; + }; + struct SetStateFlagsIndirectCommandNV { VULKAN_HPP_CONSTEXPR SetStateFlagsIndirectCommandNV( uint32_t data_ = {} ) VULKAN_HPP_NOEXCEPT : data( data_ ) {} @@ -70398,6 +73991,8 @@ namespace VULKAN_HPP_NAMESPACE struct ShaderModuleCreateInfo { + static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::eShaderModuleCreateInfo; + VULKAN_HPP_CONSTEXPR ShaderModuleCreateInfo( VULKAN_HPP_NAMESPACE::ShaderModuleCreateFlags flags_ = {}, size_t codeSize_ = {}, const uint32_t * pCode_ = {} ) VULKAN_HPP_NOEXCEPT @@ -70483,8 +74078,17 @@ namespace VULKAN_HPP_NAMESPACE "struct and wrapper have different size!" ); static_assert( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); + template <> + struct CppType + { + using Type = ShaderModuleCreateInfo; + }; + struct ShaderModuleValidationCacheCreateInfoEXT { + static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = + StructureType::eShaderModuleValidationCacheCreateInfoEXT; + VULKAN_HPP_CONSTEXPR ShaderModuleValidationCacheCreateInfoEXT( VULKAN_HPP_NAMESPACE::ValidationCacheEXT validationCache_ = {} ) VULKAN_HPP_NOEXCEPT : validationCache( validationCache_ ) @@ -70561,6 +74165,12 @@ namespace VULKAN_HPP_NAMESPACE static_assert( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); + template <> + struct CppType + { + using Type = ShaderModuleValidationCacheCreateInfoEXT; + }; + struct ShaderResourceUsageAMD { VULKAN_HPP_CONSTEXPR ShaderResourceUsageAMD( uint32_t numUsedVgprs_ = {}, @@ -70696,6 +74306,9 @@ namespace VULKAN_HPP_NAMESPACE struct SharedPresentSurfaceCapabilitiesKHR { + static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = + StructureType::eSharedPresentSurfaceCapabilitiesKHR; + VULKAN_HPP_CONSTEXPR SharedPresentSurfaceCapabilitiesKHR( VULKAN_HPP_NAMESPACE::ImageUsageFlags sharedPresentSupportedUsageFlags_ = {} ) VULKAN_HPP_NOEXCEPT : sharedPresentSupportedUsageFlags( sharedPresentSupportedUsageFlags_ ) @@ -70757,6 +74370,12 @@ namespace VULKAN_HPP_NAMESPACE static_assert( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); + template <> + struct CppType + { + using Type = SharedPresentSurfaceCapabilitiesKHR; + }; + struct SparseImageFormatProperties { VULKAN_HPP_CONSTEXPR @@ -70815,6 +74434,8 @@ namespace VULKAN_HPP_NAMESPACE struct SparseImageFormatProperties2 { + static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::eSparseImageFormatProperties2; + VULKAN_HPP_CONSTEXPR SparseImageFormatProperties2( VULKAN_HPP_NAMESPACE::SparseImageFormatProperties properties_ = {} ) VULKAN_HPP_NOEXCEPT : properties( properties_ ) @@ -70872,6 +74493,12 @@ namespace VULKAN_HPP_NAMESPACE static_assert( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); + template <> + struct CppType + { + using Type = SparseImageFormatProperties2; + }; + struct SparseImageMemoryRequirements { VULKAN_HPP_CONSTEXPR @@ -70938,6 +74565,8 @@ namespace VULKAN_HPP_NAMESPACE struct SparseImageMemoryRequirements2 { + static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::eSparseImageMemoryRequirements2; + VULKAN_HPP_CONSTEXPR SparseImageMemoryRequirements2( VULKAN_HPP_NAMESPACE::SparseImageMemoryRequirements memoryRequirements_ = {} ) VULKAN_HPP_NOEXCEPT : memoryRequirements( memoryRequirements_ ) @@ -70996,9 +74625,18 @@ namespace VULKAN_HPP_NAMESPACE static_assert( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); + template <> + struct CppType + { + using Type = SparseImageMemoryRequirements2; + }; + #ifdef VK_USE_PLATFORM_GGP struct StreamDescriptorSurfaceCreateInfoGGP { + static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = + StructureType::eStreamDescriptorSurfaceCreateInfoGGP; + VULKAN_HPP_CONSTEXPR StreamDescriptorSurfaceCreateInfoGGP( VULKAN_HPP_NAMESPACE::StreamDescriptorSurfaceCreateFlagsGGP flags_ = {}, GgpStreamDescriptor streamDescriptor_ = {} ) VULKAN_HPP_NOEXCEPT @@ -71083,6 +74721,12 @@ namespace VULKAN_HPP_NAMESPACE "struct and wrapper have different size!" ); static_assert( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); + + template <> + struct CppType + { + using Type = StreamDescriptorSurfaceCreateInfoGGP; + }; #endif /*VK_USE_PLATFORM_GGP*/ #ifdef VK_ENABLE_BETA_EXTENSIONS @@ -71179,6 +74823,8 @@ namespace VULKAN_HPP_NAMESPACE struct SubmitInfo { + static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::eSubmitInfo; + VULKAN_HPP_CONSTEXPR SubmitInfo( uint32_t waitSemaphoreCount_ = {}, const VULKAN_HPP_NAMESPACE::Semaphore * pWaitSemaphores_ = {}, @@ -71303,8 +74949,16 @@ namespace VULKAN_HPP_NAMESPACE static_assert( sizeof( SubmitInfo ) == sizeof( VkSubmitInfo ), "struct and wrapper have different size!" ); static_assert( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); + template <> + struct CppType + { + using Type = SubmitInfo; + }; + struct SubpassBeginInfo { + static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::eSubpassBeginInfo; + VULKAN_HPP_CONSTEXPR SubpassBeginInfo( VULKAN_HPP_NAMESPACE::SubpassContents contents_ = VULKAN_HPP_NAMESPACE::SubpassContents::eInline ) VULKAN_HPP_NOEXCEPT : contents( contents_ ) @@ -71372,8 +75026,17 @@ namespace VULKAN_HPP_NAMESPACE "struct and wrapper have different size!" ); static_assert( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); + template <> + struct CppType + { + using Type = SubpassBeginInfo; + }; + struct SubpassDescriptionDepthStencilResolve { + static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = + StructureType::eSubpassDescriptionDepthStencilResolve; + VULKAN_HPP_CONSTEXPR SubpassDescriptionDepthStencilResolve( VULKAN_HPP_NAMESPACE::ResolveModeFlagBits depthResolveMode_ = VULKAN_HPP_NAMESPACE::ResolveModeFlagBits::eNone, VULKAN_HPP_NAMESPACE::ResolveModeFlagBits stencilResolveMode_ = VULKAN_HPP_NAMESPACE::ResolveModeFlagBits::eNone, @@ -71470,8 +75133,16 @@ namespace VULKAN_HPP_NAMESPACE static_assert( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); + template <> + struct CppType + { + using Type = SubpassDescriptionDepthStencilResolve; + }; + struct SubpassEndInfo { + static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::eSubpassEndInfo; + VULKAN_HPP_CONSTEXPR SubpassEndInfo() VULKAN_HPP_NOEXCEPT {} SubpassEndInfo & operator=( SubpassEndInfo const & rhs ) VULKAN_HPP_NOEXCEPT @@ -71528,8 +75199,16 @@ namespace VULKAN_HPP_NAMESPACE static_assert( sizeof( SubpassEndInfo ) == sizeof( VkSubpassEndInfo ), "struct and wrapper have different size!" ); static_assert( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); + template <> + struct CppType + { + using Type = SubpassEndInfo; + }; + struct SurfaceCapabilities2EXT { + static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::eSurfaceCapabilities2EXT; + VULKAN_HPP_CONSTEXPR SurfaceCapabilities2EXT( uint32_t minImageCount_ = {}, uint32_t maxImageCount_ = {}, @@ -71624,6 +75303,12 @@ namespace VULKAN_HPP_NAMESPACE "struct and wrapper have different size!" ); static_assert( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); + template <> + struct CppType + { + using Type = SurfaceCapabilities2EXT; + }; + struct SurfaceCapabilitiesKHR { VULKAN_HPP_CONSTEXPR @@ -71709,6 +75394,8 @@ namespace VULKAN_HPP_NAMESPACE struct SurfaceCapabilities2KHR { + static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::eSurfaceCapabilities2KHR; + VULKAN_HPP_CONSTEXPR SurfaceCapabilities2KHR( VULKAN_HPP_NAMESPACE::SurfaceCapabilitiesKHR surfaceCapabilities_ = {} ) VULKAN_HPP_NOEXCEPT : surfaceCapabilities( surfaceCapabilities_ ) @@ -71764,9 +75451,18 @@ namespace VULKAN_HPP_NAMESPACE "struct and wrapper have different size!" ); static_assert( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); + template <> + struct CppType + { + using Type = SurfaceCapabilities2KHR; + }; + #ifdef VK_USE_PLATFORM_WIN32_KHR struct SurfaceCapabilitiesFullScreenExclusiveEXT { + static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = + StructureType::eSurfaceCapabilitiesFullScreenExclusiveEXT; + VULKAN_HPP_CONSTEXPR SurfaceCapabilitiesFullScreenExclusiveEXT( VULKAN_HPP_NAMESPACE::Bool32 fullScreenExclusiveSupported_ = {} ) VULKAN_HPP_NOEXCEPT : fullScreenExclusiveSupported( fullScreenExclusiveSupported_ ) @@ -71843,6 +75539,12 @@ namespace VULKAN_HPP_NAMESPACE "struct and wrapper have different size!" ); static_assert( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); + + template <> + struct CppType + { + using Type = SurfaceCapabilitiesFullScreenExclusiveEXT; + }; #endif /*VK_USE_PLATFORM_WIN32_KHR*/ struct SurfaceFormatKHR @@ -71900,6 +75602,8 @@ namespace VULKAN_HPP_NAMESPACE struct SurfaceFormat2KHR { + static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::eSurfaceFormat2KHR; + VULKAN_HPP_CONSTEXPR SurfaceFormat2KHR( VULKAN_HPP_NAMESPACE::SurfaceFormatKHR surfaceFormat_ = {} ) VULKAN_HPP_NOEXCEPT : surfaceFormat( surfaceFormat_ ) @@ -71955,9 +75659,18 @@ namespace VULKAN_HPP_NAMESPACE "struct and wrapper have different size!" ); static_assert( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); + template <> + struct CppType + { + using Type = SurfaceFormat2KHR; + }; + #ifdef VK_USE_PLATFORM_WIN32_KHR struct SurfaceFullScreenExclusiveInfoEXT { + static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = + StructureType::eSurfaceFullScreenExclusiveInfoEXT; + VULKAN_HPP_CONSTEXPR SurfaceFullScreenExclusiveInfoEXT( VULKAN_HPP_NAMESPACE::FullScreenExclusiveEXT fullScreenExclusive_ = VULKAN_HPP_NAMESPACE::FullScreenExclusiveEXT::eDefault ) VULKAN_HPP_NOEXCEPT @@ -72030,11 +75743,20 @@ namespace VULKAN_HPP_NAMESPACE "struct and wrapper have different size!" ); static_assert( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); + + template <> + struct CppType + { + using Type = SurfaceFullScreenExclusiveInfoEXT; + }; #endif /*VK_USE_PLATFORM_WIN32_KHR*/ #ifdef VK_USE_PLATFORM_WIN32_KHR struct SurfaceFullScreenExclusiveWin32InfoEXT { + static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = + StructureType::eSurfaceFullScreenExclusiveWin32InfoEXT; + VULKAN_HPP_CONSTEXPR SurfaceFullScreenExclusiveWin32InfoEXT( HMONITOR hmonitor_ = {} ) VULKAN_HPP_NOEXCEPT : hmonitor( hmonitor_ ) {} @@ -72106,10 +75828,18 @@ namespace VULKAN_HPP_NAMESPACE "struct and wrapper have different size!" ); static_assert( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); + + template <> + struct CppType + { + using Type = SurfaceFullScreenExclusiveWin32InfoEXT; + }; #endif /*VK_USE_PLATFORM_WIN32_KHR*/ struct SurfaceProtectedCapabilitiesKHR { + static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::eSurfaceProtectedCapabilitiesKHR; + VULKAN_HPP_CONSTEXPR SurfaceProtectedCapabilitiesKHR( VULKAN_HPP_NAMESPACE::Bool32 supportsProtected_ = {} ) VULKAN_HPP_NOEXCEPT : supportsProtected( supportsProtected_ ) @@ -72181,8 +75911,16 @@ namespace VULKAN_HPP_NAMESPACE static_assert( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); + template <> + struct CppType + { + using Type = SurfaceProtectedCapabilitiesKHR; + }; + struct SwapchainCounterCreateInfoEXT { + static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::eSwapchainCounterCreateInfoEXT; + VULKAN_HPP_CONSTEXPR SwapchainCounterCreateInfoEXT( VULKAN_HPP_NAMESPACE::SurfaceCounterFlagsEXT surfaceCounters_ = {} ) VULKAN_HPP_NOEXCEPT : surfaceCounters( surfaceCounters_ ) @@ -72254,8 +75992,16 @@ namespace VULKAN_HPP_NAMESPACE static_assert( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); + template <> + struct CppType + { + using Type = SwapchainCounterCreateInfoEXT; + }; + struct SwapchainCreateInfoKHR { + static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::eSwapchainCreateInfoKHR; + VULKAN_HPP_CONSTEXPR SwapchainCreateInfoKHR( VULKAN_HPP_NAMESPACE::SwapchainCreateFlagsKHR flags_ = {}, VULKAN_HPP_NAMESPACE::SurfaceKHR surface_ = {}, @@ -72473,8 +76219,17 @@ namespace VULKAN_HPP_NAMESPACE "struct and wrapper have different size!" ); static_assert( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); + template <> + struct CppType + { + using Type = SwapchainCreateInfoKHR; + }; + struct SwapchainDisplayNativeHdrCreateInfoAMD { + static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = + StructureType::eSwapchainDisplayNativeHdrCreateInfoAMD; + VULKAN_HPP_CONSTEXPR SwapchainDisplayNativeHdrCreateInfoAMD( VULKAN_HPP_NAMESPACE::Bool32 localDimmingEnable_ = {} ) VULKAN_HPP_NOEXCEPT : localDimmingEnable( localDimmingEnable_ ) {} @@ -72548,8 +76303,17 @@ namespace VULKAN_HPP_NAMESPACE static_assert( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); + template <> + struct CppType + { + using Type = SwapchainDisplayNativeHdrCreateInfoAMD; + }; + struct TextureLODGatherFormatPropertiesAMD { + static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = + StructureType::eTextureLodGatherFormatPropertiesAMD; + VULKAN_HPP_CONSTEXPR TextureLODGatherFormatPropertiesAMD( VULKAN_HPP_NAMESPACE::Bool32 supportsTextureGatherLODBiasAMD_ = {} ) VULKAN_HPP_NOEXCEPT : supportsTextureGatherLODBiasAMD( supportsTextureGatherLODBiasAMD_ ) @@ -72611,8 +76375,16 @@ namespace VULKAN_HPP_NAMESPACE static_assert( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); + template <> + struct CppType + { + using Type = TextureLODGatherFormatPropertiesAMD; + }; + struct TimelineSemaphoreSubmitInfo { + static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::eTimelineSemaphoreSubmitInfo; + VULKAN_HPP_CONSTEXPR TimelineSemaphoreSubmitInfo( uint32_t waitSemaphoreValueCount_ = {}, const uint64_t * pWaitSemaphoreValues_ = {}, @@ -72715,6 +76487,12 @@ namespace VULKAN_HPP_NAMESPACE static_assert( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); + template <> + struct CppType + { + using Type = TimelineSemaphoreSubmitInfo; + }; + #ifdef VK_ENABLE_BETA_EXTENSIONS struct TraceRaysIndirectCommandKHR { @@ -72796,6 +76574,8 @@ namespace VULKAN_HPP_NAMESPACE struct ValidationCacheCreateInfoEXT { + static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::eValidationCacheCreateInfoEXT; + VULKAN_HPP_CONSTEXPR ValidationCacheCreateInfoEXT( VULKAN_HPP_NAMESPACE::ValidationCacheCreateFlagsEXT flags_ = {}, size_t initialDataSize_ = {}, const void * pInitialData_ = {} ) VULKAN_HPP_NOEXCEPT @@ -72884,8 +76664,16 @@ namespace VULKAN_HPP_NAMESPACE static_assert( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); + template <> + struct CppType + { + using Type = ValidationCacheCreateInfoEXT; + }; + struct ValidationFeaturesEXT { + static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::eValidationFeaturesEXT; + VULKAN_HPP_CONSTEXPR ValidationFeaturesEXT( uint32_t enabledValidationFeatureCount_ = {}, const VULKAN_HPP_NAMESPACE::ValidationFeatureEnableEXT * pEnabledValidationFeatures_ = {}, @@ -72988,8 +76776,16 @@ namespace VULKAN_HPP_NAMESPACE "struct and wrapper have different size!" ); static_assert( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); + template <> + struct CppType + { + using Type = ValidationFeaturesEXT; + }; + struct ValidationFlagsEXT { + static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::eValidationFlagsEXT; + VULKAN_HPP_CONSTEXPR ValidationFlagsEXT( uint32_t disabledValidationCheckCount_ = {}, const VULKAN_HPP_NAMESPACE::ValidationCheckEXT * pDisabledValidationChecks_ = {} ) VULKAN_HPP_NOEXCEPT @@ -73069,9 +76865,17 @@ namespace VULKAN_HPP_NAMESPACE "struct and wrapper have different size!" ); static_assert( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); + template <> + struct CppType + { + using Type = ValidationFlagsEXT; + }; + #ifdef VK_USE_PLATFORM_VI_NN struct ViSurfaceCreateInfoNN { + static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::eViSurfaceCreateInfoNN; + VULKAN_HPP_CONSTEXPR ViSurfaceCreateInfoNN( VULKAN_HPP_NAMESPACE::ViSurfaceCreateFlagsNN flags_ = {}, void * window_ = {} ) VULKAN_HPP_NOEXCEPT : flags( flags_ ) @@ -73146,11 +76950,19 @@ namespace VULKAN_HPP_NAMESPACE static_assert( sizeof( ViSurfaceCreateInfoNN ) == sizeof( VkViSurfaceCreateInfoNN ), "struct and wrapper have different size!" ); static_assert( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); + + template <> + struct CppType + { + using Type = ViSurfaceCreateInfoNN; + }; #endif /*VK_USE_PLATFORM_VI_NN*/ #ifdef VK_USE_PLATFORM_WAYLAND_KHR struct WaylandSurfaceCreateInfoKHR { + static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::eWaylandSurfaceCreateInfoKHR; + VULKAN_HPP_CONSTEXPR WaylandSurfaceCreateInfoKHR( VULKAN_HPP_NAMESPACE::WaylandSurfaceCreateFlagsKHR flags_ = {}, struct wl_display * display_ = {}, struct wl_surface * surface_ = {} ) VULKAN_HPP_NOEXCEPT @@ -73238,11 +77050,20 @@ namespace VULKAN_HPP_NAMESPACE "struct and wrapper have different size!" ); static_assert( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); + + template <> + struct CppType + { + using Type = WaylandSurfaceCreateInfoKHR; + }; #endif /*VK_USE_PLATFORM_WAYLAND_KHR*/ #ifdef VK_USE_PLATFORM_WIN32_KHR struct Win32KeyedMutexAcquireReleaseInfoKHR { + static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = + StructureType::eWin32KeyedMutexAcquireReleaseInfoKHR; + VULKAN_HPP_CONSTEXPR Win32KeyedMutexAcquireReleaseInfoKHR( uint32_t acquireCount_ = {}, const VULKAN_HPP_NAMESPACE::DeviceMemory * pAcquireSyncs_ = {}, @@ -73374,11 +77195,20 @@ namespace VULKAN_HPP_NAMESPACE "struct and wrapper have different size!" ); static_assert( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); + + template <> + struct CppType + { + using Type = Win32KeyedMutexAcquireReleaseInfoKHR; + }; #endif /*VK_USE_PLATFORM_WIN32_KHR*/ #ifdef VK_USE_PLATFORM_WIN32_KHR struct Win32KeyedMutexAcquireReleaseInfoNV { + static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = + StructureType::eWin32KeyedMutexAcquireReleaseInfoNV; + VULKAN_HPP_CONSTEXPR Win32KeyedMutexAcquireReleaseInfoNV( uint32_t acquireCount_ = {}, const VULKAN_HPP_NAMESPACE::DeviceMemory * pAcquireSyncs_ = {}, @@ -73511,11 +77341,19 @@ namespace VULKAN_HPP_NAMESPACE "struct and wrapper have different size!" ); static_assert( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); + + template <> + struct CppType + { + using Type = Win32KeyedMutexAcquireReleaseInfoNV; + }; #endif /*VK_USE_PLATFORM_WIN32_KHR*/ #ifdef VK_USE_PLATFORM_WIN32_KHR struct Win32SurfaceCreateInfoKHR { + static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::eWin32SurfaceCreateInfoKHR; + VULKAN_HPP_CONSTEXPR Win32SurfaceCreateInfoKHR( VULKAN_HPP_NAMESPACE::Win32SurfaceCreateFlagsKHR flags_ = {}, HINSTANCE hinstance_ = {}, HWND hwnd_ = {} ) VULKAN_HPP_NOEXCEPT @@ -73601,10 +77439,18 @@ namespace VULKAN_HPP_NAMESPACE "struct and wrapper have different size!" ); static_assert( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); + + template <> + struct CppType + { + using Type = Win32SurfaceCreateInfoKHR; + }; #endif /*VK_USE_PLATFORM_WIN32_KHR*/ struct WriteDescriptorSet { + static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::eWriteDescriptorSet; + VULKAN_HPP_CONSTEXPR WriteDescriptorSet( VULKAN_HPP_NAMESPACE::DescriptorSet dstSet_ = {}, uint32_t dstBinding_ = {}, @@ -73742,8 +77588,17 @@ namespace VULKAN_HPP_NAMESPACE "struct and wrapper have different size!" ); static_assert( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); + template <> + struct CppType + { + using Type = WriteDescriptorSet; + }; + struct WriteDescriptorSetAccelerationStructureKHR { + static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = + StructureType::eWriteDescriptorSetAccelerationStructureKHR; + VULKAN_HPP_CONSTEXPR WriteDescriptorSetAccelerationStructureKHR( uint32_t accelerationStructureCount_ = {}, const VULKAN_HPP_NAMESPACE::AccelerationStructureKHR * pAccelerationStructures_ = {} ) VULKAN_HPP_NOEXCEPT @@ -73832,8 +77687,17 @@ namespace VULKAN_HPP_NAMESPACE static_assert( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); + template <> + struct CppType + { + using Type = WriteDescriptorSetAccelerationStructureKHR; + }; + struct WriteDescriptorSetInlineUniformBlockEXT { + static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = + StructureType::eWriteDescriptorSetInlineUniformBlockEXT; + VULKAN_HPP_CONSTEXPR WriteDescriptorSetInlineUniformBlockEXT( uint32_t dataSize_ = {}, const void * pData_ = {} ) VULKAN_HPP_NOEXCEPT : dataSize( dataSize_ ) @@ -73916,9 +77780,17 @@ namespace VULKAN_HPP_NAMESPACE static_assert( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); + template <> + struct CppType + { + using Type = WriteDescriptorSetInlineUniformBlockEXT; + }; + #ifdef VK_USE_PLATFORM_XCB_KHR struct XcbSurfaceCreateInfoKHR { + static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::eXcbSurfaceCreateInfoKHR; + VULKAN_HPP_CONSTEXPR XcbSurfaceCreateInfoKHR( VULKAN_HPP_NAMESPACE::XcbSurfaceCreateFlagsKHR flags_ = {}, xcb_connection_t * connection_ = {}, xcb_window_t window_ = {} ) VULKAN_HPP_NOEXCEPT @@ -74003,11 +77875,19 @@ namespace VULKAN_HPP_NAMESPACE static_assert( sizeof( XcbSurfaceCreateInfoKHR ) == sizeof( VkXcbSurfaceCreateInfoKHR ), "struct and wrapper have different size!" ); static_assert( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); + + template <> + struct CppType + { + using Type = XcbSurfaceCreateInfoKHR; + }; #endif /*VK_USE_PLATFORM_XCB_KHR*/ #ifdef VK_USE_PLATFORM_XLIB_KHR struct XlibSurfaceCreateInfoKHR { + static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::eXlibSurfaceCreateInfoKHR; + VULKAN_HPP_CONSTEXPR XlibSurfaceCreateInfoKHR( VULKAN_HPP_NAMESPACE::XlibSurfaceCreateFlagsKHR flags_ = {}, Display * dpy_ = {}, Window window_ = {} ) VULKAN_HPP_NOEXCEPT @@ -74092,6 +77972,12 @@ namespace VULKAN_HPP_NAMESPACE static_assert( sizeof( XlibSurfaceCreateInfoKHR ) == sizeof( VkXlibSurfaceCreateInfoKHR ), "struct and wrapper have different size!" ); static_assert( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); + + template <> + struct CppType + { + using Type = XlibSurfaceCreateInfoKHR; + }; #endif /*VK_USE_PLATFORM_XLIB_KHR*/ template