mirror/Vulkan-Hpp
1
0
Fork 0
mirror of https://github.com/KhronosGroup/Vulkan-Hpp.git synced 2024-10-14 16:32:17 +00:00
Code Issues Actions 1 Packages Projects Releases Wiki Activity

Merge pull request #626 from asuessenbach/143

Browse Source 
Update and adjustments to VK_VULKAN_HEADER 143
This commit is contained in:
Andreas Süßenbach 2020-06-15 08:36:19 +02:00 committed by GitHub
commit 4d97c949c3
No known key found for this signature in database
GPG Key ID: 4AEE18F83AFDEB23
4 changed files with 240 additions and 204 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

2
Vulkan-Headers

@ -1 +1 @@
Subproject commit 09531f27933bf04bffde9074acb302e026e8f181
Subproject commit 9d2dfca53b754dd3ab916899fed567a5290c30aa

173
VulkanHppGenerator.cpp
View File

@ -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<ParamData> 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<std::string> 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<size_t, size_t> 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<ParamData> 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<ParamData> const & params ) const
{
// check if name specifies a member of a struct
std::vector<std::string> 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<ParamData> 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 <allowduplicate> is true, but no structures are listed in <structextends>" );
line,
"attribute <allowduplicate> is true, but no structures are listed in <structextends>" );
check( m_structures.find( name ) == m_structures.end(), line, "struct <" + name + "> already specfied" );
std::map<std::string, StructureData>::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<MemberData> & members )
void VulkanHppGenerator::readStructMember( tinyxml2::XMLElement const * element,
std::vector<MemberData> & members,
bool isUnion )
{
int line = element->GetLineNum();
std::map<std::string, std::string> 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<tinyxml2::XMLElement const *> 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 <sType> with attribute <values> 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 <selection> 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 <selector> holds unknown value <" + selector + ">" );
check( m_enums.find( selectorIt->type.type ) != m_enums.end(),
line,
"member attribute <selector> references unknown enum type <" + selectorIt->type.type + ">" );
}
else if ( attribute.first == "values" )
{
check( memberData.name == "sType",
line,
"Structure member named differently than <sType> with attribute <values> 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;
}
}
}

15
VulkanHppGenerator.hpp
View File

@ -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<std::string> 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<std::string> const & extends, int line )
: structExtends( extends ), xmlLine( line )
{}
StructureData( std::vector<std::string> const & extends, int line ) : structExtends( extends ), xmlLine( line ) {}
bool allowDuplicate = false;
bool isUnion = false;
@ -499,7 +499,6 @@ private:
std::set<std::string> const & childrenTypes ) const;
std::string constructConstexprString( std::pair<std::string, StructureData> const & structData ) const;
void checkCorrectness();
bool checkLenAttribute( std::string const & len, std::vector<ParamData> 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<std::string> const & extension ) const;
std::pair<std::string, std::string> generateProtection( std::string const & type, bool isAliased ) const;
bool holdsSType( std::string const & type ) const;
bool isParam( std::string const & name, std::vector<ParamData> const & params ) const;
bool isParamIndirect( std::string const & name, std::vector<ParamData> const & params ) const;
bool isTwoStepAlgorithm( std::vector<ParamData> const & params ) const;
void readBaseType( tinyxml2::XMLElement const * element, std::map<std::string, std::string> const & attributes );
void readBitmask( tinyxml2::XMLElement const * element, std::map<std::string, std::string> const & attributes );
@ -582,7 +583,7 @@ private:
bool isUnion,
std::map<std::string, std::string> const & attributes );
void readStructAlias( tinyxml2::XMLElement const * element, std::map<std::string, std::string> const & attributes );
void readStructMember( tinyxml2::XMLElement const * element, std::vector<MemberData> & members );
void readStructMember( tinyxml2::XMLElement const * element, std::vector<MemberData> & members, bool isUnion );
void readStructMemberEnum( tinyxml2::XMLElement const * element, MemberData & memberData );
void readStructMemberName( tinyxml2::XMLElement const * element,
MemberData & memberData,

254
vulkan/vulkan.hpp
View File

@ -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 <compare>
#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<BufferViewCreateFlagBits>;
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<PipelineColorBlendStateCreateFlagBits>;
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<PipelineDepthStencilStateCreateFlagBits>;
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<PipelineDynamicStateCreateFlagBits>;
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<PipelineInputAssemblyStateCreateFlagBits>;
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<PipelineLayoutCreateFlagBits>;
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<PipelineMultisampleStateCreateFlagBits>;
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<PipelineRasterizationStateCreateFlagBits>;
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<PipelineTessellationStateCreateFlagBits>;
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<PipelineVertexInputStateCreateFlagBits>;
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<PipelineViewportStateCreateFlagBits>;
VULKAN_HPP_INLINE std::string to_string( PipelineViewportStateCreateFlags )
@ -24365,7 +24339,7 @@ namespace VULKAN_HPP_NAMESPACE
typename ResultValueType<void>::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<DevicePrivateDataCreateInfoEXT, DeviceCreateInfo>
{
enum
{
value = true
};
};
template <>
struct StructExtends<DeviceQueueGlobalPriorityCreateInfoEXT, DeviceQueueCreateInfo>
{
enum
@ -96023,6 +96005,22 @@ namespace VULKAN_HPP_NAMESPACE
};
};
template <>
struct StructExtends<PhysicalDevicePrivateDataFeaturesEXT, PhysicalDeviceFeatures2>
{
enum
{
value = true
};
};
template <>
struct StructExtends<PhysicalDevicePrivateDataFeaturesEXT, DeviceCreateInfo>
{
enum
{
value = true
};
};
template <>
struct StructExtends<PhysicalDeviceProtectedMemoryFeatures, PhysicalDeviceFeatures2>
{
enum