From 381494ed3f1a4bda87833f395041a4dff8dc058e Mon Sep 17 00:00:00 2001 From: asuessenbach Date: Mon, 15 Jun 2020 08:03:17 +0200 Subject: [PATCH] Update and adjustments to VK_VULKAN_HEADER 143 --- Vulkan-Headers | 2 +- VulkanHppGenerator.cpp | 173 +++++++++++++++++----------- VulkanHppGenerator.hpp | 15 +-- vulkan/vulkan.hpp | 254 ++++++++++++++++++++--------------------- 4 files changed, 240 insertions(+), 204 deletions(-) diff --git a/Vulkan-Headers b/Vulkan-Headers index 09531f2..9d2dfca 160000 --- a/Vulkan-Headers +++ b/Vulkan-Headers @@ -1 +1 @@ -Subproject commit 09531f27933bf04bffde9074acb302e026e8f181 +Subproject commit 9d2dfca53b754dd3ab916899fed567a5290c30aa diff --git a/VulkanHppGenerator.cpp b/VulkanHppGenerator.cpp index 87ad5e7..c119abe 100644 --- a/VulkanHppGenerator.cpp +++ b/VulkanHppGenerator.cpp @@ -2767,7 +2767,7 @@ void VulkanHppGenerator::appendFunctionHeaderArgumentEnhancedVector( std::string else { // it's a non-char vector (they are never optional) - //assert( !optional ); + assert( !optional ); if ( singular ) { // in singular case, change from pointer to reference @@ -3132,8 +3132,8 @@ void VulkanHppGenerator::appendHandle( std::string & // special handling for destroy functions bool platformLeft = false; if ( commandIt->second.alias.empty() && - ( ( commandIt->first.substr( 2, 7 ) == "Destroy" ) && ( commandName != "destroy" ) ) || - ( commandIt->first.substr( 2, 4 ) == "Free" ) ) + ( ( ( commandIt->first.substr( 2, 7 ) == "Destroy" ) && ( commandName != "destroy" ) ) || + ( commandIt->first.substr( 2, 4 ) == "Free" ) ) ) { assert( 1 < commandIt->second.params.size() ); auto handleIt = m_handles.find( commandIt->second.params[1].type.type ); @@ -4252,15 +4252,29 @@ void VulkanHppGenerator::checkCorrectness() } for ( auto const & member : structure.second.members ) { - if ( !member.values.empty() ) + if ( !member.selector.empty() ) { - assert( member.name == "sType" ); - check( std::find_if( structureTypeIt->second.values.begin(), - structureTypeIt->second.values.end(), - [&member]( auto const & evd ) { return member.values == evd.vulkanValue; } ) != - structureTypeIt->second.values.end(), - member.xmlLine, - "sType value <" + member.values + "> not listed for VkStructureType" ); + std::string const & selector = member.selector; + auto selectorIt = std::find_if( structure.second.members.begin(), + structure.second.members.end(), + [&selector]( MemberData const & md ) { return md.name == selector; } ); + assert( selectorIt != structure.second.members.end() ); + auto enumIt = m_enums.find( selectorIt->type.type ); + assert( enumIt != m_enums.end() ); + auto dataIt = m_structures.find( member.type.type ); + assert( ( dataIt != m_structures.end() ) && dataIt->second.isUnion ); + for ( auto const & data : dataIt->second.members ) + { + assert( !data.selection.empty() ); + std::string const & selection = data.selection; + check( std::find_if( enumIt->second.values.begin(), + enumIt->second.values.end(), + [&selection]( EnumValueData const & evd ) { return evd.vulkanValue == selection; } ) != + enumIt->second.values.end(), + data.xmlLine, + "union member <" + data.name + "> uses selection <" + selection + + "> that is not part of the selector type <" + selectorIt->type.type + ">" ); + } } check( m_types.find( member.type.type ) != m_types.end(), member.xmlLine, @@ -4271,6 +4285,16 @@ void VulkanHppGenerator::checkCorrectness() member.xmlLine, "struct member array size uses unknown constant <" + member.usedConstant + ">" ); } + if ( !member.values.empty() ) + { + assert( member.name == "sType" ); + check( std::find_if( structureTypeIt->second.values.begin(), + structureTypeIt->second.values.end(), + [&member]( auto const & evd ) { return member.values == evd.vulkanValue; } ) != + structureTypeIt->second.values.end(), + member.xmlLine, + "sType value <" + member.values + "> not listed for VkStructureType" ); + } } } @@ -4327,43 +4351,6 @@ void VulkanHppGenerator::checkCorrectness() } } -bool VulkanHppGenerator::checkLenAttribute( std::string const & len, std::vector const & params ) -{ - // simple: "null-terminated" or previously encountered parameter - if ( ( len == "null-terminated" ) || ( std::find_if( params.begin(), params.end(), [&len]( ParamData const & pd ) { - return pd.name == len; - } ) != params.end() ) ) - { - return true; - } - - // check if len specifies a member of a struct - std::vector lenParts = tokenize( len, "->" ); - if ( lenParts.size() == 1 ) - { - // older versions of vk.xml used the notation parameter::member - lenParts = tokenize( len, "::" ); - } - if ( lenParts.size() == 2 ) - { - auto paramIt = - std::find_if( params.begin(), params.end(), [&l = lenParts[0]]( ParamData const & pd ) { return pd.name == l; } ); - if ( paramIt != params.end() ) - { - auto structureIt = m_structures.find( paramIt->type.type ); - if ( ( structureIt != m_structures.end() ) && ( std::find_if( structureIt->second.members.begin(), - structureIt->second.members.end(), - [&n = lenParts[1]]( MemberData const & md ) { - return md.name == n; - } ) != structureIt->second.members.end() ) ) - { - return true; - } - } - } - return false; -} - bool VulkanHppGenerator::containsArray( std::string const & type ) const { // a simple recursive check if a type is or contains an array @@ -4568,12 +4555,7 @@ std::map VulkanHppGenerator::determineVectorParamIndices( std::v std::make_pair( std::distance( params.begin(), it ), ( findIt < it ) ? std::distance( params.begin(), findIt ) : INVALID_INDEX ) ); assert( ( vectorParamIndices[std::distance( params.begin(), it )] != INVALID_INDEX ) || - ( it->len == "null-terminated" ) || ( it->len == "pAllocateInfo->descriptorSetCount" ) || - ( it->len == "pAllocateInfo::descriptorSetCount" ) || - ( it->len == "pAllocateInfo->commandBufferCount" ) || - ( it->len == "pAllocateInfo::commandBufferCount" ) || - ( it->len == "pBuildInfo->geometryCount") - ); + ( it->len == "null-terminated" ) || isParamIndirect( it->len, params ) ); } } return vectorParamIndices; @@ -4720,6 +4702,38 @@ bool VulkanHppGenerator::holdsSType( std::string const & type ) const return false; } +bool VulkanHppGenerator::isParam( std::string const & name, std::vector const & params ) const +{ + return std::find_if( params.begin(), params.end(), [&name]( ParamData const & pd ) { return pd.name == name; } ) != + params.end(); +} + +bool VulkanHppGenerator::isParamIndirect( std::string const & name, std::vector const & params ) const +{ + // check if name specifies a member of a struct + std::vector nameParts = tokenize( name, "->" ); + if ( nameParts.size() == 1 ) + { + // older versions of vk.xml used the notation parameter::member + nameParts = tokenize( name, "::" ); + } + if ( nameParts.size() == 2 ) + { + auto paramIt = std::find_if( + params.begin(), params.end(), [&n = nameParts[0]]( ParamData const & pd ) { return pd.name == n; } ); + if ( paramIt != params.end() ) + { + auto structureIt = m_structures.find( paramIt->type.type ); + return ( structureIt != m_structures.end() ) && ( std::find_if( structureIt->second.members.begin(), + structureIt->second.members.end(), + [&n = nameParts[1]]( MemberData const & md ) { + return md.name == n; + } ) != structureIt->second.members.end() ); + } + } + return false; +} + 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 @@ -5002,7 +5016,8 @@ VulkanHppGenerator::ParamData VulkanHppGenerator::readCommandParam( tinyxml2::XM if ( attribute.first == "len" ) { paramData.len = attribute.second; - check( checkLenAttribute( paramData.len, params ), + check( ( paramData.len == "null-terminated" ) || isParam( paramData.len, params ) || + isParamIndirect( paramData.len, params ), line, "command param len <" + paramData.len + "> is not recognized as a valid len value" ); } @@ -6252,8 +6267,8 @@ void VulkanHppGenerator::readStruct( tinyxml2::XMLElement const * assert( !name.empty() ); // make this warn a check, as soon as vk.xml has been fixed on attribute "allowduplicate" ! warn( !allowDuplicate || !structExtends.empty(), - line, - "attribute is true, but no structures are listed in " ); + line, + "attribute is true, but no structures are listed in " ); check( m_structures.find( name ) == m_structures.end(), line, "struct <" + name + "> already specfied" ); std::map::iterator it = @@ -6271,7 +6286,7 @@ void VulkanHppGenerator::readStruct( tinyxml2::XMLElement const * } else if ( value == "member" ) { - readStructMember( child, it->second.members ); + readStructMember( child, it->second.members, isUnion ); } } it->second.subStruct = determineSubStruct( *it ); @@ -6318,7 +6333,9 @@ void VulkanHppGenerator::readStructAlias( tinyxml2::XMLElement const * "struct <" + name + "> already specified as a type" ); } -void VulkanHppGenerator::readStructMember( tinyxml2::XMLElement const * element, std::vector & members ) +void VulkanHppGenerator::readStructMember( tinyxml2::XMLElement const * element, + std::vector & members, + bool isUnion ) { int line = element->GetLineNum(); std::map attributes = getAttributes( element ); @@ -6330,6 +6347,8 @@ void VulkanHppGenerator::readStructMember( tinyxml2::XMLElement const * element, { "len", {} }, { "noautovalidity", { "true" } }, { "optional", { "false", "true" } }, + { "selection", {} }, + { "selector", {} }, { "values", {} } } ); std::vector children = getChildElements( element ); checkElements( line, children, { { "name", true }, { "type", true } }, { "comment", "enum" } ); @@ -6354,16 +6373,34 @@ void VulkanHppGenerator::readStructMember( tinyxml2::XMLElement const * element, } } - auto valuesIt = attributes.find( "values" ); - if ( valuesIt != attributes.end() ) + for ( auto const & attribute : attributes ) { - check( memberData.name == "sType", - line, - "Structure member named differently than with attribute encountered: " ); - check( m_sTypeValues.insert( valuesIt->second ).second, - line, - "<" + valuesIt->second + "> already encountered as values for the sType member of a struct" ); - memberData.values = valuesIt->second; + if ( attribute.first == "selection" ) + { + check( isUnion, line, "attribute is used with a non-union structure." ); + memberData.selection = attribute.second; + } + else if ( attribute.first == "selector" ) + { + memberData.selector = attribute.second; + std::string const & selector = memberData.selector; + auto selectorIt = std::find_if( + members.begin(), members.end(), [selector]( MemberData const & md ) { return md.name == selector; } ); + check( selectorIt != members.end(), line, "member attribute holds unknown value <" + selector + ">" ); + check( m_enums.find( selectorIt->type.type ) != m_enums.end(), + line, + "member attribute references unknown enum type <" + selectorIt->type.type + ">" ); + } + else if ( attribute.first == "values" ) + { + check( memberData.name == "sType", + line, + "Structure member named differently than with attribute encountered: " ); + check( m_sTypeValues.insert( attribute.second ).second, + line, + "<" + attribute.second + "> already encountered as values for the sType member of a struct" ); + memberData.values = attribute.second; + } } } diff --git a/VulkanHppGenerator.hpp b/VulkanHppGenerator.hpp index dbf92a1..af8b39d 100644 --- a/VulkanHppGenerator.hpp +++ b/VulkanHppGenerator.hpp @@ -149,11 +149,11 @@ private: std::string const & obsoletedBy_, std::string const & platform_, std::string const & promotedTo_ ) - : xmlLine( line ) - , deprecatedBy( deprecatedBy_ ) + : deprecatedBy( deprecatedBy_ ) , obsoletedBy( obsoletedBy_ ) , platform( platform_ ) , promotedTo( promotedTo_ ) + , xmlLine( line ) {} std::string deprecatedBy; @@ -193,6 +193,8 @@ private: std::string name; std::vector arraySizes; std::string bitCount; + std::string selection; + std::string selector; std::string values; std::string usedConstant; int xmlLine; @@ -207,9 +209,7 @@ private: struct StructureData { - StructureData( std::vector const & extends, int line ) - : structExtends( extends ), xmlLine( line ) - {} + StructureData( std::vector const & extends, int line ) : structExtends( extends ), xmlLine( line ) {} bool allowDuplicate = false; bool isUnion = false; @@ -499,7 +499,6 @@ private: 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, @@ -517,6 +516,8 @@ private: std::set const & extension ) const; std::pair generateProtection( std::string const & type, bool isAliased ) const; bool holdsSType( std::string const & type ) const; + bool isParam( std::string const & name, std::vector const & params ) const; + bool isParamIndirect( std::string const & name, std::vector const & params ) const; bool isTwoStepAlgorithm( std::vector const & params ) const; void readBaseType( tinyxml2::XMLElement const * element, std::map const & attributes ); void readBitmask( tinyxml2::XMLElement const * element, std::map const & attributes ); @@ -582,7 +583,7 @@ private: bool isUnion, std::map const & attributes ); void readStructAlias( tinyxml2::XMLElement const * element, std::map const & attributes ); - void readStructMember( tinyxml2::XMLElement const * element, std::vector & members ); + void readStructMember( tinyxml2::XMLElement const * element, std::vector & members, bool isUnion ); void readStructMemberEnum( tinyxml2::XMLElement const * element, MemberData & memberData ); void readStructMemberName( tinyxml2::XMLElement const * element, MemberData & memberData, diff --git a/vulkan/vulkan.hpp b/vulkan/vulkan.hpp index 8595f1e..1261352 100644 --- a/vulkan/vulkan.hpp +++ b/vulkan/vulkan.hpp @@ -1,32 +1,6 @@ // Copyright (c) 2015-2020 The Khronos Group Inc. // -// Licensed under the Apache License, Version 2.0 (the "License"); -// you may not use this file except in compliance with the License. -// You may obtain a copy of the License at -// -// http://www.apache.org/licenses/LICENSE-2.0 -// -// Unless required by applicable law or agreed to in writing, software -// distributed under the License is distributed on an "AS IS" BASIS, -// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. -// See the License for the specific language governing permissions and -// limitations under the License. -// -// ---- Exceptions to the Apache 2.0 License: ---- -// -// As an exception, if you use this Software to generate code and portions of -// this Software are embedded into the generated code as a result, you may -// redistribute such product without providing attribution as would otherwise -// be required by Sections 4(a), 4(b) and 4(d) of the License. -// -// In addition, if you combine or link code generated by this Software with -// software that is licensed under the GPLv2 or the LGPL v2.0 or 2.1 -// ("`Combined Software`") and if a court of competent jurisdiction determines -// that the patent provision (Section 3), the indemnity provision (Section 9) -// or other Section of the License conflicts with the conditions of the -// applicable GPL or LGPL license, you may retroactively and prospectively -// choose to deem waived or otherwise exclude such Section(s) of the License, -// but only in their entirety and only with respect to the Combined Software. +// SPDX-License-Identifier: Apache-2.0 OR MIT // // This header is generated from the Khronos Vulkan XML API Registry. @@ -78,7 +52,7 @@ # include #endif -static_assert( VK_HEADER_VERSION == 141, "Wrong VK_HEADER_VERSION!" ); +static_assert( VK_HEADER_VERSION == 143, "Wrong VK_HEADER_VERSION!" ); // 32-bit vulkan is not typesafe for handles, so don't allow copy constructors on this platform by default. // To enable this feature on 32-bit platforms please define VULKAN_HPP_TYPESAFE_CONVERSION @@ -5104,15 +5078,6 @@ namespace VULKAN_HPP_NAMESPACE } } - enum class BufferViewCreateFlagBits - { - }; - - VULKAN_HPP_INLINE std::string to_string( BufferViewCreateFlagBits ) - { - return "(void)"; - } - enum class BuildAccelerationStructureFlagBitsKHR : VkBuildAccelerationStructureFlagsKHR { eAllowUpdate = VK_BUILD_ACCELERATION_STRUCTURE_ALLOW_UPDATE_BIT_KHR, @@ -7837,15 +7802,6 @@ namespace VULKAN_HPP_NAMESPACE } } - enum class PipelineColorBlendStateCreateFlagBits - { - }; - - VULKAN_HPP_INLINE std::string to_string( PipelineColorBlendStateCreateFlagBits ) - { - return "(void)"; - } - enum class PipelineCompilerControlFlagBitsAMD : VkPipelineCompilerControlFlagsAMD { }; @@ -7924,24 +7880,6 @@ namespace VULKAN_HPP_NAMESPACE } } - enum class PipelineDepthStencilStateCreateFlagBits - { - }; - - VULKAN_HPP_INLINE std::string to_string( PipelineDepthStencilStateCreateFlagBits ) - { - return "(void)"; - } - - enum class PipelineDynamicStateCreateFlagBits - { - }; - - VULKAN_HPP_INLINE std::string to_string( PipelineDynamicStateCreateFlagBits ) - { - return "(void)"; - } - enum class PipelineExecutableStatisticFormatKHR { eBool32 = VK_PIPELINE_EXECUTABLE_STATISTIC_FORMAT_BOOL32_KHR, @@ -7962,42 +7900,6 @@ namespace VULKAN_HPP_NAMESPACE } } - enum class PipelineInputAssemblyStateCreateFlagBits - { - }; - - VULKAN_HPP_INLINE std::string to_string( PipelineInputAssemblyStateCreateFlagBits ) - { - return "(void)"; - } - - enum class PipelineLayoutCreateFlagBits - { - }; - - VULKAN_HPP_INLINE std::string to_string( PipelineLayoutCreateFlagBits ) - { - return "(void)"; - } - - enum class PipelineMultisampleStateCreateFlagBits - { - }; - - VULKAN_HPP_INLINE std::string to_string( PipelineMultisampleStateCreateFlagBits ) - { - return "(void)"; - } - - enum class PipelineRasterizationStateCreateFlagBits - { - }; - - VULKAN_HPP_INLINE std::string to_string( PipelineRasterizationStateCreateFlagBits ) - { - return "(void)"; - } - enum class PipelineShaderStageCreateFlagBits : VkPipelineShaderStageCreateFlags { eAllowVaryingSubgroupSizeEXT = VK_PIPELINE_SHADER_STAGE_CREATE_ALLOW_VARYING_SUBGROUP_SIZE_BIT_EXT, @@ -8080,33 +7982,6 @@ namespace VULKAN_HPP_NAMESPACE } } - enum class PipelineTessellationStateCreateFlagBits - { - }; - - VULKAN_HPP_INLINE std::string to_string( PipelineTessellationStateCreateFlagBits ) - { - return "(void)"; - } - - enum class PipelineVertexInputStateCreateFlagBits - { - }; - - VULKAN_HPP_INLINE std::string to_string( PipelineVertexInputStateCreateFlagBits ) - { - return "(void)"; - } - - enum class PipelineViewportStateCreateFlagBits - { - }; - - VULKAN_HPP_INLINE std::string to_string( PipelineViewportStateCreateFlagBits ) - { - return "(void)"; - } - enum class PointClippingBehavior { eAllClipPlanes = VK_POINT_CLIPPING_BEHAVIOR_ALL_CLIP_PLANES, @@ -10886,6 +10761,15 @@ namespace VULKAN_HPP_NAMESPACE return "{ " + result.substr( 0, result.size() - 3 ) + " }"; } + enum class BufferViewCreateFlagBits : VkFlags + { + }; + + VULKAN_HPP_INLINE std::string to_string( BufferViewCreateFlagBits ) + { + return "(void)"; + } + using BufferViewCreateFlags = Flags; VULKAN_HPP_INLINE std::string to_string( BufferViewCreateFlags ) @@ -13667,6 +13551,15 @@ namespace VULKAN_HPP_NAMESPACE return "{ " + result.substr( 0, result.size() - 3 ) + " }"; } + enum class PipelineColorBlendStateCreateFlagBits : VkFlags + { + }; + + VULKAN_HPP_INLINE std::string to_string( PipelineColorBlendStateCreateFlagBits ) + { + return "(void)"; + } + using PipelineColorBlendStateCreateFlags = Flags; VULKAN_HPP_INLINE std::string to_string( PipelineColorBlendStateCreateFlags ) @@ -13875,6 +13768,15 @@ namespace VULKAN_HPP_NAMESPACE return "{ " + result.substr( 0, result.size() - 3 ) + " }"; } + enum class PipelineDepthStencilStateCreateFlagBits : VkFlags + { + }; + + VULKAN_HPP_INLINE std::string to_string( PipelineDepthStencilStateCreateFlagBits ) + { + return "(void)"; + } + using PipelineDepthStencilStateCreateFlags = Flags; VULKAN_HPP_INLINE std::string to_string( PipelineDepthStencilStateCreateFlags ) @@ -13898,6 +13800,15 @@ namespace VULKAN_HPP_NAMESPACE return "{}"; } + enum class PipelineDynamicStateCreateFlagBits : VkFlags + { + }; + + VULKAN_HPP_INLINE std::string to_string( PipelineDynamicStateCreateFlagBits ) + { + return "(void)"; + } + using PipelineDynamicStateCreateFlags = Flags; VULKAN_HPP_INLINE std::string to_string( PipelineDynamicStateCreateFlags ) @@ -13905,6 +13816,15 @@ namespace VULKAN_HPP_NAMESPACE return "{}"; } + enum class PipelineInputAssemblyStateCreateFlagBits : VkFlags + { + }; + + VULKAN_HPP_INLINE std::string to_string( PipelineInputAssemblyStateCreateFlagBits ) + { + return "(void)"; + } + using PipelineInputAssemblyStateCreateFlags = Flags; VULKAN_HPP_INLINE std::string to_string( PipelineInputAssemblyStateCreateFlags ) @@ -13912,6 +13832,15 @@ namespace VULKAN_HPP_NAMESPACE return "{}"; } + enum class PipelineLayoutCreateFlagBits : VkFlags + { + }; + + VULKAN_HPP_INLINE std::string to_string( PipelineLayoutCreateFlagBits ) + { + return "(void)"; + } + using PipelineLayoutCreateFlags = Flags; VULKAN_HPP_INLINE std::string to_string( PipelineLayoutCreateFlags ) @@ -13919,6 +13848,15 @@ namespace VULKAN_HPP_NAMESPACE return "{}"; } + enum class PipelineMultisampleStateCreateFlagBits : VkFlags + { + }; + + VULKAN_HPP_INLINE std::string to_string( PipelineMultisampleStateCreateFlagBits ) + { + return "(void)"; + } + using PipelineMultisampleStateCreateFlags = Flags; VULKAN_HPP_INLINE std::string to_string( PipelineMultisampleStateCreateFlags ) @@ -13959,6 +13897,15 @@ namespace VULKAN_HPP_NAMESPACE return "{}"; } + enum class PipelineRasterizationStateCreateFlagBits : VkFlags + { + }; + + VULKAN_HPP_INLINE std::string to_string( PipelineRasterizationStateCreateFlagBits ) + { + return "(void)"; + } + using PipelineRasterizationStateCreateFlags = Flags; VULKAN_HPP_INLINE std::string to_string( PipelineRasterizationStateCreateFlags ) @@ -14142,6 +14089,15 @@ namespace VULKAN_HPP_NAMESPACE return "{ " + result.substr( 0, result.size() - 3 ) + " }"; } + enum class PipelineTessellationStateCreateFlagBits : VkFlags + { + }; + + VULKAN_HPP_INLINE std::string to_string( PipelineTessellationStateCreateFlagBits ) + { + return "(void)"; + } + using PipelineTessellationStateCreateFlags = Flags; VULKAN_HPP_INLINE std::string to_string( PipelineTessellationStateCreateFlags ) @@ -14149,6 +14105,15 @@ namespace VULKAN_HPP_NAMESPACE return "{}"; } + enum class PipelineVertexInputStateCreateFlagBits : VkFlags + { + }; + + VULKAN_HPP_INLINE std::string to_string( PipelineVertexInputStateCreateFlagBits ) + { + return "(void)"; + } + using PipelineVertexInputStateCreateFlags = Flags; VULKAN_HPP_INLINE std::string to_string( PipelineVertexInputStateCreateFlags ) @@ -14156,6 +14121,15 @@ namespace VULKAN_HPP_NAMESPACE return "{}"; } + enum class PipelineViewportStateCreateFlagBits : VkFlags + { + }; + + VULKAN_HPP_INLINE std::string to_string( PipelineViewportStateCreateFlagBits ) + { + return "(void)"; + } + using PipelineViewportStateCreateFlags = Flags; VULKAN_HPP_INLINE std::string to_string( PipelineViewportStateCreateFlags ) @@ -24365,7 +24339,7 @@ namespace VULKAN_HPP_NAMESPACE typename ResultValueType::type resetDescriptorPool( VULKAN_HPP_NAMESPACE::DescriptorPool descriptorPool, VULKAN_HPP_NAMESPACE::DescriptorPoolResetFlags flags = DescriptorPoolResetFlags(), - Dispatch const & d = VULKAN_HPP_DEFAULT_DISPATCHER ) const; + Dispatch const & d = VULKAN_HPP_DEFAULT_DISPATCHER ) const; #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ #ifdef VULKAN_HPP_DISABLE_ENHANCED_MODE @@ -94919,6 +94893,14 @@ namespace VULKAN_HPP_NAMESPACE }; }; template <> + struct StructExtends + { + enum + { + value = true + }; + }; + template <> struct StructExtends { enum @@ -96023,6 +96005,22 @@ namespace VULKAN_HPP_NAMESPACE }; }; template <> + struct StructExtends + { + enum + { + value = true + }; + }; + template <> + struct StructExtends + { + enum + { + value = true + }; + }; + template <> struct StructExtends { enum