From 5a4eceb0abaa2fdfdd646c2038487619deeacfc1 Mon Sep 17 00:00:00 2001 From: asuessenbach Date: Thu, 14 Oct 2021 08:36:04 +0200 Subject: [PATCH] Introduce factory methods for the RAII handle classes. --- VulkanHppGenerator.cpp | 771 +++++++++++++++++------ VulkanHppGenerator.hpp | 42 +- vulkan/vulkan_raii.hpp | 1316 +++++++++++++++++++++++++++++++++++++++- 3 files changed, 1927 insertions(+), 202 deletions(-) diff --git a/VulkanHppGenerator.cpp b/VulkanHppGenerator.cpp index e2e79c4..89fc032 100644 --- a/VulkanHppGenerator.cpp +++ b/VulkanHppGenerator.cpp @@ -143,8 +143,8 @@ ${basetypes} // filter out VkFlags and VkFlags64, as they are mapped to our own Flags class if ( ( baseType.first != "VkFlags" ) && ( baseType.first != "VkFlags64" ) ) { - basetypes += - " using " + stripPrefix( baseType.first, "Vk" ) + " = " + baseType.second.typeInfo.compose() + ";\n"; + basetypes += " using " + stripPrefix( baseType.first, "Vk" ) + " = " + + baseType.second.typeInfo.compose( "VULKAN_HPP_NAMESPACE" ) + ";\n"; } } @@ -621,6 +621,12 @@ ${deviceMembers} std::string VulkanHppGenerator::generateRAIIHandles() const { const std::string raiiHandlesTemplate = R"( + //======================================== + //=== RAII HANDLE forward declarations === + //======================================== + +${forwardDeclarations} + //==================== //=== RAII HANDLES === //==================== @@ -628,6 +634,17 @@ std::string VulkanHppGenerator::generateRAIIHandles() const ${raiiHandles} )"; + std::string forwardDeclarations; + for ( auto const & feature : m_features ) + { + forwardDeclarations += generateRAIIHandleForwardDeclarations( feature.second.requireData, feature.first ); + } + for ( auto const & extIt : m_extensionsByNumber ) + { + forwardDeclarations += + generateRAIIHandleForwardDeclarations( extIt.second->second.requireData, extIt.second->first ); + } + std::set listedHandles; auto handleIt = m_handles.begin(); assert( handleIt->first.empty() ); @@ -636,7 +653,8 @@ ${raiiHandles} { raiiHandles += generateRAIIHandle( *handleIt, listedHandles, m_RAIISpecialFunctions ); } - return replaceWithMap( raiiHandlesTemplate, { { "raiiHandles", raiiHandles } } ); + return replaceWithMap( raiiHandlesTemplate, + { { "forwardDeclarations", forwardDeclarations }, { "raiiHandles", raiiHandles } } ); } // Intended only for `enum class Result`! @@ -801,8 +819,7 @@ void VulkanHppGenerator::prepareRAIIHandles() { m_RAIISpecialFunctions.insert( handle.second.destructorIt->first ); } - handle.second.constructorIts = - determineRAIIHandleConstructors( handle.first, handle.second.destructorIt, m_RAIISpecialFunctions ); + handle.second.constructorIts = determineRAIIHandleConstructors( handle.first, handle.second.destructorIt ); } } @@ -1657,9 +1674,8 @@ std::vector } std::vector::const_iterator> - VulkanHppGenerator::determineRAIIHandleConstructors( std::string const & handleType, - std::map::const_iterator destructorIt, - std::set & specialFunctions ) const + VulkanHppGenerator::determineRAIIHandleConstructors( + std::string const & handleType, std::map::const_iterator destructorIt ) const { std::vector::const_iterator> constructorIts; auto isConstructorCandidate = [&handleType]( std::pair const & cd ) @@ -1727,7 +1743,6 @@ std::vector::const_iterat } if ( valid ) { - specialFunctions.insert( commandIt->first ); // filter out alias functions if ( commandIt->second.alias.empty() ) { @@ -1942,7 +1957,7 @@ std::string VulkanHppGenerator::generateArgumentListEnhanced( std::vector const & params, + size_t initialSkipCount, + std::set const & skippedParameters, + std::set const & singularParams ) const +{ + assert( initialSkipCount <= params.size() ); + std::string arguments = "*this"; + // skip the last parameter! + for ( size_t i = initialSkipCount; i < params.size() - 1; ++i ) + { + if ( skippedParameters.find( i ) == skippedParameters.end() ) + { + std::string argument = params[i].name; + if ( !params[i].type.isValue() ) + { + argument = startLowerCase( stripPrefix( argument, "p" ) ); + if ( singularParams.find( i ) != singularParams.end() ) + { + argument = stripPluralS( argument ); + } + } + else + { + assert( singularParams.find( i ) == singularParams.end() ); + } + arguments += ", " + argument; + } + } + return arguments; +} + std::string VulkanHppGenerator::generateCallArgumentsStandard( std::string const & handle, std::vector const & params ) const { @@ -2285,7 +2331,7 @@ std::string VulkanHppGenerator::generateCallArgumentsStandard( std::string const assert( param.arraySizes.size() == 1 ); assert( param.type.isValue() ); assert( param.type.postfix.empty() ); - argument = "reinterpret_cast<" + param.type.compose( false ) + " *>( " + argument + " )"; + argument = "reinterpret_cast<" + param.type.compose( "" ) + " *>( " + argument + " )"; } else if ( param.type.isValue() ) { @@ -2294,7 +2340,7 @@ std::string VulkanHppGenerator::generateCallArgumentsStandard( std::string const else { assert( !param.type.postfix.empty() ); - argument = "reinterpret_cast<" + param.type.compose( false ) + ">( " + argument + " )"; + argument = "reinterpret_cast<" + param.type.compose( "" ) + ">( " + argument + " )"; } } arguments += argument; @@ -2356,7 +2402,7 @@ std::string VulkanHppGenerator::generateCallArgumentEnhancedConstPointer( } else if ( param.optional ) { - argument = "static_cast<" + param.type.compose() + ">( " + name + " )"; + argument = "static_cast<" + param.type.compose( "VULKAN_HPP_NAMESPACE" ) + ">( " + name + " )"; } else { @@ -2364,7 +2410,7 @@ std::string VulkanHppGenerator::generateCallArgumentEnhancedConstPointer( } if ( beginsWith( param.type.type, "Vk" ) ) { - argument = "reinterpret_cast<" + param.type.compose( false ) + ">( " + argument + " )"; + argument = "reinterpret_cast<" + param.type.compose( "" ) + ">( " + argument + " )"; } } else if ( param.len == "null-terminated" ) @@ -2395,7 +2441,7 @@ std::string VulkanHppGenerator::generateCallArgumentEnhancedConstPointer( } if ( beginsWith( param.type.type, "Vk" ) || ( param.type.type == "void" ) ) { - argument = "reinterpret_cast<" + param.type.compose( false ) + ">( " + argument + " )"; + argument = "reinterpret_cast<" + param.type.compose( "" ) + ">( " + argument + " )"; } } return argument; @@ -2414,7 +2460,7 @@ std::string VulkanHppGenerator::generateCallArgumentEnhancedNonConstPointer( Par assert( param.arraySizes.empty() ); if ( beginsWith( param.type.type, "Vk" ) ) { - argument = "reinterpret_cast<" + param.type.compose( false ) + ">( &" + name + " )"; + argument = "reinterpret_cast<" + param.type.compose( "" ) + ">( &" + name + " )"; } else { @@ -2444,7 +2490,7 @@ std::string VulkanHppGenerator::generateCallArgumentEnhancedNonConstPointer( Par if ( ( beginsWith( param.type.type, "Vk" ) || ( param.type.type == "void" ) ) && ( !raiiHandleMemberFunction || !isHandleType( param.type.type ) ) ) { - argument = "reinterpret_cast<" + param.type.compose( false ) + ">( " + argument + " )"; + argument = "reinterpret_cast<" + param.type.compose( "" ) + ">( " + argument + " )"; } } } @@ -2475,7 +2521,7 @@ std::string VulkanHppGenerator::generateCallArgumentEnhancedValue( std::vector

( " + param.name + " )"; + argument = "static_cast<" + param.type.compose( "" ) + ">( " + param.name + " )"; } } else @@ -2483,7 +2529,7 @@ std::string VulkanHppGenerator::generateCallArgumentEnhancedValue( std::vector

( " + param.name + " )"; + argument = "reinterpret_cast<" + param.type.compose( "" ) + " *>( " + param.name + " )"; } } else @@ -3140,7 +3186,7 @@ std::string VulkanHppGenerator::generateCommandResultGetHandleUnique( std::strin generateArgumentListEnhanced( commandData.params, skippedParams, {}, definition, false, false, true ); std::string commandName = generateCommandName( name, commandData.params, initialSkipCount, m_tags ); std::string nodiscard = generateNoDiscard( 1 < commandData.successCodes.size(), 1 < commandData.errorCodes.size() ); - std::string returnBaseType = commandData.params[nonConstPointerIndex].type.compose(); + std::string returnBaseType = commandData.params[nonConstPointerIndex].type.compose( "VULKAN_HPP_NAMESPACE" ); assert( endsWith( returnBaseType, "*" ) ); returnBaseType.pop_back(); @@ -3315,10 +3361,10 @@ std::string VulkanHppGenerator::generateCommandResultGetTwoValues( std::string c generateArgumentListEnhanced( commandData.params, skippedParams, {}, definition, false, false, true ); std::string commandName = generateCommandName( name, commandData.params, initialSkipCount, m_tags ); std::string nodiscard = generateNoDiscard( 1 < commandData.successCodes.size(), 1 < commandData.errorCodes.size() ); - std::string firstReturnType = commandData.params[returnParamIndices[0]].type.compose(); + std::string firstReturnType = commandData.params[returnParamIndices[0]].type.compose( "VULKAN_HPP_NAMESPACE" ); assert( endsWith( firstReturnType, "*" ) ); firstReturnType.pop_back(); - std::string secondReturnType = commandData.params[returnParamIndices[1]].type.compose(); + std::string secondReturnType = commandData.params[returnParamIndices[1]].type.compose( "VULKAN_HPP_NAMESPACE" ); assert( endsWith( secondReturnType, "*" ) ); secondReturnType.pop_back(); @@ -3452,7 +3498,8 @@ std::string VulkanHppGenerator::generateCommandResultGetValue( std::string const generateArgumentListEnhanced( commandData.params, skippedParams, {}, definition, false, false, true ); std::string commandName = generateCommandName( name, commandData.params, initialSkipCount, m_tags ); std::string nodiscard = generateNoDiscard( 1 < commandData.successCodes.size(), 1 < commandData.errorCodes.size() ); - std::string returnBaseType = trimEnd( stripPostfix( commandData.params[returnParamIndex].type.compose(), "*" ) ); + std::string returnBaseType = + trimEnd( stripPostfix( commandData.params[returnParamIndex].type.compose( "VULKAN_HPP_NAMESPACE" ), "*" ) ); std::string typenameT; if ( returnBaseType == "void" ) { @@ -5875,7 +5922,8 @@ std::string VulkanHppGenerator::generateCommandVoidGetValue( std::string const & generateArgumentListEnhanced( commandData.params, skippedParameters, {}, definition, false, false, true ); std::string commandName = generateCommandName( name, commandData.params, initialSkipCount, m_tags ); std::string nodiscard = generateNoDiscard( 1 < commandData.successCodes.size(), 1 < commandData.errorCodes.size() ); - std::string returnType = stripPostfix( commandData.params[returnParamIndex].type.compose(), "*" ); + std::string returnType = + stripPostfix( commandData.params[returnParamIndex].type.compose( "VULKAN_HPP_NAMESPACE" ), "*" ); bool needsVectorSizeCheck = !vectorParamIndices.empty() && isLenByStructMember( commandData.params[vectorParamIndices.begin()->first].len, @@ -6743,8 +6791,9 @@ std::string VulkanHppGenerator::generateFunctionHeaderArgumentEnhancedVector( Pa // use our ArrayProxy bool isConst = ( param.type.prefix.find( "const" ) != std::string::npos ); return std::string( optional ? "Optional<" : "" ) + "ArrayProxy<" + - ( isTemplateParam ? ( isConst ? "const T" : "T" ) : stripPostfix( param.type.compose(), "*" ) ) + "> const &" + - ( optional ? "> " : "" ) + strippedParameterName; + ( isTemplateParam ? ( isConst ? "const T" : "T" ) + : stripPostfix( param.type.compose( "VULKAN_HPP_NAMESPACE" ), "*" ) ) + + "> const &" + ( optional ? "> " : "" ) + strippedParameterName; } std::string VulkanHppGenerator::generateFunctionPointerCheck( std::string const & function, @@ -7264,6 +7313,20 @@ std::string VulkanHppGenerator::generateRAIIHandle( std::pair( m_${parentName} ); + } +)"; + std::string parentType = stripPrefix( handle.second.destructorIt->second.params[0].type.type, "Vk" ); + getParent = replaceWithMap( getParentTemplate, + { { "parentName", startLowerCase( parentType ) }, { "parentType", parentType } } ); + } + const std::string handleTemplate = R"( ${enter} class ${handleType} { @@ -7300,6 +7363,7 @@ ${moveAssignmentInstructions} } ${getConstructorSuccessCode} +${getParent} ${dispatcherType} const * getDispatcher() const { VULKAN_HPP_ASSERT( m_dispatcher${dispatcherAccess}getVkHeaderVersion() == VK_HEADER_VERSION ); @@ -7321,6 +7385,7 @@ ${leave})"; { "enter", enter }, { "getConstructorSuccessCode", getConstructorSuccessCode }, { "getDispatcherReturn", ( handleType == "Device" ) || ( handleType == "Instance" ) ? "&" : "" }, + { "getParent", getParent }, { "handleName", handleName }, { "handleType", handleType }, { "leave", leave }, @@ -7486,11 +7551,10 @@ std::string VulkanHppGenerator::generateRAIIHandleCommandResultMultiSuccessWithE bool definition, size_t returnParamIndex ) const { - std::string str; - assert( !isHandleType( commandIt->second.params[returnParamIndex].type.type ) ); + std::string str; + std::map vectorParamIndices = determineVectorParamIndices( commandIt->second.params ); if ( commandIt->second.params[returnParamIndex].type.type == "void" ) { - std::map vectorParamIndices = determineVectorParamIndices( commandIt->second.params ); if ( vectorParamIndices.size() == 1 ) { if ( returnParamIndex == vectorParamIndices.begin()->first ) @@ -7505,9 +7569,27 @@ std::string VulkanHppGenerator::generateRAIIHandleCommandResultMultiSuccessWithE } } } + else if ( isHandleType( commandIt->second.params[returnParamIndex].type.type ) ) + { + if ( vectorParamIndices.size() == 2 ) + { + if ( returnParamIndex == std::next( vectorParamIndices.begin() )->first ) + { + if ( commandIt->second.params[vectorParamIndices.begin()->second].type.type == "uint32_t" ) + { + if ( isStructureChainAnchor( commandIt->second.params[vectorParamIndices.begin()->first].type.type ) ) + { + str = generateRAIIHandleCommandFactoryVector( + commandIt, initialSkipCount, { returnParamIndex }, vectorParamIndices, definition ); + str += generateRAIIHandleCommandFactorySingular( + commandIt, initialSkipCount, { returnParamIndex }, vectorParamIndices, definition ); + } + } + } + } + } else if ( !isStructureChainAnchor( commandIt->second.params[returnParamIndex].type.type ) ) { - std::map vectorParamIndices = determineVectorParamIndices( commandIt->second.params ); if ( vectorParamIndices.empty() ) { str = generateRAIIHandleCommandResultMultiSuccessWithErrors1ReturnValue( @@ -7529,7 +7611,8 @@ std::string VulkanHppGenerator::generateRAIIHandleCommandResultMultiSuccessWithE std::string argumentList = generateArgumentListEnhanced( commandIt->second.params, skippedParameters, {}, definition, false, false, false ); std::string commandName = generateCommandName( commandIt->first, commandIt->second.params, initialSkipCount, m_tags ); - std::string returnType = stripPostfix( commandIt->second.params[nonConstPointerParamIndices[0]].type.compose(), "*" ); + std::string returnType = stripPostfix( + commandIt->second.params[nonConstPointerParamIndices[0]].type.compose( "VULKAN_HPP_NAMESPACE" ), "*" ); if ( definition ) { @@ -7717,7 +7800,29 @@ std::string VulkanHppGenerator::generateRAIIHandleCommandResultMultiSuccessWithE if ( ( commandIt->second.params[returnParamIndices[0]].type.type == "uint32_t" ) || ( commandIt->second.params[returnParamIndices[0]].type.type == "size_t" ) ) { - if ( !isStructureChainAnchor( commandIt->second.params[returnParamIndices[1]].type.type ) ) + // needs some very special handling of "vkGetSwapchainImagesKHR" !! + if ( isHandleType( commandIt->second.params[returnParamIndices[1]].type.type ) && + ( commandIt->first != "vkGetSwapchainImagesKHR" ) ) + { + std::map vectorParamIndices = determineVectorParamIndices( commandIt->second.params ); + if ( vectorParamIndices.size() == 1 ) + { + if ( returnParamIndices[0] == vectorParamIndices.begin()->second ) + { + if ( returnParamIndices[1] == vectorParamIndices.begin()->first ) + { + if ( ( commandIt->second.successCodes.size() == 2 ) && + ( commandIt->second.successCodes[0] == "VK_SUCCESS" ) && + ( commandIt->second.successCodes[1] == "VK_INCOMPLETE" ) ) + { + return generateRAIIHandleCommandFactoryVector( + commandIt, initialSkipCount, returnParamIndices, vectorParamIndices, definition ); + } + } + } + } + } + else if ( !isStructureChainAnchor( commandIt->second.params[returnParamIndices[1]].type.type ) ) { std::map vectorParamIndices = determineVectorParamIndices( commandIt->second.params ); if ( vectorParamIndices.size() == 1 ) @@ -7753,6 +7858,7 @@ std::string VulkanHppGenerator::generateRAIIHandleCommandResultMultiSuccessWithE std::string argumentList = generateArgumentListEnhanced( commandIt->second.params, skippedParameters, {}, definition, false, false, false ); std::string commandName = generateCommandName( commandIt->first, commandIt->second.params, initialSkipCount, m_tags ); + std::string vectorElementType = commandIt->second.params[vectorParamIndices.begin()->first].type.type; if ( !isHandleType( vectorElementType ) ) { @@ -7760,7 +7866,8 @@ std::string VulkanHppGenerator::generateRAIIHandleCommandResultMultiSuccessWithE vectorElementType = ( vectorElementType == "void" ) ? "uint8_t" - : stripPostfix( commandIt->second.params[vectorParamIndices.begin()->first].type.compose(), "*" ); + : stripPostfix( + commandIt->second.params[vectorParamIndices.begin()->first].type.compose( "VULKAN_HPP_NAMESPACE" ), "*" ); } if ( definition ) @@ -8158,8 +8265,8 @@ std::string VulkanHppGenerator::generateRAIIHandleCommandResultSingleSuccessWith std::string callArguments = generateCallArgumentsEnhanced( commandIt->second.params, initialSkipCount, false, {}, true ); - std::string returnType = - stripPostfix( commandIt->second.params[nonConstPointerParamIndices[0]].type.compose(), "*" ); + std::string returnType = stripPostfix( + commandIt->second.params[nonConstPointerParamIndices[0]].type.compose( "VULKAN_HPP_NAMESPACE" ), "*" ); std::string returnVariable = startLowerCase( stripPrefix( commandIt->second.params[nonConstPointerParamIndices[0]].name, "p" ) ); @@ -8196,53 +8303,10 @@ std::string VulkanHppGenerator::generateRAIIHandleCommandResultSingleSuccessWith bool definition, size_t returnParamIndex ) const { - std::string str; - assert( !isHandleType( commandIt->second.params[returnParamIndex].type.type ) ); - if ( isStructureChainAnchor( commandIt->second.params[returnParamIndex].type.type ) ) + std::string str; + std::map vectorParamIndices = determineVectorParamIndices( commandIt->second.params ); + if ( commandIt->second.params[returnParamIndex].type.type == "void" ) { - std::map vectorParamIndices = determineVectorParamIndices( commandIt->second.params ); - if ( vectorParamIndices.empty() ) - { - str = generateRAIIHandleCommandResultSingleSuccessWithErrors1ReturnValue( - commandIt, initialSkipCount, vectorParamIndices, { returnParamIndex }, definition ); - str += generateRAIIHandleCommandResultSingleSuccessWithErrors1ReturnChain( - commandIt, initialSkipCount, vectorParamIndices, { returnParamIndex }, definition ); - } - } - else if ( commandIt->second.params[returnParamIndex].type.type != "void" ) - { - std::map vectorParamIndices = determineVectorParamIndices( commandIt->second.params ); - switch ( vectorParamIndices.size() ) - { - case 0: - str = generateRAIIHandleCommandResultSingleSuccessWithErrors1ReturnValue( - commandIt, initialSkipCount, vectorParamIndices, { returnParamIndex }, definition ); - break; - case 2: - if ( returnParamIndex == std::next( vectorParamIndices.begin() )->first ) - { - if ( vectorParamIndices.begin()->second == std::next( vectorParamIndices.begin() )->second ) - { - if ( commandIt->second.params[vectorParamIndices.begin()->second].type.type == "uint32_t" ) - { - if ( ( commandIt->second.params[vectorParamIndices.begin()->first].type.type != "void" ) && - !isHandleType( commandIt->second.params[vectorParamIndices.begin()->first].type.type ) && - !isStructureChainAnchor( commandIt->second.params[vectorParamIndices.begin()->first].type.type ) ) - { - str = generateRAIIHandleCommandResultSingleSuccessWithErrors1ReturnValueVector( - commandIt, initialSkipCount, returnParamIndex, vectorParamIndices, definition ); - str += generateRAIIHandleCommandResultSingleSuccessWithErrors1ReturnValueSingular( - commandIt, initialSkipCount, returnParamIndex, vectorParamIndices, definition ); - } - } - } - } - break; - } - } - else - { - std::map vectorParamIndices = determineVectorParamIndices( commandIt->second.params ); switch ( vectorParamIndices.size() ) { case 0: @@ -8281,6 +8345,84 @@ std::string VulkanHppGenerator::generateRAIIHandleCommandResultSingleSuccessWith break; } } + else if ( isHandleType( commandIt->second.params[returnParamIndex].type.type ) ) + { + switch ( vectorParamIndices.size() ) + { + case 0: + str = generateRAIIHandleCommandFactory( commandIt, initialSkipCount, returnParamIndex, definition ); + break; + case 1: + if ( returnParamIndex == vectorParamIndices.begin()->first ) + { + if ( m_structures.find( commandIt->second.params[vectorParamIndices.begin()->second].type.type ) != + m_structures.end() ) + { + str = generateRAIIHandleCommandFactoryVector( + commandIt, initialSkipCount, { returnParamIndex }, vectorParamIndices, definition ); + } + } + break; + case 2: + if ( returnParamIndex == std::next( vectorParamIndices.begin() )->first ) + { + if ( vectorParamIndices.begin()->second == std::next( vectorParamIndices.begin() )->second ) + { + if ( commandIt->second.params[vectorParamIndices.begin()->second].type.type == "uint32_t" ) + { + if ( isStructureChainAnchor( commandIt->second.params[vectorParamIndices.begin()->first].type.type ) ) + { + str = generateRAIIHandleCommandFactoryVector( + commandIt, initialSkipCount, { returnParamIndex }, vectorParamIndices, definition ); + str += generateRAIIHandleCommandFactorySingular( + commandIt, initialSkipCount, { returnParamIndex }, vectorParamIndices, definition ); + } + } + } + } + break; + } + } + else if ( isStructureChainAnchor( commandIt->second.params[returnParamIndex].type.type ) ) + { + if ( vectorParamIndices.empty() ) + { + str = generateRAIIHandleCommandResultSingleSuccessWithErrors1ReturnValue( + commandIt, initialSkipCount, vectorParamIndices, { returnParamIndex }, definition ); + str += generateRAIIHandleCommandResultSingleSuccessWithErrors1ReturnChain( + commandIt, initialSkipCount, vectorParamIndices, { returnParamIndex }, definition ); + } + } + else + { + switch ( vectorParamIndices.size() ) + { + case 0: + str = generateRAIIHandleCommandResultSingleSuccessWithErrors1ReturnValue( + commandIt, initialSkipCount, vectorParamIndices, { returnParamIndex }, definition ); + break; + case 2: + if ( returnParamIndex == std::next( vectorParamIndices.begin() )->first ) + { + if ( vectorParamIndices.begin()->second == std::next( vectorParamIndices.begin() )->second ) + { + if ( commandIt->second.params[vectorParamIndices.begin()->second].type.type == "uint32_t" ) + { + if ( ( commandIt->second.params[vectorParamIndices.begin()->first].type.type != "void" ) && + !isHandleType( commandIt->second.params[vectorParamIndices.begin()->first].type.type ) && + !isStructureChainAnchor( commandIt->second.params[vectorParamIndices.begin()->first].type.type ) ) + { + str = generateRAIIHandleCommandResultSingleSuccessWithErrors1ReturnValueVector( + commandIt, initialSkipCount, returnParamIndex, vectorParamIndices, definition ); + str += generateRAIIHandleCommandResultSingleSuccessWithErrors1ReturnValueSingular( + commandIt, initialSkipCount, returnParamIndex, vectorParamIndices, definition ); + } + } + } + } + break; + } + } return str; } @@ -8298,7 +8440,8 @@ std::string VulkanHppGenerator::generateRAIIHandleCommandResultSingleSuccessWith std::string argumentList = generateArgumentListEnhanced( commandIt->second.params, skippedParameters, {}, definition, false, false, false ); std::string commandName = generateCommandName( commandIt->first, commandIt->second.params, initialSkipCount, m_tags ); - std::string returnType = stripPostfix( commandIt->second.params[nonConstPointerParamIndices[0]].type.compose(), "*" ); + std::string returnType = stripPostfix( + commandIt->second.params[nonConstPointerParamIndices[0]].type.compose( "VULKAN_HPP_NAMESPACE" ), "*" ); std::string typenameT; if ( returnType == "void" ) { @@ -8962,8 +9105,15 @@ std::string VulkanHppGenerator::generateRAIIHandleCommandVoid( { case 0: str = generateRAIIHandleCommandVoid0Return( commandIt, initialSkipCount, definition ); break; case 1: - assert( !isHandleType( commandIt->second.params[returnParamIndices[0]].type.type ) ); - if ( commandIt->second.params[returnParamIndices[0]].type.type != "void" ) + if ( isHandleType( commandIt->second.params[returnParamIndices[0]].type.type ) ) + { + std::map vectorParamIndices = determineVectorParamIndices( commandIt->second.params ); + if ( vectorParamIndices.empty() ) + { + str = generateRAIIHandleCommandFactory( commandIt, initialSkipCount, returnParamIndices[0], definition ); + } + } + else if ( commandIt->second.params[returnParamIndices[0]].type.type != "void" ) { std::map vectorParamIndices = determineVectorParamIndices( commandIt->second.params ); auto returnVectorParamIt = vectorParamIndices.find( returnParamIndices[0] ); @@ -9099,8 +9249,8 @@ std::string VulkanHppGenerator::generateRAIIHandleCommandVoid1ReturnChain( std::string callArguments = generateCallArgumentsEnhanced( commandIt->second.params, initialSkipCount, false, {}, true ); - std::string returnType = - stripPostfix( commandIt->second.params[nonConstPointerParamIndices[0]].type.compose(), "*" ); + std::string returnType = stripPostfix( + commandIt->second.params[nonConstPointerParamIndices[0]].type.compose( "VULKAN_HPP_NAMESPACE" ), "*" ); std::string returnVariable = startLowerCase( stripPrefix( commandIt->second.params[nonConstPointerParamIndices[0]].name, "p" ) ); @@ -9145,7 +9295,8 @@ std::string VulkanHppGenerator::generateRAIIHandleCommandVoid1ReturnValue( std::string argumentList = generateArgumentListEnhanced( commandIt->second.params, skippedParameters, {}, definition, false, false, false ); std::string commandName = generateCommandName( commandIt->first, commandIt->second.params, initialSkipCount, m_tags ); - std::string returnType = stripPostfix( commandIt->second.params[nonConstPointerParamIndices[0]].type.compose(), "*" ); + std::string returnType = stripPostfix( + commandIt->second.params[nonConstPointerParamIndices[0]].type.compose( "VULKAN_HPP_NAMESPACE" ), "*" ); std::pair>> vectorSizeCheck = needsVectorSizeCheck( vectorParamIndices ); std::string noexceptString = vectorSizeCheck.first ? "VULKAN_HPP_NOEXCEPT_WHEN_NO_EXCEPTIONS" : "VULKAN_HPP_NOEXCEPT"; @@ -9241,8 +9392,8 @@ std::string VulkanHppGenerator::generateRAIIHandleCommandVoid2ReturnEnumerateCha generateCallArgumentsEnhanced( commandIt->second.params, initialSkipCount, true, {}, true ); std::string secondCallArguments = generateCallArgumentsEnhanced( commandIt->second.params, initialSkipCount, false, {}, true ); - std::string vectorElementType = - stripPostfix( commandIt->second.params[vectorParamIndices.begin()->first].type.compose(), "*" ); + std::string vectorElementType = stripPostfix( + commandIt->second.params[vectorParamIndices.begin()->first].type.compose( "VULKAN_HPP_NAMESPACE" ), "*" ); std::string vectorName = startLowerCase( stripPrefix( commandIt->second.params[vectorParamIndices.begin()->first].name, "p" ) ); @@ -9291,8 +9442,8 @@ std::string VulkanHppGenerator::generateRAIIHandleCommandVoid2ReturnEnumerateVal std::string argumentList = generateArgumentListEnhanced( commandIt->second.params, skippedParameters, {}, definition, false, false, false ); std::string commandName = generateCommandName( commandIt->first, commandIt->second.params, initialSkipCount, m_tags ); - std::string vectorElementType = - stripPostfix( commandIt->second.params[vectorParamIndices.begin()->first].type.compose(), "*" ); + std::string vectorElementType = stripPostfix( + commandIt->second.params[vectorParamIndices.begin()->first].type.compose( "VULKAN_HPP_NAMESPACE" ), "*" ); if ( definition ) { @@ -9534,15 +9685,71 @@ std::pair return std::make_pair( singularConstructors, arrayConstructors ); } -std::string VulkanHppGenerator::generateRAIIHandleConstructorArguments( std::string const & handleType, - std::vector const & params, - bool singular, - bool encounteredArgument ) const +std::string VulkanHppGenerator::generateRAIIHandleConstructorArgument( ParamData const & param, + bool definition, + bool singular ) const +{ + std::string argument; + if ( param.type.isConstPointer() ) + { + assert( beginsWith( param.type.type, "Vk" ) ); + assert( beginsWith( param.name, "p" ) ); + std::string argumentName = startLowerCase( stripPrefix( param.name, "p" ) ); + std::string argumentType = "VULKAN_HPP_NAMESPACE::" + stripPrefix( param.type.type, "Vk" ); + if ( param.optional ) + { + assert( param.len.empty() ); + argument = "VULKAN_HPP_NAMESPACE::Optional " + argumentName + + ( definition ? "" : " = nullptr" ); + } + else if ( param.len.empty() ) + { + argument = argumentType + " const & " + argumentName; + } + else if ( singular ) + { + argument = argumentType + " const & " + stripPluralS( argumentName ); + } + else + { + argument = "VULKAN_HPP_NAMESPACE::ArrayProxy<" + argumentType + "> const & " + argumentName; + } + } + else if ( specialPointerTypes.find( param.type.type ) != specialPointerTypes.end() ) + { + assert( !param.optional ); + assert( param.type.isNonConstPointer() ); + argument = param.type.type + " & " + param.name; + } + else if ( ( param.type.isValue() ) && isHandleType( param.type.type ) ) + { + argument = "VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::" + stripPrefix( param.type.type, "Vk" ); + if ( param.optional ) + { + argument = "VULKAN_HPP_NAMESPACE::Optional"; + } + argument += " const & " + param.name; + } + else + { + assert( !param.optional ); + argument = param.type.compose( "VULKAN_HPP_NAMESPACE" ) + " " + param.name; + } + return argument; +} + +std::string + VulkanHppGenerator::generateRAIIHandleConstructorArguments( std::pair const & handle, + std::vector const & params, + bool singular, + bool skipLeadingGrandParent, + bool encounteredArgument ) const { std::string arguments; - for ( auto param : params ) + for ( size_t i = skipLeadingGrandParent ? 1 : 0; i < params.size(); i++ ) { - if ( param.type.type != handleType ) // filter out the constructed type + ParamData const & param = params[i]; + if ( param.type.type != handle.first ) // filter out the constructed type { // the specialPointerTypes are considered const-pointers! if ( param.type.isNonConstPointer() && @@ -9552,7 +9759,7 @@ std::string VulkanHppGenerator::generateRAIIHandleConstructorArguments( std::str #if !defined( NDEBUG ) assert( param.type.type == "uint32_t" ); auto typeIt = std::find_if( - params.begin(), params.end(), [&handleType]( ParamData const & pd ) { return pd.type.type == handleType; } ); + params.begin(), params.end(), [&handle]( ParamData const & pd ) { return pd.type.type == handle.first; } ); assert( typeIt != params.end() ); assert( typeIt->len == param.name ); #endif @@ -9571,57 +9778,7 @@ std::string VulkanHppGenerator::generateRAIIHandleConstructorArguments( std::str { arguments += ", "; } - if ( param.type.isConstPointer() ) - { - assert( beginsWith( param.type.type, "Vk" ) ); - assert( beginsWith( param.name, "p" ) ); - std::string argumentName = startLowerCase( stripPrefix( param.name, "p" ) ); - std::string argumentType = "VULKAN_HPP_NAMESPACE::" + stripPrefix( param.type.type, "Vk" ); - if ( param.optional ) - { - assert( param.len.empty() ); - arguments += "VULKAN_HPP_NAMESPACE::Optional " + argumentName + " = nullptr"; - } - else if ( param.len.empty() ) - { - arguments += argumentType + " const & " + argumentName; - } - else - { - assert( std::find_if( params.begin(), - params.end(), - [¶m]( ParamData const & pd ) { return pd.name == param.len; } ) != params.end() ); - if ( singular ) - { - arguments += argumentType + " const & " + stripPluralS( argumentName ); - } - else - { - arguments += "VULKAN_HPP_NAMESPACE::ArrayProxy<" + argumentType + "> const & " + argumentName; - } - } - } - else if ( specialPointerTypes.find( param.type.type ) != specialPointerTypes.end() ) - { - assert( !param.optional ); - assert( param.type.isNonConstPointer() ); - arguments += param.type.type + " & " + param.name; - } - else if ( ( param.type.isValue() ) && isHandleType( param.type.type ) ) - { - std::string argument = - "VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::" + stripPrefix( param.type.type, "Vk" ); - if ( param.optional ) - { - argument = "VULKAN_HPP_NAMESPACE::Optional"; - } - arguments += argument + " const & " + param.name; - } - else - { - assert( !param.optional ); - arguments += param.type.compose() + " " + param.name; - } + arguments += generateRAIIHandleConstructorArgument( param, false, singular ); encounteredArgument = true; } } @@ -9632,11 +9789,22 @@ std::string VulkanHppGenerator::generateRAIIHandleConstructorCallArguments( std: std::vector const & params, bool nonConstPointerAsNullptr, std::set const & singularParams, - bool allocatorIsMemberVariable ) const + bool allocatorIsMemberVariable, + bool skipLeadingGrandParent ) const { std::string arguments; bool encounteredArgument = false; - for ( size_t i = 0; i < params.size(); ++i ) + size_t i = 0; + if ( skipLeadingGrandParent ) + { + assert( ( 1 < params.size() ) && ( m_handles.find( params[0].type.type ) != m_handles.end() ) && + ( m_handles.find( params[1].type.type ) != m_handles.end() ) ); + arguments += "static_cast<" + params[0].type.type + ">( " + params[1].name + ".get" + + stripPrefix( params[0].type.type, "Vk" ) + "() )"; + encounteredArgument = true; + i = 1; + } + for ( ; i < params.size(); ++i ) { ParamData const & param = params[i]; if ( encounteredArgument ) @@ -9685,7 +9853,7 @@ std::string VulkanHppGenerator::generateRAIIHandleConstructorCallArguments( std: } else { - arguments += "static_cast<" + param.type.type + " >( *" + param.name + " )"; + arguments += "static_cast<" + param.type.type + ">( *" + param.name + " )"; } } else @@ -9748,21 +9916,23 @@ ${leave})"; return replaceWithMap( constructorTemplate, { { "constructorArguments", - generateRAIIHandleConstructorArguments( handle.first, constructorIt->second.params, false, false ) }, + generateRAIIHandleConstructorArguments( handle, constructorIt->second.params, false, false, false ) }, { "constructorCall", constructorIt->first }, { "counterName", startLowerCase( stripPrefix( lenParamIt->name, "p" ) ) }, { "counterType", lenParamIt->type.type }, { "dispatcherType", dispatcherType }, { "enter", enter }, { "firstCallArguments", - generateRAIIHandleConstructorCallArguments( handle.first, constructorIt->second.params, true, {}, true ) }, + generateRAIIHandleConstructorCallArguments( + handle.first, constructorIt->second.params, true, {}, true, false ) }, { "handleConstructorArguments", handleConstructorArguments }, { "handleName", startLowerCase( handleType ) }, { "handleType", handleType }, { "leave", leave }, { "parentName", constructorIt->second.params.front().name }, { "secondCallArguments", - generateRAIIHandleConstructorCallArguments( handle.first, constructorIt->second.params, false, {}, true ) }, + generateRAIIHandleConstructorCallArguments( + handle.first, constructorIt->second.params, false, {}, true, false ) }, { "vectorElementType", handleParamIt->type.type }, { "vectorName", startLowerCase( stripPrefix( handleParamIt->name, "p" ) ) } } ); } @@ -9854,8 +10024,23 @@ std::string VulkanHppGenerator::generateRAIIHandleConstructorResult( std::string const & enter, std::string const & leave ) const { - std::string callArguments = generateRAIIHandleConstructorCallArguments( - handle.first, constructorIt->second.params, false, {}, handle.second.destructorIt != m_commands.end() ); + bool skipLeadingGrandParent = false; + if ( ( 1 < constructorIt->second.params.size() ) && isHandleType( constructorIt->second.params[0].type.type ) && + ( constructorIt->second.params[1].type.type == handle.second.parent ) ) + { + auto parentIt = m_handles.find( handle.second.parent ); + assert( parentIt != m_handles.end() ); + skipLeadingGrandParent = ( constructorIt->second.params[0].type.type == parentIt->second.parent ); + } + + std::string callArguments = + generateRAIIHandleConstructorCallArguments( handle.first, + constructorIt->second.params, + false, + {}, + handle.second.destructorIt != m_commands.end(), + skipLeadingGrandParent ); + std::string constructorArguments, dispatcherArgument, dispatcherInit, getDispatcher; if ( handle.first == "VkInstance" ) { @@ -9865,7 +10050,9 @@ std::string VulkanHppGenerator::generateRAIIHandleConstructorResult( } else { - dispatcherArgument = constructorIt->second.params[0].name + ".getDispatcher()"; + dispatcherArgument = + ( skipLeadingGrandParent ? constructorIt->second.params[1].name : constructorIt->second.params[0].name ) + + ".getDispatcher()"; if ( handle.first == "VkDevice" ) { dispatcherArgument = dispatcherArgument + "->vkGetDeviceProcAddr"; @@ -9876,15 +10063,19 @@ std::string VulkanHppGenerator::generateRAIIHandleConstructorResult( getDispatcher = "getDispatcher()"; } } + constructorArguments += generateRAIIHandleConstructorArguments( - handle.first, constructorIt->second.params, false, handle.first == "VkInstance" ); + handle, constructorIt->second.params, false, skipLeadingGrandParent, handle.first == "VkInstance" ); if ( ( handle.first == "VkDevice" ) || ( handle.first == "VkInstance" ) ) { dispatcherInit = "\n m_dispatcher.init( static_cast<" + handle.first + ">( m_" + startLowerCase( stripPrefix( handle.first, "Vk" ) ) + " ) );"; } std::string initializationList = generateRAIIHandleConstructorInitializationList( - handle.first, constructorIt, handle.second.destructorIt, !handle.second.secondLevelCommands.empty() ); + handle.first, + constructorIt, + handle.second.destructorIt, + !handle.second.secondLevelCommands.empty() && !skipLeadingGrandParent ); const std::string constructorTemplate = R"( @@ -9950,7 +10141,7 @@ std::string VulkanHppGenerator::generateRAIIHandleConstructorTakeOwnership( { params.erase( paramIt ); } - constructorArguments += generateRAIIHandleConstructorArguments( handle.first, params, false, true ); + constructorArguments += generateRAIIHandleConstructorArguments( handle, params, false, false, true ); initializationList += generateRAIIHandleConstructorInitializationList( handle.first, handle.second.destructorIt, handle.second.destructorIt, @@ -10052,9 +10243,10 @@ ${leave})"; return replaceWithMap( constructorTemplate, { { "callArguments", - generateRAIIHandleConstructorCallArguments( handle.first, constructorIt->second.params, false, {}, false ) }, + generateRAIIHandleConstructorCallArguments( + handle.first, constructorIt->second.params, false, {}, false, false ) }, { "constructorArguments", - generateRAIIHandleConstructorArguments( handle.first, constructorIt->second.params, false, false ) }, + generateRAIIHandleConstructorArguments( handle, constructorIt->second.params, false, false, false ) }, { "constructorCall", constructorIt->first }, { "enter", enter }, { "handleConstructorArguments", handleConstructorArguments }, @@ -10081,7 +10273,7 @@ std::string VulkanHppGenerator::generateRAIIHandleConstructorVectorSingular( std::set singularParams = determineSingularParams( returnParamIndex, vectorParamIndices ); std::string callArguments = generateRAIIHandleConstructorCallArguments( - handle.first, constructorIt->second.params, false, singularParams, true ); + handle.first, constructorIt->second.params, false, singularParams, true, false ); std::string initializationList = generateRAIIHandleConstructorInitializationList( handle.first, constructorIt, handle.second.destructorIt, !handle.second.secondLevelCommands.empty() ); std::string failureCheck = generateFailureCheck( constructorIt->second.successCodes ); @@ -10105,7 +10297,7 @@ ${leave})"; { { "initializationList", initializationList }, { "callArguments", callArguments }, { "constructorArguments", - generateRAIIHandleConstructorArguments( handle.first, constructorIt->second.params, true, false ) }, + generateRAIIHandleConstructorArguments( handle, constructorIt->second.params, true, false, false ) }, { "constructorCall", constructorIt->first }, { "enter", enter }, { "firstArgument", constructorIt->second.params[0].name }, @@ -10121,9 +10313,9 @@ std::string VulkanHppGenerator::generateRAIIHandleConstructorVoid( std::string const & leave ) const { std::string callArguments = - generateRAIIHandleConstructorCallArguments( handle.first, constructorIt->second.params, false, {}, true ); + generateRAIIHandleConstructorCallArguments( handle.first, constructorIt->second.params, false, {}, true, false ); std::string constructorArguments = - generateRAIIHandleConstructorArguments( handle.first, constructorIt->second.params, false, false ); + generateRAIIHandleConstructorArguments( handle, constructorIt->second.params, false, false, false ); std::string initializationList = generateRAIIHandleConstructorInitializationList( handle.first, constructorIt, handle.second.destructorIt, !handle.second.secondLevelCommands.empty() ); @@ -10346,8 +10538,8 @@ std::tuple assert( !handle.second.constructorIts.front()->second.params.empty() ); auto const & parentType = handle.second.constructorIts.front()->second.params.front().type; assert( isHandleType( parentType.type ) ); - memberVariables += "\n VULKAN_HPP_NAMESPACE::" + stripPrefix( parentType.type, "Vk" ) + " m_" + - startLowerCase( stripPrefix( parentType.type, "Vk" ) ) + ";"; + memberVariables += + "\n " + parentType.type + " m_" + startLowerCase( stripPrefix( parentType.type, "Vk" ) ) + ";"; } if ( multiSuccessCodeContructor ) { @@ -10381,6 +10573,24 @@ std::tuple getConstructorSuccessCode, memberVariables, moveConstructorInitializerList, moveAssignmentInstructions ); } +std::string VulkanHppGenerator::generateRAIIHandleForwardDeclarations( std::vector const & requireData, + std::string const & title ) const +{ + std::string str; + for ( auto const & require : requireData ) + { + for ( auto const & type : require.types ) + { + auto handleIt = m_handles.find( type ); + if ( handleIt != m_handles.end() ) + { + str += " class " + stripPrefix( handleIt->first, "Vk" ) + ";\n"; + } + } + } + return addTitleAndProtection( title, str ); +} + std::string VulkanHppGenerator::generateRAIIHandleSingularConstructorArguments( std::pair const & handle, std::map::const_iterator constructorIt ) const @@ -10823,7 +11033,7 @@ std::string VulkanHppGenerator::generateStructConstructorsEnhanced( std::string argumentName = startLowerCase( stripPrefix( mit->name, "p" ) ) + "_"; assert( endsWith( mit->type.postfix, "*" ) ); - std::string argumentType = trimEnd( stripPostfix( mit->type.compose(), "*" ) ); + std::string argumentType = trimEnd( stripPostfix( mit->type.compose( "VULKAN_HPP_NAMESPACE" ), "*" ) ); if ( ( mit->type.type == "void" ) && ( argumentType.find( '*' ) == std::string::npos ) ) { // the argument after stripping one pointer is just void @@ -10888,11 +11098,12 @@ std::string VulkanHppGenerator::generateStructConstructorArgument( bool str += ( listedArgument ? ( ", " ) : "" ); if ( memberData.arraySizes.empty() ) { - str += memberData.type.compose() + " "; + str += memberData.type.compose( "VULKAN_HPP_NAMESPACE" ) + " "; } else { - str += generateStandardArray( memberData.type.compose(), memberData.arraySizes ) + " const & "; + str += + generateStandardArray( memberData.type.compose( "VULKAN_HPP_NAMESPACE" ), memberData.arraySizes ) + " const & "; } str += memberData.name + "_"; @@ -11120,12 +11331,12 @@ std::pair } else if ( member.arraySizes.empty() ) { - str += member.type.compose(); + str += member.type.compose( "VULKAN_HPP_NAMESPACE" ); } else { assert( member.type.prefix.empty() && member.type.postfix.empty() ); - str += generateStandardArrayWrapper( member.type.compose(), member.arraySizes ); + str += generateStandardArrayWrapper( member.type.compose( "VULKAN_HPP_NAMESPACE" ), member.arraySizes ); } str += " " + member.name; if ( !member.value.empty() ) @@ -11198,9 +11409,10 @@ std::string VulkanHppGenerator::generateStructSetter( std::string const & } )"; - std::string memberType = member.arraySizes.empty() - ? member.type.compose() - : generateStandardArray( member.type.compose(), member.arraySizes ); + std::string memberType = + member.arraySizes.empty() + ? member.type.compose( "VULKAN_HPP_NAMESPACE" ) + : generateStandardArray( member.type.compose( "VULKAN_HPP_NAMESPACE" ), member.arraySizes ); std::string assignment; if ( !member.bitCount.empty() && beginsWith( member.type.type, "Vk" ) ) { @@ -11411,8 +11623,9 @@ std::string VulkanHppGenerator::generateUnion( std::pairarraySizes.empty() ) - ? memberIt->type.compose() - : ( "const " + generateStandardArray( memberIt->type.compose(), memberIt->arraySizes ) + "&" ); + ? memberIt->type.compose( "VULKAN_HPP_NAMESPACE" ) + : ( "const " + + generateStandardArray( memberIt->type.compose( "VULKAN_HPP_NAMESPACE" ), memberIt->arraySizes ) + "&" ); static const std::string constructorTemplate = R"( ${unionName}( ${memberType} ${argumentName}_${defaultAssignment} ) @@ -11460,8 +11673,9 @@ std::string VulkanHppGenerator::generateUnion( std::pairtype.prefix.empty() && lenMember->type.postfix.empty(), line, - "member attribute references a member of unexpected type <" + lenMember->type.compose() + ">" ); + "member attribute references a member of unexpected type <" + + lenMember->type.compose( "VULKAN_HPP_NAMESPACE" ) + ">" ); } if ( 1 < memberData.len.size() ) { @@ -14831,7 +15046,7 @@ std::string // the argument ist not a vector assert( param.type.postfix.empty() ); // and its not a pointer -> just use its type and name here - str += param.type.compose() + " " + param.name + generateCArraySizes( param.arraySizes ); + str += param.type.compose( "VULKAN_HPP_NAMESPACE" ) + " " + param.name + generateCArraySizes( param.arraySizes ); } else { @@ -14938,6 +15153,182 @@ std::string return functionDeclarations; } +std::string + VulkanHppGenerator::generateRAIIHandleCommandFactory( std::map::const_iterator commandIt, + size_t initialSkipCount, + size_t returnParamIndex, + bool definition ) const +{ + std::set skippedParameters = + determineSkippedParams( commandIt->second.params, initialSkipCount, {}, { returnParamIndex }, false ); + std::string argumentList = + generateRAIIHandleCommandFactoryArgumentList( commandIt->second.params, skippedParameters, definition, false ); + std::string commandName = generateCommandName( commandIt->first, commandIt->second.params, initialSkipCount, m_tags ); + std::string handleType = + stripPostfix( commandIt->second.params[returnParamIndex].type.compose( "VULKAN_HPP_RAII_NAMESPACE" ), " *" ); + + if ( definition ) + { + std::string const definitionTemplate = + R"( + VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE ${handleType} ${className}::${commandName}( ${argumentList} ) const + { + return ${handleType}( ${callArguments} ); + } +)"; + + return replaceWithMap( + definitionTemplate, + { { "argumentList", argumentList }, + { "callArguments", + generateCallArgumentsRAIIFactory( commandIt->second.params, initialSkipCount, skippedParameters, {} ) }, + { "className", + initialSkipCount ? stripPrefix( commandIt->second.params[initialSkipCount - 1].type.type, "Vk" ) + : "Context" }, + { "commandName", commandName }, + { "handleType", handleType } } ); + } + else + { + std::string const declarationTemplate = + R"( + VULKAN_HPP_NODISCARD ${handleType} ${commandName}( ${argumentList} ) const; +)"; + + return replaceWithMap( + declarationTemplate, + { { "argumentList", argumentList }, { "commandName", commandName }, { "handleType", handleType } } ); + } +} + +std::string + VulkanHppGenerator::generateRAIIHandleCommandFactoryArgumentList( std::vector const & params, + std::set const & skippedParameters, + bool definition, + bool singular ) const +{ + std::string arguments; + bool encounteredArgument = false; + for ( size_t i = 0; i < params.size(); ++i ) + { + if ( skippedParameters.find( i ) == skippedParameters.end() ) + { + if ( encounteredArgument ) + { + arguments += ", "; + } + arguments += generateRAIIHandleConstructorArgument( params[i], definition, singular ); + encounteredArgument = true; + } + } + return arguments; +} + +std::string VulkanHppGenerator::generateRAIIHandleCommandFactorySingular( + std::map::const_iterator commandIt, + size_t initialSkipCount, + std::vector const & returnParamIndices, + std::map const & vectorParamIndices, + bool definition ) const +{ + assert( isHandleType( commandIt->second.params[returnParamIndices.back()].type.type ) ); + + std::set skippedParameters = + determineSkippedParams( commandIt->second.params, initialSkipCount, vectorParamIndices, returnParamIndices, true ); + std::set singularParams = determineSingularParams( returnParamIndices.back(), vectorParamIndices ); + std::string argumentList = + generateRAIIHandleCommandFactoryArgumentList( commandIt->second.params, skippedParameters, definition, true ); + std::string commandName = + stripPluralS( generateCommandName( commandIt->first, commandIt->second.params, initialSkipCount, m_tags ) ); + std::string handleType = stripPostfix( + commandIt->second.params[returnParamIndices.back()].type.compose( "VULKAN_HPP_RAII_NAMESPACE" ), " *" ); + + if ( definition ) + { + std::string const definitionTemplate = + R"( + VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE ${handleType} ${className}::${commandName}( ${argumentList} ) const + { + return ${handleType}( ${callArguments} ); + } +)"; + + return replaceWithMap( + definitionTemplate, + { { "argumentList", argumentList }, + { "callArguments", + generateCallArgumentsRAIIFactory( + commandIt->second.params, initialSkipCount, skippedParameters, singularParams ) }, + { "className", + initialSkipCount ? stripPrefix( commandIt->second.params[initialSkipCount - 1].type.type, "Vk" ) + : "Context" }, + { "commandName", commandName }, + { "handleType", handleType } } ); + } + else + { + std::string const declarationTemplate = + R"( + VULKAN_HPP_NODISCARD ${handleType} ${commandName}( ${argumentList} ) const; +)"; + + return replaceWithMap( + declarationTemplate, + { { "argumentList", argumentList }, { "commandName", commandName }, { "handleType", handleType } } ); + } +} + +std::string VulkanHppGenerator::generateRAIIHandleCommandFactoryVector( + std::map::const_iterator commandIt, + size_t initialSkipCount, + std::vector const & returnParamIndices, + std::map const & vectorParamIndices, + bool definition ) const +{ + assert( isHandleType( commandIt->second.params[returnParamIndices.back()].type.type ) ); + + std::set skippedParameters = + determineSkippedParams( commandIt->second.params, initialSkipCount, vectorParamIndices, returnParamIndices, false ); + std::string argumentList = + generateRAIIHandleCommandFactoryArgumentList( commandIt->second.params, skippedParameters, definition, false ); + std::string commandName = generateCommandName( commandIt->first, commandIt->second.params, initialSkipCount, m_tags ); + std::string handleType = stripPostfix( + commandIt->second.params[returnParamIndices.back()].type.compose( "VULKAN_HPP_RAII_NAMESPACE" ), " *" ); + + if ( definition ) + { + std::string const definitionTemplate = + R"( + VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE std::vector<${handleType}> ${className}::${commandName}( ${argumentList} ) const + { + return ${handleType}s( ${callArguments} ); + } +)"; + + return replaceWithMap( + definitionTemplate, + { { "argumentList", argumentList }, + { "callArguments", + generateCallArgumentsRAIIFactory( commandIt->second.params, initialSkipCount, skippedParameters, {} ) }, + { "className", + initialSkipCount ? stripPrefix( commandIt->second.params[initialSkipCount - 1].type.type, "Vk" ) + : "Context" }, + { "commandName", commandName }, + { "handleType", handleType } } ); + } + else + { + std::string const declarationTemplate = + R"( + VULKAN_HPP_NODISCARD std::vector<${handleType}> ${commandName}( ${argumentList} ) const; +)"; + + return replaceWithMap( + declarationTemplate, + { { "argumentList", argumentList }, { "commandName", commandName }, { "handleType", handleType } } ); + } +} + std::string VulkanHppGenerator::generateRAIIHandleCommandResult( std::map::const_iterator commandIt, size_t initialSkipCount, bool definition ) const { @@ -15034,12 +15425,12 @@ std::string VulkanHppGenerator::generateRAIIHandleCommandResultMultiSuccessNoErr } } -std::string VulkanHppGenerator::TypeInfo::compose( bool inNamespace ) const +std::string VulkanHppGenerator::TypeInfo::compose( std::string const & nameSpace ) const { return prefix + ( prefix.empty() ? "" : " " ) + - ( inNamespace - ? ( ( ( type.substr( 0, 2 ) == "Vk" ) ? "VULKAN_HPP_NAMESPACE::" : "" ) + stripPrefix( type, "Vk" ) ) - : type ) + + ( nameSpace.empty() + ? type + : ( ( ( type.substr( 0, 2 ) == "Vk" ) ? ( nameSpace + "::" ) : "" ) + stripPrefix( type, "Vk" ) ) ) + ( postfix.empty() ? "" : " " ) + postfix; } diff --git a/VulkanHppGenerator.hpp b/VulkanHppGenerator.hpp index 73e32e0..bb3238f 100644 --- a/VulkanHppGenerator.hpp +++ b/VulkanHppGenerator.hpp @@ -50,7 +50,7 @@ public: private: struct TypeInfo { - std::string compose( bool inNamespace = true ) const; + std::string compose( std::string const & nameSpace ) const; bool operator==( TypeInfo const & rhs ) const { @@ -384,8 +384,7 @@ private: std::vector determineNonConstPointerParamIndices( std::vector const & params ) const; std::vector::const_iterator> determineRAIIHandleConstructors( std::string const & handleType, - std::map::const_iterator destructorIt, - std::set & specialFunctions ) const; + std::map::const_iterator destructorIt ) const; std::map::const_iterator determineRAIIHandleDestructor( std::string const & handleType ) const; std::set determineSkippedParams( std::vector const & params, @@ -415,6 +414,10 @@ private: bool nonConstPointerAsNullptr, std::set const & singularParams, bool raiiHandleMemberFunction ) const; + std::string generateCallArgumentsRAIIFactory( std::vector const & params, + size_t initialSkipCount, + std::set const & skippedParameters, + std::set const & singularParams ) const; std::string generateCallArgumentsStandard( std::string const & handle, std::vector const & params ) const; std::string generateCallArgumentEnhanced( std::vector const & params, size_t paramIndex, @@ -885,6 +888,24 @@ private: bool definition ) const; std::string generateRAIIHandleCommandDeclarations( std::pair const & handle, std::set const & specialFunctions ) const; + std::string generateRAIIHandleCommandFactory( std::map::const_iterator commandIt, + size_t initialSkipCount, + size_t returnParamIndex, + bool definition ) const; + std::string generateRAIIHandleCommandFactoryArgumentList( std::vector const & params, + std::set const & skippedParameters, + bool definition, + bool singular ) const; + std::string generateRAIIHandleCommandFactorySingular( std::map::const_iterator commandIt, + size_t initialSkipCount, + std::vector const & returnParamIndices, + std::map const & vectorParamIndices, + bool definition ) const; + std::string generateRAIIHandleCommandFactoryVector( std::map::const_iterator commandIt, + size_t initialSkipCount, + std::vector const & returnParamIndices, + std::map const & vectorParamIndices, + bool definition ) const; std::string generateRAIIHandleCommandResult( std::map::const_iterator commandIt, size_t initialSkipCount, bool definition ) const; @@ -1074,15 +1095,18 @@ private: std::map const & vectorParamIndices ) const; std::pair generateRAIIHandleConstructors( std::pair const & handle ) const; - std::string generateRAIIHandleConstructorArguments( std::string const & handleType, - std::vector const & params, - bool singular, - bool encounteredArgument ) const; + std::string generateRAIIHandleConstructorArgument( ParamData const & param, bool definition, bool singular ) const; + std::string generateRAIIHandleConstructorArguments( std::pair const & handle, + std::vector const & params, + bool singular, + bool skipLeadingGrandParent, + bool encounteredArgument ) const; std::string generateRAIIHandleConstructorCallArguments( std::string const & handleType, std::vector const & params, bool nonConstPointerAsNullptr, std::set const & singularParams, - bool allocatorIsMemberVariable ) const; + bool allocatorIsMemberVariable, + bool skipLeadingGrandParent ) const; std::string generateRAIIHandleConstructorEnumerate( std::pair const & handle, std::map::const_iterator constructorIt, std::vector::const_iterator handleParamIt, @@ -1125,6 +1149,8 @@ private: std::tuple generateRAIIHandleDetails( std::pair const & handle, std::string const & destructorCall ) const; + std::string generateRAIIHandleForwardDeclarations( std::vector const & requireData, + std::string const & title ) const; std::string generateRAIIHandleSingularConstructorArguments( std::pair const & handle, std::map::const_iterator constructorIt ) const; diff --git a/vulkan/vulkan_raii.hpp b/vulkan/vulkan_raii.hpp index 4839b09..fb23260 100644 --- a/vulkan/vulkan_raii.hpp +++ b/vulkan/vulkan_raii.hpp @@ -2214,6 +2214,93 @@ namespace VULKAN_HPP_NAMESPACE PFN_vkCmdSetCoarseSampleOrderNV vkCmdSetCoarseSampleOrderNV = 0; }; + //======================================== + //=== RAII HANDLE forward declarations === + //======================================== + + //=== VK_VERSION_1_0 === + class Instance; + class PhysicalDevice; + class Device; + class Queue; + class DeviceMemory; + class Fence; + class Semaphore; + class Event; + class QueryPool; + class Buffer; + class BufferView; + class Image; + class ImageView; + class ShaderModule; + class PipelineCache; + class Pipeline; + class PipelineLayout; + class Sampler; + class DescriptorPool; + class DescriptorSet; + class DescriptorSetLayout; + class Framebuffer; + class RenderPass; + class CommandPool; + class CommandBuffer; + + //=== VK_VERSION_1_1 === + class SamplerYcbcrConversion; + class DescriptorUpdateTemplate; + + //=== VK_KHR_surface === + class SurfaceKHR; + + //=== VK_KHR_swapchain === + class SwapchainKHR; + + //=== VK_KHR_display === + class DisplayKHR; + class DisplayModeKHR; + + //=== VK_EXT_debug_report === + class DebugReportCallbackEXT; + +# if defined( VK_ENABLE_BETA_EXTENSIONS ) + //=== VK_KHR_video_queue === + class VideoSessionKHR; + class VideoSessionParametersKHR; +# endif /*VK_ENABLE_BETA_EXTENSIONS*/ + + //=== VK_NVX_binary_import === + class CuModuleNVX; + class CuFunctionNVX; + + //=== VK_EXT_debug_utils === + class DebugUtilsMessengerEXT; + + //=== VK_KHR_acceleration_structure === + class AccelerationStructureKHR; + + //=== VK_EXT_validation_cache === + class ValidationCacheEXT; + + //=== VK_NV_ray_tracing === + class AccelerationStructureNV; + + //=== VK_INTEL_performance_query === + class PerformanceConfigurationINTEL; + + //=== VK_KHR_deferred_host_operations === + class DeferredOperationKHR; + + //=== VK_NV_device_generated_commands === + class IndirectCommandsLayoutNV; + + //=== VK_EXT_private_data === + class PrivateDataSlotEXT; + +# if defined( VK_USE_PLATFORM_FUCHSIA ) + //=== VK_FUCHSIA_buffer_collection === + class BufferCollectionFUCHSIA; +# endif /*VK_USE_PLATFORM_FUCHSIA*/ + //==================== //=== RAII HANDLES === //==================== @@ -2244,6 +2331,10 @@ namespace VULKAN_HPP_NAMESPACE //=== VK_VERSION_1_0 === + VULKAN_HPP_NODISCARD VULKAN_HPP_RAII_NAMESPACE::Instance createInstance( + VULKAN_HPP_NAMESPACE::InstanceCreateInfo const & createInfo, + VULKAN_HPP_NAMESPACE::Optional allocator = nullptr ) const; + VULKAN_HPP_NODISCARD std::vector enumerateInstanceExtensionProperties( Optional layerName VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT ) const; @@ -2342,6 +2433,11 @@ namespace VULKAN_HPP_NAMESPACE return m_instance; } + VULKAN_HPP_NAMESPACE::Instance getInstance() const VULKAN_HPP_NOEXCEPT + { + return static_cast( m_instance ); + } + VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::InstanceDispatcher const * getDispatcher() const { VULKAN_HPP_ASSERT( m_dispatcher.getVkHeaderVersion() == VK_HEADER_VERSION ); @@ -2350,6 +2446,8 @@ namespace VULKAN_HPP_NAMESPACE //=== VK_VERSION_1_0 === + VULKAN_HPP_NODISCARD std::vector enumeratePhysicalDevices() const; + VULKAN_HPP_NODISCARD PFN_vkVoidFunction getProcAddr( const std::string & name ) const VULKAN_HPP_NOEXCEPT; //=== VK_VERSION_1_1 === @@ -2357,8 +2455,58 @@ namespace VULKAN_HPP_NAMESPACE VULKAN_HPP_NODISCARD std::vector enumeratePhysicalDeviceGroups() const; + //=== VK_KHR_display === + + VULKAN_HPP_NODISCARD VULKAN_HPP_RAII_NAMESPACE::SurfaceKHR createDisplayPlaneSurfaceKHR( + VULKAN_HPP_NAMESPACE::DisplaySurfaceCreateInfoKHR const & createInfo, + VULKAN_HPP_NAMESPACE::Optional allocator = nullptr ) const; + +# if defined( VK_USE_PLATFORM_XLIB_KHR ) + //=== VK_KHR_xlib_surface === + + VULKAN_HPP_NODISCARD VULKAN_HPP_RAII_NAMESPACE::SurfaceKHR createXlibSurfaceKHR( + VULKAN_HPP_NAMESPACE::XlibSurfaceCreateInfoKHR const & createInfo, + VULKAN_HPP_NAMESPACE::Optional allocator = nullptr ) const; +# endif /*VK_USE_PLATFORM_XLIB_KHR*/ + +# if defined( VK_USE_PLATFORM_XCB_KHR ) + //=== VK_KHR_xcb_surface === + + VULKAN_HPP_NODISCARD VULKAN_HPP_RAII_NAMESPACE::SurfaceKHR createXcbSurfaceKHR( + VULKAN_HPP_NAMESPACE::XcbSurfaceCreateInfoKHR const & createInfo, + VULKAN_HPP_NAMESPACE::Optional allocator = nullptr ) const; +# endif /*VK_USE_PLATFORM_XCB_KHR*/ + +# if defined( VK_USE_PLATFORM_WAYLAND_KHR ) + //=== VK_KHR_wayland_surface === + + VULKAN_HPP_NODISCARD VULKAN_HPP_RAII_NAMESPACE::SurfaceKHR createWaylandSurfaceKHR( + VULKAN_HPP_NAMESPACE::WaylandSurfaceCreateInfoKHR const & createInfo, + VULKAN_HPP_NAMESPACE::Optional allocator = nullptr ) const; +# endif /*VK_USE_PLATFORM_WAYLAND_KHR*/ + +# if defined( VK_USE_PLATFORM_ANDROID_KHR ) + //=== VK_KHR_android_surface === + + VULKAN_HPP_NODISCARD VULKAN_HPP_RAII_NAMESPACE::SurfaceKHR createAndroidSurfaceKHR( + VULKAN_HPP_NAMESPACE::AndroidSurfaceCreateInfoKHR const & createInfo, + VULKAN_HPP_NAMESPACE::Optional allocator = nullptr ) const; +# endif /*VK_USE_PLATFORM_ANDROID_KHR*/ + +# if defined( VK_USE_PLATFORM_WIN32_KHR ) + //=== VK_KHR_win32_surface === + + VULKAN_HPP_NODISCARD VULKAN_HPP_RAII_NAMESPACE::SurfaceKHR createWin32SurfaceKHR( + VULKAN_HPP_NAMESPACE::Win32SurfaceCreateInfoKHR const & createInfo, + VULKAN_HPP_NAMESPACE::Optional allocator = nullptr ) const; +# endif /*VK_USE_PLATFORM_WIN32_KHR*/ + //=== VK_EXT_debug_report === + VULKAN_HPP_NODISCARD VULKAN_HPP_RAII_NAMESPACE::DebugReportCallbackEXT createDebugReportCallbackEXT( + VULKAN_HPP_NAMESPACE::DebugReportCallbackCreateInfoEXT const & createInfo, + VULKAN_HPP_NAMESPACE::Optional allocator = nullptr ) const; + void debugReportMessageEXT( VULKAN_HPP_NAMESPACE::DebugReportFlagsEXT flags, VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT objectType_, uint64_t object, @@ -2367,18 +2515,92 @@ namespace VULKAN_HPP_NAMESPACE const std::string & layerPrefix, const std::string & message ) const VULKAN_HPP_NOEXCEPT; +# if defined( VK_USE_PLATFORM_GGP ) + //=== VK_GGP_stream_descriptor_surface === + + VULKAN_HPP_NODISCARD VULKAN_HPP_RAII_NAMESPACE::SurfaceKHR createStreamDescriptorSurfaceGGP( + VULKAN_HPP_NAMESPACE::StreamDescriptorSurfaceCreateInfoGGP const & createInfo, + VULKAN_HPP_NAMESPACE::Optional allocator = nullptr ) const; +# endif /*VK_USE_PLATFORM_GGP*/ + +# if defined( VK_USE_PLATFORM_VI_NN ) + //=== VK_NN_vi_surface === + + VULKAN_HPP_NODISCARD VULKAN_HPP_RAII_NAMESPACE::SurfaceKHR createViSurfaceNN( + VULKAN_HPP_NAMESPACE::ViSurfaceCreateInfoNN const & createInfo, + VULKAN_HPP_NAMESPACE::Optional allocator = nullptr ) const; +# endif /*VK_USE_PLATFORM_VI_NN*/ + //=== VK_KHR_device_group_creation === VULKAN_HPP_NODISCARD std::vector enumeratePhysicalDeviceGroupsKHR() const; +# if defined( VK_USE_PLATFORM_IOS_MVK ) + //=== VK_MVK_ios_surface === + + VULKAN_HPP_NODISCARD VULKAN_HPP_RAII_NAMESPACE::SurfaceKHR createIOSSurfaceMVK( + VULKAN_HPP_NAMESPACE::IOSSurfaceCreateInfoMVK const & createInfo, + VULKAN_HPP_NAMESPACE::Optional allocator = nullptr ) const; +# endif /*VK_USE_PLATFORM_IOS_MVK*/ + +# if defined( VK_USE_PLATFORM_MACOS_MVK ) + //=== VK_MVK_macos_surface === + + VULKAN_HPP_NODISCARD VULKAN_HPP_RAII_NAMESPACE::SurfaceKHR createMacOSSurfaceMVK( + VULKAN_HPP_NAMESPACE::MacOSSurfaceCreateInfoMVK const & createInfo, + VULKAN_HPP_NAMESPACE::Optional allocator = nullptr ) const; +# endif /*VK_USE_PLATFORM_MACOS_MVK*/ + //=== VK_EXT_debug_utils === + VULKAN_HPP_NODISCARD VULKAN_HPP_RAII_NAMESPACE::DebugUtilsMessengerEXT createDebugUtilsMessengerEXT( + VULKAN_HPP_NAMESPACE::DebugUtilsMessengerCreateInfoEXT const & createInfo, + VULKAN_HPP_NAMESPACE::Optional allocator = nullptr ) const; + void submitDebugUtilsMessageEXT( VULKAN_HPP_NAMESPACE::DebugUtilsMessageSeverityFlagBitsEXT messageSeverity, VULKAN_HPP_NAMESPACE::DebugUtilsMessageTypeFlagsEXT messageTypes, const VULKAN_HPP_NAMESPACE::DebugUtilsMessengerCallbackDataEXT & callbackData ) const VULKAN_HPP_NOEXCEPT; +# if defined( VK_USE_PLATFORM_FUCHSIA ) + //=== VK_FUCHSIA_imagepipe_surface === + + VULKAN_HPP_NODISCARD VULKAN_HPP_RAII_NAMESPACE::SurfaceKHR createImagePipeSurfaceFUCHSIA( + VULKAN_HPP_NAMESPACE::ImagePipeSurfaceCreateInfoFUCHSIA const & createInfo, + VULKAN_HPP_NAMESPACE::Optional allocator = nullptr ) const; +# endif /*VK_USE_PLATFORM_FUCHSIA*/ + +# if defined( VK_USE_PLATFORM_METAL_EXT ) + //=== VK_EXT_metal_surface === + + VULKAN_HPP_NODISCARD VULKAN_HPP_RAII_NAMESPACE::SurfaceKHR createMetalSurfaceEXT( + VULKAN_HPP_NAMESPACE::MetalSurfaceCreateInfoEXT const & createInfo, + VULKAN_HPP_NAMESPACE::Optional allocator = nullptr ) const; +# endif /*VK_USE_PLATFORM_METAL_EXT*/ + + //=== VK_EXT_headless_surface === + + VULKAN_HPP_NODISCARD VULKAN_HPP_RAII_NAMESPACE::SurfaceKHR createHeadlessSurfaceEXT( + VULKAN_HPP_NAMESPACE::HeadlessSurfaceCreateInfoEXT const & createInfo, + VULKAN_HPP_NAMESPACE::Optional allocator = nullptr ) const; + +# if defined( VK_USE_PLATFORM_DIRECTFB_EXT ) + //=== VK_EXT_directfb_surface === + + VULKAN_HPP_NODISCARD VULKAN_HPP_RAII_NAMESPACE::SurfaceKHR createDirectFBSurfaceEXT( + VULKAN_HPP_NAMESPACE::DirectFBSurfaceCreateInfoEXT const & createInfo, + VULKAN_HPP_NAMESPACE::Optional allocator = nullptr ) const; +# endif /*VK_USE_PLATFORM_DIRECTFB_EXT*/ + +# if defined( VK_USE_PLATFORM_SCREEN_QNX ) + //=== VK_QNX_screen_surface === + + VULKAN_HPP_NODISCARD VULKAN_HPP_RAII_NAMESPACE::SurfaceKHR createScreenSurfaceQNX( + VULKAN_HPP_NAMESPACE::ScreenSurfaceCreateInfoQNX const & createInfo, + VULKAN_HPP_NAMESPACE::Optional allocator = nullptr ) const; +# endif /*VK_USE_PLATFORM_SCREEN_QNX*/ + private: VULKAN_HPP_NAMESPACE::Instance m_instance; const VkAllocationCallbacks * m_allocator = nullptr; @@ -2457,6 +2679,10 @@ namespace VULKAN_HPP_NAMESPACE VULKAN_HPP_NODISCARD VULKAN_HPP_NAMESPACE::PhysicalDeviceMemoryProperties getMemoryProperties() const VULKAN_HPP_NOEXCEPT; + VULKAN_HPP_NODISCARD VULKAN_HPP_RAII_NAMESPACE::Device createDevice( + VULKAN_HPP_NAMESPACE::DeviceCreateInfo const & createInfo, + VULKAN_HPP_NAMESPACE::Optional allocator = nullptr ) const; + VULKAN_HPP_NODISCARD std::vector enumerateDeviceExtensionProperties( Optional layerName VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT ) const; @@ -2547,6 +2773,9 @@ namespace VULKAN_HPP_NAMESPACE VULKAN_HPP_NODISCARD std::vector getDisplayPlanePropertiesKHR() const; + VULKAN_HPP_NODISCARD std::vector + getDisplayPlaneSupportedDisplaysKHR( uint32_t planeIndex ) const; + # if defined( VK_USE_PLATFORM_XLIB_KHR ) //=== VK_KHR_xlib_surface === @@ -2659,6 +2888,9 @@ namespace VULKAN_HPP_NAMESPACE //=== VK_EXT_acquire_xlib_display === void acquireXlibDisplayEXT( Display & dpy, VULKAN_HPP_NAMESPACE::DisplayKHR display ) const; + + VULKAN_HPP_NODISCARD VULKAN_HPP_RAII_NAMESPACE::DisplayKHR getRandROutputDisplayEXT( Display & dpy, + RROutput rrOutput ) const; # endif /*VK_USE_PLATFORM_XLIB_XRANDR_EXT*/ //=== VK_EXT_display_surface_counter === @@ -2742,6 +2974,15 @@ namespace VULKAN_HPP_NAMESPACE void acquireDrmDisplayEXT( int32_t drmFd, VULKAN_HPP_NAMESPACE::DisplayKHR display ) const; + VULKAN_HPP_NODISCARD VULKAN_HPP_RAII_NAMESPACE::DisplayKHR getDrmDisplayEXT( int32_t drmFd, + uint32_t connectorId ) const; + +# if defined( VK_USE_PLATFORM_WIN32_KHR ) + //=== VK_NV_acquire_winrt_display === + + VULKAN_HPP_NODISCARD VULKAN_HPP_RAII_NAMESPACE::DisplayKHR getWinrtDisplayNV( uint32_t deviceRelativeId ) const; +# endif /*VK_USE_PLATFORM_WIN32_KHR*/ + # if defined( VK_USE_PLATFORM_DIRECTFB_EXT ) //=== VK_EXT_directfb_surface === @@ -2884,6 +3125,11 @@ namespace VULKAN_HPP_NAMESPACE return m_device; } + VULKAN_HPP_NAMESPACE::Device getDevice() const VULKAN_HPP_NOEXCEPT + { + return static_cast( m_device ); + } + VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::DeviceDispatcher const * getDispatcher() const { VULKAN_HPP_ASSERT( m_dispatcher.getVkHeaderVersion() == VK_HEADER_VERSION ); @@ -2894,14 +3140,25 @@ namespace VULKAN_HPP_NAMESPACE VULKAN_HPP_NODISCARD PFN_vkVoidFunction getProcAddr( const std::string & name ) const VULKAN_HPP_NOEXCEPT; + VULKAN_HPP_NODISCARD VULKAN_HPP_RAII_NAMESPACE::Queue getQueue( uint32_t queueFamilyIndex, + uint32_t queueIndex ) const; + void waitIdle() const; + VULKAN_HPP_NODISCARD VULKAN_HPP_RAII_NAMESPACE::DeviceMemory allocateMemory( + VULKAN_HPP_NAMESPACE::MemoryAllocateInfo const & allocateInfo, + VULKAN_HPP_NAMESPACE::Optional allocator = nullptr ) const; + void flushMappedMemoryRanges( ArrayProxy const & memoryRanges ) const; void invalidateMappedMemoryRanges( ArrayProxy const & memoryRanges ) const; + VULKAN_HPP_NODISCARD VULKAN_HPP_RAII_NAMESPACE::Fence createFence( + VULKAN_HPP_NAMESPACE::FenceCreateInfo const & createInfo, + VULKAN_HPP_NAMESPACE::Optional allocator = nullptr ) const; + void resetFences( ArrayProxy const & fences ) const; VULKAN_HPP_NODISCARD VULKAN_HPP_NAMESPACE::Result @@ -2909,10 +3166,104 @@ namespace VULKAN_HPP_NAMESPACE VULKAN_HPP_NAMESPACE::Bool32 waitAll, uint64_t timeout ) const; + VULKAN_HPP_NODISCARD VULKAN_HPP_RAII_NAMESPACE::Semaphore createSemaphore( + VULKAN_HPP_NAMESPACE::SemaphoreCreateInfo const & createInfo, + VULKAN_HPP_NAMESPACE::Optional allocator = nullptr ) const; + + VULKAN_HPP_NODISCARD VULKAN_HPP_RAII_NAMESPACE::Event createEvent( + VULKAN_HPP_NAMESPACE::EventCreateInfo const & createInfo, + VULKAN_HPP_NAMESPACE::Optional allocator = nullptr ) const; + + VULKAN_HPP_NODISCARD VULKAN_HPP_RAII_NAMESPACE::QueryPool createQueryPool( + VULKAN_HPP_NAMESPACE::QueryPoolCreateInfo const & createInfo, + VULKAN_HPP_NAMESPACE::Optional allocator = nullptr ) const; + + VULKAN_HPP_NODISCARD VULKAN_HPP_RAII_NAMESPACE::Buffer createBuffer( + VULKAN_HPP_NAMESPACE::BufferCreateInfo const & createInfo, + VULKAN_HPP_NAMESPACE::Optional allocator = nullptr ) const; + + VULKAN_HPP_NODISCARD VULKAN_HPP_RAII_NAMESPACE::BufferView createBufferView( + VULKAN_HPP_NAMESPACE::BufferViewCreateInfo const & createInfo, + VULKAN_HPP_NAMESPACE::Optional allocator = nullptr ) const; + + VULKAN_HPP_NODISCARD VULKAN_HPP_RAII_NAMESPACE::Image createImage( + VULKAN_HPP_NAMESPACE::ImageCreateInfo const & createInfo, + VULKAN_HPP_NAMESPACE::Optional allocator = nullptr ) const; + + VULKAN_HPP_NODISCARD VULKAN_HPP_RAII_NAMESPACE::ImageView createImageView( + VULKAN_HPP_NAMESPACE::ImageViewCreateInfo const & createInfo, + VULKAN_HPP_NAMESPACE::Optional allocator = nullptr ) const; + + VULKAN_HPP_NODISCARD VULKAN_HPP_RAII_NAMESPACE::ShaderModule createShaderModule( + VULKAN_HPP_NAMESPACE::ShaderModuleCreateInfo const & createInfo, + VULKAN_HPP_NAMESPACE::Optional allocator = nullptr ) const; + + VULKAN_HPP_NODISCARD VULKAN_HPP_RAII_NAMESPACE::PipelineCache createPipelineCache( + VULKAN_HPP_NAMESPACE::PipelineCacheCreateInfo const & createInfo, + VULKAN_HPP_NAMESPACE::Optional allocator = nullptr ) const; + + VULKAN_HPP_NODISCARD std::vector createGraphicsPipelines( + VULKAN_HPP_NAMESPACE::Optional const & + pipelineCache, + VULKAN_HPP_NAMESPACE::ArrayProxy const & createInfos, + VULKAN_HPP_NAMESPACE::Optional allocator = nullptr ) const; + + VULKAN_HPP_NODISCARD VULKAN_HPP_RAII_NAMESPACE::Pipeline createGraphicsPipeline( + VULKAN_HPP_NAMESPACE::Optional const & + pipelineCache, + VULKAN_HPP_NAMESPACE::GraphicsPipelineCreateInfo const & createInfo, + VULKAN_HPP_NAMESPACE::Optional allocator = nullptr ) const; + + VULKAN_HPP_NODISCARD std::vector createComputePipelines( + VULKAN_HPP_NAMESPACE::Optional const & + pipelineCache, + VULKAN_HPP_NAMESPACE::ArrayProxy const & createInfos, + VULKAN_HPP_NAMESPACE::Optional allocator = nullptr ) const; + + VULKAN_HPP_NODISCARD VULKAN_HPP_RAII_NAMESPACE::Pipeline createComputePipeline( + VULKAN_HPP_NAMESPACE::Optional const & + pipelineCache, + VULKAN_HPP_NAMESPACE::ComputePipelineCreateInfo const & createInfo, + VULKAN_HPP_NAMESPACE::Optional allocator = nullptr ) const; + + VULKAN_HPP_NODISCARD VULKAN_HPP_RAII_NAMESPACE::PipelineLayout createPipelineLayout( + VULKAN_HPP_NAMESPACE::PipelineLayoutCreateInfo const & createInfo, + VULKAN_HPP_NAMESPACE::Optional allocator = nullptr ) const; + + VULKAN_HPP_NODISCARD VULKAN_HPP_RAII_NAMESPACE::Sampler createSampler( + VULKAN_HPP_NAMESPACE::SamplerCreateInfo const & createInfo, + VULKAN_HPP_NAMESPACE::Optional allocator = nullptr ) const; + + VULKAN_HPP_NODISCARD VULKAN_HPP_RAII_NAMESPACE::DescriptorSetLayout createDescriptorSetLayout( + VULKAN_HPP_NAMESPACE::DescriptorSetLayoutCreateInfo const & createInfo, + VULKAN_HPP_NAMESPACE::Optional allocator = nullptr ) const; + + VULKAN_HPP_NODISCARD VULKAN_HPP_RAII_NAMESPACE::DescriptorPool createDescriptorPool( + VULKAN_HPP_NAMESPACE::DescriptorPoolCreateInfo const & createInfo, + VULKAN_HPP_NAMESPACE::Optional allocator = nullptr ) const; + + VULKAN_HPP_NODISCARD std::vector + allocateDescriptorSets( VULKAN_HPP_NAMESPACE::DescriptorSetAllocateInfo const & allocateInfo ) const; + void updateDescriptorSets( ArrayProxy const & descriptorWrites, ArrayProxy const & descriptorCopies ) const VULKAN_HPP_NOEXCEPT; + VULKAN_HPP_NODISCARD VULKAN_HPP_RAII_NAMESPACE::Framebuffer createFramebuffer( + VULKAN_HPP_NAMESPACE::FramebufferCreateInfo const & createInfo, + VULKAN_HPP_NAMESPACE::Optional allocator = nullptr ) const; + + VULKAN_HPP_NODISCARD VULKAN_HPP_RAII_NAMESPACE::RenderPass createRenderPass( + VULKAN_HPP_NAMESPACE::RenderPassCreateInfo const & createInfo, + VULKAN_HPP_NAMESPACE::Optional allocator = nullptr ) const; + + VULKAN_HPP_NODISCARD VULKAN_HPP_RAII_NAMESPACE::CommandPool createCommandPool( + VULKAN_HPP_NAMESPACE::CommandPoolCreateInfo const & createInfo, + VULKAN_HPP_NAMESPACE::Optional allocator = nullptr ) const; + + VULKAN_HPP_NODISCARD std::vector + allocateCommandBuffers( VULKAN_HPP_NAMESPACE::CommandBufferAllocateInfo const & allocateInfo ) const; + //=== VK_VERSION_1_1 === void bindBufferMemory2( ArrayProxy const & bindInfos ) const; @@ -2940,6 +3291,17 @@ namespace VULKAN_HPP_NAMESPACE getImageSparseMemoryRequirements2( const VULKAN_HPP_NAMESPACE::ImageSparseMemoryRequirementsInfo2 & info ) const VULKAN_HPP_NOEXCEPT; + VULKAN_HPP_NODISCARD VULKAN_HPP_RAII_NAMESPACE::Queue + getQueue2( VULKAN_HPP_NAMESPACE::DeviceQueueInfo2 const & queueInfo ) const; + + VULKAN_HPP_NODISCARD VULKAN_HPP_RAII_NAMESPACE::SamplerYcbcrConversion createSamplerYcbcrConversion( + VULKAN_HPP_NAMESPACE::SamplerYcbcrConversionCreateInfo const & createInfo, + VULKAN_HPP_NAMESPACE::Optional allocator = nullptr ) const; + + VULKAN_HPP_NODISCARD VULKAN_HPP_RAII_NAMESPACE::DescriptorUpdateTemplate createDescriptorUpdateTemplate( + VULKAN_HPP_NAMESPACE::DescriptorUpdateTemplateCreateInfo const & createInfo, + VULKAN_HPP_NAMESPACE::Optional allocator = nullptr ) const; + VULKAN_HPP_NODISCARD VULKAN_HPP_NAMESPACE::DescriptorSetLayoutSupport getDescriptorSetLayoutSupport( const VULKAN_HPP_NAMESPACE::DescriptorSetLayoutCreateInfo & createInfo ) const VULKAN_HPP_NOEXCEPT; @@ -2949,6 +3311,10 @@ namespace VULKAN_HPP_NAMESPACE //=== VK_VERSION_1_2 === + VULKAN_HPP_NODISCARD VULKAN_HPP_RAII_NAMESPACE::RenderPass createRenderPass2( + VULKAN_HPP_NAMESPACE::RenderPassCreateInfo2 const & createInfo, + VULKAN_HPP_NAMESPACE::Optional allocator = nullptr ) const; + VULKAN_HPP_NODISCARD VULKAN_HPP_NAMESPACE::Result waitSemaphores( const VULKAN_HPP_NAMESPACE::SemaphoreWaitInfo & waitInfo, uint64_t timeout ) const; @@ -2965,6 +3331,10 @@ namespace VULKAN_HPP_NAMESPACE //=== VK_KHR_swapchain === + VULKAN_HPP_NODISCARD VULKAN_HPP_RAII_NAMESPACE::SwapchainKHR createSwapchainKHR( + VULKAN_HPP_NAMESPACE::SwapchainCreateInfoKHR const & createInfo, + VULKAN_HPP_NAMESPACE::Optional allocator = nullptr ) const; + VULKAN_HPP_NODISCARD VULKAN_HPP_NAMESPACE::DeviceGroupPresentCapabilitiesKHR getGroupPresentCapabilitiesKHR() const; @@ -2974,12 +3344,44 @@ namespace VULKAN_HPP_NAMESPACE VULKAN_HPP_NODISCARD std::pair acquireNextImage2KHR( const VULKAN_HPP_NAMESPACE::AcquireNextImageInfoKHR & acquireInfo ) const; + //=== VK_KHR_display_swapchain === + + VULKAN_HPP_NODISCARD std::vector createSharedSwapchainsKHR( + VULKAN_HPP_NAMESPACE::ArrayProxy const & createInfos, + VULKAN_HPP_NAMESPACE::Optional allocator = nullptr ) const; + + VULKAN_HPP_NODISCARD VULKAN_HPP_RAII_NAMESPACE::SwapchainKHR createSharedSwapchainKHR( + VULKAN_HPP_NAMESPACE::SwapchainCreateInfoKHR const & createInfo, + VULKAN_HPP_NAMESPACE::Optional allocator = nullptr ) const; + //=== VK_EXT_debug_marker === void debugMarkerSetObjectTagEXT( const VULKAN_HPP_NAMESPACE::DebugMarkerObjectTagInfoEXT & tagInfo ) const; void debugMarkerSetObjectNameEXT( const VULKAN_HPP_NAMESPACE::DebugMarkerObjectNameInfoEXT & nameInfo ) const; +# if defined( VK_ENABLE_BETA_EXTENSIONS ) + //=== VK_KHR_video_queue === + + VULKAN_HPP_NODISCARD VULKAN_HPP_RAII_NAMESPACE::VideoSessionKHR createVideoSessionKHR( + VULKAN_HPP_NAMESPACE::VideoSessionCreateInfoKHR const & createInfo, + VULKAN_HPP_NAMESPACE::Optional allocator = nullptr ) const; + + VULKAN_HPP_NODISCARD VULKAN_HPP_RAII_NAMESPACE::VideoSessionParametersKHR createVideoSessionParametersKHR( + VULKAN_HPP_NAMESPACE::VideoSessionParametersCreateInfoKHR const & createInfo, + VULKAN_HPP_NAMESPACE::Optional allocator = nullptr ) const; +# endif /*VK_ENABLE_BETA_EXTENSIONS*/ + + //=== VK_NVX_binary_import === + + VULKAN_HPP_NODISCARD VULKAN_HPP_RAII_NAMESPACE::CuModuleNVX createCuModuleNVX( + VULKAN_HPP_NAMESPACE::CuModuleCreateInfoNVX const & createInfo, + VULKAN_HPP_NAMESPACE::Optional allocator = nullptr ) const; + + VULKAN_HPP_NODISCARD VULKAN_HPP_RAII_NAMESPACE::CuFunctionNVX createCuFunctionNVX( + VULKAN_HPP_NAMESPACE::CuFunctionCreateInfoNVX const & createInfo, + VULKAN_HPP_NAMESPACE::Optional allocator = nullptr ) const; + //=== VK_NVX_image_view_handle === VULKAN_HPP_NODISCARD uint32_t @@ -3026,6 +3428,10 @@ namespace VULKAN_HPP_NAMESPACE //=== VK_KHR_descriptor_update_template === + VULKAN_HPP_NODISCARD VULKAN_HPP_RAII_NAMESPACE::DescriptorUpdateTemplate createDescriptorUpdateTemplateKHR( + VULKAN_HPP_NAMESPACE::DescriptorUpdateTemplateCreateInfo const & createInfo, + VULKAN_HPP_NAMESPACE::Optional allocator = nullptr ) const; + void destroyDescriptorUpdateTemplateKHR( VULKAN_HPP_NAMESPACE::DescriptorUpdateTemplate descriptorUpdateTemplate VULKAN_HPP_DEFAULT_ARGUMENT_ASSIGNMENT, Optional allocator @@ -3036,12 +3442,27 @@ namespace VULKAN_HPP_NAMESPACE void displayPowerControlEXT( VULKAN_HPP_NAMESPACE::DisplayKHR display, const VULKAN_HPP_NAMESPACE::DisplayPowerInfoEXT & displayPowerInfo ) const; + VULKAN_HPP_NODISCARD VULKAN_HPP_RAII_NAMESPACE::Fence registerEventEXT( + VULKAN_HPP_NAMESPACE::DeviceEventInfoEXT const & deviceEventInfo, + VULKAN_HPP_NAMESPACE::Optional allocator = nullptr ) const; + + VULKAN_HPP_NODISCARD VULKAN_HPP_RAII_NAMESPACE::Fence registerDisplayEventEXT( + VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::DisplayKHR const & display, + VULKAN_HPP_NAMESPACE::DisplayEventInfoEXT const & displayEventInfo, + VULKAN_HPP_NAMESPACE::Optional allocator = nullptr ) const; + //=== VK_EXT_hdr_metadata === void setHdrMetadataEXT( ArrayProxy const & swapchains, ArrayProxy const & metadata ) const VULKAN_HPP_NOEXCEPT_WHEN_NO_EXCEPTIONS; + //=== VK_KHR_create_renderpass2 === + + VULKAN_HPP_NODISCARD VULKAN_HPP_RAII_NAMESPACE::RenderPass createRenderPass2KHR( + VULKAN_HPP_NAMESPACE::RenderPassCreateInfo2 const & createInfo, + VULKAN_HPP_NAMESPACE::Optional allocator = nullptr ) const; + # if defined( VK_USE_PLATFORM_WIN32_KHR ) //=== VK_KHR_external_fence_win32 === @@ -3106,6 +3527,10 @@ namespace VULKAN_HPP_NAMESPACE //=== VK_KHR_acceleration_structure === + VULKAN_HPP_NODISCARD VULKAN_HPP_RAII_NAMESPACE::AccelerationStructureKHR createAccelerationStructureKHR( + VULKAN_HPP_NAMESPACE::AccelerationStructureCreateInfoKHR const & createInfo, + VULKAN_HPP_NAMESPACE::Optional allocator = nullptr ) const; + VULKAN_HPP_NODISCARD VULKAN_HPP_NAMESPACE::Result buildAccelerationStructuresKHR( VULKAN_HPP_NAMESPACE::DeferredOperationKHR deferredOperation, ArrayProxy const & infos, @@ -3153,6 +3578,10 @@ namespace VULKAN_HPP_NAMESPACE //=== VK_KHR_sampler_ycbcr_conversion === + VULKAN_HPP_NODISCARD VULKAN_HPP_RAII_NAMESPACE::SamplerYcbcrConversion createSamplerYcbcrConversionKHR( + VULKAN_HPP_NAMESPACE::SamplerYcbcrConversionCreateInfo const & createInfo, + VULKAN_HPP_NAMESPACE::Optional allocator = nullptr ) const; + void destroySamplerYcbcrConversionKHR( VULKAN_HPP_NAMESPACE::SamplerYcbcrConversion ycbcrConversion VULKAN_HPP_DEFAULT_ARGUMENT_ASSIGNMENT, Optional allocator @@ -3164,8 +3593,18 @@ namespace VULKAN_HPP_NAMESPACE void bindImageMemory2KHR( ArrayProxy const & bindInfos ) const; + //=== VK_EXT_validation_cache === + + VULKAN_HPP_NODISCARD VULKAN_HPP_RAII_NAMESPACE::ValidationCacheEXT createValidationCacheEXT( + VULKAN_HPP_NAMESPACE::ValidationCacheCreateInfoEXT const & createInfo, + VULKAN_HPP_NAMESPACE::Optional allocator = nullptr ) const; + //=== VK_NV_ray_tracing === + VULKAN_HPP_NODISCARD VULKAN_HPP_RAII_NAMESPACE::AccelerationStructureNV createAccelerationStructureNV( + VULKAN_HPP_NAMESPACE::AccelerationStructureCreateInfoNV const & createInfo, + VULKAN_HPP_NAMESPACE::Optional allocator = nullptr ) const; + VULKAN_HPP_NODISCARD VULKAN_HPP_NAMESPACE::MemoryRequirements2KHR getAccelerationStructureMemoryRequirementsNV( const VULKAN_HPP_NAMESPACE::AccelerationStructureMemoryRequirementsInfoNV & info ) const VULKAN_HPP_NOEXCEPT; @@ -3176,6 +3615,18 @@ namespace VULKAN_HPP_NAMESPACE void bindAccelerationStructureMemoryNV( ArrayProxy const & bindInfos ) const; + VULKAN_HPP_NODISCARD std::vector createRayTracingPipelinesNV( + VULKAN_HPP_NAMESPACE::Optional const & + pipelineCache, + VULKAN_HPP_NAMESPACE::ArrayProxy const & createInfos, + VULKAN_HPP_NAMESPACE::Optional allocator = nullptr ) const; + + VULKAN_HPP_NODISCARD VULKAN_HPP_RAII_NAMESPACE::Pipeline createRayTracingPipelineNV( + VULKAN_HPP_NAMESPACE::Optional const & + pipelineCache, + VULKAN_HPP_NAMESPACE::RayTracingPipelineCreateInfoNV const & createInfo, + VULKAN_HPP_NAMESPACE::Optional allocator = nullptr ) const; + //=== VK_KHR_maintenance3 === VULKAN_HPP_NODISCARD VULKAN_HPP_NAMESPACE::DescriptorSetLayoutSupport getDescriptorSetLayoutSupportKHR( @@ -3213,6 +3664,10 @@ namespace VULKAN_HPP_NAMESPACE void uninitializePerformanceApiINTEL() const VULKAN_HPP_NOEXCEPT; + VULKAN_HPP_NODISCARD VULKAN_HPP_RAII_NAMESPACE::PerformanceConfigurationINTEL + acquirePerformanceConfigurationINTEL( + VULKAN_HPP_NAMESPACE::PerformanceConfigurationAcquireInfoINTEL const & acquireInfo ) const; + VULKAN_HPP_NODISCARD VULKAN_HPP_NAMESPACE::PerformanceValueINTEL getPerformanceParameterINTEL( VULKAN_HPP_NAMESPACE::PerformanceParameterTypeINTEL parameter ) const; @@ -3239,6 +3694,11 @@ namespace VULKAN_HPP_NAMESPACE VULKAN_HPP_NODISCARD uint64_t getMemoryOpaqueCaptureAddressKHR( const VULKAN_HPP_NAMESPACE::DeviceMemoryOpaqueCaptureAddressInfo & info ) const VULKAN_HPP_NOEXCEPT; + //=== VK_KHR_deferred_host_operations === + + VULKAN_HPP_NODISCARD VULKAN_HPP_RAII_NAMESPACE::DeferredOperationKHR createDeferredOperationKHR( + VULKAN_HPP_NAMESPACE::Optional allocator = nullptr ) const; + //=== VK_KHR_pipeline_executable_properties === VULKAN_HPP_NODISCARD std::vector @@ -3261,8 +3721,16 @@ namespace VULKAN_HPP_NAMESPACE VULKAN_HPP_NODISCARD StructureChain getGeneratedCommandsMemoryRequirementsNV( const VULKAN_HPP_NAMESPACE::GeneratedCommandsMemoryRequirementsInfoNV & info ) const VULKAN_HPP_NOEXCEPT; + VULKAN_HPP_NODISCARD VULKAN_HPP_RAII_NAMESPACE::IndirectCommandsLayoutNV createIndirectCommandsLayoutNV( + VULKAN_HPP_NAMESPACE::IndirectCommandsLayoutCreateInfoNV const & createInfo, + VULKAN_HPP_NAMESPACE::Optional allocator = nullptr ) const; + //=== VK_EXT_private_data === + VULKAN_HPP_NODISCARD VULKAN_HPP_RAII_NAMESPACE::PrivateDataSlotEXT createPrivateDataSlotEXT( + VULKAN_HPP_NAMESPACE::PrivateDataSlotCreateInfoEXT const & createInfo, + VULKAN_HPP_NAMESPACE::Optional allocator = nullptr ) const; + void setPrivateDataEXT( VULKAN_HPP_NAMESPACE::ObjectType objectType_, uint64_t objectHandle, VULKAN_HPP_NAMESPACE::PrivateDataSlotEXT privateDataSlot, @@ -3273,6 +3741,24 @@ namespace VULKAN_HPP_NAMESPACE uint64_t objectHandle, VULKAN_HPP_NAMESPACE::PrivateDataSlotEXT privateDataSlot ) const VULKAN_HPP_NOEXCEPT; + //=== VK_KHR_ray_tracing_pipeline === + + VULKAN_HPP_NODISCARD std::vector createRayTracingPipelinesKHR( + VULKAN_HPP_NAMESPACE::Optional< + const VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::DeferredOperationKHR> const & deferredOperation, + VULKAN_HPP_NAMESPACE::Optional const & + pipelineCache, + VULKAN_HPP_NAMESPACE::ArrayProxy const & createInfos, + VULKAN_HPP_NAMESPACE::Optional allocator = nullptr ) const; + + VULKAN_HPP_NODISCARD VULKAN_HPP_RAII_NAMESPACE::Pipeline createRayTracingPipelineKHR( + VULKAN_HPP_NAMESPACE::Optional< + const VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::DeferredOperationKHR> const & deferredOperation, + VULKAN_HPP_NAMESPACE::Optional const & + pipelineCache, + VULKAN_HPP_NAMESPACE::RayTracingPipelineCreateInfoKHR const & createInfo, + VULKAN_HPP_NAMESPACE::Optional allocator = nullptr ) const; + # if defined( VK_USE_PLATFORM_FUCHSIA ) //=== VK_FUCHSIA_external_memory === @@ -3294,6 +3780,14 @@ namespace VULKAN_HPP_NAMESPACE const VULKAN_HPP_NAMESPACE::SemaphoreGetZirconHandleInfoFUCHSIA & getZirconHandleInfo ) const; # endif /*VK_USE_PLATFORM_FUCHSIA*/ +# if defined( VK_USE_PLATFORM_FUCHSIA ) + //=== VK_FUCHSIA_buffer_collection === + + VULKAN_HPP_NODISCARD VULKAN_HPP_RAII_NAMESPACE::BufferCollectionFUCHSIA createBufferCollectionFUCHSIA( + VULKAN_HPP_NAMESPACE::BufferCollectionCreateInfoFUCHSIA const & createInfo, + VULKAN_HPP_NAMESPACE::Optional allocator = nullptr ) const; +# endif /*VK_USE_PLATFORM_FUCHSIA*/ + //=== VK_NV_external_memory_rdma === VULKAN_HPP_NODISCARD VULKAN_HPP_NAMESPACE::RemoteAddressNV getMemoryRemoteAddressNV( @@ -3412,6 +3906,11 @@ namespace VULKAN_HPP_NAMESPACE return m_accelerationStructureKHR; } + VULKAN_HPP_NAMESPACE::Device getDevice() const VULKAN_HPP_NOEXCEPT + { + return static_cast( m_device ); + } + VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::DeviceDispatcher const * getDispatcher() const { VULKAN_HPP_ASSERT( m_dispatcher->getVkHeaderVersion() == VK_HEADER_VERSION ); @@ -3512,6 +4011,11 @@ namespace VULKAN_HPP_NAMESPACE return m_accelerationStructureNV; } + VULKAN_HPP_NAMESPACE::Device getDevice() const VULKAN_HPP_NOEXCEPT + { + return static_cast( m_device ); + } + VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::DeviceDispatcher const * getDispatcher() const { VULKAN_HPP_ASSERT( m_dispatcher->getVkHeaderVersion() == VK_HEADER_VERSION ); @@ -3613,6 +4117,11 @@ namespace VULKAN_HPP_NAMESPACE return m_buffer; } + VULKAN_HPP_NAMESPACE::Device getDevice() const VULKAN_HPP_NOEXCEPT + { + return static_cast( m_device ); + } + VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::DeviceDispatcher const * getDispatcher() const { VULKAN_HPP_ASSERT( m_dispatcher->getVkHeaderVersion() == VK_HEADER_VERSION ); @@ -3720,6 +4229,11 @@ namespace VULKAN_HPP_NAMESPACE return m_bufferCollectionFUCHSIA; } + VULKAN_HPP_NAMESPACE::Device getDevice() const VULKAN_HPP_NOEXCEPT + { + return static_cast( m_device ); + } + VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::DeviceDispatcher const * getDispatcher() const { VULKAN_HPP_ASSERT( m_dispatcher->getVkHeaderVersion() == VK_HEADER_VERSION ); @@ -3823,6 +4337,11 @@ namespace VULKAN_HPP_NAMESPACE return m_bufferView; } + VULKAN_HPP_NAMESPACE::Device getDevice() const VULKAN_HPP_NOEXCEPT + { + return static_cast( m_device ); + } + VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::DeviceDispatcher const * getDispatcher() const { VULKAN_HPP_ASSERT( m_dispatcher->getVkHeaderVersion() == VK_HEADER_VERSION ); @@ -3916,6 +4435,11 @@ namespace VULKAN_HPP_NAMESPACE return m_commandPool; } + VULKAN_HPP_NAMESPACE::Device getDevice() const VULKAN_HPP_NOEXCEPT + { + return static_cast( m_device ); + } + VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::DeviceDispatcher const * getDispatcher() const { VULKAN_HPP_ASSERT( m_dispatcher->getVkHeaderVersion() == VK_HEADER_VERSION ); @@ -4011,6 +4535,11 @@ namespace VULKAN_HPP_NAMESPACE return m_commandBuffer; } + VULKAN_HPP_NAMESPACE::Device getDevice() const VULKAN_HPP_NOEXCEPT + { + return static_cast( m_device ); + } + VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::DeviceDispatcher const * getDispatcher() const { VULKAN_HPP_ASSERT( m_dispatcher->getVkHeaderVersion() == VK_HEADER_VERSION ); @@ -4857,6 +5386,11 @@ namespace VULKAN_HPP_NAMESPACE return m_cuFunctionNVX; } + VULKAN_HPP_NAMESPACE::Device getDevice() const VULKAN_HPP_NOEXCEPT + { + return static_cast( m_device ); + } + VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::DeviceDispatcher const * getDispatcher() const { VULKAN_HPP_ASSERT( m_dispatcher->getVkHeaderVersion() == VK_HEADER_VERSION ); @@ -4950,6 +5484,11 @@ namespace VULKAN_HPP_NAMESPACE return m_cuModuleNVX; } + VULKAN_HPP_NAMESPACE::Device getDevice() const VULKAN_HPP_NOEXCEPT + { + return static_cast( m_device ); + } + VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::DeviceDispatcher const * getDispatcher() const { VULKAN_HPP_ASSERT( m_dispatcher->getVkHeaderVersion() == VK_HEADER_VERSION ); @@ -5050,6 +5589,11 @@ namespace VULKAN_HPP_NAMESPACE return m_debugReportCallbackEXT; } + VULKAN_HPP_NAMESPACE::Instance getInstance() const VULKAN_HPP_NOEXCEPT + { + return static_cast( m_instance ); + } + VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::InstanceDispatcher const * getDispatcher() const { VULKAN_HPP_ASSERT( m_dispatcher->getVkHeaderVersion() == VK_HEADER_VERSION ); @@ -5150,6 +5694,11 @@ namespace VULKAN_HPP_NAMESPACE return m_debugUtilsMessengerEXT; } + VULKAN_HPP_NAMESPACE::Instance getInstance() const VULKAN_HPP_NOEXCEPT + { + return static_cast( m_instance ); + } + VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::InstanceDispatcher const * getDispatcher() const { VULKAN_HPP_ASSERT( m_dispatcher->getVkHeaderVersion() == VK_HEADER_VERSION ); @@ -5248,6 +5797,11 @@ namespace VULKAN_HPP_NAMESPACE return m_deferredOperationKHR; } + VULKAN_HPP_NAMESPACE::Device getDevice() const VULKAN_HPP_NOEXCEPT + { + return static_cast( m_device ); + } + VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::DeviceDispatcher const * getDispatcher() const { VULKAN_HPP_ASSERT( m_dispatcher->getVkHeaderVersion() == VK_HEADER_VERSION ); @@ -5353,6 +5907,11 @@ namespace VULKAN_HPP_NAMESPACE return m_descriptorPool; } + VULKAN_HPP_NAMESPACE::Device getDevice() const VULKAN_HPP_NOEXCEPT + { + return static_cast( m_device ); + } + VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::DeviceDispatcher const * getDispatcher() const { VULKAN_HPP_ASSERT( m_dispatcher->getVkHeaderVersion() == VK_HEADER_VERSION ); @@ -5442,6 +6001,11 @@ namespace VULKAN_HPP_NAMESPACE return m_descriptorSet; } + VULKAN_HPP_NAMESPACE::Device getDevice() const VULKAN_HPP_NOEXCEPT + { + return static_cast( m_device ); + } + VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::DeviceDispatcher const * getDispatcher() const { VULKAN_HPP_ASSERT( m_dispatcher->getVkHeaderVersion() == VK_HEADER_VERSION ); @@ -5588,6 +6152,11 @@ namespace VULKAN_HPP_NAMESPACE return m_descriptorSetLayout; } + VULKAN_HPP_NAMESPACE::Device getDevice() const VULKAN_HPP_NOEXCEPT + { + return static_cast( m_device ); + } + VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::DeviceDispatcher const * getDispatcher() const { VULKAN_HPP_ASSERT( m_dispatcher->getVkHeaderVersion() == VK_HEADER_VERSION ); @@ -5688,6 +6257,11 @@ namespace VULKAN_HPP_NAMESPACE return m_descriptorUpdateTemplate; } + VULKAN_HPP_NAMESPACE::Device getDevice() const VULKAN_HPP_NOEXCEPT + { + return static_cast( m_device ); + } + VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::DeviceDispatcher const * getDispatcher() const { VULKAN_HPP_ASSERT( m_dispatcher->getVkHeaderVersion() == VK_HEADER_VERSION ); @@ -5783,6 +6357,11 @@ namespace VULKAN_HPP_NAMESPACE return m_deviceMemory; } + VULKAN_HPP_NAMESPACE::Device getDevice() const VULKAN_HPP_NOEXCEPT + { + return static_cast( m_device ); + } + VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::DeviceDispatcher const * getDispatcher() const { VULKAN_HPP_ASSERT( m_dispatcher->getVkHeaderVersion() == VK_HEADER_VERSION ); @@ -5929,6 +6508,11 @@ namespace VULKAN_HPP_NAMESPACE return m_displayKHR; } + VULKAN_HPP_NAMESPACE::PhysicalDevice getPhysicalDevice() const VULKAN_HPP_NOEXCEPT + { + return static_cast( m_physicalDevice ); + } + VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::InstanceDispatcher const * getDispatcher() const { VULKAN_HPP_ASSERT( m_dispatcher->getVkHeaderVersion() == VK_HEADER_VERSION ); @@ -5939,6 +6523,10 @@ namespace VULKAN_HPP_NAMESPACE VULKAN_HPP_NODISCARD std::vector getModeProperties() const; + VULKAN_HPP_NODISCARD VULKAN_HPP_RAII_NAMESPACE::DisplayModeKHR createMode( + VULKAN_HPP_NAMESPACE::DisplayModeCreateInfoKHR const & createInfo, + VULKAN_HPP_NAMESPACE::Optional allocator = nullptr ) const; + //=== VK_KHR_get_display_properties2 === VULKAN_HPP_NODISCARD std::vector getModeProperties2() const; @@ -6011,15 +6599,14 @@ namespace VULKAN_HPP_NAMESPACE public: DisplayModeKHR( - VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::PhysicalDevice const & physicalDevice, VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::DisplayKHR const & display, VULKAN_HPP_NAMESPACE::DisplayModeCreateInfoKHR const & createInfo, VULKAN_HPP_NAMESPACE::Optional allocator = nullptr ) - : m_physicalDevice( *physicalDevice ), m_dispatcher( physicalDevice.getDispatcher() ) + : m_dispatcher( display.getDispatcher() ) { VULKAN_HPP_NAMESPACE::Result result = static_cast( getDispatcher()->vkCreateDisplayModeKHR( - static_cast( *physicalDevice ), + static_cast( display.getPhysicalDevice() ), static_cast( *display ), reinterpret_cast( &createInfo ), reinterpret_cast( @@ -6075,7 +6662,7 @@ namespace VULKAN_HPP_NAMESPACE private: VULKAN_HPP_NAMESPACE::DisplayModeKHR m_displayModeKHR; - VULKAN_HPP_NAMESPACE::PhysicalDevice m_physicalDevice; + VkPhysicalDevice m_physicalDevice; VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::InstanceDispatcher const * m_dispatcher = nullptr; }; @@ -6159,6 +6746,11 @@ namespace VULKAN_HPP_NAMESPACE return m_event; } + VULKAN_HPP_NAMESPACE::Device getDevice() const VULKAN_HPP_NOEXCEPT + { + return static_cast( m_device ); + } + VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::DeviceDispatcher const * getDispatcher() const { VULKAN_HPP_ASSERT( m_dispatcher->getVkHeaderVersion() == VK_HEADER_VERSION ); @@ -6301,6 +6893,11 @@ namespace VULKAN_HPP_NAMESPACE return m_fence; } + VULKAN_HPP_NAMESPACE::Device getDevice() const VULKAN_HPP_NOEXCEPT + { + return static_cast( m_device ); + } + VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::DeviceDispatcher const * getDispatcher() const { VULKAN_HPP_ASSERT( m_dispatcher->getVkHeaderVersion() == VK_HEADER_VERSION ); @@ -6398,6 +6995,11 @@ namespace VULKAN_HPP_NAMESPACE return m_framebuffer; } + VULKAN_HPP_NAMESPACE::Device getDevice() const VULKAN_HPP_NOEXCEPT + { + return static_cast( m_device ); + } + VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::DeviceDispatcher const * getDispatcher() const { VULKAN_HPP_ASSERT( m_dispatcher->getVkHeaderVersion() == VK_HEADER_VERSION ); @@ -6491,6 +7093,11 @@ namespace VULKAN_HPP_NAMESPACE return m_image; } + VULKAN_HPP_NAMESPACE::Device getDevice() const VULKAN_HPP_NOEXCEPT + { + return static_cast( m_device ); + } + VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::DeviceDispatcher const * getDispatcher() const { VULKAN_HPP_ASSERT( m_dispatcher->getVkHeaderVersion() == VK_HEADER_VERSION ); @@ -6601,6 +7208,11 @@ namespace VULKAN_HPP_NAMESPACE return m_imageView; } + VULKAN_HPP_NAMESPACE::Device getDevice() const VULKAN_HPP_NOEXCEPT + { + return static_cast( m_device ); + } + VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::DeviceDispatcher const * getDispatcher() const { VULKAN_HPP_ASSERT( m_dispatcher->getVkHeaderVersion() == VK_HEADER_VERSION ); @@ -6705,6 +7317,11 @@ namespace VULKAN_HPP_NAMESPACE return m_indirectCommandsLayoutNV; } + VULKAN_HPP_NAMESPACE::Device getDevice() const VULKAN_HPP_NOEXCEPT + { + return static_cast( m_device ); + } + VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::DeviceDispatcher const * getDispatcher() const { VULKAN_HPP_ASSERT( m_dispatcher->getVkHeaderVersion() == VK_HEADER_VERSION ); @@ -6794,6 +7411,11 @@ namespace VULKAN_HPP_NAMESPACE return m_performanceConfigurationINTEL; } + VULKAN_HPP_NAMESPACE::Device getDevice() const VULKAN_HPP_NOEXCEPT + { + return static_cast( m_device ); + } + VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::DeviceDispatcher const * getDispatcher() const { VULKAN_HPP_ASSERT( m_dispatcher->getVkHeaderVersion() == VK_HEADER_VERSION ); @@ -6890,6 +7512,11 @@ namespace VULKAN_HPP_NAMESPACE return m_pipelineCache; } + VULKAN_HPP_NAMESPACE::Device getDevice() const VULKAN_HPP_NOEXCEPT + { + return static_cast( m_device ); + } + VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::DeviceDispatcher const * getDispatcher() const { VULKAN_HPP_ASSERT( m_dispatcher->getVkHeaderVersion() == VK_HEADER_VERSION ); @@ -7094,6 +7721,11 @@ namespace VULKAN_HPP_NAMESPACE return m_constructorSuccessCode; } + VULKAN_HPP_NAMESPACE::Device getDevice() const VULKAN_HPP_NOEXCEPT + { + return static_cast( m_device ); + } + VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::DeviceDispatcher const * getDispatcher() const { VULKAN_HPP_ASSERT( m_dispatcher->getVkHeaderVersion() == VK_HEADER_VERSION ); @@ -7397,6 +8029,11 @@ namespace VULKAN_HPP_NAMESPACE return m_pipelineLayout; } + VULKAN_HPP_NAMESPACE::Device getDevice() const VULKAN_HPP_NOEXCEPT + { + return static_cast( m_device ); + } + VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::DeviceDispatcher const * getDispatcher() const { VULKAN_HPP_ASSERT( m_dispatcher->getVkHeaderVersion() == VK_HEADER_VERSION ); @@ -7497,6 +8134,11 @@ namespace VULKAN_HPP_NAMESPACE return m_privateDataSlotEXT; } + VULKAN_HPP_NAMESPACE::Device getDevice() const VULKAN_HPP_NOEXCEPT + { + return static_cast( m_device ); + } + VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::DeviceDispatcher const * getDispatcher() const { VULKAN_HPP_ASSERT( m_dispatcher->getVkHeaderVersion() == VK_HEADER_VERSION ); @@ -7590,6 +8232,11 @@ namespace VULKAN_HPP_NAMESPACE return m_queryPool; } + VULKAN_HPP_NAMESPACE::Device getDevice() const VULKAN_HPP_NOEXCEPT + { + return static_cast( m_device ); + } + VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::DeviceDispatcher const * getDispatcher() const { VULKAN_HPP_ASSERT( m_dispatcher->getVkHeaderVersion() == VK_HEADER_VERSION ); @@ -7837,6 +8484,11 @@ namespace VULKAN_HPP_NAMESPACE return m_renderPass; } + VULKAN_HPP_NAMESPACE::Device getDevice() const VULKAN_HPP_NOEXCEPT + { + return static_cast( m_device ); + } + VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::DeviceDispatcher const * getDispatcher() const { VULKAN_HPP_ASSERT( m_dispatcher->getVkHeaderVersion() == VK_HEADER_VERSION ); @@ -7939,6 +8591,11 @@ namespace VULKAN_HPP_NAMESPACE return m_sampler; } + VULKAN_HPP_NAMESPACE::Device getDevice() const VULKAN_HPP_NOEXCEPT + { + return static_cast( m_device ); + } + VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::DeviceDispatcher const * getDispatcher() const { VULKAN_HPP_ASSERT( m_dispatcher->getVkHeaderVersion() == VK_HEADER_VERSION ); @@ -8039,6 +8696,11 @@ namespace VULKAN_HPP_NAMESPACE return m_samplerYcbcrConversion; } + VULKAN_HPP_NAMESPACE::Device getDevice() const VULKAN_HPP_NOEXCEPT + { + return static_cast( m_device ); + } + VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::DeviceDispatcher const * getDispatcher() const { VULKAN_HPP_ASSERT( m_dispatcher->getVkHeaderVersion() == VK_HEADER_VERSION ); @@ -8132,6 +8794,11 @@ namespace VULKAN_HPP_NAMESPACE return m_semaphore; } + VULKAN_HPP_NAMESPACE::Device getDevice() const VULKAN_HPP_NOEXCEPT + { + return static_cast( m_device ); + } + VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::DeviceDispatcher const * getDispatcher() const { VULKAN_HPP_ASSERT( m_dispatcher->getVkHeaderVersion() == VK_HEADER_VERSION ); @@ -8237,6 +8904,11 @@ namespace VULKAN_HPP_NAMESPACE return m_shaderModule; } + VULKAN_HPP_NAMESPACE::Device getDevice() const VULKAN_HPP_NOEXCEPT + { + return static_cast( m_device ); + } + VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::DeviceDispatcher const * getDispatcher() const { VULKAN_HPP_ASSERT( m_dispatcher->getVkHeaderVersion() == VK_HEADER_VERSION ); @@ -8633,6 +9305,11 @@ namespace VULKAN_HPP_NAMESPACE return m_surfaceKHR; } + VULKAN_HPP_NAMESPACE::Instance getInstance() const VULKAN_HPP_NOEXCEPT + { + return static_cast( m_instance ); + } + VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::InstanceDispatcher const * getDispatcher() const { VULKAN_HPP_ASSERT( m_dispatcher->getVkHeaderVersion() == VK_HEADER_VERSION ); @@ -8736,6 +9413,11 @@ namespace VULKAN_HPP_NAMESPACE return m_swapchainKHR; } + VULKAN_HPP_NAMESPACE::Device getDevice() const VULKAN_HPP_NOEXCEPT + { + return static_cast( m_device ); + } + VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::DeviceDispatcher const * getDispatcher() const { VULKAN_HPP_ASSERT( m_dispatcher->getVkHeaderVersion() == VK_HEADER_VERSION ); @@ -8919,6 +9601,11 @@ namespace VULKAN_HPP_NAMESPACE return m_validationCacheEXT; } + VULKAN_HPP_NAMESPACE::Device getDevice() const VULKAN_HPP_NOEXCEPT + { + return static_cast( m_device ); + } + VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::DeviceDispatcher const * getDispatcher() const { VULKAN_HPP_ASSERT( m_dispatcher->getVkHeaderVersion() == VK_HEADER_VERSION ); @@ -9024,6 +9711,11 @@ namespace VULKAN_HPP_NAMESPACE return m_videoSessionKHR; } + VULKAN_HPP_NAMESPACE::Device getDevice() const VULKAN_HPP_NOEXCEPT + { + return static_cast( m_device ); + } + VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::DeviceDispatcher const * getDispatcher() const { VULKAN_HPP_ASSERT( m_dispatcher->getVkHeaderVersion() == VK_HEADER_VERSION ); @@ -9133,6 +9825,11 @@ namespace VULKAN_HPP_NAMESPACE return m_videoSessionParametersKHR; } + VULKAN_HPP_NAMESPACE::Device getDevice() const VULKAN_HPP_NOEXCEPT + { + return static_cast( m_device ); + } + VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::DeviceDispatcher const * getDispatcher() const { VULKAN_HPP_ASSERT( m_dispatcher->getVkHeaderVersion() == VK_HEADER_VERSION ); @@ -9157,6 +9854,19 @@ namespace VULKAN_HPP_NAMESPACE //=== VK_VERSION_1_0 === + VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE VULKAN_HPP_RAII_NAMESPACE::Instance Context::createInstance( + VULKAN_HPP_NAMESPACE::InstanceCreateInfo const & createInfo, + VULKAN_HPP_NAMESPACE::Optional allocator ) const + { + return VULKAN_HPP_RAII_NAMESPACE::Instance( *this, createInfo, allocator ); + } + + VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE std::vector + Instance::enumeratePhysicalDevices() const + { + return VULKAN_HPP_RAII_NAMESPACE::PhysicalDevices( *this ); + } + VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE VULKAN_HPP_NAMESPACE::PhysicalDeviceFeatures PhysicalDevice::getFeatures() const VULKAN_HPP_NOEXCEPT { @@ -9247,6 +9957,13 @@ namespace VULKAN_HPP_NAMESPACE return getDispatcher()->vkGetDeviceProcAddr( static_cast( m_device ), name.c_str() ); } + VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE VULKAN_HPP_RAII_NAMESPACE::Device PhysicalDevice::createDevice( + VULKAN_HPP_NAMESPACE::DeviceCreateInfo const & createInfo, + VULKAN_HPP_NAMESPACE::Optional allocator ) const + { + return VULKAN_HPP_RAII_NAMESPACE::Device( *this, createInfo, allocator ); + } + VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE std::vector Context::enumerateInstanceExtensionProperties( Optional layerName ) const { @@ -9374,6 +10091,12 @@ namespace VULKAN_HPP_NAMESPACE return properties; } + VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE VULKAN_HPP_RAII_NAMESPACE::Queue + Device::getQueue( uint32_t queueFamilyIndex, uint32_t queueIndex ) const + { + return VULKAN_HPP_RAII_NAMESPACE::Queue( *this, queueFamilyIndex, queueIndex ); + } + VULKAN_HPP_INLINE void Queue::submit( ArrayProxy const & submits, VULKAN_HPP_NAMESPACE::Fence fence ) const { @@ -9408,6 +10131,13 @@ namespace VULKAN_HPP_NAMESPACE } } + VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE VULKAN_HPP_RAII_NAMESPACE::DeviceMemory Device::allocateMemory( + VULKAN_HPP_NAMESPACE::MemoryAllocateInfo const & allocateInfo, + VULKAN_HPP_NAMESPACE::Optional allocator ) const + { + return VULKAN_HPP_RAII_NAMESPACE::DeviceMemory( *this, allocateInfo, allocator ); + } + VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE void * DeviceMemory::mapMemory( VULKAN_HPP_NAMESPACE::DeviceSize offset, VULKAN_HPP_NAMESPACE::DeviceSize size, @@ -9583,6 +10313,13 @@ namespace VULKAN_HPP_NAMESPACE } } + VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE VULKAN_HPP_RAII_NAMESPACE::Fence Device::createFence( + VULKAN_HPP_NAMESPACE::FenceCreateInfo const & createInfo, + VULKAN_HPP_NAMESPACE::Optional allocator ) const + { + return VULKAN_HPP_RAII_NAMESPACE::Fence( *this, createInfo, allocator ); + } + VULKAN_HPP_INLINE void Device::resetFences( ArrayProxy const & fences ) const { VULKAN_HPP_NAMESPACE::Result result = static_cast( getDispatcher()->vkResetFences( @@ -9624,6 +10361,20 @@ namespace VULKAN_HPP_NAMESPACE return result; } + VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE VULKAN_HPP_RAII_NAMESPACE::Semaphore Device::createSemaphore( + VULKAN_HPP_NAMESPACE::SemaphoreCreateInfo const & createInfo, + VULKAN_HPP_NAMESPACE::Optional allocator ) const + { + return VULKAN_HPP_RAII_NAMESPACE::Semaphore( *this, createInfo, allocator ); + } + + VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE VULKAN_HPP_RAII_NAMESPACE::Event Device::createEvent( + VULKAN_HPP_NAMESPACE::EventCreateInfo const & createInfo, + VULKAN_HPP_NAMESPACE::Optional allocator ) const + { + return VULKAN_HPP_RAII_NAMESPACE::Event( *this, createInfo, allocator ); + } + VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE VULKAN_HPP_NAMESPACE::Result Event::getStatus() const { VULKAN_HPP_NAMESPACE::Result result = static_cast( @@ -9656,6 +10407,13 @@ namespace VULKAN_HPP_NAMESPACE } } + VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE VULKAN_HPP_RAII_NAMESPACE::QueryPool Device::createQueryPool( + VULKAN_HPP_NAMESPACE::QueryPoolCreateInfo const & createInfo, + VULKAN_HPP_NAMESPACE::Optional allocator ) const + { + return VULKAN_HPP_RAII_NAMESPACE::QueryPool( *this, createInfo, allocator ); + } + template VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE std::pair> QueryPool::getResults( uint32_t firstQuery, @@ -9708,6 +10466,27 @@ namespace VULKAN_HPP_NAMESPACE return std::make_pair( result, data ); } + VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE VULKAN_HPP_RAII_NAMESPACE::Buffer Device::createBuffer( + VULKAN_HPP_NAMESPACE::BufferCreateInfo const & createInfo, + VULKAN_HPP_NAMESPACE::Optional allocator ) const + { + return VULKAN_HPP_RAII_NAMESPACE::Buffer( *this, createInfo, allocator ); + } + + VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE VULKAN_HPP_RAII_NAMESPACE::BufferView Device::createBufferView( + VULKAN_HPP_NAMESPACE::BufferViewCreateInfo const & createInfo, + VULKAN_HPP_NAMESPACE::Optional allocator ) const + { + return VULKAN_HPP_RAII_NAMESPACE::BufferView( *this, createInfo, allocator ); + } + + VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE VULKAN_HPP_RAII_NAMESPACE::Image Device::createImage( + VULKAN_HPP_NAMESPACE::ImageCreateInfo const & createInfo, + VULKAN_HPP_NAMESPACE::Optional allocator ) const + { + return VULKAN_HPP_RAII_NAMESPACE::Image( *this, createInfo, allocator ); + } + VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE VULKAN_HPP_NAMESPACE::SubresourceLayout Image::getSubresourceLayout( const VULKAN_HPP_NAMESPACE::ImageSubresource & subresource ) const VULKAN_HPP_NOEXCEPT { @@ -9719,6 +10498,27 @@ namespace VULKAN_HPP_NAMESPACE return layout; } + VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE VULKAN_HPP_RAII_NAMESPACE::ImageView Device::createImageView( + VULKAN_HPP_NAMESPACE::ImageViewCreateInfo const & createInfo, + VULKAN_HPP_NAMESPACE::Optional allocator ) const + { + return VULKAN_HPP_RAII_NAMESPACE::ImageView( *this, createInfo, allocator ); + } + + VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE VULKAN_HPP_RAII_NAMESPACE::ShaderModule Device::createShaderModule( + VULKAN_HPP_NAMESPACE::ShaderModuleCreateInfo const & createInfo, + VULKAN_HPP_NAMESPACE::Optional allocator ) const + { + return VULKAN_HPP_RAII_NAMESPACE::ShaderModule( *this, createInfo, allocator ); + } + + VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE VULKAN_HPP_RAII_NAMESPACE::PipelineCache Device::createPipelineCache( + VULKAN_HPP_NAMESPACE::PipelineCacheCreateInfo const & createInfo, + VULKAN_HPP_NAMESPACE::Optional allocator ) const + { + return VULKAN_HPP_RAII_NAMESPACE::PipelineCache( *this, createInfo, allocator ); + } + VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE std::vector PipelineCache::getData() const { std::vector data; @@ -9764,6 +10564,73 @@ namespace VULKAN_HPP_NAMESPACE } } + VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE std::vector + Device::createGraphicsPipelines( + VULKAN_HPP_NAMESPACE::Optional const & + pipelineCache, + VULKAN_HPP_NAMESPACE::ArrayProxy const & createInfos, + VULKAN_HPP_NAMESPACE::Optional allocator ) const + { + return VULKAN_HPP_RAII_NAMESPACE::Pipelines( *this, pipelineCache, createInfos, allocator ); + } + + VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE VULKAN_HPP_RAII_NAMESPACE::Pipeline Device::createGraphicsPipeline( + VULKAN_HPP_NAMESPACE::Optional const & + pipelineCache, + VULKAN_HPP_NAMESPACE::GraphicsPipelineCreateInfo const & createInfo, + VULKAN_HPP_NAMESPACE::Optional allocator ) const + { + return VULKAN_HPP_RAII_NAMESPACE::Pipeline( *this, pipelineCache, createInfo, allocator ); + } + + VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE std::vector + Device::createComputePipelines( + VULKAN_HPP_NAMESPACE::Optional const & + pipelineCache, + VULKAN_HPP_NAMESPACE::ArrayProxy const & createInfos, + VULKAN_HPP_NAMESPACE::Optional allocator ) const + { + return VULKAN_HPP_RAII_NAMESPACE::Pipelines( *this, pipelineCache, createInfos, allocator ); + } + + VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE VULKAN_HPP_RAII_NAMESPACE::Pipeline Device::createComputePipeline( + VULKAN_HPP_NAMESPACE::Optional const & + pipelineCache, + VULKAN_HPP_NAMESPACE::ComputePipelineCreateInfo const & createInfo, + VULKAN_HPP_NAMESPACE::Optional allocator ) const + { + return VULKAN_HPP_RAII_NAMESPACE::Pipeline( *this, pipelineCache, createInfo, allocator ); + } + + VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE VULKAN_HPP_RAII_NAMESPACE::PipelineLayout Device::createPipelineLayout( + VULKAN_HPP_NAMESPACE::PipelineLayoutCreateInfo const & createInfo, + VULKAN_HPP_NAMESPACE::Optional allocator ) const + { + return VULKAN_HPP_RAII_NAMESPACE::PipelineLayout( *this, createInfo, allocator ); + } + + VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE VULKAN_HPP_RAII_NAMESPACE::Sampler Device::createSampler( + VULKAN_HPP_NAMESPACE::SamplerCreateInfo const & createInfo, + VULKAN_HPP_NAMESPACE::Optional allocator ) const + { + return VULKAN_HPP_RAII_NAMESPACE::Sampler( *this, createInfo, allocator ); + } + + VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE VULKAN_HPP_RAII_NAMESPACE::DescriptorSetLayout + Device::createDescriptorSetLayout( + VULKAN_HPP_NAMESPACE::DescriptorSetLayoutCreateInfo const & createInfo, + VULKAN_HPP_NAMESPACE::Optional allocator ) const + { + return VULKAN_HPP_RAII_NAMESPACE::DescriptorSetLayout( *this, createInfo, allocator ); + } + + VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE VULKAN_HPP_RAII_NAMESPACE::DescriptorPool Device::createDescriptorPool( + VULKAN_HPP_NAMESPACE::DescriptorPoolCreateInfo const & createInfo, + VULKAN_HPP_NAMESPACE::Optional allocator ) const + { + return VULKAN_HPP_RAII_NAMESPACE::DescriptorPool( *this, createInfo, allocator ); + } + VULKAN_HPP_INLINE void DescriptorPool::reset( VULKAN_HPP_NAMESPACE::DescriptorPoolResetFlags flags ) const VULKAN_HPP_NOEXCEPT { @@ -9772,6 +10639,12 @@ namespace VULKAN_HPP_NAMESPACE static_cast( flags ) ); } + VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE std::vector + Device::allocateDescriptorSets( VULKAN_HPP_NAMESPACE::DescriptorSetAllocateInfo const & allocateInfo ) const + { + return VULKAN_HPP_RAII_NAMESPACE::DescriptorSets( *this, allocateInfo ); + } + VULKAN_HPP_INLINE void Device::updateDescriptorSets( ArrayProxy const & descriptorWrites, ArrayProxy const & descriptorCopies ) const VULKAN_HPP_NOEXCEPT @@ -9784,6 +10657,20 @@ namespace VULKAN_HPP_NAMESPACE reinterpret_cast( descriptorCopies.data() ) ); } + VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE VULKAN_HPP_RAII_NAMESPACE::Framebuffer Device::createFramebuffer( + VULKAN_HPP_NAMESPACE::FramebufferCreateInfo const & createInfo, + VULKAN_HPP_NAMESPACE::Optional allocator ) const + { + return VULKAN_HPP_RAII_NAMESPACE::Framebuffer( *this, createInfo, allocator ); + } + + VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE VULKAN_HPP_RAII_NAMESPACE::RenderPass Device::createRenderPass( + VULKAN_HPP_NAMESPACE::RenderPassCreateInfo const & createInfo, + VULKAN_HPP_NAMESPACE::Optional allocator ) const + { + return VULKAN_HPP_RAII_NAMESPACE::RenderPass( *this, createInfo, allocator ); + } + VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE VULKAN_HPP_NAMESPACE::Extent2D RenderPass::getRenderAreaGranularity() const VULKAN_HPP_NOEXCEPT { @@ -9794,6 +10681,13 @@ namespace VULKAN_HPP_NAMESPACE return granularity; } + VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE VULKAN_HPP_RAII_NAMESPACE::CommandPool Device::createCommandPool( + VULKAN_HPP_NAMESPACE::CommandPoolCreateInfo const & createInfo, + VULKAN_HPP_NAMESPACE::Optional allocator ) const + { + return VULKAN_HPP_RAII_NAMESPACE::CommandPool( *this, createInfo, allocator ); + } + VULKAN_HPP_INLINE void CommandPool::reset( VULKAN_HPP_NAMESPACE::CommandPoolResetFlags flags ) const { VULKAN_HPP_NAMESPACE::Result result = static_cast( @@ -9806,6 +10700,12 @@ namespace VULKAN_HPP_NAMESPACE } } + VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE std::vector + Device::allocateCommandBuffers( VULKAN_HPP_NAMESPACE::CommandBufferAllocateInfo const & allocateInfo ) const + { + return VULKAN_HPP_RAII_NAMESPACE::CommandBuffers( *this, allocateInfo ); + } + VULKAN_HPP_INLINE void CommandBuffer::begin( const VULKAN_HPP_NAMESPACE::CommandBufferBeginInfo & beginInfo ) const { VULKAN_HPP_NAMESPACE::Result result = static_cast( @@ -10716,6 +11616,28 @@ namespace VULKAN_HPP_NAMESPACE static_cast( flags ) ); } + VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE VULKAN_HPP_RAII_NAMESPACE::Queue + Device::getQueue2( VULKAN_HPP_NAMESPACE::DeviceQueueInfo2 const & queueInfo ) const + { + return VULKAN_HPP_RAII_NAMESPACE::Queue( *this, queueInfo ); + } + + VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE VULKAN_HPP_RAII_NAMESPACE::SamplerYcbcrConversion + Device::createSamplerYcbcrConversion( + VULKAN_HPP_NAMESPACE::SamplerYcbcrConversionCreateInfo const & createInfo, + VULKAN_HPP_NAMESPACE::Optional allocator ) const + { + return VULKAN_HPP_RAII_NAMESPACE::SamplerYcbcrConversion( *this, createInfo, allocator ); + } + + VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE VULKAN_HPP_RAII_NAMESPACE::DescriptorUpdateTemplate + Device::createDescriptorUpdateTemplate( + VULKAN_HPP_NAMESPACE::DescriptorUpdateTemplateCreateInfo const & createInfo, + VULKAN_HPP_NAMESPACE::Optional allocator ) const + { + return VULKAN_HPP_RAII_NAMESPACE::DescriptorUpdateTemplate( *this, createInfo, allocator ); + } + VULKAN_HPP_INLINE void DescriptorSet::updateWithTemplate( VULKAN_HPP_NAMESPACE::DescriptorUpdateTemplate descriptorUpdateTemplate, const void * pData ) const VULKAN_HPP_NOEXCEPT @@ -10823,6 +11745,13 @@ namespace VULKAN_HPP_NAMESPACE stride ); } + VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE VULKAN_HPP_RAII_NAMESPACE::RenderPass Device::createRenderPass2( + VULKAN_HPP_NAMESPACE::RenderPassCreateInfo2 const & createInfo, + VULKAN_HPP_NAMESPACE::Optional allocator ) const + { + return VULKAN_HPP_RAII_NAMESPACE::RenderPass( *this, createInfo, allocator ); + } + VULKAN_HPP_INLINE void CommandBuffer::beginRenderPass2( const VULKAN_HPP_NAMESPACE::RenderPassBeginInfo & renderPassBegin, const VULKAN_HPP_NAMESPACE::SubpassBeginInfo & subpassBeginInfo ) const VULKAN_HPP_NOEXCEPT @@ -11034,6 +11963,13 @@ namespace VULKAN_HPP_NAMESPACE //=== VK_KHR_swapchain === + VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE VULKAN_HPP_RAII_NAMESPACE::SwapchainKHR Device::createSwapchainKHR( + VULKAN_HPP_NAMESPACE::SwapchainCreateInfoKHR const & createInfo, + VULKAN_HPP_NAMESPACE::Optional allocator ) const + { + return VULKAN_HPP_RAII_NAMESPACE::SwapchainKHR( *this, createInfo, allocator ); + } + VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE std::vector SwapchainKHR::getImages() const { VULKAN_HPP_ASSERT( getDispatcher()->vkGetSwapchainImagesKHR && @@ -11287,6 +12223,12 @@ namespace VULKAN_HPP_NAMESPACE return properties; } + VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE std::vector + PhysicalDevice::getDisplayPlaneSupportedDisplaysKHR( uint32_t planeIndex ) const + { + return VULKAN_HPP_RAII_NAMESPACE::DisplayKHRs( *this, planeIndex ); + } + VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE std::vector DisplayKHR::getModeProperties() const { @@ -11325,6 +12267,13 @@ namespace VULKAN_HPP_NAMESPACE return properties; } + VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE VULKAN_HPP_RAII_NAMESPACE::DisplayModeKHR DisplayKHR::createMode( + VULKAN_HPP_NAMESPACE::DisplayModeCreateInfoKHR const & createInfo, + VULKAN_HPP_NAMESPACE::Optional allocator ) const + { + return VULKAN_HPP_RAII_NAMESPACE::DisplayModeKHR( *this, createInfo, allocator ); + } + VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE VULKAN_HPP_NAMESPACE::DisplayPlaneCapabilitiesKHR DisplayModeKHR::getDisplayPlaneCapabilities( uint32_t planeIndex ) const { @@ -11345,9 +12294,40 @@ namespace VULKAN_HPP_NAMESPACE return capabilities; } + VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE VULKAN_HPP_RAII_NAMESPACE::SurfaceKHR Instance::createDisplayPlaneSurfaceKHR( + VULKAN_HPP_NAMESPACE::DisplaySurfaceCreateInfoKHR const & createInfo, + VULKAN_HPP_NAMESPACE::Optional allocator ) const + { + return VULKAN_HPP_RAII_NAMESPACE::SurfaceKHR( *this, createInfo, allocator ); + } + + //=== VK_KHR_display_swapchain === + + VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE std::vector + Device::createSharedSwapchainsKHR( + VULKAN_HPP_NAMESPACE::ArrayProxy const & createInfos, + VULKAN_HPP_NAMESPACE::Optional allocator ) const + { + return VULKAN_HPP_RAII_NAMESPACE::SwapchainKHRs( *this, createInfos, allocator ); + } + + VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE VULKAN_HPP_RAII_NAMESPACE::SwapchainKHR Device::createSharedSwapchainKHR( + VULKAN_HPP_NAMESPACE::SwapchainCreateInfoKHR const & createInfo, + VULKAN_HPP_NAMESPACE::Optional allocator ) const + { + return VULKAN_HPP_RAII_NAMESPACE::SwapchainKHR( *this, createInfo, allocator ); + } + # if defined( VK_USE_PLATFORM_XLIB_KHR ) //=== VK_KHR_xlib_surface === + VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE VULKAN_HPP_RAII_NAMESPACE::SurfaceKHR Instance::createXlibSurfaceKHR( + VULKAN_HPP_NAMESPACE::XlibSurfaceCreateInfoKHR const & createInfo, + VULKAN_HPP_NAMESPACE::Optional allocator ) const + { + return VULKAN_HPP_RAII_NAMESPACE::SurfaceKHR( *this, createInfo, allocator ); + } + VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE VULKAN_HPP_NAMESPACE::Bool32 PhysicalDevice::getXlibPresentationSupportKHR( uint32_t queueFamilyIndex, Display & dpy, VisualID visualID ) const VULKAN_HPP_NOEXCEPT { @@ -11363,6 +12343,13 @@ namespace VULKAN_HPP_NAMESPACE # if defined( VK_USE_PLATFORM_XCB_KHR ) //=== VK_KHR_xcb_surface === + VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE VULKAN_HPP_RAII_NAMESPACE::SurfaceKHR Instance::createXcbSurfaceKHR( + VULKAN_HPP_NAMESPACE::XcbSurfaceCreateInfoKHR const & createInfo, + VULKAN_HPP_NAMESPACE::Optional allocator ) const + { + return VULKAN_HPP_RAII_NAMESPACE::SurfaceKHR( *this, createInfo, allocator ); + } + VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE VULKAN_HPP_NAMESPACE::Bool32 PhysicalDevice::getXcbPresentationSupportKHR( uint32_t queueFamilyIndex, xcb_connection_t & connection, xcb_visualid_t visual_id ) const VULKAN_HPP_NOEXCEPT { @@ -11378,6 +12365,13 @@ namespace VULKAN_HPP_NAMESPACE # if defined( VK_USE_PLATFORM_WAYLAND_KHR ) //=== VK_KHR_wayland_surface === + VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE VULKAN_HPP_RAII_NAMESPACE::SurfaceKHR Instance::createWaylandSurfaceKHR( + VULKAN_HPP_NAMESPACE::WaylandSurfaceCreateInfoKHR const & createInfo, + VULKAN_HPP_NAMESPACE::Optional allocator ) const + { + return VULKAN_HPP_RAII_NAMESPACE::SurfaceKHR( *this, createInfo, allocator ); + } + VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE VULKAN_HPP_NAMESPACE::Bool32 PhysicalDevice::getWaylandPresentationSupportKHR( uint32_t queueFamilyIndex, struct wl_display & display ) const VULKAN_HPP_NOEXCEPT @@ -11392,9 +12386,27 @@ namespace VULKAN_HPP_NAMESPACE } # endif /*VK_USE_PLATFORM_WAYLAND_KHR*/ +# if defined( VK_USE_PLATFORM_ANDROID_KHR ) + //=== VK_KHR_android_surface === + + VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE VULKAN_HPP_RAII_NAMESPACE::SurfaceKHR Instance::createAndroidSurfaceKHR( + VULKAN_HPP_NAMESPACE::AndroidSurfaceCreateInfoKHR const & createInfo, + VULKAN_HPP_NAMESPACE::Optional allocator ) const + { + return VULKAN_HPP_RAII_NAMESPACE::SurfaceKHR( *this, createInfo, allocator ); + } +# endif /*VK_USE_PLATFORM_ANDROID_KHR*/ + # if defined( VK_USE_PLATFORM_WIN32_KHR ) //=== VK_KHR_win32_surface === + VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE VULKAN_HPP_RAII_NAMESPACE::SurfaceKHR Instance::createWin32SurfaceKHR( + VULKAN_HPP_NAMESPACE::Win32SurfaceCreateInfoKHR const & createInfo, + VULKAN_HPP_NAMESPACE::Optional allocator ) const + { + return VULKAN_HPP_RAII_NAMESPACE::SurfaceKHR( *this, createInfo, allocator ); + } + VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE VULKAN_HPP_NAMESPACE::Bool32 PhysicalDevice::getWin32PresentationSupportKHR( uint32_t queueFamilyIndex ) const VULKAN_HPP_NOEXCEPT { @@ -11409,6 +12421,14 @@ namespace VULKAN_HPP_NAMESPACE //=== VK_EXT_debug_report === + VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE VULKAN_HPP_RAII_NAMESPACE::DebugReportCallbackEXT + Instance::createDebugReportCallbackEXT( + VULKAN_HPP_NAMESPACE::DebugReportCallbackCreateInfoEXT const & createInfo, + VULKAN_HPP_NAMESPACE::Optional allocator ) const + { + return VULKAN_HPP_RAII_NAMESPACE::DebugReportCallbackEXT( *this, createInfo, allocator ); + } + VULKAN_HPP_INLINE void Instance::debugReportMessageEXT( VULKAN_HPP_NAMESPACE::DebugReportFlagsEXT flags, VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT objectType_, uint64_t object, @@ -11575,6 +12595,13 @@ namespace VULKAN_HPP_NAMESPACE return videoFormatProperties; } + VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE VULKAN_HPP_RAII_NAMESPACE::VideoSessionKHR Device::createVideoSessionKHR( + VULKAN_HPP_NAMESPACE::VideoSessionCreateInfoKHR const & createInfo, + VULKAN_HPP_NAMESPACE::Optional allocator ) const + { + return VULKAN_HPP_RAII_NAMESPACE::VideoSessionKHR( *this, createInfo, allocator ); + } + VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE std::vector VideoSessionKHR::getMemoryRequirements() const { @@ -11633,6 +12660,14 @@ namespace VULKAN_HPP_NAMESPACE } } + VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE VULKAN_HPP_RAII_NAMESPACE::VideoSessionParametersKHR + Device::createVideoSessionParametersKHR( + VULKAN_HPP_NAMESPACE::VideoSessionParametersCreateInfoKHR const & createInfo, + VULKAN_HPP_NAMESPACE::Optional allocator ) const + { + return VULKAN_HPP_RAII_NAMESPACE::VideoSessionParametersKHR( *this, createInfo, allocator ); + } + VULKAN_HPP_INLINE void VideoSessionParametersKHR::update( const VULKAN_HPP_NAMESPACE::VideoSessionParametersUpdateInfoKHR & updateInfo ) const { @@ -11839,6 +12874,20 @@ namespace VULKAN_HPP_NAMESPACE //=== VK_NVX_binary_import === + VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE VULKAN_HPP_RAII_NAMESPACE::CuModuleNVX Device::createCuModuleNVX( + VULKAN_HPP_NAMESPACE::CuModuleCreateInfoNVX const & createInfo, + VULKAN_HPP_NAMESPACE::Optional allocator ) const + { + return VULKAN_HPP_RAII_NAMESPACE::CuModuleNVX( *this, createInfo, allocator ); + } + + VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE VULKAN_HPP_RAII_NAMESPACE::CuFunctionNVX Device::createCuFunctionNVX( + VULKAN_HPP_NAMESPACE::CuFunctionCreateInfoNVX const & createInfo, + VULKAN_HPP_NAMESPACE::Optional allocator ) const + { + return VULKAN_HPP_RAII_NAMESPACE::CuFunctionNVX( *this, createInfo, allocator ); + } + VULKAN_HPP_INLINE void CommandBuffer::cuLaunchKernelNVX( const VULKAN_HPP_NAMESPACE::CuLaunchInfoNVX & launchInfo ) const VULKAN_HPP_NOEXCEPT { @@ -11967,6 +13016,18 @@ namespace VULKAN_HPP_NAMESPACE return info; } +# if defined( VK_USE_PLATFORM_GGP ) + //=== VK_GGP_stream_descriptor_surface === + + VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE VULKAN_HPP_RAII_NAMESPACE::SurfaceKHR + Instance::createStreamDescriptorSurfaceGGP( + VULKAN_HPP_NAMESPACE::StreamDescriptorSurfaceCreateInfoGGP const & createInfo, + VULKAN_HPP_NAMESPACE::Optional allocator ) const + { + return VULKAN_HPP_RAII_NAMESPACE::SurfaceKHR( *this, createInfo, allocator ); + } +# endif /*VK_USE_PLATFORM_GGP*/ + //=== VK_NV_external_memory_capabilities === VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE VULKAN_HPP_NAMESPACE::ExternalImageFormatPropertiesNV @@ -12311,6 +13372,17 @@ namespace VULKAN_HPP_NAMESPACE groupCountZ ); } +# if defined( VK_USE_PLATFORM_VI_NN ) + //=== VK_NN_vi_surface === + + VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE VULKAN_HPP_RAII_NAMESPACE::SurfaceKHR Instance::createViSurfaceNN( + VULKAN_HPP_NAMESPACE::ViSurfaceCreateInfoNN const & createInfo, + VULKAN_HPP_NAMESPACE::Optional allocator ) const + { + return VULKAN_HPP_RAII_NAMESPACE::SurfaceKHR( *this, createInfo, allocator ); + } +# endif /*VK_USE_PLATFORM_VI_NN*/ + //=== VK_KHR_maintenance1 === VULKAN_HPP_INLINE void @@ -12625,6 +13697,14 @@ namespace VULKAN_HPP_NAMESPACE //=== VK_KHR_descriptor_update_template === + VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE VULKAN_HPP_RAII_NAMESPACE::DescriptorUpdateTemplate + Device::createDescriptorUpdateTemplateKHR( + VULKAN_HPP_NAMESPACE::DescriptorUpdateTemplateCreateInfo const & createInfo, + VULKAN_HPP_NAMESPACE::Optional allocator ) const + { + return VULKAN_HPP_RAII_NAMESPACE::DescriptorUpdateTemplate( *this, createInfo, allocator ); + } + VULKAN_HPP_INLINE void Device::destroyDescriptorUpdateTemplateKHR( VULKAN_HPP_NAMESPACE::DescriptorUpdateTemplate descriptorUpdateTemplate, Optional allocator ) const VULKAN_HPP_NOEXCEPT @@ -12689,6 +13769,12 @@ namespace VULKAN_HPP_NAMESPACE throwResultException( result, VULKAN_HPP_NAMESPACE_STRING "::PhysicalDevice::acquireXlibDisplayEXT" ); } } + + VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE VULKAN_HPP_RAII_NAMESPACE::DisplayKHR + PhysicalDevice::getRandROutputDisplayEXT( Display & dpy, RROutput rrOutput ) const + { + return VULKAN_HPP_RAII_NAMESPACE::DisplayKHR( *this, dpy, rrOutput ); + } # endif /*VK_USE_PLATFORM_XLIB_XRANDR_EXT*/ //=== VK_EXT_display_surface_counter === @@ -12733,6 +13819,21 @@ namespace VULKAN_HPP_NAMESPACE } } + VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE VULKAN_HPP_RAII_NAMESPACE::Fence Device::registerEventEXT( + VULKAN_HPP_NAMESPACE::DeviceEventInfoEXT const & deviceEventInfo, + VULKAN_HPP_NAMESPACE::Optional allocator ) const + { + return VULKAN_HPP_RAII_NAMESPACE::Fence( *this, deviceEventInfo, allocator ); + } + + VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE VULKAN_HPP_RAII_NAMESPACE::Fence Device::registerDisplayEventEXT( + VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::DisplayKHR const & display, + VULKAN_HPP_NAMESPACE::DisplayEventInfoEXT const & displayEventInfo, + VULKAN_HPP_NAMESPACE::Optional allocator ) const + { + return VULKAN_HPP_RAII_NAMESPACE::Fence( *this, display, displayEventInfo, allocator ); + } + VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE uint64_t SwapchainKHR::getCounterEXT( VULKAN_HPP_NAMESPACE::SurfaceCounterFlagBitsEXT counter ) const { @@ -12858,6 +13959,13 @@ namespace VULKAN_HPP_NAMESPACE //=== VK_KHR_create_renderpass2 === + VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE VULKAN_HPP_RAII_NAMESPACE::RenderPass Device::createRenderPass2KHR( + VULKAN_HPP_NAMESPACE::RenderPassCreateInfo2 const & createInfo, + VULKAN_HPP_NAMESPACE::Optional allocator ) const + { + return VULKAN_HPP_RAII_NAMESPACE::RenderPass( *this, createInfo, allocator ); + } + VULKAN_HPP_INLINE void CommandBuffer::beginRenderPass2KHR( const VULKAN_HPP_NAMESPACE::RenderPassBeginInfo & renderPassBegin, const VULKAN_HPP_NAMESPACE::SubpassBeginInfo & subpassBeginInfo ) const VULKAN_HPP_NOEXCEPT @@ -13304,6 +14412,28 @@ namespace VULKAN_HPP_NAMESPACE return capabilities; } +# if defined( VK_USE_PLATFORM_IOS_MVK ) + //=== VK_MVK_ios_surface === + + VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE VULKAN_HPP_RAII_NAMESPACE::SurfaceKHR Instance::createIOSSurfaceMVK( + VULKAN_HPP_NAMESPACE::IOSSurfaceCreateInfoMVK const & createInfo, + VULKAN_HPP_NAMESPACE::Optional allocator ) const + { + return VULKAN_HPP_RAII_NAMESPACE::SurfaceKHR( *this, createInfo, allocator ); + } +# endif /*VK_USE_PLATFORM_IOS_MVK*/ + +# if defined( VK_USE_PLATFORM_MACOS_MVK ) + //=== VK_MVK_macos_surface === + + VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE VULKAN_HPP_RAII_NAMESPACE::SurfaceKHR Instance::createMacOSSurfaceMVK( + VULKAN_HPP_NAMESPACE::MacOSSurfaceCreateInfoMVK const & createInfo, + VULKAN_HPP_NAMESPACE::Optional allocator ) const + { + return VULKAN_HPP_RAII_NAMESPACE::SurfaceKHR( *this, createInfo, allocator ); + } +# endif /*VK_USE_PLATFORM_MACOS_MVK*/ + //=== VK_EXT_debug_utils === VULKAN_HPP_INLINE void @@ -13392,6 +14522,14 @@ namespace VULKAN_HPP_NAMESPACE reinterpret_cast( &labelInfo ) ); } + VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE VULKAN_HPP_RAII_NAMESPACE::DebugUtilsMessengerEXT + Instance::createDebugUtilsMessengerEXT( + VULKAN_HPP_NAMESPACE::DebugUtilsMessengerCreateInfoEXT const & createInfo, + VULKAN_HPP_NAMESPACE::Optional allocator ) const + { + return VULKAN_HPP_RAII_NAMESPACE::DebugUtilsMessengerEXT( *this, createInfo, allocator ); + } + VULKAN_HPP_INLINE void Instance::submitDebugUtilsMessageEXT( VULKAN_HPP_NAMESPACE::DebugUtilsMessageSeverityFlagBitsEXT messageSeverity, VULKAN_HPP_NAMESPACE::DebugUtilsMessageTypeFlagsEXT messageTypes, @@ -13598,6 +14736,14 @@ namespace VULKAN_HPP_NAMESPACE //=== VK_KHR_acceleration_structure === + VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE VULKAN_HPP_RAII_NAMESPACE::AccelerationStructureKHR + Device::createAccelerationStructureKHR( + VULKAN_HPP_NAMESPACE::AccelerationStructureCreateInfoKHR const & createInfo, + VULKAN_HPP_NAMESPACE::Optional allocator ) const + { + return VULKAN_HPP_RAII_NAMESPACE::AccelerationStructureKHR( *this, createInfo, allocator ); + } + VULKAN_HPP_INLINE void CommandBuffer::buildAccelerationStructuresKHR( ArrayProxy const & infos, ArrayProxy const & pBuildRangeInfos ) @@ -13923,6 +15069,14 @@ namespace VULKAN_HPP_NAMESPACE //=== VK_KHR_sampler_ycbcr_conversion === + VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE VULKAN_HPP_RAII_NAMESPACE::SamplerYcbcrConversion + Device::createSamplerYcbcrConversionKHR( + VULKAN_HPP_NAMESPACE::SamplerYcbcrConversionCreateInfo const & createInfo, + VULKAN_HPP_NAMESPACE::Optional allocator ) const + { + return VULKAN_HPP_RAII_NAMESPACE::SamplerYcbcrConversion( *this, createInfo, allocator ); + } + VULKAN_HPP_INLINE void Device::destroySamplerYcbcrConversionKHR( VULKAN_HPP_NAMESPACE::SamplerYcbcrConversion ycbcrConversion, Optional allocator ) const VULKAN_HPP_NOEXCEPT @@ -13997,6 +15151,14 @@ namespace VULKAN_HPP_NAMESPACE //=== VK_EXT_validation_cache === + VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE VULKAN_HPP_RAII_NAMESPACE::ValidationCacheEXT + Device::createValidationCacheEXT( + VULKAN_HPP_NAMESPACE::ValidationCacheCreateInfoEXT const & createInfo, + VULKAN_HPP_NAMESPACE::Optional allocator ) const + { + return VULKAN_HPP_RAII_NAMESPACE::ValidationCacheEXT( *this, createInfo, allocator ); + } + VULKAN_HPP_INLINE void ValidationCacheEXT::merge( ArrayProxy const & srcCaches ) const { @@ -14098,6 +15260,14 @@ namespace VULKAN_HPP_NAMESPACE //=== VK_NV_ray_tracing === + VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE VULKAN_HPP_RAII_NAMESPACE::AccelerationStructureNV + Device::createAccelerationStructureNV( + VULKAN_HPP_NAMESPACE::AccelerationStructureCreateInfoNV const & createInfo, + VULKAN_HPP_NAMESPACE::Optional allocator ) const + { + return VULKAN_HPP_RAII_NAMESPACE::AccelerationStructureNV( *this, createInfo, allocator ); + } + VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE VULKAN_HPP_NAMESPACE::MemoryRequirements2KHR Device::getAccelerationStructureMemoryRequirementsNV( const VULKAN_HPP_NAMESPACE::AccelerationStructureMemoryRequirementsInfoNV & info ) const VULKAN_HPP_NOEXCEPT @@ -14225,6 +15395,25 @@ namespace VULKAN_HPP_NAMESPACE depth ); } + VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE std::vector + Device::createRayTracingPipelinesNV( + VULKAN_HPP_NAMESPACE::Optional const & + pipelineCache, + VULKAN_HPP_NAMESPACE::ArrayProxy const & createInfos, + VULKAN_HPP_NAMESPACE::Optional allocator ) const + { + return VULKAN_HPP_RAII_NAMESPACE::Pipelines( *this, pipelineCache, createInfos, allocator ); + } + + VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE VULKAN_HPP_RAII_NAMESPACE::Pipeline Device::createRayTracingPipelineNV( + VULKAN_HPP_NAMESPACE::Optional const & + pipelineCache, + VULKAN_HPP_NAMESPACE::RayTracingPipelineCreateInfoNV const & createInfo, + VULKAN_HPP_NAMESPACE::Optional allocator ) const + { + return VULKAN_HPP_RAII_NAMESPACE::Pipeline( *this, pipelineCache, createInfo, allocator ); + } + template VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE std::vector Pipeline::getRayTracingShaderGroupHandlesNV( uint32_t firstGroup, uint32_t groupCount, size_t dataSize ) const @@ -14764,6 +15953,13 @@ namespace VULKAN_HPP_NAMESPACE } } + VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE VULKAN_HPP_RAII_NAMESPACE::PerformanceConfigurationINTEL + Device::acquirePerformanceConfigurationINTEL( + VULKAN_HPP_NAMESPACE::PerformanceConfigurationAcquireInfoINTEL const & acquireInfo ) const + { + return VULKAN_HPP_RAII_NAMESPACE::PerformanceConfigurationINTEL( *this, acquireInfo ); + } + VULKAN_HPP_INLINE void Queue::setPerformanceConfigurationINTEL( VULKAN_HPP_NAMESPACE::PerformanceConfigurationINTEL configuration ) const { @@ -14812,6 +16008,29 @@ namespace VULKAN_HPP_NAMESPACE static_cast( localDimmingEnable ) ); } +# if defined( VK_USE_PLATFORM_FUCHSIA ) + //=== VK_FUCHSIA_imagepipe_surface === + + VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE VULKAN_HPP_RAII_NAMESPACE::SurfaceKHR + Instance::createImagePipeSurfaceFUCHSIA( + VULKAN_HPP_NAMESPACE::ImagePipeSurfaceCreateInfoFUCHSIA const & createInfo, + VULKAN_HPP_NAMESPACE::Optional allocator ) const + { + return VULKAN_HPP_RAII_NAMESPACE::SurfaceKHR( *this, createInfo, allocator ); + } +# endif /*VK_USE_PLATFORM_FUCHSIA*/ + +# if defined( VK_USE_PLATFORM_METAL_EXT ) + //=== VK_EXT_metal_surface === + + VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE VULKAN_HPP_RAII_NAMESPACE::SurfaceKHR Instance::createMetalSurfaceEXT( + VULKAN_HPP_NAMESPACE::MetalSurfaceCreateInfoEXT const & createInfo, + VULKAN_HPP_NAMESPACE::Optional allocator ) const + { + return VULKAN_HPP_RAII_NAMESPACE::SurfaceKHR( *this, createInfo, allocator ); + } +# endif /*VK_USE_PLATFORM_METAL_EXT*/ + //=== VK_KHR_fragment_shading_rate === VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE std::vector @@ -15110,6 +16329,15 @@ namespace VULKAN_HPP_NAMESPACE } # endif /*VK_USE_PLATFORM_WIN32_KHR*/ + //=== VK_EXT_headless_surface === + + VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE VULKAN_HPP_RAII_NAMESPACE::SurfaceKHR Instance::createHeadlessSurfaceEXT( + VULKAN_HPP_NAMESPACE::HeadlessSurfaceCreateInfoEXT const & createInfo, + VULKAN_HPP_NAMESPACE::Optional allocator ) const + { + return VULKAN_HPP_RAII_NAMESPACE::SurfaceKHR( *this, createInfo, allocator ); + } + //=== VK_KHR_buffer_device_address === VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE VULKAN_HPP_NAMESPACE::DeviceAddress Device::getBufferAddressKHR( @@ -15342,6 +16570,13 @@ namespace VULKAN_HPP_NAMESPACE //=== VK_KHR_deferred_host_operations === + VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE VULKAN_HPP_RAII_NAMESPACE::DeferredOperationKHR + Device::createDeferredOperationKHR( + VULKAN_HPP_NAMESPACE::Optional allocator ) const + { + return VULKAN_HPP_RAII_NAMESPACE::DeferredOperationKHR( *this, allocator ); + } + VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE uint32_t DeferredOperationKHR::getMaxConcurrency() const VULKAN_HPP_NOEXCEPT { VULKAN_HPP_ASSERT( @@ -15584,6 +16819,14 @@ namespace VULKAN_HPP_NAMESPACE groupIndex ); } + VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE VULKAN_HPP_RAII_NAMESPACE::IndirectCommandsLayoutNV + Device::createIndirectCommandsLayoutNV( + VULKAN_HPP_NAMESPACE::IndirectCommandsLayoutCreateInfoNV const & createInfo, + VULKAN_HPP_NAMESPACE::Optional allocator ) const + { + return VULKAN_HPP_RAII_NAMESPACE::IndirectCommandsLayoutNV( *this, createInfo, allocator ); + } + //=== VK_EXT_acquire_drm_display === VULKAN_HPP_INLINE void PhysicalDevice::acquireDrmDisplayEXT( int32_t drmFd, @@ -15601,8 +16844,22 @@ namespace VULKAN_HPP_NAMESPACE } } + VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE VULKAN_HPP_RAII_NAMESPACE::DisplayKHR + PhysicalDevice::getDrmDisplayEXT( int32_t drmFd, uint32_t connectorId ) const + { + return VULKAN_HPP_RAII_NAMESPACE::DisplayKHR( *this, drmFd, connectorId ); + } + //=== VK_EXT_private_data === + VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE VULKAN_HPP_RAII_NAMESPACE::PrivateDataSlotEXT + Device::createPrivateDataSlotEXT( + VULKAN_HPP_NAMESPACE::PrivateDataSlotCreateInfoEXT const & createInfo, + VULKAN_HPP_NAMESPACE::Optional allocator ) const + { + return VULKAN_HPP_RAII_NAMESPACE::PrivateDataSlotEXT( *this, createInfo, allocator ); + } + VULKAN_HPP_INLINE void Device::setPrivateDataEXT( VULKAN_HPP_NAMESPACE::ObjectType objectType_, uint64_t objectHandle, VULKAN_HPP_NAMESPACE::PrivateDataSlotEXT privateDataSlot, @@ -15871,11 +17128,24 @@ namespace VULKAN_HPP_NAMESPACE throwResultException( result, VULKAN_HPP_NAMESPACE_STRING "::DisplayKHR::acquireWinrtNV" ); } } + + VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE VULKAN_HPP_RAII_NAMESPACE::DisplayKHR + PhysicalDevice::getWinrtDisplayNV( uint32_t deviceRelativeId ) const + { + return VULKAN_HPP_RAII_NAMESPACE::DisplayKHR( *this, deviceRelativeId ); + } # endif /*VK_USE_PLATFORM_WIN32_KHR*/ # if defined( VK_USE_PLATFORM_DIRECTFB_EXT ) //=== VK_EXT_directfb_surface === + VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE VULKAN_HPP_RAII_NAMESPACE::SurfaceKHR Instance::createDirectFBSurfaceEXT( + VULKAN_HPP_NAMESPACE::DirectFBSurfaceCreateInfoEXT const & createInfo, + VULKAN_HPP_NAMESPACE::Optional allocator ) const + { + return VULKAN_HPP_RAII_NAMESPACE::SurfaceKHR( *this, createInfo, allocator ); + } + VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE VULKAN_HPP_NAMESPACE::Bool32 PhysicalDevice::getDirectFBPresentationSupportEXT( uint32_t queueFamilyIndex, IDirectFB & dfb ) const VULKAN_HPP_NOEXCEPT @@ -15915,6 +17185,29 @@ namespace VULKAN_HPP_NAMESPACE depth ); } + VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE std::vector + Device::createRayTracingPipelinesKHR( + VULKAN_HPP_NAMESPACE::Optional< + const VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::DeferredOperationKHR> const & deferredOperation, + VULKAN_HPP_NAMESPACE::Optional const & + pipelineCache, + VULKAN_HPP_NAMESPACE::ArrayProxy const & createInfos, + VULKAN_HPP_NAMESPACE::Optional allocator ) const + { + return VULKAN_HPP_RAII_NAMESPACE::Pipelines( *this, deferredOperation, pipelineCache, createInfos, allocator ); + } + + VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE VULKAN_HPP_RAII_NAMESPACE::Pipeline Device::createRayTracingPipelineKHR( + VULKAN_HPP_NAMESPACE::Optional< + const VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::DeferredOperationKHR> const & deferredOperation, + VULKAN_HPP_NAMESPACE::Optional const & + pipelineCache, + VULKAN_HPP_NAMESPACE::RayTracingPipelineCreateInfoKHR const & createInfo, + VULKAN_HPP_NAMESPACE::Optional allocator ) const + { + return VULKAN_HPP_RAII_NAMESPACE::Pipeline( *this, deferredOperation, pipelineCache, createInfo, allocator ); + } + template VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE std::vector Pipeline::getRayTracingShaderGroupHandlesKHR( uint32_t firstGroup, uint32_t groupCount, size_t dataSize ) const @@ -16157,6 +17450,14 @@ namespace VULKAN_HPP_NAMESPACE # if defined( VK_USE_PLATFORM_FUCHSIA ) //=== VK_FUCHSIA_buffer_collection === + VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE VULKAN_HPP_RAII_NAMESPACE::BufferCollectionFUCHSIA + Device::createBufferCollectionFUCHSIA( + VULKAN_HPP_NAMESPACE::BufferCollectionCreateInfoFUCHSIA const & createInfo, + VULKAN_HPP_NAMESPACE::Optional allocator ) const + { + return VULKAN_HPP_RAII_NAMESPACE::BufferCollectionFUCHSIA( *this, createInfo, allocator ); + } + VULKAN_HPP_INLINE void BufferCollectionFUCHSIA::setImageConstraints( const VULKAN_HPP_NAMESPACE::ImageConstraintsInfoFUCHSIA & imageConstraintsInfo ) const { @@ -16342,6 +17643,13 @@ namespace VULKAN_HPP_NAMESPACE # if defined( VK_USE_PLATFORM_SCREEN_QNX ) //=== VK_QNX_screen_surface === + VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE VULKAN_HPP_RAII_NAMESPACE::SurfaceKHR Instance::createScreenSurfaceQNX( + VULKAN_HPP_NAMESPACE::ScreenSurfaceCreateInfoQNX const & createInfo, + VULKAN_HPP_NAMESPACE::Optional allocator ) const + { + return VULKAN_HPP_RAII_NAMESPACE::SurfaceKHR( *this, createInfo, allocator ); + } + VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE VULKAN_HPP_NAMESPACE::Bool32 PhysicalDevice::getScreenPresentationSupportQNX( uint32_t queueFamilyIndex, struct _screen_window & window ) const VULKAN_HPP_NOEXCEPT