From 0beeac873a5f2fb9d293361b064b436822542bec Mon Sep 17 00:00:00 2001 From: asuessenbach Date: Mon, 8 Nov 2021 17:31:36 +0100 Subject: [PATCH] Remove dumb parent-pointer in raii-objects. --- VulkanHppGenerator.cpp | 459 +++++--- VulkanHppGenerator.hpp | 20 +- vulkan/vulkan_raii.hpp | 2398 +++++++++++++++++----------------------- 3 files changed, 1311 insertions(+), 1566 deletions(-) diff --git a/VulkanHppGenerator.cpp b/VulkanHppGenerator.cpp index bbb3f23..4a8ba4c 100644 --- a/VulkanHppGenerator.cpp +++ b/VulkanHppGenerator.cpp @@ -2254,26 +2254,21 @@ std::string VulkanHppGenerator::generateCallArgumentsEnhanced( CommandData const encounteredArgument = true; break; case 2: - assert( isHandleType( commandData.params[0].type.type ) && commandData.params[0].type.isValue() ); - assert( commandData.params[0].arraySizes.empty() && commandData.params[0].len.empty() ); - assert( commandData.params[0].type.type == commandData.handle ); - if ( skipLeadingGrandParent( *m_handles.find( commandData.params[1].type.type ) ) ) { - auto [parentType, parentName] = getParentTypeAndName( *m_handles.find( commandData.params[1].type.type ) ); - arguments = "static_cast<" + commandData.handle + ">( **m_" + parentName + "->get" + - stripPrefix( commandData.handle, "Vk" ) + "() )"; - } - else - { - arguments = "static_cast<" + commandData.handle + ">( **m_" + + assert( isHandleType( commandData.params[0].type.type ) && commandData.params[0].type.isValue() ); + assert( commandData.params[0].arraySizes.empty() && commandData.params[0].len.empty() ); + assert( commandData.params[0].type.type == commandData.handle ); + auto handleIt = m_handles.find( commandData.params[1].type.type ); + assert( handleIt != m_handles.end() ); + arguments = "static_cast<" + commandData.handle + ">( m_" + startLowerCase( stripPrefix( commandData.handle, "Vk" ) ) + " )"; - } - assert( isHandleType( commandData.params[1].type.type ) && commandData.params[1].type.isValue() ); - assert( commandData.params[1].arraySizes.empty() && commandData.params[1].len.empty() ); - arguments += ", static_cast<" + commandData.params[1].type.type + ">( m_" + - startLowerCase( stripPrefix( commandData.params[1].type.type, "Vk" ) ) + " )"; - encounteredArgument = true; + assert( commandData.params[1].type.isValue() && commandData.params[1].arraySizes.empty() && + commandData.params[1].len.empty() ); + arguments += ", static_cast<" + commandData.params[1].type.type + ">( m_" + + generateRAIIHandleConstructorParamName( handleIt->first, handleIt->second.destructorIt ) + " )"; + encounteredArgument = true; + } break; } } @@ -7169,16 +7164,15 @@ std::string VulkanHppGenerator::generateRAIIHandle( std::pairsecond.params.empty() ); + std::string parentType = stripPrefix( handle.second.destructorIt->second.params.front().type.type, "Vk" ); + getParent = " VULKAN_HPP_NAMESPACE::" + parentType + " get" + parentType + "() const\n"; + getParent += " {\n"; + getParent += " return m_" + handle.second.destructorIt->second.params.front().name + ";\n"; + getParent += " }\n"; + } + const std::string handleTemplate = R"( ${enter} class ${handleType} { @@ -7247,11 +7253,7 @@ ${moveAssignmentInstructions} } ${getConstructorSuccessCode} - VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::${parentType} const * get${parentType}() const VULKAN_HPP_NOEXCEPT - { - return m_${parentName}; - } - +${getParent} ${dispatcherType} const * getDispatcher() const { VULKAN_HPP_ASSERT( m_dispatcher->getVkHeaderVersion() == VK_HEADER_VERSION ); @@ -7272,6 +7274,7 @@ ${leave})"; { "enter", enter }, { "getConstructorSuccessCode", getConstructorSuccessCode }, { "getDispatcherReturn", ( handleType == "Device" ) || ( handleType == "Instance" ) ? "&*" : "" }, + { "getParent", getParent }, { "handleName", handleName }, { "handleType", handleType }, { "leave", leave }, @@ -7280,8 +7283,6 @@ ${leave})"; { "moveAssignmentInstructions", moveAssignmentInstructions }, { "moveConstructorInitializerList", moveConstructorInitializerList }, { "objTypeEnum", objTypeEnum }, - { "parentType", parentType }, - { "parentName", parentName }, { "singularConstructors", singularConstructors } } ); if ( !arrayConstructors.empty() ) @@ -9628,7 +9629,8 @@ std::string VulkanHppGenerator::generateRAIIHandleConstructorArguments( std::string arguments = "VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::" + parentType + " const & " + parentName; if ( takesOwnership ) { - arguments += ", " + handle.first + " " + startLowerCase( stripPrefix( handle.first, "Vk" ) ); + arguments += + ", " + handle.first + " " + generateRAIIHandleConstructorParamName( handle.first, handle.second.destructorIt ); } if ( constructorIt != m_commands.end() ) @@ -9688,7 +9690,7 @@ std::string VulkanHppGenerator::generateRAIIHandleConstructorCallArguments( assert( ( 1 < constructorIt->second.params.size() ) && ( m_handles.find( constructorIt->second.params[0].type.type ) != m_handles.end() ) && ( m_handles.find( constructorIt->second.params[1].type.type ) != m_handles.end() ) ); - arguments += "static_cast<" + constructorIt->second.params[0].type.type + ">( **" + + arguments += "static_cast<" + constructorIt->second.params[0].type.type + ">( " + constructorIt->second.params[1].name + ".get" + stripPrefix( constructorIt->second.params[0].type.type, "Vk" ) + "() )"; encounteredArgument = true; @@ -9708,8 +9710,8 @@ std::string VulkanHppGenerator::generateRAIIHandleConstructorCallArguments( { assert( !param.optional ); assert( singularParams.empty() || ( param.len == constructorIt->second.params[*singularParams.begin()].name ) ); - arguments += - "reinterpret_cast<" + handle.first + "*>( &m_" + startLowerCase( stripPrefix( handle.first, "Vk" ) ) + " )"; + std::string paramName = generateRAIIHandleConstructorParamName( handle.first, handle.second.destructorIt ); + arguments += "reinterpret_cast<" + handle.first + "*>( &m_" + paramName + " )"; } else if ( nonConstPointerAsNullptr ) { @@ -9725,8 +9727,7 @@ std::string VulkanHppGenerator::generateRAIIHandleConstructorCallArguments( assert( param.optional ); if ( allocatorIsMemberVariable ) { - // VkAllocationCallbacks is stored as a member of the handle class ! - arguments += "m_allocator"; + arguments += "reinterpret_cast( m_allocator )"; } else { @@ -9830,81 +9831,140 @@ std::string VulkanHppGenerator::generateRAIIHandleConstructorInitializationList( bool takesOwnership ) const { auto [parentType, parentName] = getParentTypeAndName( handle ); - std::string handleName = startLowerCase( stripPrefix( handle.first, "Vk" ) ); - - std::string initializationList = "m_" + parentName + "( &" + parentName + " )"; - if ( takesOwnership ) - { - initializationList += ", m_" + handleName + "( " + handleName + " )"; - } + std::string handleName = generateRAIIHandleConstructorParamName( handle.first, destructorIt ); + std::string initializationList; if ( destructorIt != m_commands.end() ) { for ( auto destructorParam : destructorIt->second.params ) { - if ( ( destructorParam.type.type != ( "Vk" + parentType ) ) && ( destructorParam.type.type != handle.first ) ) + if ( destructorParam.type.type == "Vk" + parentType ) { - if ( isHandleType( destructorParam.type.type ) ) + initializationList += "m_" + parentName + "( *" + parentName + " ), "; + } + else if ( destructorParam.type.type == handle.first ) + { + if ( takesOwnership ) { - assert( destructorParam.type.isValue() && destructorParam.arraySizes.empty() && destructorParam.len.empty() && - !destructorParam.optional ); - initializationList += ", m_" + startLowerCase( stripPrefix( destructorParam.type.type, "Vk" ) ) + "( "; - auto constructorParamIt = std::find_if( constructorIt->second.params.begin(), - constructorIt->second.params.end(), - [&destructorParam]( ParamData const & pd ) - { return pd.type.type == destructorParam.type.type; } ); - if ( constructorParamIt != constructorIt->second.params.end() ) - { - assert( constructorParamIt->type.isValue() && constructorParamIt->arraySizes.empty() && - constructorParamIt->len.empty() && !constructorParamIt->optional ); - initializationList += constructorParamIt->name; - } - else - { -#if !defined( NDEBUG ) - bool found = false; -#endif - for ( auto constructorParam : constructorIt->second.params ) - { - auto structureIt = m_structures.find( constructorParam.type.type ); - if ( structureIt != m_structures.end() ) - { - auto structureMemberIt = std::find_if( structureIt->second.members.begin(), - structureIt->second.members.end(), - [&destructorParam]( MemberData const & md ) - { return md.type.type == destructorParam.type.type; } ); - if ( structureMemberIt != structureIt->second.members.end() ) - { - assert( constructorParam.type.isConstPointer() && constructorParam.arraySizes.empty() && - constructorParam.len.empty() && !constructorParam.optional ); - initializationList += - startLowerCase( stripPrefix( constructorParam.name, "p" ) ) + "." + structureMemberIt->name; -#if !defined( NDEBUG ) - found = true; -#endif - break; - } - } - } - assert( found ); - } - initializationList += " )"; + initializationList += "m_" + handleName + "( " + handleName + " ), "; } - else if ( destructorParam.type.type == "VkAllocationCallbacks" ) + } + else if ( destructorParam.type.type == "VkAllocationCallbacks" ) + { + assert( destructorParam.type.isConstPointer() && destructorParam.arraySizes.empty() && + destructorParam.len.empty() && destructorParam.optional ); + initializationList += + "m_allocator( static_cast( allocator ) ), "; + } + else if ( isHandleType( destructorParam.type.type ) ) + { + assert( destructorParam.type.isValue() && destructorParam.arraySizes.empty() && destructorParam.len.empty() && + !destructorParam.optional ); + initializationList += "m_" + destructorParam.name + "( "; + auto constructorParamIt = std::find_if( constructorIt->second.params.begin(), + constructorIt->second.params.end(), + [&destructorParam]( ParamData const & pd ) + { return pd.type.type == destructorParam.type.type; } ); + if ( constructorParamIt != constructorIt->second.params.end() ) { - assert( destructorParam.type.isConstPointer() && destructorParam.arraySizes.empty() && - destructorParam.len.empty() && destructorParam.optional ); - initializationList += - ", m_allocator( reinterpret_cast( static_cast( allocator ) ) )"; + assert( constructorParamIt->type.isValue() && constructorParamIt->arraySizes.empty() && + constructorParamIt->len.empty() && !constructorParamIt->optional ); + if ( constructorParamIt->type.type == "Vk" + parentType ) + { + initializationList += "*"; + } + initializationList += constructorParamIt->name; } else { - // we can ignore all other parameters here ! +#if !defined( NDEBUG ) + bool found = false; +#endif + for ( auto constructorParam : constructorIt->second.params ) + { + auto structureIt = m_structures.find( constructorParam.type.type ); + if ( structureIt != m_structures.end() ) + { + auto structureMemberIt = std::find_if( structureIt->second.members.begin(), + structureIt->second.members.end(), + [&destructorParam]( MemberData const & md ) + { return md.type.type == destructorParam.type.type; } ); + if ( structureMemberIt != structureIt->second.members.end() ) + { + assert( constructorParam.type.isConstPointer() && constructorParam.arraySizes.empty() && + constructorParam.len.empty() && !constructorParam.optional ); + initializationList += + startLowerCase( stripPrefix( constructorParam.name, "p" ) ) + "." + structureMemberIt->name; +#if !defined( NDEBUG ) + found = true; +#endif + break; + } + } + } + assert( found ); } + initializationList += " ), "; + } + else + { + // we can ignore all other parameters here ! } } } - return initializationList; + else + { + if ( !handle.second.secondLevelCommands.empty() ) + { + assert( !handle.second.constructorIts.empty() ); + auto constructorCommandIt = m_commands.find( handle.second.constructorIts.front()->first ); + assert( ( constructorCommandIt != m_commands.end() ) && ( 1 < constructorCommandIt->second.params.size() ) ); + assert( std::next( constructorCommandIt->second.params.begin() )->type.type == "Vk" + parentType ); + + auto commandIt = m_commands.find( *handle.second.secondLevelCommands.begin() ); + assert( ( commandIt != m_commands.end() ) && ( 1 < commandIt->second.params.size() ) ); + assert( commandIt->second.params.front().type.type == constructorCommandIt->second.params.front().type.type ); + assert( std::next( commandIt->second.params.begin() )->type.type == handle.first ); + + std::string grandParentType = stripPrefix( commandIt->second.params.front().type.type, "Vk" ); + initializationList += + "m_" + startLowerCase( grandParentType ) + "( " + parentName + ".get" + grandParentType + "() ), "; + } + if ( takesOwnership ) + { + initializationList += "m_" + handleName + "( " + handleName + " ), "; + } + } + return initializationList.empty() ? initializationList + : initializationList.substr( 0, initializationList.size() - 2 ); +} + +std::string VulkanHppGenerator::generateRAIIHandleConstructorParamName( + std::string const & type, std::map::const_iterator destructorIt ) const +{ + if ( destructorIt != m_commands.end() ) + { + auto destructorParamIt = + std::find_if( destructorIt->second.params.begin(), + destructorIt->second.params.end(), + [&type]( ParamData const & destructorParam ) { return destructorParam.type.type == type; } ); + if ( destructorParamIt != destructorIt->second.params.end() ) + { + assert( std::find_if( std::next( destructorParamIt ), + destructorIt->second.params.end(), + [&type]( ParamData const & destructorParam ) + { return destructorParam.type.type == type; } ) == destructorIt->second.params.end() ); + if ( !destructorParamIt->type.isValue() ) + { + return startLowerCase( stripPrefix( stripPluralS( destructorParamIt->name ), "p" ) ); + } + else + { + return destructorParamIt->name; + } + } + } + return startLowerCase( stripPrefix( type, "Vk" ) ); } std::string VulkanHppGenerator::generateRAIIHandleConstructorResult( @@ -9919,7 +9979,7 @@ std::string VulkanHppGenerator::generateRAIIHandleConstructorResult( std::string dispatcherInitializer, dispatcherInit; if ( ( handle.first != "VkInstance" ) && ( handle.first != "VkDevice" ) ) { - dispatcherInitializer = ", m_dispatcher( " + getDispatcher + " )"; + dispatcherInitializer = "m_dispatcher( " + getDispatcher + " )"; } else { @@ -9937,6 +9997,10 @@ std::string VulkanHppGenerator::generateRAIIHandleConstructorResult( std::string initializationList = generateRAIIHandleConstructorInitializationList( handle, constructorIt, handle.second.destructorIt, false ); + if ( !initializationList.empty() && !dispatcherInitializer.empty() ) + { + initializationList += ", "; + } const std::string constructorTemplate = R"( @@ -9973,12 +10037,6 @@ std::string VulkanHppGenerator::generateRAIIHandleConstructorTakeOwnership( auto [parentType, parentName] = getParentTypeAndName( handle ); - std::string dispatcherInitializer; - if ( ( handle.first != "VkInstance" ) && ( handle.first != "VkDevice" ) ) - { - dispatcherInitializer = ", m_dispatcher( " + parentName + ".getDispatcher() )"; - } - std::string constructorArguments = generateRAIIHandleConstructorArguments( handle, handle.second.destructorIt, false, true ); std::string initializationList = generateRAIIHandleConstructorInitializationList( @@ -9997,6 +10055,16 @@ std::string VulkanHppGenerator::generateRAIIHandleConstructorTakeOwnership( initializationList += ", m_constructorSuccessCode( successCode )"; } + std::string dispatcherInitializer; + if ( ( handle.first != "VkInstance" ) && ( handle.first != "VkDevice" ) ) + { + dispatcherInitializer = "m_dispatcher( " + parentName + ".getDispatcher() )"; + } + if ( !initializationList.empty() && !dispatcherInitializer.empty() ) + { + initializationList += ", "; + } + std::string dispatcherInit; if ( ( handle.first == "VkDevice" ) || ( handle.first == "VkInstance" ) ) { @@ -10160,12 +10228,15 @@ std::string VulkanHppGenerator::generateRAIIHandleConstructorVoid( std::string constructorArguments = generateRAIIHandleConstructorArguments( handle, constructorIt, false, false ); std::string initializationList = generateRAIIHandleConstructorInitializationList( handle, constructorIt, handle.second.destructorIt, false ); - assert( !initializationList.empty() ); + if ( !initializationList.empty() ) + { + initializationList += ", "; + } const std::string constructorTemplate = R"( ${enter} ${handleType}( ${constructorArguments} ) - : ${initializationList}, m_dispatcher( ${firstArgument}.getDispatcher() ) + : ${initializationList}m_dispatcher( ${firstArgument}.getDispatcher() ) { getDispatcher()->${constructorCall}( ${callArguments} ); } @@ -10190,7 +10261,8 @@ std::string VulkanHppGenerator::generateRAIIHandleContext( std::pair( "vkGetInstanceProcAddr" ) ) ) + : m_dispatcher( new VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::ContextDispatcher( + m_dynamicLoader.getProcAddress( "vkGetInstanceProcAddr" ) ) ) {} ~Context() = default; @@ -10232,8 +10304,7 @@ ${memberFunctionDeclarations} } std::pair - VulkanHppGenerator::generateRAIIHandleDestructor( std::string const & parentType, - std::string const & handleType, + VulkanHppGenerator::generateRAIIHandleDestructor( std::string const & handleType, std::map::const_iterator destructorIt, std::string const & enter ) const { @@ -10245,8 +10316,7 @@ std::pair destructorLeave.clear(); } std::string destructorCall = - destructorIt->first + "( " + - generateRAIIHandleDestructorCallArguments( parentType, handleType, destructorIt->second.params ) + " )"; + destructorIt->first + "( " + generateRAIIHandleDestructorCallArguments( handleType, destructorIt ) + " )"; const std::string destructorTemplate = R"( ${enter}~${handleType}() @@ -10258,55 +10328,61 @@ ${enter}~${handleType}() } ${leave})"; - std::string destructor = replaceWithMap( destructorTemplate, - { { "destructorCall", destructorCall }, - { "enter", destructorEnter }, - { "handleName", startLowerCase( stripPrefix( handleType, "Vk" ) ) }, - { "handleType", stripPrefix( handleType, "Vk" ) }, - { "leave", destructorLeave } } ); + std::string destructor = + replaceWithMap( destructorTemplate, + { { "destructorCall", destructorCall }, + { "enter", destructorEnter }, + { "handleName", generateRAIIHandleConstructorParamName( handleType, destructorIt ) }, + { "handleType", stripPrefix( handleType, "Vk" ) }, + { "leave", destructorLeave } } ); return std::make_pair( destructor, destructorCall ); } -std::string VulkanHppGenerator::generateRAIIHandleDestructorCallArguments( std::string const & parentType, - std::string const & handleType, - std::vector const & params ) const +std::string VulkanHppGenerator::generateRAIIHandleDestructorCallArguments( + std::string const & handleType, std::map::const_iterator destructorIt ) const { std::string arguments; bool encounteredArgument = false; - for ( auto param : params ) + for ( auto param : destructorIt->second.params ) { if ( encounteredArgument ) { arguments += ", "; } - if ( param.type.type == "VkAllocationCallbacks" ) + if ( param.type.type == handleType ) { - // VkAllocationCallbacks is stored as a member of the handle class - arguments += "m_allocator"; + std::string handleName = param.name; + if ( param.type.isValue() ) + { + arguments += "static_cast<" + handleType + ">( m_" + handleName + " )"; + } + else + { + arguments += "reinterpret_cast<" + handleType + " const *>( &m_" + + stripPluralS( startLowerCase( stripPrefix( handleName, "p" ) ) ) + " )"; + } + } + else if ( param.type.type == "VkAllocationCallbacks" ) + { + // vk::AllocationCallbacks is stored as a member of the handle class + arguments += "reinterpret_cast( m_allocator )"; } else if ( isHandleType( param.type.type ) ) { assert( param.arraySizes.empty() ); - std::string argument = "m_" + startLowerCase( stripPrefix( param.type.type, "Vk" ) ); + std::string argument = "m_" + param.name; if ( param.type.isValue() ) { - if ( param.type.type == parentType ) - { - argument = "static_cast<" + param.type.type + ">( **" + argument + " )"; - } - else if ( param.type.type == handleType ) - { - argument = "static_cast<" + param.type.type + ">( " + argument + " )"; - } - arguments += argument; + arguments += "static_cast<" + param.type.type + ">( " + argument + " )"; } else { assert( param.type.isConstPointer() ); - assert( !param.len.empty() && - ( std::find_if( params.begin(), - params.end(), - [¶m]( ParamData const & pd ) { return pd.name == param.len; } ) != params.end() ) ); + assert( !param.len.empty() && ( std::find_if( destructorIt->second.params.begin(), + destructorIt->second.params.end(), + [¶m]( ParamData const & pd ) { + return pd.name == param.len; + } ) != destructorIt->second.params.end() ) ); arguments += "reinterpret_cast<" + param.type.type + " const *>( &" + argument + " )"; } } @@ -10314,9 +10390,10 @@ std::string VulkanHppGenerator::generateRAIIHandleDestructorCallArguments( std:: { assert( ( param.type.type == "uint32_t" ) && param.type.isValue() && param.arraySizes.empty() && param.len.empty() && !param.optional ); - assert( std::find_if( params.begin(), - params.end(), - [¶m]( ParamData const & pd ) { return pd.len == param.name; } ) != params.end() ); + assert( std::find_if( destructorIt->second.params.begin(), + destructorIt->second.params.end(), + [¶m]( ParamData const & pd ) + { return pd.len == param.name; } ) != destructorIt->second.params.end() ); arguments += "1"; } encounteredArgument = true; @@ -10342,25 +10419,10 @@ std::tuple auto [parentType, parentName] = getParentTypeAndName( handle ); - std::string moveConstructorInitializerList = "m_" + parentName + - "( VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange( rhs.m_" + - parentName + ", nullptr ) ), "; - std::string moveAssignmentInstructions = " m_" + parentName + - " = VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange( rhs.m_" + - parentName + ", nullptr );\n"; - std::string memberVariables = - " VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::" + parentType + " const * m_" + parentName + " = nullptr;"; - std::string handleType = stripPrefix( handle.first, "Vk" ); - std::string handleName = startLowerCase( handleType ); - - moveConstructorInitializerList += - "m_" + handleName + "( VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange( rhs.m_" + handleName + ", {} ) )"; - moveAssignmentInstructions += " m_" + handleName + - " = VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange( rhs.m_" + handleName + - ", {} );"; - memberVariables += " VULKAN_HPP_NAMESPACE::" + handleType + " m_" + handleName + ";"; + std::string handleName = generateRAIIHandleConstructorParamName( handle.first, handle.second.destructorIt ); + std::string moveConstructorInitializerList, moveAssignmentInstructions, memberVariables; if ( handle.second.destructorIt != m_commands.end() ) { moveAssignmentInstructions = " if ( m_" + handleName + @@ -10369,42 +10431,79 @@ std::tuple " getDispatcher()->" + destructorCall + ";\n" - " }\n" - " " + - moveAssignmentInstructions; + " }"; for ( auto const & destructorParam : handle.second.destructorIt->second.params ) { - if ( ( destructorParam.type.type != "Vk" + parentType ) && ( destructorParam.type.type != handle.first ) && - ( std::find_if( handle.second.destructorIt->second.params.begin(), - handle.second.destructorIt->second.params.end(), - [&destructorParam]( ParamData const & pd ) { return pd.len == destructorParam.name; } ) == - handle.second.destructorIt->second.params.end() ) ) + if ( destructorParam.type.type == "Vk" + parentType ) + { + moveConstructorInitializerList = "m_" + parentName + + "( VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange( rhs.m_" + + parentName + ", {} ) ), "; + moveAssignmentInstructions = "\n m_" + parentName + + " = VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange( rhs.m_" + + parentName + ", {} );"; + memberVariables = "\n VULKAN_HPP_NAMESPACE::" + parentType + " m_" + parentName + " = {};"; + } + else if ( destructorParam.type.type == handle.first ) + { + moveConstructorInitializerList += "m_" + handleName + + "( VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange( rhs.m_" + + handleName + ", {} ) ), "; + moveAssignmentInstructions += "\n m_" + handleName + + " = VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange( rhs.m_" + + handleName + ", {} );"; + memberVariables += "\n VULKAN_HPP_NAMESPACE::" + handleType + " m_" + handleName + " = {};"; + } + else if ( std::find_if( handle.second.destructorIt->second.params.begin(), + handle.second.destructorIt->second.params.end(), + [&destructorParam]( ParamData const & pd ) { return pd.len == destructorParam.name; } ) == + handle.second.destructorIt->second.params.end() ) { std::string name = destructorParam.name; if ( !destructorParam.type.isValue() ) { name = startLowerCase( stripPrefix( name, "p" ) ); } - memberVariables += "\n " + destructorParam.type.prefix + " " + destructorParam.type.type + " " + - destructorParam.type.postfix + " m_" + name + - ( destructorParam.type.postfix.empty() ? "" : " = nullptr" ) + ";"; - moveConstructorInitializerList += ", m_" + name + "( rhs.m_" + name + " )"; - moveAssignmentInstructions += "\n m_" + name + " = rhs.m_" + name + ";"; + memberVariables += "\n " + destructorParam.type.compose( "VULKAN_HPP_NAMESPACE" ) + " m_" + name + " = " + + ( destructorParam.type.postfix.empty() ? "{}" : "nullptr" ) + ";"; + moveConstructorInitializerList += + "m_" + name + "( VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange( rhs.m_" + name + ", {} ) ), "; + moveAssignmentInstructions += "\n m_" + name + + " = VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange( rhs.m_" + name + + ", {} );"; } } } -#if !defined( NDEBUG ) - else if ( !handle.second.secondLevelCommands.empty() ) + else { - assert( !handle.second.constructorIts.empty() ); - assert( !handle.second.constructorIts.front()->second.params.empty() ); - auto const & frontType = handle.second.constructorIts.front()->second.params.front().type.type; - assert( isHandleType( frontType ) ); - auto handleIt = m_handles.find( "Vk" + parentType ); - assert( handleIt != m_handles.end() ); - assert( handleIt->second.parent == frontType ); + if ( !handle.second.secondLevelCommands.empty() ) + { + assert( !handle.second.constructorIts.empty() ); + assert( !handle.second.constructorIts.front()->second.params.empty() ); + auto const & frontType = handle.second.constructorIts.front()->second.params.front().type.type; + assert( isHandleType( frontType ) ); + auto handleIt = m_handles.find( "Vk" + parentType ); + assert( handleIt != m_handles.end() ); + assert( handleIt->second.parent == frontType ); + std::string frontName = handle.second.constructorIts.front()->second.params.front().name; + + moveConstructorInitializerList = "m_" + frontName + + "( VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange( rhs.m_" + + frontName + ", {} ) ), "; + moveAssignmentInstructions = "\n m_" + frontName + + " = VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange( rhs.m_" + frontName + + ", {} );"; + memberVariables = "\n VULKAN_HPP_NAMESPACE::" + stripPrefix( frontType, "Vk" ) + " m_" + frontName + " = {};"; + } + moveConstructorInitializerList += "m_" + handleName + + "( VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange( rhs.m_" + + handleName + ", {} ) ), "; + moveAssignmentInstructions += "\n m_" + handleName + + " = VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange( rhs.m_" + handleName + + ", {} );"; + memberVariables += "\n VULKAN_HPP_NAMESPACE::" + handleType + " m_" + handleName + " = {};"; } -#endif + if ( multiSuccessCodeContructor ) { memberVariables += "\n VULKAN_HPP_NAMESPACE::Result m_constructorSuccessCode;"; @@ -10433,13 +10532,13 @@ std::tuple if ( ( handle.first == "VkInstance" ) || ( handle.first == "VkDevice" ) ) { - moveConstructorInitializerList += ", m_dispatcher( rhs.m_dispatcher.release() )"; + moveConstructorInitializerList += "m_dispatcher( rhs.m_dispatcher.release() )"; moveAssignmentInstructions += "\n m_dispatcher.reset( rhs.m_dispatcher.release() );"; } else { moveConstructorInitializerList += - ", m_dispatcher( VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange( rhs.m_dispatcher, nullptr ) )"; + "m_dispatcher( VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange( rhs.m_dispatcher, nullptr ) )"; moveAssignmentInstructions += "\n m_dispatcher = VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange( rhs.m_dispatcher, nullptr );"; } diff --git a/VulkanHppGenerator.hpp b/VulkanHppGenerator.hpp index e4e286a..e67de99 100644 --- a/VulkanHppGenerator.hpp +++ b/VulkanHppGenerator.hpp @@ -1104,10 +1104,13 @@ private: std::string const & enter, std::string const & leave ) const; std::string - generateRAIIHandleConstructorInitializationList( std::pair const & handle, - std::map::const_iterator constructorIt, - std::map::const_iterator destructorIt, - bool takesOwnership ) const; + generateRAIIHandleConstructorInitializationList( std::pair const & handle, + std::map::const_iterator constructorIt, + std::map::const_iterator destructorIt, + bool takesOwnership ) const; + std::string + generateRAIIHandleConstructorParamName( std::string const & type, + std::map::const_iterator destructorIt ) const; std::string generateRAIIHandleConstructorResult( std::pair const & handle, std::map::const_iterator constructorIt, std::string const & enter, @@ -1131,13 +1134,12 @@ private: std::string generateRAIIHandleContext( std::pair const & handle, std::set const & specialFunctions ) const; std::pair - generateRAIIHandleDestructor( std::string const & parentType, - std::string const & handleType, + generateRAIIHandleDestructor( std::string const & handleType, std::map::const_iterator destructorIt, std::string const & enter ) const; - std::string generateRAIIHandleDestructorCallArguments( std::string const & parentType, - std::string const & handleType, - std::vector const & params ) const; + std::string + generateRAIIHandleDestructorCallArguments( std::string const & handleType, + std::map::const_iterator destructorIt ) const; std::tuple generateRAIIHandleDetails( std::pair const & handle, std::string const & destructorCall ) const; diff --git a/vulkan/vulkan_raii.hpp b/vulkan/vulkan_raii.hpp index 413a2f9..4c925f8 100644 --- a/vulkan/vulkan_raii.hpp +++ b/vulkan/vulkan_raii.hpp @@ -2372,13 +2372,11 @@ namespace VULKAN_HPP_NAMESPACE Instance( VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::Context const & context, VULKAN_HPP_NAMESPACE::InstanceCreateInfo const & createInfo, VULKAN_HPP_NAMESPACE::Optional allocator = nullptr ) - : m_context( &context ) - , m_allocator( reinterpret_cast( - static_cast( allocator ) ) ) + : m_allocator( static_cast( allocator ) ) { VULKAN_HPP_NAMESPACE::Result result = static_cast( context.getDispatcher()->vkCreateInstance( reinterpret_cast( &createInfo ), - m_allocator, + reinterpret_cast( m_allocator ), reinterpret_cast( &m_instance ) ) ); if ( result != VULKAN_HPP_NAMESPACE::Result::eSuccess ) { @@ -2391,10 +2389,8 @@ namespace VULKAN_HPP_NAMESPACE Instance( VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::Context const & context, VkInstance instance, VULKAN_HPP_NAMESPACE::Optional allocator = nullptr ) - : m_context( &context ) - , m_instance( instance ) - , m_allocator( reinterpret_cast( - static_cast( allocator ) ) ) + : m_instance( instance ) + , m_allocator( static_cast( allocator ) ) { m_dispatcher.reset( new VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::InstanceDispatcher( context.getDispatcher()->vkGetInstanceProcAddr, static_cast( m_instance ) ) ); @@ -2406,16 +2402,16 @@ namespace VULKAN_HPP_NAMESPACE { if ( m_instance ) { - getDispatcher()->vkDestroyInstance( static_cast( m_instance ), m_allocator ); + getDispatcher()->vkDestroyInstance( static_cast( m_instance ), + reinterpret_cast( m_allocator ) ); } } Instance() = delete; Instance( Instance const & ) = delete; Instance( Instance && rhs ) VULKAN_HPP_NOEXCEPT - : m_context( VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange( rhs.m_context, nullptr ) ) - , m_instance( VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange( rhs.m_instance, {} ) ) - , m_allocator( rhs.m_allocator ) + : m_instance( VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange( rhs.m_instance, {} ) ) + , m_allocator( VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange( rhs.m_allocator, {} ) ) , m_dispatcher( rhs.m_dispatcher.release() ) {} Instance & operator=( Instance const & ) = delete; @@ -2425,11 +2421,11 @@ namespace VULKAN_HPP_NAMESPACE { if ( m_instance ) { - getDispatcher()->vkDestroyInstance( static_cast( m_instance ), m_allocator ); + getDispatcher()->vkDestroyInstance( static_cast( m_instance ), + reinterpret_cast( m_allocator ) ); } - m_context = VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange( rhs.m_context, nullptr ); m_instance = VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange( rhs.m_instance, {} ); - m_allocator = rhs.m_allocator; + m_allocator = VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange( rhs.m_allocator, {} ); m_dispatcher.reset( rhs.m_dispatcher.release() ); } return *this; @@ -2440,11 +2436,6 @@ namespace VULKAN_HPP_NAMESPACE return m_instance; } - VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::Context const * getContext() const VULKAN_HPP_NOEXCEPT - { - return m_context; - } - VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::InstanceDispatcher const * getDispatcher() const { VULKAN_HPP_ASSERT( m_dispatcher->getVkHeaderVersion() == VK_HEADER_VERSION ); @@ -2609,9 +2600,8 @@ namespace VULKAN_HPP_NAMESPACE # endif /*VK_USE_PLATFORM_SCREEN_QNX*/ private: - VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::Context const * m_context = nullptr; - VULKAN_HPP_NAMESPACE::Instance m_instance; - const VkAllocationCallbacks * m_allocator = nullptr; + VULKAN_HPP_NAMESPACE::Instance m_instance = {}; + const VULKAN_HPP_NAMESPACE::AllocationCallbacks * m_allocator = nullptr; std::unique_ptr m_dispatcher; }; @@ -2628,7 +2618,7 @@ namespace VULKAN_HPP_NAMESPACE public: PhysicalDevice( VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::Instance const & instance, VkPhysicalDevice physicalDevice ) - : m_instance( &instance ), m_physicalDevice( physicalDevice ), m_dispatcher( instance.getDispatcher() ) + : m_physicalDevice( physicalDevice ), m_dispatcher( instance.getDispatcher() ) {} PhysicalDevice( std::nullptr_t ) {} @@ -2636,8 +2626,7 @@ namespace VULKAN_HPP_NAMESPACE PhysicalDevice() = delete; PhysicalDevice( PhysicalDevice const & ) = delete; PhysicalDevice( PhysicalDevice && rhs ) VULKAN_HPP_NOEXCEPT - : m_instance( VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange( rhs.m_instance, nullptr ) ) - , m_physicalDevice( VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange( rhs.m_physicalDevice, {} ) ) + : m_physicalDevice( VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange( rhs.m_physicalDevice, {} ) ) , m_dispatcher( VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange( rhs.m_dispatcher, nullptr ) ) {} PhysicalDevice & operator=( PhysicalDevice const & ) = delete; @@ -2645,7 +2634,6 @@ namespace VULKAN_HPP_NAMESPACE { if ( this != &rhs ) { - m_instance = VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange( rhs.m_instance, nullptr ); m_physicalDevice = VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange( rhs.m_physicalDevice, {} ); m_dispatcher = VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange( rhs.m_dispatcher, nullptr ); } @@ -2657,11 +2645,6 @@ namespace VULKAN_HPP_NAMESPACE return m_physicalDevice; } - VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::Instance const * getInstance() const VULKAN_HPP_NOEXCEPT - { - return m_instance; - } - VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::InstanceDispatcher const * getDispatcher() const { VULKAN_HPP_ASSERT( m_dispatcher->getVkHeaderVersion() == VK_HEADER_VERSION ); @@ -3010,9 +2993,8 @@ namespace VULKAN_HPP_NAMESPACE # endif /*VK_USE_PLATFORM_SCREEN_QNX*/ private: - VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::Instance const * m_instance = nullptr; - VULKAN_HPP_NAMESPACE::PhysicalDevice m_physicalDevice; - VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::InstanceDispatcher const * m_dispatcher = nullptr; + VULKAN_HPP_NAMESPACE::PhysicalDevice m_physicalDevice = {}; + VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::InstanceDispatcher const * m_dispatcher = nullptr; }; class PhysicalDevices : public std::vector @@ -3072,15 +3054,14 @@ namespace VULKAN_HPP_NAMESPACE Device( VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::PhysicalDevice const & physicalDevice, VULKAN_HPP_NAMESPACE::DeviceCreateInfo const & createInfo, VULKAN_HPP_NAMESPACE::Optional allocator = nullptr ) - : m_physicalDevice( &physicalDevice ) - , m_allocator( reinterpret_cast( - static_cast( allocator ) ) ) + : m_allocator( static_cast( allocator ) ) { - VULKAN_HPP_NAMESPACE::Result result = static_cast( - physicalDevice.getDispatcher()->vkCreateDevice( static_cast( *physicalDevice ), - reinterpret_cast( &createInfo ), - m_allocator, - reinterpret_cast( &m_device ) ) ); + VULKAN_HPP_NAMESPACE::Result result = + static_cast( physicalDevice.getDispatcher()->vkCreateDevice( + static_cast( *physicalDevice ), + reinterpret_cast( &createInfo ), + reinterpret_cast( m_allocator ), + reinterpret_cast( &m_device ) ) ); if ( result != VULKAN_HPP_NAMESPACE::Result::eSuccess ) { throwResultException( result, "vkCreateDevice" ); @@ -3092,10 +3073,7 @@ namespace VULKAN_HPP_NAMESPACE Device( VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::PhysicalDevice const & physicalDevice, VkDevice device, VULKAN_HPP_NAMESPACE::Optional allocator = nullptr ) - : m_physicalDevice( &physicalDevice ) - , m_device( device ) - , m_allocator( reinterpret_cast( - static_cast( allocator ) ) ) + : m_device( device ), m_allocator( static_cast( allocator ) ) { m_dispatcher.reset( new VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::DeviceDispatcher( physicalDevice.getDispatcher()->vkGetDeviceProcAddr, static_cast( m_device ) ) ); @@ -3107,16 +3085,16 @@ namespace VULKAN_HPP_NAMESPACE { if ( m_device ) { - getDispatcher()->vkDestroyDevice( static_cast( m_device ), m_allocator ); + getDispatcher()->vkDestroyDevice( static_cast( m_device ), + reinterpret_cast( m_allocator ) ); } } Device() = delete; Device( Device const & ) = delete; Device( Device && rhs ) VULKAN_HPP_NOEXCEPT - : m_physicalDevice( VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange( rhs.m_physicalDevice, nullptr ) ) - , m_device( VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange( rhs.m_device, {} ) ) - , m_allocator( rhs.m_allocator ) + : m_device( VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange( rhs.m_device, {} ) ) + , m_allocator( VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange( rhs.m_allocator, {} ) ) , m_dispatcher( rhs.m_dispatcher.release() ) {} Device & operator=( Device const & ) = delete; @@ -3126,11 +3104,11 @@ namespace VULKAN_HPP_NAMESPACE { if ( m_device ) { - getDispatcher()->vkDestroyDevice( static_cast( m_device ), m_allocator ); + getDispatcher()->vkDestroyDevice( static_cast( m_device ), + reinterpret_cast( m_allocator ) ); } - m_physicalDevice = VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange( rhs.m_physicalDevice, nullptr ); - m_device = VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange( rhs.m_device, {} ); - m_allocator = rhs.m_allocator; + m_device = VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange( rhs.m_device, {} ); + m_allocator = VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange( rhs.m_allocator, {} ); m_dispatcher.reset( rhs.m_dispatcher.release() ); } return *this; @@ -3141,12 +3119,6 @@ namespace VULKAN_HPP_NAMESPACE return m_device; } - VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::PhysicalDevice const * - getPhysicalDevice() const VULKAN_HPP_NOEXCEPT - { - return m_physicalDevice; - } - VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::DeviceDispatcher const * getDispatcher() const { VULKAN_HPP_ASSERT( m_dispatcher->getVkHeaderVersion() == VK_HEADER_VERSION ); @@ -3831,9 +3803,8 @@ namespace VULKAN_HPP_NAMESPACE VULKAN_HPP_NOEXCEPT; private: - VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::PhysicalDevice const * m_physicalDevice = nullptr; - VULKAN_HPP_NAMESPACE::Device m_device; - const VkAllocationCallbacks * m_allocator = nullptr; + VULKAN_HPP_NAMESPACE::Device m_device = {}; + const VULKAN_HPP_NAMESPACE::AllocationCallbacks * m_allocator = nullptr; std::unique_ptr m_dispatcher; }; @@ -3852,17 +3823,16 @@ namespace VULKAN_HPP_NAMESPACE VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::Device const & device, VULKAN_HPP_NAMESPACE::AccelerationStructureCreateInfoKHR const & createInfo, VULKAN_HPP_NAMESPACE::Optional allocator = nullptr ) - : m_device( &device ) - , m_allocator( reinterpret_cast( - static_cast( allocator ) ) ) + : m_device( *device ) + , m_allocator( static_cast( allocator ) ) , m_dispatcher( device.getDispatcher() ) { VULKAN_HPP_NAMESPACE::Result result = static_cast( device.getDispatcher()->vkCreateAccelerationStructureKHR( static_cast( *device ), reinterpret_cast( &createInfo ), - m_allocator, - reinterpret_cast( &m_accelerationStructureKHR ) ) ); + reinterpret_cast( m_allocator ), + reinterpret_cast( &m_accelerationStructure ) ) ); if ( result != VULKAN_HPP_NAMESPACE::Result::eSuccess ) { throwResultException( result, "vkCreateAccelerationStructureKHR" ); @@ -3871,12 +3841,11 @@ namespace VULKAN_HPP_NAMESPACE AccelerationStructureKHR( VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::Device const & device, - VkAccelerationStructureKHR accelerationStructureKHR, + VkAccelerationStructureKHR accelerationStructure, VULKAN_HPP_NAMESPACE::Optional allocator = nullptr ) - : m_device( &device ) - , m_accelerationStructureKHR( accelerationStructureKHR ) - , m_allocator( reinterpret_cast( - static_cast( allocator ) ) ) + : m_device( *device ) + , m_accelerationStructure( accelerationStructure ) + , m_allocator( static_cast( allocator ) ) , m_dispatcher( device.getDispatcher() ) {} @@ -3884,22 +3853,22 @@ namespace VULKAN_HPP_NAMESPACE ~AccelerationStructureKHR() { - if ( m_accelerationStructureKHR ) + if ( m_accelerationStructure ) { getDispatcher()->vkDestroyAccelerationStructureKHR( - static_cast( **m_device ), - static_cast( m_accelerationStructureKHR ), - m_allocator ); + static_cast( m_device ), + static_cast( m_accelerationStructure ), + reinterpret_cast( m_allocator ) ); } } AccelerationStructureKHR() = delete; AccelerationStructureKHR( AccelerationStructureKHR const & ) = delete; AccelerationStructureKHR( AccelerationStructureKHR && rhs ) VULKAN_HPP_NOEXCEPT - : m_device( VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange( rhs.m_device, nullptr ) ) - , m_accelerationStructureKHR( - VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange( rhs.m_accelerationStructureKHR, {} ) ) - , m_allocator( rhs.m_allocator ) + : m_device( VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange( rhs.m_device, {} ) ) + , m_accelerationStructure( + VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange( rhs.m_accelerationStructure, {} ) ) + , m_allocator( VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange( rhs.m_allocator, {} ) ) , m_dispatcher( VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange( rhs.m_dispatcher, nullptr ) ) {} AccelerationStructureKHR & operator=( AccelerationStructureKHR const & ) = delete; @@ -3907,17 +3876,10 @@ namespace VULKAN_HPP_NAMESPACE { if ( this != &rhs ) { - if ( m_accelerationStructureKHR ) - { - getDispatcher()->vkDestroyAccelerationStructureKHR( - static_cast( **m_device ), - static_cast( m_accelerationStructureKHR ), - m_allocator ); - } - m_device = VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange( rhs.m_device, nullptr ); - m_accelerationStructureKHR = - VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange( rhs.m_accelerationStructureKHR, {} ); - m_allocator = rhs.m_allocator; + m_device = VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange( rhs.m_device, {} ); + m_accelerationStructure = + VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange( rhs.m_accelerationStructure, {} ); + m_allocator = VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange( rhs.m_allocator, {} ); m_dispatcher = VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange( rhs.m_dispatcher, nullptr ); } return *this; @@ -3925,10 +3887,10 @@ namespace VULKAN_HPP_NAMESPACE VULKAN_HPP_NAMESPACE::AccelerationStructureKHR const & operator*() const VULKAN_HPP_NOEXCEPT { - return m_accelerationStructureKHR; + return m_accelerationStructure; } - VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::Device const * getDevice() const VULKAN_HPP_NOEXCEPT + VULKAN_HPP_NAMESPACE::Device getDevice() const { return m_device; } @@ -3940,10 +3902,10 @@ namespace VULKAN_HPP_NAMESPACE } private: - VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::Device const * m_device = nullptr; - VULKAN_HPP_NAMESPACE::AccelerationStructureKHR m_accelerationStructureKHR; - const VkAllocationCallbacks * m_allocator = nullptr; - VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::DeviceDispatcher const * m_dispatcher = nullptr; + VULKAN_HPP_NAMESPACE::Device m_device = {}; + VULKAN_HPP_NAMESPACE::AccelerationStructureKHR m_accelerationStructure = {}; + const VULKAN_HPP_NAMESPACE::AllocationCallbacks * m_allocator = nullptr; + VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::DeviceDispatcher const * m_dispatcher = nullptr; }; class AccelerationStructureNV @@ -3961,17 +3923,16 @@ namespace VULKAN_HPP_NAMESPACE VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::Device const & device, VULKAN_HPP_NAMESPACE::AccelerationStructureCreateInfoNV const & createInfo, VULKAN_HPP_NAMESPACE::Optional allocator = nullptr ) - : m_device( &device ) - , m_allocator( reinterpret_cast( - static_cast( allocator ) ) ) + : m_device( *device ) + , m_allocator( static_cast( allocator ) ) , m_dispatcher( device.getDispatcher() ) { VULKAN_HPP_NAMESPACE::Result result = static_cast( device.getDispatcher()->vkCreateAccelerationStructureNV( static_cast( *device ), reinterpret_cast( &createInfo ), - m_allocator, - reinterpret_cast( &m_accelerationStructureNV ) ) ); + reinterpret_cast( m_allocator ), + reinterpret_cast( &m_accelerationStructure ) ) ); if ( result != VULKAN_HPP_NAMESPACE::Result::eSuccess ) { throwResultException( result, "vkCreateAccelerationStructureNV" ); @@ -3980,12 +3941,11 @@ namespace VULKAN_HPP_NAMESPACE AccelerationStructureNV( VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::Device const & device, - VkAccelerationStructureNV accelerationStructureNV, + VkAccelerationStructureNV accelerationStructure, VULKAN_HPP_NAMESPACE::Optional allocator = nullptr ) - : m_device( &device ) - , m_accelerationStructureNV( accelerationStructureNV ) - , m_allocator( reinterpret_cast( - static_cast( allocator ) ) ) + : m_device( *device ) + , m_accelerationStructure( accelerationStructure ) + , m_allocator( static_cast( allocator ) ) , m_dispatcher( device.getDispatcher() ) {} @@ -3993,22 +3953,22 @@ namespace VULKAN_HPP_NAMESPACE ~AccelerationStructureNV() { - if ( m_accelerationStructureNV ) + if ( m_accelerationStructure ) { getDispatcher()->vkDestroyAccelerationStructureNV( - static_cast( **m_device ), - static_cast( m_accelerationStructureNV ), - m_allocator ); + static_cast( m_device ), + static_cast( m_accelerationStructure ), + reinterpret_cast( m_allocator ) ); } } AccelerationStructureNV() = delete; AccelerationStructureNV( AccelerationStructureNV const & ) = delete; AccelerationStructureNV( AccelerationStructureNV && rhs ) VULKAN_HPP_NOEXCEPT - : m_device( VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange( rhs.m_device, nullptr ) ) - , m_accelerationStructureNV( - VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange( rhs.m_accelerationStructureNV, {} ) ) - , m_allocator( rhs.m_allocator ) + : m_device( VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange( rhs.m_device, {} ) ) + , m_accelerationStructure( + VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange( rhs.m_accelerationStructure, {} ) ) + , m_allocator( VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange( rhs.m_allocator, {} ) ) , m_dispatcher( VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange( rhs.m_dispatcher, nullptr ) ) {} AccelerationStructureNV & operator=( AccelerationStructureNV const & ) = delete; @@ -4016,17 +3976,10 @@ namespace VULKAN_HPP_NAMESPACE { if ( this != &rhs ) { - if ( m_accelerationStructureNV ) - { - getDispatcher()->vkDestroyAccelerationStructureNV( - static_cast( **m_device ), - static_cast( m_accelerationStructureNV ), - m_allocator ); - } - m_device = VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange( rhs.m_device, nullptr ); - m_accelerationStructureNV = - VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange( rhs.m_accelerationStructureNV, {} ); - m_allocator = rhs.m_allocator; + m_device = VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange( rhs.m_device, {} ); + m_accelerationStructure = + VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange( rhs.m_accelerationStructure, {} ); + m_allocator = VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange( rhs.m_allocator, {} ); m_dispatcher = VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange( rhs.m_dispatcher, nullptr ); } return *this; @@ -4034,10 +3987,10 @@ namespace VULKAN_HPP_NAMESPACE VULKAN_HPP_NAMESPACE::AccelerationStructureNV const & operator*() const VULKAN_HPP_NOEXCEPT { - return m_accelerationStructureNV; + return m_accelerationStructure; } - VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::Device const * getDevice() const VULKAN_HPP_NOEXCEPT + VULKAN_HPP_NAMESPACE::Device getDevice() const { return m_device; } @@ -4057,10 +4010,10 @@ namespace VULKAN_HPP_NAMESPACE VULKAN_HPP_NODISCARD T getHandle() const; private: - VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::Device const * m_device = nullptr; - VULKAN_HPP_NAMESPACE::AccelerationStructureNV m_accelerationStructureNV; - const VkAllocationCallbacks * m_allocator = nullptr; - VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::DeviceDispatcher const * m_dispatcher = nullptr; + VULKAN_HPP_NAMESPACE::Device m_device = {}; + VULKAN_HPP_NAMESPACE::AccelerationStructureNV m_accelerationStructure = {}; + const VULKAN_HPP_NAMESPACE::AllocationCallbacks * m_allocator = nullptr; + VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::DeviceDispatcher const * m_dispatcher = nullptr; }; class Buffer @@ -4077,15 +4030,14 @@ namespace VULKAN_HPP_NAMESPACE Buffer( VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::Device const & device, VULKAN_HPP_NAMESPACE::BufferCreateInfo const & createInfo, VULKAN_HPP_NAMESPACE::Optional allocator = nullptr ) - : m_device( &device ) - , m_allocator( reinterpret_cast( - static_cast( allocator ) ) ) + : m_device( *device ) + , m_allocator( static_cast( allocator ) ) , m_dispatcher( device.getDispatcher() ) { VULKAN_HPP_NAMESPACE::Result result = static_cast( device.getDispatcher()->vkCreateBuffer( static_cast( *device ), reinterpret_cast( &createInfo ), - m_allocator, + reinterpret_cast( m_allocator ), reinterpret_cast( &m_buffer ) ) ); if ( result != VULKAN_HPP_NAMESPACE::Result::eSuccess ) { @@ -4096,10 +4048,9 @@ namespace VULKAN_HPP_NAMESPACE Buffer( VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::Device const & device, VkBuffer buffer, VULKAN_HPP_NAMESPACE::Optional allocator = nullptr ) - : m_device( &device ) + : m_device( *device ) , m_buffer( buffer ) - , m_allocator( reinterpret_cast( - static_cast( allocator ) ) ) + , m_allocator( static_cast( allocator ) ) , m_dispatcher( device.getDispatcher() ) {} @@ -4109,17 +4060,18 @@ namespace VULKAN_HPP_NAMESPACE { if ( m_buffer ) { - getDispatcher()->vkDestroyBuffer( - static_cast( **m_device ), static_cast( m_buffer ), m_allocator ); + getDispatcher()->vkDestroyBuffer( static_cast( m_device ), + static_cast( m_buffer ), + reinterpret_cast( m_allocator ) ); } } Buffer() = delete; Buffer( Buffer const & ) = delete; Buffer( Buffer && rhs ) VULKAN_HPP_NOEXCEPT - : m_device( VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange( rhs.m_device, nullptr ) ) + : m_device( VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange( rhs.m_device, {} ) ) , m_buffer( VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange( rhs.m_buffer, {} ) ) - , m_allocator( rhs.m_allocator ) + , m_allocator( VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange( rhs.m_allocator, {} ) ) , m_dispatcher( VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange( rhs.m_dispatcher, nullptr ) ) {} Buffer & operator=( Buffer const & ) = delete; @@ -4127,14 +4079,9 @@ namespace VULKAN_HPP_NAMESPACE { if ( this != &rhs ) { - if ( m_buffer ) - { - getDispatcher()->vkDestroyBuffer( - static_cast( **m_device ), static_cast( m_buffer ), m_allocator ); - } - m_device = VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange( rhs.m_device, nullptr ); + m_device = VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange( rhs.m_device, {} ); m_buffer = VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange( rhs.m_buffer, {} ); - m_allocator = rhs.m_allocator; + m_allocator = VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange( rhs.m_allocator, {} ); m_dispatcher = VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange( rhs.m_dispatcher, nullptr ); } return *this; @@ -4145,7 +4092,7 @@ namespace VULKAN_HPP_NAMESPACE return m_buffer; } - VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::Device const * getDevice() const VULKAN_HPP_NOEXCEPT + VULKAN_HPP_NAMESPACE::Device getDevice() const { return m_device; } @@ -4163,9 +4110,9 @@ namespace VULKAN_HPP_NAMESPACE VULKAN_HPP_NODISCARD VULKAN_HPP_NAMESPACE::MemoryRequirements getMemoryRequirements() const VULKAN_HPP_NOEXCEPT; private: - VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::Device const * m_device = nullptr; - VULKAN_HPP_NAMESPACE::Buffer m_buffer; - const VkAllocationCallbacks * m_allocator = nullptr; + VULKAN_HPP_NAMESPACE::Device m_device = {}; + VULKAN_HPP_NAMESPACE::Buffer m_buffer = {}; + const VULKAN_HPP_NAMESPACE::AllocationCallbacks * m_allocator = nullptr; VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::DeviceDispatcher const * m_dispatcher = nullptr; }; @@ -4185,17 +4132,16 @@ namespace VULKAN_HPP_NAMESPACE VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::Device const & device, VULKAN_HPP_NAMESPACE::BufferCollectionCreateInfoFUCHSIA const & createInfo, VULKAN_HPP_NAMESPACE::Optional allocator = nullptr ) - : m_device( &device ) - , m_allocator( reinterpret_cast( - static_cast( allocator ) ) ) + : m_device( *device ) + , m_allocator( static_cast( allocator ) ) , m_dispatcher( device.getDispatcher() ) { VULKAN_HPP_NAMESPACE::Result result = static_cast( device.getDispatcher()->vkCreateBufferCollectionFUCHSIA( static_cast( *device ), reinterpret_cast( &createInfo ), - m_allocator, - reinterpret_cast( &m_bufferCollectionFUCHSIA ) ) ); + reinterpret_cast( m_allocator ), + reinterpret_cast( &m_collection ) ) ); if ( result != VULKAN_HPP_NAMESPACE::Result::eSuccess ) { throwResultException( result, "vkCreateBufferCollectionFUCHSIA" ); @@ -4204,12 +4150,11 @@ namespace VULKAN_HPP_NAMESPACE BufferCollectionFUCHSIA( VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::Device const & device, - VkBufferCollectionFUCHSIA bufferCollectionFUCHSIA, + VkBufferCollectionFUCHSIA collection, VULKAN_HPP_NAMESPACE::Optional allocator = nullptr ) - : m_device( &device ) - , m_bufferCollectionFUCHSIA( bufferCollectionFUCHSIA ) - , m_allocator( reinterpret_cast( - static_cast( allocator ) ) ) + : m_device( *device ) + , m_collection( collection ) + , m_allocator( static_cast( allocator ) ) , m_dispatcher( device.getDispatcher() ) {} @@ -4217,22 +4162,21 @@ namespace VULKAN_HPP_NAMESPACE ~BufferCollectionFUCHSIA() { - if ( m_bufferCollectionFUCHSIA ) + if ( m_collection ) { getDispatcher()->vkDestroyBufferCollectionFUCHSIA( - static_cast( **m_device ), - static_cast( m_bufferCollectionFUCHSIA ), - m_allocator ); + static_cast( m_device ), + static_cast( m_collection ), + reinterpret_cast( m_allocator ) ); } } BufferCollectionFUCHSIA() = delete; BufferCollectionFUCHSIA( BufferCollectionFUCHSIA const & ) = delete; BufferCollectionFUCHSIA( BufferCollectionFUCHSIA && rhs ) VULKAN_HPP_NOEXCEPT - : m_device( VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange( rhs.m_device, nullptr ) ) - , m_bufferCollectionFUCHSIA( - VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange( rhs.m_bufferCollectionFUCHSIA, {} ) ) - , m_allocator( rhs.m_allocator ) + : m_device( VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange( rhs.m_device, {} ) ) + , m_collection( VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange( rhs.m_collection, {} ) ) + , m_allocator( VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange( rhs.m_allocator, {} ) ) , m_dispatcher( VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange( rhs.m_dispatcher, nullptr ) ) {} BufferCollectionFUCHSIA & operator=( BufferCollectionFUCHSIA const & ) = delete; @@ -4240,17 +4184,9 @@ namespace VULKAN_HPP_NAMESPACE { if ( this != &rhs ) { - if ( m_bufferCollectionFUCHSIA ) - { - getDispatcher()->vkDestroyBufferCollectionFUCHSIA( - static_cast( **m_device ), - static_cast( m_bufferCollectionFUCHSIA ), - m_allocator ); - } - m_device = VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange( rhs.m_device, nullptr ); - m_bufferCollectionFUCHSIA = - VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange( rhs.m_bufferCollectionFUCHSIA, {} ); - m_allocator = rhs.m_allocator; + m_device = VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange( rhs.m_device, {} ); + m_collection = VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange( rhs.m_collection, {} ); + m_allocator = VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange( rhs.m_allocator, {} ); m_dispatcher = VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange( rhs.m_dispatcher, nullptr ); } return *this; @@ -4258,10 +4194,10 @@ namespace VULKAN_HPP_NAMESPACE VULKAN_HPP_NAMESPACE::BufferCollectionFUCHSIA const & operator*() const VULKAN_HPP_NOEXCEPT { - return m_bufferCollectionFUCHSIA; + return m_collection; } - VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::Device const * getDevice() const VULKAN_HPP_NOEXCEPT + VULKAN_HPP_NAMESPACE::Device getDevice() const { return m_device; } @@ -4282,9 +4218,9 @@ namespace VULKAN_HPP_NAMESPACE VULKAN_HPP_NODISCARD VULKAN_HPP_NAMESPACE::BufferCollectionPropertiesFUCHSIA getProperties() const; private: - VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::Device const * m_device = nullptr; - VULKAN_HPP_NAMESPACE::BufferCollectionFUCHSIA m_bufferCollectionFUCHSIA; - const VkAllocationCallbacks * m_allocator = nullptr; + VULKAN_HPP_NAMESPACE::Device m_device = {}; + VULKAN_HPP_NAMESPACE::BufferCollectionFUCHSIA m_collection = {}; + const VULKAN_HPP_NAMESPACE::AllocationCallbacks * m_allocator = nullptr; VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::DeviceDispatcher const * m_dispatcher = nullptr; }; # endif /*VK_USE_PLATFORM_FUCHSIA*/ @@ -4303,15 +4239,14 @@ namespace VULKAN_HPP_NAMESPACE BufferView( VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::Device const & device, VULKAN_HPP_NAMESPACE::BufferViewCreateInfo const & createInfo, VULKAN_HPP_NAMESPACE::Optional allocator = nullptr ) - : m_device( &device ) - , m_allocator( reinterpret_cast( - static_cast( allocator ) ) ) + : m_device( *device ) + , m_allocator( static_cast( allocator ) ) , m_dispatcher( device.getDispatcher() ) { VULKAN_HPP_NAMESPACE::Result result = static_cast( device.getDispatcher()->vkCreateBufferView( static_cast( *device ), reinterpret_cast( &createInfo ), - m_allocator, + reinterpret_cast( m_allocator ), reinterpret_cast( &m_bufferView ) ) ); if ( result != VULKAN_HPP_NAMESPACE::Result::eSuccess ) { @@ -4322,10 +4257,9 @@ namespace VULKAN_HPP_NAMESPACE BufferView( VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::Device const & device, VkBufferView bufferView, VULKAN_HPP_NAMESPACE::Optional allocator = nullptr ) - : m_device( &device ) + : m_device( *device ) , m_bufferView( bufferView ) - , m_allocator( reinterpret_cast( - static_cast( allocator ) ) ) + , m_allocator( static_cast( allocator ) ) , m_dispatcher( device.getDispatcher() ) {} @@ -4335,17 +4269,18 @@ namespace VULKAN_HPP_NAMESPACE { if ( m_bufferView ) { - getDispatcher()->vkDestroyBufferView( - static_cast( **m_device ), static_cast( m_bufferView ), m_allocator ); + getDispatcher()->vkDestroyBufferView( static_cast( m_device ), + static_cast( m_bufferView ), + reinterpret_cast( m_allocator ) ); } } BufferView() = delete; BufferView( BufferView const & ) = delete; BufferView( BufferView && rhs ) VULKAN_HPP_NOEXCEPT - : m_device( VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange( rhs.m_device, nullptr ) ) + : m_device( VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange( rhs.m_device, {} ) ) , m_bufferView( VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange( rhs.m_bufferView, {} ) ) - , m_allocator( rhs.m_allocator ) + , m_allocator( VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange( rhs.m_allocator, {} ) ) , m_dispatcher( VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange( rhs.m_dispatcher, nullptr ) ) {} BufferView & operator=( BufferView const & ) = delete; @@ -4353,14 +4288,9 @@ namespace VULKAN_HPP_NAMESPACE { if ( this != &rhs ) { - if ( m_bufferView ) - { - getDispatcher()->vkDestroyBufferView( - static_cast( **m_device ), static_cast( m_bufferView ), m_allocator ); - } - m_device = VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange( rhs.m_device, nullptr ); + m_device = VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange( rhs.m_device, {} ); m_bufferView = VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange( rhs.m_bufferView, {} ); - m_allocator = rhs.m_allocator; + m_allocator = VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange( rhs.m_allocator, {} ); m_dispatcher = VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange( rhs.m_dispatcher, nullptr ); } return *this; @@ -4371,7 +4301,7 @@ namespace VULKAN_HPP_NAMESPACE return m_bufferView; } - VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::Device const * getDevice() const VULKAN_HPP_NOEXCEPT + VULKAN_HPP_NAMESPACE::Device getDevice() const { return m_device; } @@ -4383,9 +4313,9 @@ namespace VULKAN_HPP_NAMESPACE } private: - VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::Device const * m_device = nullptr; - VULKAN_HPP_NAMESPACE::BufferView m_bufferView; - const VkAllocationCallbacks * m_allocator = nullptr; + VULKAN_HPP_NAMESPACE::Device m_device = {}; + VULKAN_HPP_NAMESPACE::BufferView m_bufferView = {}; + const VULKAN_HPP_NAMESPACE::AllocationCallbacks * m_allocator = nullptr; VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::DeviceDispatcher const * m_dispatcher = nullptr; }; @@ -4403,15 +4333,14 @@ namespace VULKAN_HPP_NAMESPACE CommandPool( VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::Device const & device, VULKAN_HPP_NAMESPACE::CommandPoolCreateInfo const & createInfo, VULKAN_HPP_NAMESPACE::Optional allocator = nullptr ) - : m_device( &device ) - , m_allocator( reinterpret_cast( - static_cast( allocator ) ) ) + : m_device( *device ) + , m_allocator( static_cast( allocator ) ) , m_dispatcher( device.getDispatcher() ) { VULKAN_HPP_NAMESPACE::Result result = static_cast( device.getDispatcher()->vkCreateCommandPool( static_cast( *device ), reinterpret_cast( &createInfo ), - m_allocator, + reinterpret_cast( m_allocator ), reinterpret_cast( &m_commandPool ) ) ); if ( result != VULKAN_HPP_NAMESPACE::Result::eSuccess ) { @@ -4422,10 +4351,9 @@ namespace VULKAN_HPP_NAMESPACE CommandPool( VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::Device const & device, VkCommandPool commandPool, VULKAN_HPP_NAMESPACE::Optional allocator = nullptr ) - : m_device( &device ) + : m_device( *device ) , m_commandPool( commandPool ) - , m_allocator( reinterpret_cast( - static_cast( allocator ) ) ) + , m_allocator( static_cast( allocator ) ) , m_dispatcher( device.getDispatcher() ) {} @@ -4435,17 +4363,18 @@ namespace VULKAN_HPP_NAMESPACE { if ( m_commandPool ) { - getDispatcher()->vkDestroyCommandPool( - static_cast( **m_device ), static_cast( m_commandPool ), m_allocator ); + getDispatcher()->vkDestroyCommandPool( static_cast( m_device ), + static_cast( m_commandPool ), + reinterpret_cast( m_allocator ) ); } } CommandPool() = delete; CommandPool( CommandPool const & ) = delete; CommandPool( CommandPool && rhs ) VULKAN_HPP_NOEXCEPT - : m_device( VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange( rhs.m_device, nullptr ) ) + : m_device( VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange( rhs.m_device, {} ) ) , m_commandPool( VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange( rhs.m_commandPool, {} ) ) - , m_allocator( rhs.m_allocator ) + , m_allocator( VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange( rhs.m_allocator, {} ) ) , m_dispatcher( VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange( rhs.m_dispatcher, nullptr ) ) {} CommandPool & operator=( CommandPool const & ) = delete; @@ -4453,14 +4382,9 @@ namespace VULKAN_HPP_NAMESPACE { if ( this != &rhs ) { - if ( m_commandPool ) - { - getDispatcher()->vkDestroyCommandPool( - static_cast( **m_device ), static_cast( m_commandPool ), m_allocator ); - } - m_device = VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange( rhs.m_device, nullptr ); + m_device = VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange( rhs.m_device, {} ); m_commandPool = VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange( rhs.m_commandPool, {} ); - m_allocator = rhs.m_allocator; + m_allocator = VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange( rhs.m_allocator, {} ); m_dispatcher = VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange( rhs.m_dispatcher, nullptr ); } return *this; @@ -4471,7 +4395,7 @@ namespace VULKAN_HPP_NAMESPACE return m_commandPool; } - VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::Device const * getDevice() const VULKAN_HPP_NOEXCEPT + VULKAN_HPP_NAMESPACE::Device getDevice() const { return m_device; } @@ -4497,10 +4421,10 @@ namespace VULKAN_HPP_NAMESPACE VULKAN_HPP_NOEXCEPT; private: - VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::Device const * m_device = nullptr; - VULKAN_HPP_NAMESPACE::CommandPool m_commandPool; - const VkAllocationCallbacks * m_allocator = nullptr; - VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::DeviceDispatcher const * m_dispatcher = nullptr; + VULKAN_HPP_NAMESPACE::Device m_device = {}; + VULKAN_HPP_NAMESPACE::CommandPool m_commandPool = {}; + const VULKAN_HPP_NAMESPACE::AllocationCallbacks * m_allocator = nullptr; + VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::DeviceDispatcher const * m_dispatcher = nullptr; }; class CommandBuffer @@ -4517,9 +4441,9 @@ namespace VULKAN_HPP_NAMESPACE CommandBuffer( VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::Device const & device, VkCommandBuffer commandBuffer, VkCommandPool commandPool ) - : m_device( &device ) - , m_commandBuffer( commandBuffer ) + : m_device( *device ) , m_commandPool( commandPool ) + , m_commandBuffer( commandBuffer ) , m_dispatcher( device.getDispatcher() ) {} @@ -4529,8 +4453,8 @@ namespace VULKAN_HPP_NAMESPACE { if ( m_commandBuffer ) { - getDispatcher()->vkFreeCommandBuffers( static_cast( **m_device ), - m_commandPool, + getDispatcher()->vkFreeCommandBuffers( static_cast( m_device ), + static_cast( m_commandPool ), 1, reinterpret_cast( &m_commandBuffer ) ); } @@ -4539,9 +4463,9 @@ namespace VULKAN_HPP_NAMESPACE CommandBuffer() = delete; CommandBuffer( CommandBuffer const & ) = delete; CommandBuffer( CommandBuffer && rhs ) VULKAN_HPP_NOEXCEPT - : m_device( VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange( rhs.m_device, nullptr ) ) + : m_device( VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange( rhs.m_device, {} ) ) + , m_commandPool( VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange( rhs.m_commandPool, {} ) ) , m_commandBuffer( VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange( rhs.m_commandBuffer, {} ) ) - , m_commandPool( rhs.m_commandPool ) , m_dispatcher( VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange( rhs.m_dispatcher, nullptr ) ) {} CommandBuffer & operator=( CommandBuffer const & ) = delete; @@ -4549,16 +4473,9 @@ namespace VULKAN_HPP_NAMESPACE { if ( this != &rhs ) { - if ( m_commandBuffer ) - { - getDispatcher()->vkFreeCommandBuffers( static_cast( **m_device ), - m_commandPool, - 1, - reinterpret_cast( &m_commandBuffer ) ); - } - m_device = VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange( rhs.m_device, nullptr ); + m_device = VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange( rhs.m_device, {} ); + m_commandPool = VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange( rhs.m_commandPool, {} ); m_commandBuffer = VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange( rhs.m_commandBuffer, {} ); - m_commandPool = rhs.m_commandPool; m_dispatcher = VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange( rhs.m_dispatcher, nullptr ); } return *this; @@ -4569,7 +4486,7 @@ namespace VULKAN_HPP_NAMESPACE return m_commandBuffer; } - VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::Device const * getDevice() const VULKAN_HPP_NOEXCEPT + VULKAN_HPP_NAMESPACE::Device getDevice() const { return m_device; } @@ -5300,10 +5217,10 @@ namespace VULKAN_HPP_NAMESPACE VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT; private: - VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::Device const * m_device = nullptr; - VULKAN_HPP_NAMESPACE::CommandBuffer m_commandBuffer; - VkCommandPool m_commandPool; - VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::DeviceDispatcher const * m_dispatcher = nullptr; + VULKAN_HPP_NAMESPACE::Device m_device = {}; + VULKAN_HPP_NAMESPACE::CommandPool m_commandPool = {}; + VULKAN_HPP_NAMESPACE::CommandBuffer m_commandBuffer = {}; + VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::DeviceDispatcher const * m_dispatcher = nullptr; }; class CommandBuffers : public std::vector @@ -5354,17 +5271,16 @@ namespace VULKAN_HPP_NAMESPACE VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::Device const & device, VULKAN_HPP_NAMESPACE::CuFunctionCreateInfoNVX const & createInfo, VULKAN_HPP_NAMESPACE::Optional allocator = nullptr ) - : m_device( &device ) - , m_allocator( reinterpret_cast( - static_cast( allocator ) ) ) + : m_device( *device ) + , m_allocator( static_cast( allocator ) ) , m_dispatcher( device.getDispatcher() ) { VULKAN_HPP_NAMESPACE::Result result = static_cast( device.getDispatcher()->vkCreateCuFunctionNVX( static_cast( *device ), reinterpret_cast( &createInfo ), - m_allocator, - reinterpret_cast( &m_cuFunctionNVX ) ) ); + reinterpret_cast( m_allocator ), + reinterpret_cast( &m_function ) ) ); if ( result != VULKAN_HPP_NAMESPACE::Result::eSuccess ) { throwResultException( result, "vkCreateCuFunctionNVX" ); @@ -5373,12 +5289,11 @@ namespace VULKAN_HPP_NAMESPACE CuFunctionNVX( VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::Device const & device, - VkCuFunctionNVX cuFunctionNVX, + VkCuFunctionNVX function, VULKAN_HPP_NAMESPACE::Optional allocator = nullptr ) - : m_device( &device ) - , m_cuFunctionNVX( cuFunctionNVX ) - , m_allocator( reinterpret_cast( - static_cast( allocator ) ) ) + : m_device( *device ) + , m_function( function ) + , m_allocator( static_cast( allocator ) ) , m_dispatcher( device.getDispatcher() ) {} @@ -5386,19 +5301,20 @@ namespace VULKAN_HPP_NAMESPACE ~CuFunctionNVX() { - if ( m_cuFunctionNVX ) + if ( m_function ) { - getDispatcher()->vkDestroyCuFunctionNVX( - static_cast( **m_device ), static_cast( m_cuFunctionNVX ), m_allocator ); + getDispatcher()->vkDestroyCuFunctionNVX( static_cast( m_device ), + static_cast( m_function ), + reinterpret_cast( m_allocator ) ); } } CuFunctionNVX() = delete; CuFunctionNVX( CuFunctionNVX const & ) = delete; CuFunctionNVX( CuFunctionNVX && rhs ) VULKAN_HPP_NOEXCEPT - : m_device( VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange( rhs.m_device, nullptr ) ) - , m_cuFunctionNVX( VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange( rhs.m_cuFunctionNVX, {} ) ) - , m_allocator( rhs.m_allocator ) + : m_device( VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange( rhs.m_device, {} ) ) + , m_function( VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange( rhs.m_function, {} ) ) + , m_allocator( VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange( rhs.m_allocator, {} ) ) , m_dispatcher( VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange( rhs.m_dispatcher, nullptr ) ) {} CuFunctionNVX & operator=( CuFunctionNVX const & ) = delete; @@ -5406,25 +5322,20 @@ namespace VULKAN_HPP_NAMESPACE { if ( this != &rhs ) { - if ( m_cuFunctionNVX ) - { - getDispatcher()->vkDestroyCuFunctionNVX( - static_cast( **m_device ), static_cast( m_cuFunctionNVX ), m_allocator ); - } - m_device = VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange( rhs.m_device, nullptr ); - m_cuFunctionNVX = VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange( rhs.m_cuFunctionNVX, {} ); - m_allocator = rhs.m_allocator; - m_dispatcher = VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange( rhs.m_dispatcher, nullptr ); + m_device = VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange( rhs.m_device, {} ); + m_function = VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange( rhs.m_function, {} ); + m_allocator = VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange( rhs.m_allocator, {} ); + m_dispatcher = VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange( rhs.m_dispatcher, nullptr ); } return *this; } VULKAN_HPP_NAMESPACE::CuFunctionNVX const & operator*() const VULKAN_HPP_NOEXCEPT { - return m_cuFunctionNVX; + return m_function; } - VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::Device const * getDevice() const VULKAN_HPP_NOEXCEPT + VULKAN_HPP_NAMESPACE::Device getDevice() const { return m_device; } @@ -5436,9 +5347,9 @@ namespace VULKAN_HPP_NAMESPACE } private: - VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::Device const * m_device = nullptr; - VULKAN_HPP_NAMESPACE::CuFunctionNVX m_cuFunctionNVX; - const VkAllocationCallbacks * m_allocator = nullptr; + VULKAN_HPP_NAMESPACE::Device m_device = {}; + VULKAN_HPP_NAMESPACE::CuFunctionNVX m_function = {}; + const VULKAN_HPP_NAMESPACE::AllocationCallbacks * m_allocator = nullptr; VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::DeviceDispatcher const * m_dispatcher = nullptr; }; @@ -5456,16 +5367,15 @@ namespace VULKAN_HPP_NAMESPACE CuModuleNVX( VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::Device const & device, VULKAN_HPP_NAMESPACE::CuModuleCreateInfoNVX const & createInfo, VULKAN_HPP_NAMESPACE::Optional allocator = nullptr ) - : m_device( &device ) - , m_allocator( reinterpret_cast( - static_cast( allocator ) ) ) + : m_device( *device ) + , m_allocator( static_cast( allocator ) ) , m_dispatcher( device.getDispatcher() ) { VULKAN_HPP_NAMESPACE::Result result = static_cast( device.getDispatcher()->vkCreateCuModuleNVX( static_cast( *device ), reinterpret_cast( &createInfo ), - m_allocator, - reinterpret_cast( &m_cuModuleNVX ) ) ); + reinterpret_cast( m_allocator ), + reinterpret_cast( &m_module ) ) ); if ( result != VULKAN_HPP_NAMESPACE::Result::eSuccess ) { throwResultException( result, "vkCreateCuModuleNVX" ); @@ -5473,12 +5383,11 @@ namespace VULKAN_HPP_NAMESPACE } CuModuleNVX( VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::Device const & device, - VkCuModuleNVX cuModuleNVX, + VkCuModuleNVX module, VULKAN_HPP_NAMESPACE::Optional allocator = nullptr ) - : m_device( &device ) - , m_cuModuleNVX( cuModuleNVX ) - , m_allocator( reinterpret_cast( - static_cast( allocator ) ) ) + : m_device( *device ) + , m_module( module ) + , m_allocator( static_cast( allocator ) ) , m_dispatcher( device.getDispatcher() ) {} @@ -5486,19 +5395,20 @@ namespace VULKAN_HPP_NAMESPACE ~CuModuleNVX() { - if ( m_cuModuleNVX ) + if ( m_module ) { - getDispatcher()->vkDestroyCuModuleNVX( - static_cast( **m_device ), static_cast( m_cuModuleNVX ), m_allocator ); + getDispatcher()->vkDestroyCuModuleNVX( static_cast( m_device ), + static_cast( m_module ), + reinterpret_cast( m_allocator ) ); } } CuModuleNVX() = delete; CuModuleNVX( CuModuleNVX const & ) = delete; CuModuleNVX( CuModuleNVX && rhs ) VULKAN_HPP_NOEXCEPT - : m_device( VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange( rhs.m_device, nullptr ) ) - , m_cuModuleNVX( VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange( rhs.m_cuModuleNVX, {} ) ) - , m_allocator( rhs.m_allocator ) + : m_device( VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange( rhs.m_device, {} ) ) + , m_module( VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange( rhs.m_module, {} ) ) + , m_allocator( VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange( rhs.m_allocator, {} ) ) , m_dispatcher( VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange( rhs.m_dispatcher, nullptr ) ) {} CuModuleNVX & operator=( CuModuleNVX const & ) = delete; @@ -5506,25 +5416,20 @@ namespace VULKAN_HPP_NAMESPACE { if ( this != &rhs ) { - if ( m_cuModuleNVX ) - { - getDispatcher()->vkDestroyCuModuleNVX( - static_cast( **m_device ), static_cast( m_cuModuleNVX ), m_allocator ); - } - m_device = VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange( rhs.m_device, nullptr ); - m_cuModuleNVX = VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange( rhs.m_cuModuleNVX, {} ); - m_allocator = rhs.m_allocator; - m_dispatcher = VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange( rhs.m_dispatcher, nullptr ); + m_device = VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange( rhs.m_device, {} ); + m_module = VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange( rhs.m_module, {} ); + m_allocator = VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange( rhs.m_allocator, {} ); + m_dispatcher = VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange( rhs.m_dispatcher, nullptr ); } return *this; } VULKAN_HPP_NAMESPACE::CuModuleNVX const & operator*() const VULKAN_HPP_NOEXCEPT { - return m_cuModuleNVX; + return m_module; } - VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::Device const * getDevice() const VULKAN_HPP_NOEXCEPT + VULKAN_HPP_NAMESPACE::Device getDevice() const { return m_device; } @@ -5536,9 +5441,9 @@ namespace VULKAN_HPP_NAMESPACE } private: - VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::Device const * m_device = nullptr; - VULKAN_HPP_NAMESPACE::CuModuleNVX m_cuModuleNVX; - const VkAllocationCallbacks * m_allocator = nullptr; + VULKAN_HPP_NAMESPACE::Device m_device = {}; + VULKAN_HPP_NAMESPACE::CuModuleNVX m_module = {}; + const VULKAN_HPP_NAMESPACE::AllocationCallbacks * m_allocator = nullptr; VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::DeviceDispatcher const * m_dispatcher = nullptr; }; @@ -5557,17 +5462,16 @@ namespace VULKAN_HPP_NAMESPACE VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::Instance const & instance, VULKAN_HPP_NAMESPACE::DebugReportCallbackCreateInfoEXT const & createInfo, VULKAN_HPP_NAMESPACE::Optional allocator = nullptr ) - : m_instance( &instance ) - , m_allocator( reinterpret_cast( - static_cast( allocator ) ) ) + : m_instance( *instance ) + , m_allocator( static_cast( allocator ) ) , m_dispatcher( instance.getDispatcher() ) { VULKAN_HPP_NAMESPACE::Result result = static_cast( instance.getDispatcher()->vkCreateDebugReportCallbackEXT( static_cast( *instance ), reinterpret_cast( &createInfo ), - m_allocator, - reinterpret_cast( &m_debugReportCallbackEXT ) ) ); + reinterpret_cast( m_allocator ), + reinterpret_cast( &m_callback ) ) ); if ( result != VULKAN_HPP_NAMESPACE::Result::eSuccess ) { throwResultException( result, "vkCreateDebugReportCallbackEXT" ); @@ -5576,12 +5480,11 @@ namespace VULKAN_HPP_NAMESPACE DebugReportCallbackEXT( VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::Instance const & instance, - VkDebugReportCallbackEXT debugReportCallbackEXT, + VkDebugReportCallbackEXT callback, VULKAN_HPP_NAMESPACE::Optional allocator = nullptr ) - : m_instance( &instance ) - , m_debugReportCallbackEXT( debugReportCallbackEXT ) - , m_allocator( reinterpret_cast( - static_cast( allocator ) ) ) + : m_instance( *instance ) + , m_callback( callback ) + , m_allocator( static_cast( allocator ) ) , m_dispatcher( instance.getDispatcher() ) {} @@ -5589,22 +5492,21 @@ namespace VULKAN_HPP_NAMESPACE ~DebugReportCallbackEXT() { - if ( m_debugReportCallbackEXT ) + if ( m_callback ) { getDispatcher()->vkDestroyDebugReportCallbackEXT( - static_cast( **m_instance ), - static_cast( m_debugReportCallbackEXT ), - m_allocator ); + static_cast( m_instance ), + static_cast( m_callback ), + reinterpret_cast( m_allocator ) ); } } DebugReportCallbackEXT() = delete; DebugReportCallbackEXT( DebugReportCallbackEXT const & ) = delete; DebugReportCallbackEXT( DebugReportCallbackEXT && rhs ) VULKAN_HPP_NOEXCEPT - : m_instance( VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange( rhs.m_instance, nullptr ) ) - , m_debugReportCallbackEXT( - VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange( rhs.m_debugReportCallbackEXT, {} ) ) - , m_allocator( rhs.m_allocator ) + : m_instance( VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange( rhs.m_instance, {} ) ) + , m_callback( VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange( rhs.m_callback, {} ) ) + , m_allocator( VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange( rhs.m_allocator, {} ) ) , m_dispatcher( VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange( rhs.m_dispatcher, nullptr ) ) {} DebugReportCallbackEXT & operator=( DebugReportCallbackEXT const & ) = delete; @@ -5612,17 +5514,9 @@ namespace VULKAN_HPP_NAMESPACE { if ( this != &rhs ) { - if ( m_debugReportCallbackEXT ) - { - getDispatcher()->vkDestroyDebugReportCallbackEXT( - static_cast( **m_instance ), - static_cast( m_debugReportCallbackEXT ), - m_allocator ); - } - m_instance = VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange( rhs.m_instance, nullptr ); - m_debugReportCallbackEXT = - VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange( rhs.m_debugReportCallbackEXT, {} ); - m_allocator = rhs.m_allocator; + m_instance = VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange( rhs.m_instance, {} ); + m_callback = VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange( rhs.m_callback, {} ); + m_allocator = VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange( rhs.m_allocator, {} ); m_dispatcher = VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange( rhs.m_dispatcher, nullptr ); } return *this; @@ -5630,10 +5524,10 @@ namespace VULKAN_HPP_NAMESPACE VULKAN_HPP_NAMESPACE::DebugReportCallbackEXT const & operator*() const VULKAN_HPP_NOEXCEPT { - return m_debugReportCallbackEXT; + return m_callback; } - VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::Instance const * getInstance() const VULKAN_HPP_NOEXCEPT + VULKAN_HPP_NAMESPACE::Instance getInstance() const { return m_instance; } @@ -5645,9 +5539,9 @@ namespace VULKAN_HPP_NAMESPACE } private: - VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::Instance const * m_instance = nullptr; - VULKAN_HPP_NAMESPACE::DebugReportCallbackEXT m_debugReportCallbackEXT; - const VkAllocationCallbacks * m_allocator = nullptr; + VULKAN_HPP_NAMESPACE::Instance m_instance = {}; + VULKAN_HPP_NAMESPACE::DebugReportCallbackEXT m_callback = {}; + const VULKAN_HPP_NAMESPACE::AllocationCallbacks * m_allocator = nullptr; VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::InstanceDispatcher const * m_dispatcher = nullptr; }; @@ -5666,17 +5560,16 @@ namespace VULKAN_HPP_NAMESPACE VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::Instance const & instance, VULKAN_HPP_NAMESPACE::DebugUtilsMessengerCreateInfoEXT const & createInfo, VULKAN_HPP_NAMESPACE::Optional allocator = nullptr ) - : m_instance( &instance ) - , m_allocator( reinterpret_cast( - static_cast( allocator ) ) ) + : m_instance( *instance ) + , m_allocator( static_cast( allocator ) ) , m_dispatcher( instance.getDispatcher() ) { VULKAN_HPP_NAMESPACE::Result result = static_cast( instance.getDispatcher()->vkCreateDebugUtilsMessengerEXT( static_cast( *instance ), reinterpret_cast( &createInfo ), - m_allocator, - reinterpret_cast( &m_debugUtilsMessengerEXT ) ) ); + reinterpret_cast( m_allocator ), + reinterpret_cast( &m_messenger ) ) ); if ( result != VULKAN_HPP_NAMESPACE::Result::eSuccess ) { throwResultException( result, "vkCreateDebugUtilsMessengerEXT" ); @@ -5685,12 +5578,11 @@ namespace VULKAN_HPP_NAMESPACE DebugUtilsMessengerEXT( VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::Instance const & instance, - VkDebugUtilsMessengerEXT debugUtilsMessengerEXT, + VkDebugUtilsMessengerEXT messenger, VULKAN_HPP_NAMESPACE::Optional allocator = nullptr ) - : m_instance( &instance ) - , m_debugUtilsMessengerEXT( debugUtilsMessengerEXT ) - , m_allocator( reinterpret_cast( - static_cast( allocator ) ) ) + : m_instance( *instance ) + , m_messenger( messenger ) + , m_allocator( static_cast( allocator ) ) , m_dispatcher( instance.getDispatcher() ) {} @@ -5698,22 +5590,21 @@ namespace VULKAN_HPP_NAMESPACE ~DebugUtilsMessengerEXT() { - if ( m_debugUtilsMessengerEXT ) + if ( m_messenger ) { getDispatcher()->vkDestroyDebugUtilsMessengerEXT( - static_cast( **m_instance ), - static_cast( m_debugUtilsMessengerEXT ), - m_allocator ); + static_cast( m_instance ), + static_cast( m_messenger ), + reinterpret_cast( m_allocator ) ); } } DebugUtilsMessengerEXT() = delete; DebugUtilsMessengerEXT( DebugUtilsMessengerEXT const & ) = delete; DebugUtilsMessengerEXT( DebugUtilsMessengerEXT && rhs ) VULKAN_HPP_NOEXCEPT - : m_instance( VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange( rhs.m_instance, nullptr ) ) - , m_debugUtilsMessengerEXT( - VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange( rhs.m_debugUtilsMessengerEXT, {} ) ) - , m_allocator( rhs.m_allocator ) + : m_instance( VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange( rhs.m_instance, {} ) ) + , m_messenger( VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange( rhs.m_messenger, {} ) ) + , m_allocator( VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange( rhs.m_allocator, {} ) ) , m_dispatcher( VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange( rhs.m_dispatcher, nullptr ) ) {} DebugUtilsMessengerEXT & operator=( DebugUtilsMessengerEXT const & ) = delete; @@ -5721,17 +5612,9 @@ namespace VULKAN_HPP_NAMESPACE { if ( this != &rhs ) { - if ( m_debugUtilsMessengerEXT ) - { - getDispatcher()->vkDestroyDebugUtilsMessengerEXT( - static_cast( **m_instance ), - static_cast( m_debugUtilsMessengerEXT ), - m_allocator ); - } - m_instance = VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange( rhs.m_instance, nullptr ); - m_debugUtilsMessengerEXT = - VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange( rhs.m_debugUtilsMessengerEXT, {} ); - m_allocator = rhs.m_allocator; + m_instance = VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange( rhs.m_instance, {} ); + m_messenger = VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange( rhs.m_messenger, {} ); + m_allocator = VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange( rhs.m_allocator, {} ); m_dispatcher = VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange( rhs.m_dispatcher, nullptr ); } return *this; @@ -5739,10 +5622,10 @@ namespace VULKAN_HPP_NAMESPACE VULKAN_HPP_NAMESPACE::DebugUtilsMessengerEXT const & operator*() const VULKAN_HPP_NOEXCEPT { - return m_debugUtilsMessengerEXT; + return m_messenger; } - VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::Instance const * getInstance() const VULKAN_HPP_NOEXCEPT + VULKAN_HPP_NAMESPACE::Instance getInstance() const { return m_instance; } @@ -5754,9 +5637,9 @@ namespace VULKAN_HPP_NAMESPACE } private: - VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::Instance const * m_instance = nullptr; - VULKAN_HPP_NAMESPACE::DebugUtilsMessengerEXT m_debugUtilsMessengerEXT; - const VkAllocationCallbacks * m_allocator = nullptr; + VULKAN_HPP_NAMESPACE::Instance m_instance = {}; + VULKAN_HPP_NAMESPACE::DebugUtilsMessengerEXT m_messenger = {}; + const VULKAN_HPP_NAMESPACE::AllocationCallbacks * m_allocator = nullptr; VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::InstanceDispatcher const * m_dispatcher = nullptr; }; @@ -5774,16 +5657,15 @@ namespace VULKAN_HPP_NAMESPACE DeferredOperationKHR( VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::Device const & device, VULKAN_HPP_NAMESPACE::Optional allocator = nullptr ) - : m_device( &device ) - , m_allocator( reinterpret_cast( - static_cast( allocator ) ) ) + : m_device( *device ) + , m_allocator( static_cast( allocator ) ) , m_dispatcher( device.getDispatcher() ) { VULKAN_HPP_NAMESPACE::Result result = static_cast( device.getDispatcher()->vkCreateDeferredOperationKHR( static_cast( *device ), - m_allocator, - reinterpret_cast( &m_deferredOperationKHR ) ) ); + reinterpret_cast( m_allocator ), + reinterpret_cast( &m_operation ) ) ); if ( result != VULKAN_HPP_NAMESPACE::Result::eSuccess ) { throwResultException( result, "vkCreateDeferredOperationKHR" ); @@ -5792,12 +5674,11 @@ namespace VULKAN_HPP_NAMESPACE DeferredOperationKHR( VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::Device const & device, - VkDeferredOperationKHR deferredOperationKHR, + VkDeferredOperationKHR operation, VULKAN_HPP_NAMESPACE::Optional allocator = nullptr ) - : m_device( &device ) - , m_deferredOperationKHR( deferredOperationKHR ) - , m_allocator( reinterpret_cast( - static_cast( allocator ) ) ) + : m_device( *device ) + , m_operation( operation ) + , m_allocator( static_cast( allocator ) ) , m_dispatcher( device.getDispatcher() ) {} @@ -5805,21 +5686,21 @@ namespace VULKAN_HPP_NAMESPACE ~DeferredOperationKHR() { - if ( m_deferredOperationKHR ) + if ( m_operation ) { - getDispatcher()->vkDestroyDeferredOperationKHR( static_cast( **m_device ), - static_cast( m_deferredOperationKHR ), - m_allocator ); + getDispatcher()->vkDestroyDeferredOperationKHR( + static_cast( m_device ), + static_cast( m_operation ), + reinterpret_cast( m_allocator ) ); } } DeferredOperationKHR() = delete; DeferredOperationKHR( DeferredOperationKHR const & ) = delete; DeferredOperationKHR( DeferredOperationKHR && rhs ) VULKAN_HPP_NOEXCEPT - : m_device( VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange( rhs.m_device, nullptr ) ) - , m_deferredOperationKHR( VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange( rhs.m_deferredOperationKHR, - {} ) ) - , m_allocator( rhs.m_allocator ) + : m_device( VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange( rhs.m_device, {} ) ) + , m_operation( VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange( rhs.m_operation, {} ) ) + , m_allocator( VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange( rhs.m_allocator, {} ) ) , m_dispatcher( VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange( rhs.m_dispatcher, nullptr ) ) {} DeferredOperationKHR & operator=( DeferredOperationKHR const & ) = delete; @@ -5827,17 +5708,9 @@ namespace VULKAN_HPP_NAMESPACE { if ( this != &rhs ) { - if ( m_deferredOperationKHR ) - { - getDispatcher()->vkDestroyDeferredOperationKHR( - static_cast( **m_device ), - static_cast( m_deferredOperationKHR ), - m_allocator ); - } - m_device = VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange( rhs.m_device, nullptr ); - m_deferredOperationKHR = - VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange( rhs.m_deferredOperationKHR, {} ); - m_allocator = rhs.m_allocator; + m_device = VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange( rhs.m_device, {} ); + m_operation = VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange( rhs.m_operation, {} ); + m_allocator = VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange( rhs.m_allocator, {} ); m_dispatcher = VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange( rhs.m_dispatcher, nullptr ); } return *this; @@ -5845,10 +5718,10 @@ namespace VULKAN_HPP_NAMESPACE VULKAN_HPP_NAMESPACE::DeferredOperationKHR const & operator*() const VULKAN_HPP_NOEXCEPT { - return m_deferredOperationKHR; + return m_operation; } - VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::Device const * getDevice() const VULKAN_HPP_NOEXCEPT + VULKAN_HPP_NAMESPACE::Device getDevice() const { return m_device; } @@ -5868,9 +5741,9 @@ namespace VULKAN_HPP_NAMESPACE VULKAN_HPP_NODISCARD VULKAN_HPP_NAMESPACE::Result join() const; private: - VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::Device const * m_device = nullptr; - VULKAN_HPP_NAMESPACE::DeferredOperationKHR m_deferredOperationKHR; - const VkAllocationCallbacks * m_allocator = nullptr; + VULKAN_HPP_NAMESPACE::Device m_device = {}; + VULKAN_HPP_NAMESPACE::DeferredOperationKHR m_operation = {}; + const VULKAN_HPP_NAMESPACE::AllocationCallbacks * m_allocator = nullptr; VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::DeviceDispatcher const * m_dispatcher = nullptr; }; @@ -5889,16 +5762,15 @@ namespace VULKAN_HPP_NAMESPACE VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::Device const & device, VULKAN_HPP_NAMESPACE::DescriptorPoolCreateInfo const & createInfo, VULKAN_HPP_NAMESPACE::Optional allocator = nullptr ) - : m_device( &device ) - , m_allocator( reinterpret_cast( - static_cast( allocator ) ) ) + : m_device( *device ) + , m_allocator( static_cast( allocator ) ) , m_dispatcher( device.getDispatcher() ) { VULKAN_HPP_NAMESPACE::Result result = static_cast( device.getDispatcher()->vkCreateDescriptorPool( static_cast( *device ), reinterpret_cast( &createInfo ), - m_allocator, + reinterpret_cast( m_allocator ), reinterpret_cast( &m_descriptorPool ) ) ); if ( result != VULKAN_HPP_NAMESPACE::Result::eSuccess ) { @@ -5910,10 +5782,9 @@ namespace VULKAN_HPP_NAMESPACE VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::Device const & device, VkDescriptorPool descriptorPool, VULKAN_HPP_NAMESPACE::Optional allocator = nullptr ) - : m_device( &device ) + : m_device( *device ) , m_descriptorPool( descriptorPool ) - , m_allocator( reinterpret_cast( - static_cast( allocator ) ) ) + , m_allocator( static_cast( allocator ) ) , m_dispatcher( device.getDispatcher() ) {} @@ -5923,17 +5794,18 @@ namespace VULKAN_HPP_NAMESPACE { if ( m_descriptorPool ) { - getDispatcher()->vkDestroyDescriptorPool( - static_cast( **m_device ), static_cast( m_descriptorPool ), m_allocator ); + getDispatcher()->vkDestroyDescriptorPool( static_cast( m_device ), + static_cast( m_descriptorPool ), + reinterpret_cast( m_allocator ) ); } } DescriptorPool() = delete; DescriptorPool( DescriptorPool const & ) = delete; DescriptorPool( DescriptorPool && rhs ) VULKAN_HPP_NOEXCEPT - : m_device( VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange( rhs.m_device, nullptr ) ) + : m_device( VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange( rhs.m_device, {} ) ) , m_descriptorPool( VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange( rhs.m_descriptorPool, {} ) ) - , m_allocator( rhs.m_allocator ) + , m_allocator( VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange( rhs.m_allocator, {} ) ) , m_dispatcher( VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange( rhs.m_dispatcher, nullptr ) ) {} DescriptorPool & operator=( DescriptorPool const & ) = delete; @@ -5941,14 +5813,9 @@ namespace VULKAN_HPP_NAMESPACE { if ( this != &rhs ) { - if ( m_descriptorPool ) - { - getDispatcher()->vkDestroyDescriptorPool( - static_cast( **m_device ), static_cast( m_descriptorPool ), m_allocator ); - } - m_device = VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange( rhs.m_device, nullptr ); + m_device = VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange( rhs.m_device, {} ); m_descriptorPool = VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange( rhs.m_descriptorPool, {} ); - m_allocator = rhs.m_allocator; + m_allocator = VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange( rhs.m_allocator, {} ); m_dispatcher = VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange( rhs.m_dispatcher, nullptr ); } return *this; @@ -5959,7 +5826,7 @@ namespace VULKAN_HPP_NAMESPACE return m_descriptorPool; } - VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::Device const * getDevice() const VULKAN_HPP_NOEXCEPT + VULKAN_HPP_NAMESPACE::Device getDevice() const { return m_device; } @@ -5976,10 +5843,10 @@ namespace VULKAN_HPP_NAMESPACE VULKAN_HPP_NOEXCEPT; private: - VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::Device const * m_device = nullptr; - VULKAN_HPP_NAMESPACE::DescriptorPool m_descriptorPool; - const VkAllocationCallbacks * m_allocator = nullptr; - VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::DeviceDispatcher const * m_dispatcher = nullptr; + VULKAN_HPP_NAMESPACE::Device m_device = {}; + VULKAN_HPP_NAMESPACE::DescriptorPool m_descriptorPool = {}; + const VULKAN_HPP_NAMESPACE::AllocationCallbacks * m_allocator = nullptr; + VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::DeviceDispatcher const * m_dispatcher = nullptr; }; class DescriptorSet @@ -5996,9 +5863,9 @@ namespace VULKAN_HPP_NAMESPACE DescriptorSet( VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::Device const & device, VkDescriptorSet descriptorSet, VkDescriptorPool descriptorPool ) - : m_device( &device ) - , m_descriptorSet( descriptorSet ) + : m_device( *device ) , m_descriptorPool( descriptorPool ) + , m_descriptorSet( descriptorSet ) , m_dispatcher( device.getDispatcher() ) {} @@ -6008,8 +5875,8 @@ namespace VULKAN_HPP_NAMESPACE { if ( m_descriptorSet ) { - getDispatcher()->vkFreeDescriptorSets( static_cast( **m_device ), - m_descriptorPool, + getDispatcher()->vkFreeDescriptorSets( static_cast( m_device ), + static_cast( m_descriptorPool ), 1, reinterpret_cast( &m_descriptorSet ) ); } @@ -6018,9 +5885,9 @@ namespace VULKAN_HPP_NAMESPACE DescriptorSet() = delete; DescriptorSet( DescriptorSet const & ) = delete; DescriptorSet( DescriptorSet && rhs ) VULKAN_HPP_NOEXCEPT - : m_device( VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange( rhs.m_device, nullptr ) ) + : m_device( VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange( rhs.m_device, {} ) ) + , m_descriptorPool( VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange( rhs.m_descriptorPool, {} ) ) , m_descriptorSet( VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange( rhs.m_descriptorSet, {} ) ) - , m_descriptorPool( rhs.m_descriptorPool ) , m_dispatcher( VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange( rhs.m_dispatcher, nullptr ) ) {} DescriptorSet & operator=( DescriptorSet const & ) = delete; @@ -6028,16 +5895,9 @@ namespace VULKAN_HPP_NAMESPACE { if ( this != &rhs ) { - if ( m_descriptorSet ) - { - getDispatcher()->vkFreeDescriptorSets( static_cast( **m_device ), - m_descriptorPool, - 1, - reinterpret_cast( &m_descriptorSet ) ); - } - m_device = VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange( rhs.m_device, nullptr ); + m_device = VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange( rhs.m_device, {} ); + m_descriptorPool = VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange( rhs.m_descriptorPool, {} ); m_descriptorSet = VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange( rhs.m_descriptorSet, {} ); - m_descriptorPool = rhs.m_descriptorPool; m_dispatcher = VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange( rhs.m_dispatcher, nullptr ); } return *this; @@ -6048,7 +5908,7 @@ namespace VULKAN_HPP_NAMESPACE return m_descriptorSet; } - VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::Device const * getDevice() const VULKAN_HPP_NOEXCEPT + VULKAN_HPP_NAMESPACE::Device getDevice() const { return m_device; } @@ -6070,10 +5930,10 @@ namespace VULKAN_HPP_NAMESPACE const void * pData ) const VULKAN_HPP_NOEXCEPT; private: - VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::Device const * m_device = nullptr; - VULKAN_HPP_NAMESPACE::DescriptorSet m_descriptorSet; - VkDescriptorPool m_descriptorPool; - VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::DeviceDispatcher const * m_dispatcher = nullptr; + VULKAN_HPP_NAMESPACE::Device m_device = {}; + VULKAN_HPP_NAMESPACE::DescriptorPool m_descriptorPool = {}; + VULKAN_HPP_NAMESPACE::DescriptorSet m_descriptorSet = {}; + VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::DeviceDispatcher const * m_dispatcher = nullptr; }; class DescriptorSets : public std::vector @@ -6124,16 +5984,15 @@ namespace VULKAN_HPP_NAMESPACE VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::Device const & device, VULKAN_HPP_NAMESPACE::DescriptorSetLayoutCreateInfo const & createInfo, VULKAN_HPP_NAMESPACE::Optional allocator = nullptr ) - : m_device( &device ) - , m_allocator( reinterpret_cast( - static_cast( allocator ) ) ) + : m_device( *device ) + , m_allocator( static_cast( allocator ) ) , m_dispatcher( device.getDispatcher() ) { VULKAN_HPP_NAMESPACE::Result result = static_cast( device.getDispatcher()->vkCreateDescriptorSetLayout( static_cast( *device ), reinterpret_cast( &createInfo ), - m_allocator, + reinterpret_cast( m_allocator ), reinterpret_cast( &m_descriptorSetLayout ) ) ); if ( result != VULKAN_HPP_NAMESPACE::Result::eSuccess ) { @@ -6145,10 +6004,9 @@ namespace VULKAN_HPP_NAMESPACE VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::Device const & device, VkDescriptorSetLayout descriptorSetLayout, VULKAN_HPP_NAMESPACE::Optional allocator = nullptr ) - : m_device( &device ) + : m_device( *device ) , m_descriptorSetLayout( descriptorSetLayout ) - , m_allocator( reinterpret_cast( - static_cast( allocator ) ) ) + , m_allocator( static_cast( allocator ) ) , m_dispatcher( device.getDispatcher() ) {} @@ -6158,19 +6016,20 @@ namespace VULKAN_HPP_NAMESPACE { if ( m_descriptorSetLayout ) { - getDispatcher()->vkDestroyDescriptorSetLayout( static_cast( **m_device ), - static_cast( m_descriptorSetLayout ), - m_allocator ); + getDispatcher()->vkDestroyDescriptorSetLayout( + static_cast( m_device ), + static_cast( m_descriptorSetLayout ), + reinterpret_cast( m_allocator ) ); } } DescriptorSetLayout() = delete; DescriptorSetLayout( DescriptorSetLayout const & ) = delete; DescriptorSetLayout( DescriptorSetLayout && rhs ) VULKAN_HPP_NOEXCEPT - : m_device( VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange( rhs.m_device, nullptr ) ) + : m_device( VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange( rhs.m_device, {} ) ) , m_descriptorSetLayout( VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange( rhs.m_descriptorSetLayout, {} ) ) - , m_allocator( rhs.m_allocator ) + , m_allocator( VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange( rhs.m_allocator, {} ) ) , m_dispatcher( VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange( rhs.m_dispatcher, nullptr ) ) {} DescriptorSetLayout & operator=( DescriptorSetLayout const & ) = delete; @@ -6178,16 +6037,10 @@ namespace VULKAN_HPP_NAMESPACE { if ( this != &rhs ) { - if ( m_descriptorSetLayout ) - { - getDispatcher()->vkDestroyDescriptorSetLayout( static_cast( **m_device ), - static_cast( m_descriptorSetLayout ), - m_allocator ); - } - m_device = VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange( rhs.m_device, nullptr ); + m_device = VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange( rhs.m_device, {} ); m_descriptorSetLayout = VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange( rhs.m_descriptorSetLayout, {} ); - m_allocator = rhs.m_allocator; + m_allocator = VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange( rhs.m_allocator, {} ); m_dispatcher = VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange( rhs.m_dispatcher, nullptr ); } return *this; @@ -6198,7 +6051,7 @@ namespace VULKAN_HPP_NAMESPACE return m_descriptorSetLayout; } - VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::Device const * getDevice() const VULKAN_HPP_NOEXCEPT + VULKAN_HPP_NAMESPACE::Device getDevice() const { return m_device; } @@ -6210,10 +6063,10 @@ namespace VULKAN_HPP_NAMESPACE } private: - VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::Device const * m_device = nullptr; - VULKAN_HPP_NAMESPACE::DescriptorSetLayout m_descriptorSetLayout; - const VkAllocationCallbacks * m_allocator = nullptr; - VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::DeviceDispatcher const * m_dispatcher = nullptr; + VULKAN_HPP_NAMESPACE::Device m_device = {}; + VULKAN_HPP_NAMESPACE::DescriptorSetLayout m_descriptorSetLayout = {}; + const VULKAN_HPP_NAMESPACE::AllocationCallbacks * m_allocator = nullptr; + VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::DeviceDispatcher const * m_dispatcher = nullptr; }; class DescriptorUpdateTemplate @@ -6231,16 +6084,15 @@ namespace VULKAN_HPP_NAMESPACE VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::Device const & device, VULKAN_HPP_NAMESPACE::DescriptorUpdateTemplateCreateInfo const & createInfo, VULKAN_HPP_NAMESPACE::Optional allocator = nullptr ) - : m_device( &device ) - , m_allocator( reinterpret_cast( - static_cast( allocator ) ) ) + : m_device( *device ) + , m_allocator( static_cast( allocator ) ) , m_dispatcher( device.getDispatcher() ) { VULKAN_HPP_NAMESPACE::Result result = static_cast( device.getDispatcher()->vkCreateDescriptorUpdateTemplate( static_cast( *device ), reinterpret_cast( &createInfo ), - m_allocator, + reinterpret_cast( m_allocator ), reinterpret_cast( &m_descriptorUpdateTemplate ) ) ); if ( result != VULKAN_HPP_NAMESPACE::Result::eSuccess ) { @@ -6252,10 +6104,9 @@ namespace VULKAN_HPP_NAMESPACE VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::Device const & device, VkDescriptorUpdateTemplate descriptorUpdateTemplate, VULKAN_HPP_NAMESPACE::Optional allocator = nullptr ) - : m_device( &device ) + : m_device( *device ) , m_descriptorUpdateTemplate( descriptorUpdateTemplate ) - , m_allocator( reinterpret_cast( - static_cast( allocator ) ) ) + , m_allocator( static_cast( allocator ) ) , m_dispatcher( device.getDispatcher() ) {} @@ -6266,19 +6117,19 @@ namespace VULKAN_HPP_NAMESPACE if ( m_descriptorUpdateTemplate ) { getDispatcher()->vkDestroyDescriptorUpdateTemplate( - static_cast( **m_device ), + static_cast( m_device ), static_cast( m_descriptorUpdateTemplate ), - m_allocator ); + reinterpret_cast( m_allocator ) ); } } DescriptorUpdateTemplate() = delete; DescriptorUpdateTemplate( DescriptorUpdateTemplate const & ) = delete; DescriptorUpdateTemplate( DescriptorUpdateTemplate && rhs ) VULKAN_HPP_NOEXCEPT - : m_device( VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange( rhs.m_device, nullptr ) ) + : m_device( VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange( rhs.m_device, {} ) ) , m_descriptorUpdateTemplate( VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange( rhs.m_descriptorUpdateTemplate, {} ) ) - , m_allocator( rhs.m_allocator ) + , m_allocator( VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange( rhs.m_allocator, {} ) ) , m_dispatcher( VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange( rhs.m_dispatcher, nullptr ) ) {} DescriptorUpdateTemplate & operator=( DescriptorUpdateTemplate const & ) = delete; @@ -6286,17 +6137,10 @@ namespace VULKAN_HPP_NAMESPACE { if ( this != &rhs ) { - if ( m_descriptorUpdateTemplate ) - { - getDispatcher()->vkDestroyDescriptorUpdateTemplate( - static_cast( **m_device ), - static_cast( m_descriptorUpdateTemplate ), - m_allocator ); - } - m_device = VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange( rhs.m_device, nullptr ); + m_device = VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange( rhs.m_device, {} ); m_descriptorUpdateTemplate = VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange( rhs.m_descriptorUpdateTemplate, {} ); - m_allocator = rhs.m_allocator; + m_allocator = VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange( rhs.m_allocator, {} ); m_dispatcher = VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange( rhs.m_dispatcher, nullptr ); } return *this; @@ -6307,7 +6151,7 @@ namespace VULKAN_HPP_NAMESPACE return m_descriptorUpdateTemplate; } - VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::Device const * getDevice() const VULKAN_HPP_NOEXCEPT + VULKAN_HPP_NAMESPACE::Device getDevice() const { return m_device; } @@ -6319,10 +6163,10 @@ namespace VULKAN_HPP_NAMESPACE } private: - VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::Device const * m_device = nullptr; - VULKAN_HPP_NAMESPACE::DescriptorUpdateTemplate m_descriptorUpdateTemplate; - const VkAllocationCallbacks * m_allocator = nullptr; - VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::DeviceDispatcher const * m_dispatcher = nullptr; + VULKAN_HPP_NAMESPACE::Device m_device = {}; + VULKAN_HPP_NAMESPACE::DescriptorUpdateTemplate m_descriptorUpdateTemplate = {}; + const VULKAN_HPP_NAMESPACE::AllocationCallbacks * m_allocator = nullptr; + VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::DeviceDispatcher const * m_dispatcher = nullptr; }; class DeviceMemory @@ -6340,16 +6184,15 @@ namespace VULKAN_HPP_NAMESPACE VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::Device const & device, VULKAN_HPP_NAMESPACE::MemoryAllocateInfo const & allocateInfo, VULKAN_HPP_NAMESPACE::Optional allocator = nullptr ) - : m_device( &device ) - , m_allocator( reinterpret_cast( - static_cast( allocator ) ) ) + : m_device( *device ) + , m_allocator( static_cast( allocator ) ) , m_dispatcher( device.getDispatcher() ) { VULKAN_HPP_NAMESPACE::Result result = static_cast( device.getDispatcher()->vkAllocateMemory( static_cast( *device ), reinterpret_cast( &allocateInfo ), - m_allocator, - reinterpret_cast( &m_deviceMemory ) ) ); + reinterpret_cast( m_allocator ), + reinterpret_cast( &m_memory ) ) ); if ( result != VULKAN_HPP_NAMESPACE::Result::eSuccess ) { throwResultException( result, "vkAllocateMemory" ); @@ -6358,12 +6201,11 @@ namespace VULKAN_HPP_NAMESPACE DeviceMemory( VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::Device const & device, - VkDeviceMemory deviceMemory, + VkDeviceMemory memory, VULKAN_HPP_NAMESPACE::Optional allocator = nullptr ) - : m_device( &device ) - , m_deviceMemory( deviceMemory ) - , m_allocator( reinterpret_cast( - static_cast( allocator ) ) ) + : m_device( *device ) + , m_memory( memory ) + , m_allocator( static_cast( allocator ) ) , m_dispatcher( device.getDispatcher() ) {} @@ -6371,19 +6213,20 @@ namespace VULKAN_HPP_NAMESPACE ~DeviceMemory() { - if ( m_deviceMemory ) + if ( m_memory ) { - getDispatcher()->vkFreeMemory( - static_cast( **m_device ), static_cast( m_deviceMemory ), m_allocator ); + getDispatcher()->vkFreeMemory( static_cast( m_device ), + static_cast( m_memory ), + reinterpret_cast( m_allocator ) ); } } DeviceMemory() = delete; DeviceMemory( DeviceMemory const & ) = delete; DeviceMemory( DeviceMemory && rhs ) VULKAN_HPP_NOEXCEPT - : m_device( VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange( rhs.m_device, nullptr ) ) - , m_deviceMemory( VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange( rhs.m_deviceMemory, {} ) ) - , m_allocator( rhs.m_allocator ) + : m_device( VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange( rhs.m_device, {} ) ) + , m_memory( VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange( rhs.m_memory, {} ) ) + , m_allocator( VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange( rhs.m_allocator, {} ) ) , m_dispatcher( VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange( rhs.m_dispatcher, nullptr ) ) {} DeviceMemory & operator=( DeviceMemory const & ) = delete; @@ -6391,25 +6234,20 @@ namespace VULKAN_HPP_NAMESPACE { if ( this != &rhs ) { - if ( m_deviceMemory ) - { - getDispatcher()->vkFreeMemory( - static_cast( **m_device ), static_cast( m_deviceMemory ), m_allocator ); - } - m_device = VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange( rhs.m_device, nullptr ); - m_deviceMemory = VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange( rhs.m_deviceMemory, {} ); - m_allocator = rhs.m_allocator; - m_dispatcher = VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange( rhs.m_dispatcher, nullptr ); + m_device = VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange( rhs.m_device, {} ); + m_memory = VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange( rhs.m_memory, {} ); + m_allocator = VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange( rhs.m_allocator, {} ); + m_dispatcher = VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange( rhs.m_dispatcher, nullptr ); } return *this; } VULKAN_HPP_NAMESPACE::DeviceMemory const & operator*() const VULKAN_HPP_NOEXCEPT { - return m_deviceMemory; + return m_memory; } - VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::Device const * getDevice() const VULKAN_HPP_NOEXCEPT + VULKAN_HPP_NAMESPACE::Device getDevice() const { return m_device; } @@ -6443,9 +6281,9 @@ namespace VULKAN_HPP_NAMESPACE void setPriorityEXT( float priority ) const VULKAN_HPP_NOEXCEPT; private: - VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::Device const * m_device = nullptr; - VULKAN_HPP_NAMESPACE::DeviceMemory m_deviceMemory; - const VkAllocationCallbacks * m_allocator = nullptr; + VULKAN_HPP_NAMESPACE::Device m_device = {}; + VULKAN_HPP_NAMESPACE::DeviceMemory m_memory = {}; + const VULKAN_HPP_NAMESPACE::AllocationCallbacks * m_allocator = nullptr; VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::DeviceDispatcher const * m_dispatcher = nullptr; }; @@ -6463,13 +6301,13 @@ namespace VULKAN_HPP_NAMESPACE DisplayKHR( VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::PhysicalDevice const & physicalDevice, int32_t drmFd, uint32_t connectorId ) - : m_physicalDevice( &physicalDevice ), m_dispatcher( physicalDevice.getDispatcher() ) + : m_physicalDevice( *physicalDevice ), m_dispatcher( physicalDevice.getDispatcher() ) { VULKAN_HPP_NAMESPACE::Result result = static_cast( physicalDevice.getDispatcher()->vkGetDrmDisplayEXT( static_cast( *physicalDevice ), drmFd, connectorId, - reinterpret_cast( &m_displayKHR ) ) ); + reinterpret_cast( &m_display ) ) ); if ( result != VULKAN_HPP_NAMESPACE::Result::eSuccess ) { throwResultException( result, "vkGetDrmDisplayEXT" ); @@ -6480,14 +6318,14 @@ namespace VULKAN_HPP_NAMESPACE DisplayKHR( VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::PhysicalDevice const & physicalDevice, Display & dpy, RROutput rrOutput ) - : m_physicalDevice( &physicalDevice ), m_dispatcher( physicalDevice.getDispatcher() ) + : m_physicalDevice( *physicalDevice ), m_dispatcher( physicalDevice.getDispatcher() ) { VULKAN_HPP_NAMESPACE::Result result = static_cast( physicalDevice.getDispatcher()->vkGetRandROutputDisplayEXT( static_cast( *physicalDevice ), &dpy, rrOutput, - reinterpret_cast( &m_displayKHR ) ) ); + reinterpret_cast( &m_display ) ) ); if ( result != VULKAN_HPP_NAMESPACE::Result::eSuccess ) { throwResultException( result, "vkGetRandROutputDisplayEXT" ); @@ -6498,12 +6336,12 @@ namespace VULKAN_HPP_NAMESPACE # if defined( VK_USE_PLATFORM_WIN32_KHR ) DisplayKHR( VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::PhysicalDevice const & physicalDevice, uint32_t deviceRelativeId ) - : m_physicalDevice( &physicalDevice ), m_dispatcher( physicalDevice.getDispatcher() ) + : m_physicalDevice( *physicalDevice ), m_dispatcher( physicalDevice.getDispatcher() ) { VULKAN_HPP_NAMESPACE::Result result = static_cast( physicalDevice.getDispatcher()->vkGetWinrtDisplayNV( static_cast( *physicalDevice ), deviceRelativeId, - reinterpret_cast( &m_displayKHR ) ) ); + reinterpret_cast( &m_display ) ) ); if ( result != VULKAN_HPP_NAMESPACE::Result::eSuccess ) { throwResultException( result, "vkGetWinrtDisplayNV" ); @@ -6512,28 +6350,26 @@ namespace VULKAN_HPP_NAMESPACE # endif /*VK_USE_PLATFORM_WIN32_KHR*/ DisplayKHR( VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::PhysicalDevice const & physicalDevice, - VkDisplayKHR displayKHR ) - : m_physicalDevice( &physicalDevice ) - , m_displayKHR( displayKHR ) - , m_dispatcher( physicalDevice.getDispatcher() ) + VkDisplayKHR display ) + : m_physicalDevice( *physicalDevice ), m_display( display ), m_dispatcher( physicalDevice.getDispatcher() ) {} DisplayKHR( std::nullptr_t ) {} ~DisplayKHR() { - if ( m_displayKHR ) + if ( m_display ) { - getDispatcher()->vkReleaseDisplayEXT( static_cast( **m_physicalDevice ), - static_cast( m_displayKHR ) ); + getDispatcher()->vkReleaseDisplayEXT( static_cast( m_physicalDevice ), + static_cast( m_display ) ); } } DisplayKHR() = delete; DisplayKHR( DisplayKHR const & ) = delete; DisplayKHR( DisplayKHR && rhs ) VULKAN_HPP_NOEXCEPT - : m_physicalDevice( VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange( rhs.m_physicalDevice, nullptr ) ) - , m_displayKHR( VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange( rhs.m_displayKHR, {} ) ) + : m_physicalDevice( VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange( rhs.m_physicalDevice, {} ) ) + , m_display( VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange( rhs.m_display, {} ) ) , m_dispatcher( VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange( rhs.m_dispatcher, nullptr ) ) {} DisplayKHR & operator=( DisplayKHR const & ) = delete; @@ -6541,13 +6377,8 @@ namespace VULKAN_HPP_NAMESPACE { if ( this != &rhs ) { - if ( m_displayKHR ) - { - getDispatcher()->vkReleaseDisplayEXT( static_cast( **m_physicalDevice ), - static_cast( m_displayKHR ) ); - } - m_physicalDevice = VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange( rhs.m_physicalDevice, nullptr ); - m_displayKHR = VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange( rhs.m_displayKHR, {} ); + m_physicalDevice = VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange( rhs.m_physicalDevice, {} ); + m_display = VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange( rhs.m_display, {} ); m_dispatcher = VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange( rhs.m_dispatcher, nullptr ); } return *this; @@ -6555,11 +6386,10 @@ namespace VULKAN_HPP_NAMESPACE VULKAN_HPP_NAMESPACE::DisplayKHR const & operator*() const VULKAN_HPP_NOEXCEPT { - return m_displayKHR; + return m_display; } - VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::PhysicalDevice const * - getPhysicalDevice() const VULKAN_HPP_NOEXCEPT + VULKAN_HPP_NAMESPACE::PhysicalDevice getPhysicalDevice() const { return m_physicalDevice; } @@ -6589,9 +6419,9 @@ namespace VULKAN_HPP_NAMESPACE # endif /*VK_USE_PLATFORM_WIN32_KHR*/ private: - VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::PhysicalDevice const * m_physicalDevice = nullptr; - VULKAN_HPP_NAMESPACE::DisplayKHR m_displayKHR; - VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::InstanceDispatcher const * m_dispatcher = nullptr; + VULKAN_HPP_NAMESPACE::PhysicalDevice m_physicalDevice = {}; + VULKAN_HPP_NAMESPACE::DisplayKHR m_display = {}; + VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::InstanceDispatcher const * m_dispatcher = nullptr; }; class DisplayKHRs : public std::vector @@ -6653,11 +6483,11 @@ namespace VULKAN_HPP_NAMESPACE VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::DisplayKHR const & display, VULKAN_HPP_NAMESPACE::DisplayModeCreateInfoKHR const & createInfo, VULKAN_HPP_NAMESPACE::Optional allocator = nullptr ) - : m_display( &display ), m_dispatcher( display.getDispatcher() ) + : m_physicalDevice( display.getPhysicalDevice() ), m_dispatcher( display.getDispatcher() ) { VULKAN_HPP_NAMESPACE::Result result = static_cast( display.getDispatcher()->vkCreateDisplayModeKHR( - static_cast( **display.getPhysicalDevice() ), + static_cast( display.getPhysicalDevice() ), static_cast( *display ), reinterpret_cast( &createInfo ), reinterpret_cast( @@ -6671,7 +6501,9 @@ namespace VULKAN_HPP_NAMESPACE DisplayModeKHR( VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::DisplayKHR const & display, VkDisplayModeKHR displayModeKHR ) - : m_display( &display ), m_displayModeKHR( displayModeKHR ), m_dispatcher( display.getDispatcher() ) + : m_physicalDevice( display.getPhysicalDevice() ) + , m_displayModeKHR( displayModeKHR ) + , m_dispatcher( display.getDispatcher() ) {} DisplayModeKHR( std::nullptr_t ) {} @@ -6679,7 +6511,7 @@ namespace VULKAN_HPP_NAMESPACE DisplayModeKHR() = delete; DisplayModeKHR( DisplayModeKHR const & ) = delete; DisplayModeKHR( DisplayModeKHR && rhs ) VULKAN_HPP_NOEXCEPT - : m_display( VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange( rhs.m_display, nullptr ) ) + : m_physicalDevice( VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange( rhs.m_physicalDevice, {} ) ) , m_displayModeKHR( VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange( rhs.m_displayModeKHR, {} ) ) , m_dispatcher( VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange( rhs.m_dispatcher, nullptr ) ) {} @@ -6688,7 +6520,7 @@ namespace VULKAN_HPP_NAMESPACE { if ( this != &rhs ) { - m_display = VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange( rhs.m_display, nullptr ); + m_physicalDevice = VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange( rhs.m_physicalDevice, {} ); m_displayModeKHR = VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange( rhs.m_displayModeKHR, {} ); m_dispatcher = VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange( rhs.m_dispatcher, nullptr ); } @@ -6700,11 +6532,6 @@ namespace VULKAN_HPP_NAMESPACE return m_displayModeKHR; } - VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::DisplayKHR const * getDisplayKHR() const VULKAN_HPP_NOEXCEPT - { - return m_display; - } - VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::InstanceDispatcher const * getDispatcher() const { VULKAN_HPP_ASSERT( m_dispatcher->getVkHeaderVersion() == VK_HEADER_VERSION ); @@ -6717,9 +6544,9 @@ namespace VULKAN_HPP_NAMESPACE getDisplayPlaneCapabilities( uint32_t planeIndex ) const; private: - VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::DisplayKHR const * m_display = nullptr; - VULKAN_HPP_NAMESPACE::DisplayModeKHR m_displayModeKHR; - VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::InstanceDispatcher const * m_dispatcher = nullptr; + VULKAN_HPP_NAMESPACE::PhysicalDevice m_physicalDevice = {}; + VULKAN_HPP_NAMESPACE::DisplayModeKHR m_displayModeKHR = {}; + VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::InstanceDispatcher const * m_dispatcher = nullptr; }; class Event @@ -6736,15 +6563,14 @@ namespace VULKAN_HPP_NAMESPACE Event( VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::Device const & device, VULKAN_HPP_NAMESPACE::EventCreateInfo const & createInfo, VULKAN_HPP_NAMESPACE::Optional allocator = nullptr ) - : m_device( &device ) - , m_allocator( reinterpret_cast( - static_cast( allocator ) ) ) + : m_device( *device ) + , m_allocator( static_cast( allocator ) ) , m_dispatcher( device.getDispatcher() ) { VULKAN_HPP_NAMESPACE::Result result = static_cast( device.getDispatcher()->vkCreateEvent( static_cast( *device ), reinterpret_cast( &createInfo ), - m_allocator, + reinterpret_cast( m_allocator ), reinterpret_cast( &m_event ) ) ); if ( result != VULKAN_HPP_NAMESPACE::Result::eSuccess ) { @@ -6755,10 +6581,9 @@ namespace VULKAN_HPP_NAMESPACE Event( VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::Device const & device, VkEvent event, VULKAN_HPP_NAMESPACE::Optional allocator = nullptr ) - : m_device( &device ) + : m_device( *device ) , m_event( event ) - , m_allocator( reinterpret_cast( - static_cast( allocator ) ) ) + , m_allocator( static_cast( allocator ) ) , m_dispatcher( device.getDispatcher() ) {} @@ -6768,17 +6593,18 @@ namespace VULKAN_HPP_NAMESPACE { if ( m_event ) { - getDispatcher()->vkDestroyEvent( - static_cast( **m_device ), static_cast( m_event ), m_allocator ); + getDispatcher()->vkDestroyEvent( static_cast( m_device ), + static_cast( m_event ), + reinterpret_cast( m_allocator ) ); } } Event() = delete; Event( Event const & ) = delete; Event( Event && rhs ) VULKAN_HPP_NOEXCEPT - : m_device( VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange( rhs.m_device, nullptr ) ) + : m_device( VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange( rhs.m_device, {} ) ) , m_event( VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange( rhs.m_event, {} ) ) - , m_allocator( rhs.m_allocator ) + , m_allocator( VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange( rhs.m_allocator, {} ) ) , m_dispatcher( VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange( rhs.m_dispatcher, nullptr ) ) {} Event & operator=( Event const & ) = delete; @@ -6786,14 +6612,9 @@ namespace VULKAN_HPP_NAMESPACE { if ( this != &rhs ) { - if ( m_event ) - { - getDispatcher()->vkDestroyEvent( - static_cast( **m_device ), static_cast( m_event ), m_allocator ); - } - m_device = VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange( rhs.m_device, nullptr ); + m_device = VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange( rhs.m_device, {} ); m_event = VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange( rhs.m_event, {} ); - m_allocator = rhs.m_allocator; + m_allocator = VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange( rhs.m_allocator, {} ); m_dispatcher = VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange( rhs.m_dispatcher, nullptr ); } return *this; @@ -6804,7 +6625,7 @@ namespace VULKAN_HPP_NAMESPACE return m_event; } - VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::Device const * getDevice() const VULKAN_HPP_NOEXCEPT + VULKAN_HPP_NAMESPACE::Device getDevice() const { return m_device; } @@ -6824,9 +6645,9 @@ namespace VULKAN_HPP_NAMESPACE void reset() const; private: - VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::Device const * m_device = nullptr; - VULKAN_HPP_NAMESPACE::Event m_event; - const VkAllocationCallbacks * m_allocator = nullptr; + VULKAN_HPP_NAMESPACE::Device m_device = {}; + VULKAN_HPP_NAMESPACE::Event m_event = {}; + const VULKAN_HPP_NAMESPACE::AllocationCallbacks * m_allocator = nullptr; VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::DeviceDispatcher const * m_dispatcher = nullptr; }; @@ -6844,15 +6665,14 @@ namespace VULKAN_HPP_NAMESPACE Fence( VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::Device const & device, VULKAN_HPP_NAMESPACE::FenceCreateInfo const & createInfo, VULKAN_HPP_NAMESPACE::Optional allocator = nullptr ) - : m_device( &device ) - , m_allocator( reinterpret_cast( - static_cast( allocator ) ) ) + : m_device( *device ) + , m_allocator( static_cast( allocator ) ) , m_dispatcher( device.getDispatcher() ) { VULKAN_HPP_NAMESPACE::Result result = static_cast( device.getDispatcher()->vkCreateFence( static_cast( *device ), reinterpret_cast( &createInfo ), - m_allocator, + reinterpret_cast( m_allocator ), reinterpret_cast( &m_fence ) ) ); if ( result != VULKAN_HPP_NAMESPACE::Result::eSuccess ) { @@ -6863,16 +6683,15 @@ namespace VULKAN_HPP_NAMESPACE Fence( VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::Device const & device, VULKAN_HPP_NAMESPACE::DeviceEventInfoEXT const & deviceEventInfo, VULKAN_HPP_NAMESPACE::Optional allocator = nullptr ) - : m_device( &device ) - , m_allocator( reinterpret_cast( - static_cast( allocator ) ) ) + : m_device( *device ) + , m_allocator( static_cast( allocator ) ) , m_dispatcher( device.getDispatcher() ) { VULKAN_HPP_NAMESPACE::Result result = static_cast( device.getDispatcher()->vkRegisterDeviceEventEXT( static_cast( *device ), reinterpret_cast( &deviceEventInfo ), - m_allocator, + reinterpret_cast( m_allocator ), reinterpret_cast( &m_fence ) ) ); if ( result != VULKAN_HPP_NAMESPACE::Result::eSuccess ) { @@ -6884,9 +6703,8 @@ namespace VULKAN_HPP_NAMESPACE VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::DisplayKHR const & display, VULKAN_HPP_NAMESPACE::DisplayEventInfoEXT const & displayEventInfo, VULKAN_HPP_NAMESPACE::Optional allocator = nullptr ) - : m_device( &device ) - , m_allocator( reinterpret_cast( - static_cast( allocator ) ) ) + : m_device( *device ) + , m_allocator( static_cast( allocator ) ) , m_dispatcher( device.getDispatcher() ) { VULKAN_HPP_NAMESPACE::Result result = @@ -6894,7 +6712,7 @@ namespace VULKAN_HPP_NAMESPACE static_cast( *device ), static_cast( *display ), reinterpret_cast( &displayEventInfo ), - m_allocator, + reinterpret_cast( m_allocator ), reinterpret_cast( &m_fence ) ) ); if ( result != VULKAN_HPP_NAMESPACE::Result::eSuccess ) { @@ -6905,10 +6723,9 @@ namespace VULKAN_HPP_NAMESPACE Fence( VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::Device const & device, VkFence fence, VULKAN_HPP_NAMESPACE::Optional allocator = nullptr ) - : m_device( &device ) + : m_device( *device ) , m_fence( fence ) - , m_allocator( reinterpret_cast( - static_cast( allocator ) ) ) + , m_allocator( static_cast( allocator ) ) , m_dispatcher( device.getDispatcher() ) {} @@ -6918,17 +6735,18 @@ namespace VULKAN_HPP_NAMESPACE { if ( m_fence ) { - getDispatcher()->vkDestroyFence( - static_cast( **m_device ), static_cast( m_fence ), m_allocator ); + getDispatcher()->vkDestroyFence( static_cast( m_device ), + static_cast( m_fence ), + reinterpret_cast( m_allocator ) ); } } Fence() = delete; Fence( Fence const & ) = delete; Fence( Fence && rhs ) VULKAN_HPP_NOEXCEPT - : m_device( VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange( rhs.m_device, nullptr ) ) + : m_device( VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange( rhs.m_device, {} ) ) , m_fence( VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange( rhs.m_fence, {} ) ) - , m_allocator( rhs.m_allocator ) + , m_allocator( VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange( rhs.m_allocator, {} ) ) , m_dispatcher( VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange( rhs.m_dispatcher, nullptr ) ) {} Fence & operator=( Fence const & ) = delete; @@ -6936,14 +6754,9 @@ namespace VULKAN_HPP_NAMESPACE { if ( this != &rhs ) { - if ( m_fence ) - { - getDispatcher()->vkDestroyFence( - static_cast( **m_device ), static_cast( m_fence ), m_allocator ); - } - m_device = VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange( rhs.m_device, nullptr ); + m_device = VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange( rhs.m_device, {} ); m_fence = VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange( rhs.m_fence, {} ); - m_allocator = rhs.m_allocator; + m_allocator = VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange( rhs.m_allocator, {} ); m_dispatcher = VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange( rhs.m_dispatcher, nullptr ); } return *this; @@ -6954,7 +6767,7 @@ namespace VULKAN_HPP_NAMESPACE return m_fence; } - VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::Device const * getDevice() const VULKAN_HPP_NOEXCEPT + VULKAN_HPP_NAMESPACE::Device getDevice() const { return m_device; } @@ -6970,9 +6783,9 @@ namespace VULKAN_HPP_NAMESPACE VULKAN_HPP_NODISCARD VULKAN_HPP_NAMESPACE::Result getStatus() const; private: - VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::Device const * m_device = nullptr; - VULKAN_HPP_NAMESPACE::Fence m_fence; - const VkAllocationCallbacks * m_allocator = nullptr; + VULKAN_HPP_NAMESPACE::Device m_device = {}; + VULKAN_HPP_NAMESPACE::Fence m_fence = {}; + const VULKAN_HPP_NAMESPACE::AllocationCallbacks * m_allocator = nullptr; VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::DeviceDispatcher const * m_dispatcher = nullptr; }; @@ -6990,15 +6803,14 @@ namespace VULKAN_HPP_NAMESPACE Framebuffer( VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::Device const & device, VULKAN_HPP_NAMESPACE::FramebufferCreateInfo const & createInfo, VULKAN_HPP_NAMESPACE::Optional allocator = nullptr ) - : m_device( &device ) - , m_allocator( reinterpret_cast( - static_cast( allocator ) ) ) + : m_device( *device ) + , m_allocator( static_cast( allocator ) ) , m_dispatcher( device.getDispatcher() ) { VULKAN_HPP_NAMESPACE::Result result = static_cast( device.getDispatcher()->vkCreateFramebuffer( static_cast( *device ), reinterpret_cast( &createInfo ), - m_allocator, + reinterpret_cast( m_allocator ), reinterpret_cast( &m_framebuffer ) ) ); if ( result != VULKAN_HPP_NAMESPACE::Result::eSuccess ) { @@ -7009,10 +6821,9 @@ namespace VULKAN_HPP_NAMESPACE Framebuffer( VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::Device const & device, VkFramebuffer framebuffer, VULKAN_HPP_NAMESPACE::Optional allocator = nullptr ) - : m_device( &device ) + : m_device( *device ) , m_framebuffer( framebuffer ) - , m_allocator( reinterpret_cast( - static_cast( allocator ) ) ) + , m_allocator( static_cast( allocator ) ) , m_dispatcher( device.getDispatcher() ) {} @@ -7022,17 +6833,18 @@ namespace VULKAN_HPP_NAMESPACE { if ( m_framebuffer ) { - getDispatcher()->vkDestroyFramebuffer( - static_cast( **m_device ), static_cast( m_framebuffer ), m_allocator ); + getDispatcher()->vkDestroyFramebuffer( static_cast( m_device ), + static_cast( m_framebuffer ), + reinterpret_cast( m_allocator ) ); } } Framebuffer() = delete; Framebuffer( Framebuffer const & ) = delete; Framebuffer( Framebuffer && rhs ) VULKAN_HPP_NOEXCEPT - : m_device( VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange( rhs.m_device, nullptr ) ) + : m_device( VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange( rhs.m_device, {} ) ) , m_framebuffer( VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange( rhs.m_framebuffer, {} ) ) - , m_allocator( rhs.m_allocator ) + , m_allocator( VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange( rhs.m_allocator, {} ) ) , m_dispatcher( VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange( rhs.m_dispatcher, nullptr ) ) {} Framebuffer & operator=( Framebuffer const & ) = delete; @@ -7040,14 +6852,9 @@ namespace VULKAN_HPP_NAMESPACE { if ( this != &rhs ) { - if ( m_framebuffer ) - { - getDispatcher()->vkDestroyFramebuffer( - static_cast( **m_device ), static_cast( m_framebuffer ), m_allocator ); - } - m_device = VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange( rhs.m_device, nullptr ); + m_device = VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange( rhs.m_device, {} ); m_framebuffer = VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange( rhs.m_framebuffer, {} ); - m_allocator = rhs.m_allocator; + m_allocator = VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange( rhs.m_allocator, {} ); m_dispatcher = VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange( rhs.m_dispatcher, nullptr ); } return *this; @@ -7058,7 +6865,7 @@ namespace VULKAN_HPP_NAMESPACE return m_framebuffer; } - VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::Device const * getDevice() const VULKAN_HPP_NOEXCEPT + VULKAN_HPP_NAMESPACE::Device getDevice() const { return m_device; } @@ -7070,10 +6877,10 @@ namespace VULKAN_HPP_NAMESPACE } private: - VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::Device const * m_device = nullptr; - VULKAN_HPP_NAMESPACE::Framebuffer m_framebuffer; - const VkAllocationCallbacks * m_allocator = nullptr; - VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::DeviceDispatcher const * m_dispatcher = nullptr; + VULKAN_HPP_NAMESPACE::Device m_device = {}; + VULKAN_HPP_NAMESPACE::Framebuffer m_framebuffer = {}; + const VULKAN_HPP_NAMESPACE::AllocationCallbacks * m_allocator = nullptr; + VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::DeviceDispatcher const * m_dispatcher = nullptr; }; class Image @@ -7090,15 +6897,14 @@ namespace VULKAN_HPP_NAMESPACE Image( VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::Device const & device, VULKAN_HPP_NAMESPACE::ImageCreateInfo const & createInfo, VULKAN_HPP_NAMESPACE::Optional allocator = nullptr ) - : m_device( &device ) - , m_allocator( reinterpret_cast( - static_cast( allocator ) ) ) + : m_device( *device ) + , m_allocator( static_cast( allocator ) ) , m_dispatcher( device.getDispatcher() ) { VULKAN_HPP_NAMESPACE::Result result = static_cast( device.getDispatcher()->vkCreateImage( static_cast( *device ), reinterpret_cast( &createInfo ), - m_allocator, + reinterpret_cast( m_allocator ), reinterpret_cast( &m_image ) ) ); if ( result != VULKAN_HPP_NAMESPACE::Result::eSuccess ) { @@ -7109,10 +6915,9 @@ namespace VULKAN_HPP_NAMESPACE Image( VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::Device const & device, VkImage image, VULKAN_HPP_NAMESPACE::Optional allocator = nullptr ) - : m_device( &device ) + : m_device( *device ) , m_image( image ) - , m_allocator( reinterpret_cast( - static_cast( allocator ) ) ) + , m_allocator( static_cast( allocator ) ) , m_dispatcher( device.getDispatcher() ) {} @@ -7122,17 +6927,18 @@ namespace VULKAN_HPP_NAMESPACE { if ( m_image ) { - getDispatcher()->vkDestroyImage( - static_cast( **m_device ), static_cast( m_image ), m_allocator ); + getDispatcher()->vkDestroyImage( static_cast( m_device ), + static_cast( m_image ), + reinterpret_cast( m_allocator ) ); } } Image() = delete; Image( Image const & ) = delete; Image( Image && rhs ) VULKAN_HPP_NOEXCEPT - : m_device( VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange( rhs.m_device, nullptr ) ) + : m_device( VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange( rhs.m_device, {} ) ) , m_image( VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange( rhs.m_image, {} ) ) - , m_allocator( rhs.m_allocator ) + , m_allocator( VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange( rhs.m_allocator, {} ) ) , m_dispatcher( VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange( rhs.m_dispatcher, nullptr ) ) {} Image & operator=( Image const & ) = delete; @@ -7140,14 +6946,9 @@ namespace VULKAN_HPP_NAMESPACE { if ( this != &rhs ) { - if ( m_image ) - { - getDispatcher()->vkDestroyImage( - static_cast( **m_device ), static_cast( m_image ), m_allocator ); - } - m_device = VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange( rhs.m_device, nullptr ); + m_device = VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange( rhs.m_device, {} ); m_image = VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange( rhs.m_image, {} ); - m_allocator = rhs.m_allocator; + m_allocator = VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange( rhs.m_allocator, {} ); m_dispatcher = VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange( rhs.m_dispatcher, nullptr ); } return *this; @@ -7158,7 +6959,7 @@ namespace VULKAN_HPP_NAMESPACE return m_image; } - VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::Device const * getDevice() const VULKAN_HPP_NOEXCEPT + VULKAN_HPP_NAMESPACE::Device getDevice() const { return m_device; } @@ -7187,9 +6988,9 @@ namespace VULKAN_HPP_NAMESPACE getDrmFormatModifierPropertiesEXT() const; private: - VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::Device const * m_device = nullptr; - VULKAN_HPP_NAMESPACE::Image m_image; - const VkAllocationCallbacks * m_allocator = nullptr; + VULKAN_HPP_NAMESPACE::Device m_device = {}; + VULKAN_HPP_NAMESPACE::Image m_image = {}; + const VULKAN_HPP_NAMESPACE::AllocationCallbacks * m_allocator = nullptr; VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::DeviceDispatcher const * m_dispatcher = nullptr; }; @@ -7207,15 +7008,14 @@ namespace VULKAN_HPP_NAMESPACE ImageView( VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::Device const & device, VULKAN_HPP_NAMESPACE::ImageViewCreateInfo const & createInfo, VULKAN_HPP_NAMESPACE::Optional allocator = nullptr ) - : m_device( &device ) - , m_allocator( reinterpret_cast( - static_cast( allocator ) ) ) + : m_device( *device ) + , m_allocator( static_cast( allocator ) ) , m_dispatcher( device.getDispatcher() ) { VULKAN_HPP_NAMESPACE::Result result = static_cast( device.getDispatcher()->vkCreateImageView( static_cast( *device ), reinterpret_cast( &createInfo ), - m_allocator, + reinterpret_cast( m_allocator ), reinterpret_cast( &m_imageView ) ) ); if ( result != VULKAN_HPP_NAMESPACE::Result::eSuccess ) { @@ -7226,10 +7026,9 @@ namespace VULKAN_HPP_NAMESPACE ImageView( VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::Device const & device, VkImageView imageView, VULKAN_HPP_NAMESPACE::Optional allocator = nullptr ) - : m_device( &device ) + : m_device( *device ) , m_imageView( imageView ) - , m_allocator( reinterpret_cast( - static_cast( allocator ) ) ) + , m_allocator( static_cast( allocator ) ) , m_dispatcher( device.getDispatcher() ) {} @@ -7239,17 +7038,18 @@ namespace VULKAN_HPP_NAMESPACE { if ( m_imageView ) { - getDispatcher()->vkDestroyImageView( - static_cast( **m_device ), static_cast( m_imageView ), m_allocator ); + getDispatcher()->vkDestroyImageView( static_cast( m_device ), + static_cast( m_imageView ), + reinterpret_cast( m_allocator ) ); } } ImageView() = delete; ImageView( ImageView const & ) = delete; ImageView( ImageView && rhs ) VULKAN_HPP_NOEXCEPT - : m_device( VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange( rhs.m_device, nullptr ) ) + : m_device( VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange( rhs.m_device, {} ) ) , m_imageView( VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange( rhs.m_imageView, {} ) ) - , m_allocator( rhs.m_allocator ) + , m_allocator( VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange( rhs.m_allocator, {} ) ) , m_dispatcher( VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange( rhs.m_dispatcher, nullptr ) ) {} ImageView & operator=( ImageView const & ) = delete; @@ -7257,14 +7057,9 @@ namespace VULKAN_HPP_NAMESPACE { if ( this != &rhs ) { - if ( m_imageView ) - { - getDispatcher()->vkDestroyImageView( - static_cast( **m_device ), static_cast( m_imageView ), m_allocator ); - } - m_device = VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange( rhs.m_device, nullptr ); + m_device = VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange( rhs.m_device, {} ); m_imageView = VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange( rhs.m_imageView, {} ); - m_allocator = rhs.m_allocator; + m_allocator = VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange( rhs.m_allocator, {} ); m_dispatcher = VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange( rhs.m_dispatcher, nullptr ); } return *this; @@ -7275,7 +7070,7 @@ namespace VULKAN_HPP_NAMESPACE return m_imageView; } - VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::Device const * getDevice() const VULKAN_HPP_NOEXCEPT + VULKAN_HPP_NAMESPACE::Device getDevice() const { return m_device; } @@ -7291,9 +7086,9 @@ namespace VULKAN_HPP_NAMESPACE VULKAN_HPP_NODISCARD VULKAN_HPP_NAMESPACE::ImageViewAddressPropertiesNVX getAddressNVX() const; private: - VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::Device const * m_device = nullptr; - VULKAN_HPP_NAMESPACE::ImageView m_imageView; - const VkAllocationCallbacks * m_allocator = nullptr; + VULKAN_HPP_NAMESPACE::Device m_device = {}; + VULKAN_HPP_NAMESPACE::ImageView m_imageView = {}; + const VULKAN_HPP_NAMESPACE::AllocationCallbacks * m_allocator = nullptr; VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::DeviceDispatcher const * m_dispatcher = nullptr; }; @@ -7312,17 +7107,16 @@ namespace VULKAN_HPP_NAMESPACE VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::Device const & device, VULKAN_HPP_NAMESPACE::IndirectCommandsLayoutCreateInfoNV const & createInfo, VULKAN_HPP_NAMESPACE::Optional allocator = nullptr ) - : m_device( &device ) - , m_allocator( reinterpret_cast( - static_cast( allocator ) ) ) + : m_device( *device ) + , m_allocator( static_cast( allocator ) ) , m_dispatcher( device.getDispatcher() ) { VULKAN_HPP_NAMESPACE::Result result = static_cast( device.getDispatcher()->vkCreateIndirectCommandsLayoutNV( static_cast( *device ), reinterpret_cast( &createInfo ), - m_allocator, - reinterpret_cast( &m_indirectCommandsLayoutNV ) ) ); + reinterpret_cast( m_allocator ), + reinterpret_cast( &m_indirectCommandsLayout ) ) ); if ( result != VULKAN_HPP_NAMESPACE::Result::eSuccess ) { throwResultException( result, "vkCreateIndirectCommandsLayoutNV" ); @@ -7331,12 +7125,11 @@ namespace VULKAN_HPP_NAMESPACE IndirectCommandsLayoutNV( VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::Device const & device, - VkIndirectCommandsLayoutNV indirectCommandsLayoutNV, + VkIndirectCommandsLayoutNV indirectCommandsLayout, VULKAN_HPP_NAMESPACE::Optional allocator = nullptr ) - : m_device( &device ) - , m_indirectCommandsLayoutNV( indirectCommandsLayoutNV ) - , m_allocator( reinterpret_cast( - static_cast( allocator ) ) ) + : m_device( *device ) + , m_indirectCommandsLayout( indirectCommandsLayout ) + , m_allocator( static_cast( allocator ) ) , m_dispatcher( device.getDispatcher() ) {} @@ -7344,22 +7137,22 @@ namespace VULKAN_HPP_NAMESPACE ~IndirectCommandsLayoutNV() { - if ( m_indirectCommandsLayoutNV ) + if ( m_indirectCommandsLayout ) { getDispatcher()->vkDestroyIndirectCommandsLayoutNV( - static_cast( **m_device ), - static_cast( m_indirectCommandsLayoutNV ), - m_allocator ); + static_cast( m_device ), + static_cast( m_indirectCommandsLayout ), + reinterpret_cast( m_allocator ) ); } } IndirectCommandsLayoutNV() = delete; IndirectCommandsLayoutNV( IndirectCommandsLayoutNV const & ) = delete; IndirectCommandsLayoutNV( IndirectCommandsLayoutNV && rhs ) VULKAN_HPP_NOEXCEPT - : m_device( VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange( rhs.m_device, nullptr ) ) - , m_indirectCommandsLayoutNV( - VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange( rhs.m_indirectCommandsLayoutNV, {} ) ) - , m_allocator( rhs.m_allocator ) + : m_device( VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange( rhs.m_device, {} ) ) + , m_indirectCommandsLayout( + VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange( rhs.m_indirectCommandsLayout, {} ) ) + , m_allocator( VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange( rhs.m_allocator, {} ) ) , m_dispatcher( VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange( rhs.m_dispatcher, nullptr ) ) {} IndirectCommandsLayoutNV & operator=( IndirectCommandsLayoutNV const & ) = delete; @@ -7367,17 +7160,10 @@ namespace VULKAN_HPP_NAMESPACE { if ( this != &rhs ) { - if ( m_indirectCommandsLayoutNV ) - { - getDispatcher()->vkDestroyIndirectCommandsLayoutNV( - static_cast( **m_device ), - static_cast( m_indirectCommandsLayoutNV ), - m_allocator ); - } - m_device = VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange( rhs.m_device, nullptr ); - m_indirectCommandsLayoutNV = - VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange( rhs.m_indirectCommandsLayoutNV, {} ); - m_allocator = rhs.m_allocator; + m_device = VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange( rhs.m_device, {} ); + m_indirectCommandsLayout = + VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange( rhs.m_indirectCommandsLayout, {} ); + m_allocator = VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange( rhs.m_allocator, {} ); m_dispatcher = VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange( rhs.m_dispatcher, nullptr ); } return *this; @@ -7385,10 +7171,10 @@ namespace VULKAN_HPP_NAMESPACE VULKAN_HPP_NAMESPACE::IndirectCommandsLayoutNV const & operator*() const VULKAN_HPP_NOEXCEPT { - return m_indirectCommandsLayoutNV; + return m_indirectCommandsLayout; } - VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::Device const * getDevice() const VULKAN_HPP_NOEXCEPT + VULKAN_HPP_NAMESPACE::Device getDevice() const { return m_device; } @@ -7400,10 +7186,10 @@ namespace VULKAN_HPP_NAMESPACE } private: - VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::Device const * m_device = nullptr; - VULKAN_HPP_NAMESPACE::IndirectCommandsLayoutNV m_indirectCommandsLayoutNV; - const VkAllocationCallbacks * m_allocator = nullptr; - VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::DeviceDispatcher const * m_dispatcher = nullptr; + VULKAN_HPP_NAMESPACE::Device m_device = {}; + VULKAN_HPP_NAMESPACE::IndirectCommandsLayoutNV m_indirectCommandsLayout = {}; + const VULKAN_HPP_NAMESPACE::AllocationCallbacks * m_allocator = nullptr; + VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::DeviceDispatcher const * m_dispatcher = nullptr; }; class PerformanceConfigurationINTEL @@ -7420,13 +7206,13 @@ namespace VULKAN_HPP_NAMESPACE PerformanceConfigurationINTEL( VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::Device const & device, VULKAN_HPP_NAMESPACE::PerformanceConfigurationAcquireInfoINTEL const & acquireInfo ) - : m_device( &device ), m_dispatcher( device.getDispatcher() ) + : m_device( *device ), m_dispatcher( device.getDispatcher() ) { VULKAN_HPP_NAMESPACE::Result result = static_cast( device.getDispatcher()->vkAcquirePerformanceConfigurationINTEL( static_cast( *device ), reinterpret_cast( &acquireInfo ), - reinterpret_cast( &m_performanceConfigurationINTEL ) ) ); + reinterpret_cast( &m_configuration ) ) ); if ( result != VULKAN_HPP_NAMESPACE::Result::eSuccess ) { throwResultException( result, "vkAcquirePerformanceConfigurationINTEL" ); @@ -7434,30 +7220,26 @@ namespace VULKAN_HPP_NAMESPACE } PerformanceConfigurationINTEL( VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::Device const & device, - VkPerformanceConfigurationINTEL performanceConfigurationINTEL ) - : m_device( &device ) - , m_performanceConfigurationINTEL( performanceConfigurationINTEL ) - , m_dispatcher( device.getDispatcher() ) + VkPerformanceConfigurationINTEL configuration ) + : m_device( *device ), m_configuration( configuration ), m_dispatcher( device.getDispatcher() ) {} PerformanceConfigurationINTEL( std::nullptr_t ) {} ~PerformanceConfigurationINTEL() { - if ( m_performanceConfigurationINTEL ) + if ( m_configuration ) { getDispatcher()->vkReleasePerformanceConfigurationINTEL( - static_cast( **m_device ), - static_cast( m_performanceConfigurationINTEL ) ); + static_cast( m_device ), static_cast( m_configuration ) ); } } PerformanceConfigurationINTEL() = delete; PerformanceConfigurationINTEL( PerformanceConfigurationINTEL const & ) = delete; PerformanceConfigurationINTEL( PerformanceConfigurationINTEL && rhs ) VULKAN_HPP_NOEXCEPT - : m_device( VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange( rhs.m_device, nullptr ) ) - , m_performanceConfigurationINTEL( - VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange( rhs.m_performanceConfigurationINTEL, {} ) ) + : m_device( VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange( rhs.m_device, {} ) ) + , m_configuration( VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange( rhs.m_configuration, {} ) ) , m_dispatcher( VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange( rhs.m_dispatcher, nullptr ) ) {} PerformanceConfigurationINTEL & operator=( PerformanceConfigurationINTEL const & ) = delete; @@ -7465,26 +7247,19 @@ namespace VULKAN_HPP_NAMESPACE { if ( this != &rhs ) { - if ( m_performanceConfigurationINTEL ) - { - getDispatcher()->vkReleasePerformanceConfigurationINTEL( - static_cast( **m_device ), - static_cast( m_performanceConfigurationINTEL ) ); - } - m_device = VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange( rhs.m_device, nullptr ); - m_performanceConfigurationINTEL = - VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange( rhs.m_performanceConfigurationINTEL, {} ); - m_dispatcher = VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange( rhs.m_dispatcher, nullptr ); + m_device = VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange( rhs.m_device, {} ); + m_configuration = VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange( rhs.m_configuration, {} ); + m_dispatcher = VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange( rhs.m_dispatcher, nullptr ); } return *this; } VULKAN_HPP_NAMESPACE::PerformanceConfigurationINTEL const & operator*() const VULKAN_HPP_NOEXCEPT { - return m_performanceConfigurationINTEL; + return m_configuration; } - VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::Device const * getDevice() const VULKAN_HPP_NOEXCEPT + VULKAN_HPP_NAMESPACE::Device getDevice() const { return m_device; } @@ -7496,9 +7271,9 @@ namespace VULKAN_HPP_NAMESPACE } private: - VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::Device const * m_device = nullptr; - VULKAN_HPP_NAMESPACE::PerformanceConfigurationINTEL m_performanceConfigurationINTEL; - VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::DeviceDispatcher const * m_dispatcher = nullptr; + VULKAN_HPP_NAMESPACE::Device m_device = {}; + VULKAN_HPP_NAMESPACE::PerformanceConfigurationINTEL m_configuration = {}; + VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::DeviceDispatcher const * m_dispatcher = nullptr; }; class PipelineCache @@ -7516,16 +7291,15 @@ namespace VULKAN_HPP_NAMESPACE VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::Device const & device, VULKAN_HPP_NAMESPACE::PipelineCacheCreateInfo const & createInfo, VULKAN_HPP_NAMESPACE::Optional allocator = nullptr ) - : m_device( &device ) - , m_allocator( reinterpret_cast( - static_cast( allocator ) ) ) + : m_device( *device ) + , m_allocator( static_cast( allocator ) ) , m_dispatcher( device.getDispatcher() ) { VULKAN_HPP_NAMESPACE::Result result = static_cast( device.getDispatcher()->vkCreatePipelineCache( static_cast( *device ), reinterpret_cast( &createInfo ), - m_allocator, + reinterpret_cast( m_allocator ), reinterpret_cast( &m_pipelineCache ) ) ); if ( result != VULKAN_HPP_NAMESPACE::Result::eSuccess ) { @@ -7537,10 +7311,9 @@ namespace VULKAN_HPP_NAMESPACE VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::Device const & device, VkPipelineCache pipelineCache, VULKAN_HPP_NAMESPACE::Optional allocator = nullptr ) - : m_device( &device ) + : m_device( *device ) , m_pipelineCache( pipelineCache ) - , m_allocator( reinterpret_cast( - static_cast( allocator ) ) ) + , m_allocator( static_cast( allocator ) ) , m_dispatcher( device.getDispatcher() ) {} @@ -7550,17 +7323,18 @@ namespace VULKAN_HPP_NAMESPACE { if ( m_pipelineCache ) { - getDispatcher()->vkDestroyPipelineCache( - static_cast( **m_device ), static_cast( m_pipelineCache ), m_allocator ); + getDispatcher()->vkDestroyPipelineCache( static_cast( m_device ), + static_cast( m_pipelineCache ), + reinterpret_cast( m_allocator ) ); } } PipelineCache() = delete; PipelineCache( PipelineCache const & ) = delete; PipelineCache( PipelineCache && rhs ) VULKAN_HPP_NOEXCEPT - : m_device( VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange( rhs.m_device, nullptr ) ) + : m_device( VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange( rhs.m_device, {} ) ) , m_pipelineCache( VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange( rhs.m_pipelineCache, {} ) ) - , m_allocator( rhs.m_allocator ) + , m_allocator( VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange( rhs.m_allocator, {} ) ) , m_dispatcher( VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange( rhs.m_dispatcher, nullptr ) ) {} PipelineCache & operator=( PipelineCache const & ) = delete; @@ -7568,14 +7342,9 @@ namespace VULKAN_HPP_NAMESPACE { if ( this != &rhs ) { - if ( m_pipelineCache ) - { - getDispatcher()->vkDestroyPipelineCache( - static_cast( **m_device ), static_cast( m_pipelineCache ), m_allocator ); - } - m_device = VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange( rhs.m_device, nullptr ); + m_device = VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange( rhs.m_device, {} ); m_pipelineCache = VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange( rhs.m_pipelineCache, {} ); - m_allocator = rhs.m_allocator; + m_allocator = VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange( rhs.m_allocator, {} ); m_dispatcher = VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange( rhs.m_dispatcher, nullptr ); } return *this; @@ -7586,7 +7355,7 @@ namespace VULKAN_HPP_NAMESPACE return m_pipelineCache; } - VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::Device const * getDevice() const VULKAN_HPP_NOEXCEPT + VULKAN_HPP_NAMESPACE::Device getDevice() const { return m_device; } @@ -7604,10 +7373,10 @@ namespace VULKAN_HPP_NAMESPACE void merge( ArrayProxy const & srcCaches ) const; private: - VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::Device const * m_device = nullptr; - VULKAN_HPP_NAMESPACE::PipelineCache m_pipelineCache; - const VkAllocationCallbacks * m_allocator = nullptr; - VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::DeviceDispatcher const * m_dispatcher = nullptr; + VULKAN_HPP_NAMESPACE::Device m_device = {}; + VULKAN_HPP_NAMESPACE::PipelineCache m_pipelineCache = {}; + const VULKAN_HPP_NAMESPACE::AllocationCallbacks * m_allocator = nullptr; + VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::DeviceDispatcher const * m_dispatcher = nullptr; }; class Pipeline @@ -7627,9 +7396,8 @@ namespace VULKAN_HPP_NAMESPACE pipelineCache, VULKAN_HPP_NAMESPACE::ComputePipelineCreateInfo const & createInfo, VULKAN_HPP_NAMESPACE::Optional allocator = nullptr ) - : m_device( &device ) - , m_allocator( reinterpret_cast( - static_cast( allocator ) ) ) + : m_device( *device ) + , m_allocator( static_cast( allocator ) ) , m_dispatcher( device.getDispatcher() ) { m_constructorSuccessCode = static_cast( getDispatcher()->vkCreateComputePipelines( @@ -7637,7 +7405,7 @@ namespace VULKAN_HPP_NAMESPACE pipelineCache ? static_cast( **pipelineCache ) : 0, 1, reinterpret_cast( &createInfo ), - m_allocator, + reinterpret_cast( m_allocator ), reinterpret_cast( &m_pipeline ) ) ); if ( ( m_constructorSuccessCode != VULKAN_HPP_NAMESPACE::Result::eSuccess ) && ( m_constructorSuccessCode != VULKAN_HPP_NAMESPACE::Result::ePipelineCompileRequiredEXT ) ) @@ -7652,9 +7420,8 @@ namespace VULKAN_HPP_NAMESPACE pipelineCache, VULKAN_HPP_NAMESPACE::GraphicsPipelineCreateInfo const & createInfo, VULKAN_HPP_NAMESPACE::Optional allocator = nullptr ) - : m_device( &device ) - , m_allocator( reinterpret_cast( - static_cast( allocator ) ) ) + : m_device( *device ) + , m_allocator( static_cast( allocator ) ) , m_dispatcher( device.getDispatcher() ) { m_constructorSuccessCode = @@ -7663,7 +7430,7 @@ namespace VULKAN_HPP_NAMESPACE pipelineCache ? static_cast( **pipelineCache ) : 0, 1, reinterpret_cast( &createInfo ), - m_allocator, + reinterpret_cast( m_allocator ), reinterpret_cast( &m_pipeline ) ) ); if ( ( m_constructorSuccessCode != VULKAN_HPP_NAMESPACE::Result::eSuccess ) && ( m_constructorSuccessCode != VULKAN_HPP_NAMESPACE::Result::ePipelineCompileRequiredEXT ) ) @@ -7680,9 +7447,8 @@ namespace VULKAN_HPP_NAMESPACE pipelineCache, VULKAN_HPP_NAMESPACE::RayTracingPipelineCreateInfoKHR const & createInfo, VULKAN_HPP_NAMESPACE::Optional allocator = nullptr ) - : m_device( &device ) - , m_allocator( reinterpret_cast( - static_cast( allocator ) ) ) + : m_device( *device ) + , m_allocator( static_cast( allocator ) ) , m_dispatcher( device.getDispatcher() ) { m_constructorSuccessCode = @@ -7692,7 +7458,7 @@ namespace VULKAN_HPP_NAMESPACE pipelineCache ? static_cast( **pipelineCache ) : 0, 1, reinterpret_cast( &createInfo ), - m_allocator, + reinterpret_cast( m_allocator ), reinterpret_cast( &m_pipeline ) ) ); if ( ( m_constructorSuccessCode != VULKAN_HPP_NAMESPACE::Result::eSuccess ) && ( m_constructorSuccessCode != VULKAN_HPP_NAMESPACE::Result::eOperationDeferredKHR ) && @@ -7709,9 +7475,8 @@ namespace VULKAN_HPP_NAMESPACE pipelineCache, VULKAN_HPP_NAMESPACE::RayTracingPipelineCreateInfoNV const & createInfo, VULKAN_HPP_NAMESPACE::Optional allocator = nullptr ) - : m_device( &device ) - , m_allocator( reinterpret_cast( - static_cast( allocator ) ) ) + : m_device( *device ) + , m_allocator( static_cast( allocator ) ) , m_dispatcher( device.getDispatcher() ) { m_constructorSuccessCode = @@ -7720,7 +7485,7 @@ namespace VULKAN_HPP_NAMESPACE pipelineCache ? static_cast( **pipelineCache ) : 0, 1, reinterpret_cast( &createInfo ), - m_allocator, + reinterpret_cast( m_allocator ), reinterpret_cast( &m_pipeline ) ) ); if ( ( m_constructorSuccessCode != VULKAN_HPP_NAMESPACE::Result::eSuccess ) && ( m_constructorSuccessCode != VULKAN_HPP_NAMESPACE::Result::ePipelineCompileRequiredEXT ) ) @@ -7733,10 +7498,9 @@ namespace VULKAN_HPP_NAMESPACE VkPipeline pipeline, VULKAN_HPP_NAMESPACE::Optional allocator = nullptr, VULKAN_HPP_NAMESPACE::Result successCode = VULKAN_HPP_NAMESPACE::Result::eSuccess ) - : m_device( &device ) + : m_device( *device ) , m_pipeline( pipeline ) - , m_allocator( reinterpret_cast( - static_cast( allocator ) ) ) + , m_allocator( static_cast( allocator ) ) , m_constructorSuccessCode( successCode ) , m_dispatcher( device.getDispatcher() ) {} @@ -7747,17 +7511,18 @@ namespace VULKAN_HPP_NAMESPACE { if ( m_pipeline ) { - getDispatcher()->vkDestroyPipeline( - static_cast( **m_device ), static_cast( m_pipeline ), m_allocator ); + getDispatcher()->vkDestroyPipeline( static_cast( m_device ), + static_cast( m_pipeline ), + reinterpret_cast( m_allocator ) ); } } Pipeline() = delete; Pipeline( Pipeline const & ) = delete; Pipeline( Pipeline && rhs ) VULKAN_HPP_NOEXCEPT - : m_device( VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange( rhs.m_device, nullptr ) ) + : m_device( VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange( rhs.m_device, {} ) ) , m_pipeline( VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange( rhs.m_pipeline, {} ) ) - , m_allocator( rhs.m_allocator ) + , m_allocator( VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange( rhs.m_allocator, {} ) ) , m_dispatcher( VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange( rhs.m_dispatcher, nullptr ) ) {} Pipeline & operator=( Pipeline const & ) = delete; @@ -7765,14 +7530,9 @@ namespace VULKAN_HPP_NAMESPACE { if ( this != &rhs ) { - if ( m_pipeline ) - { - getDispatcher()->vkDestroyPipeline( - static_cast( **m_device ), static_cast( m_pipeline ), m_allocator ); - } - m_device = VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange( rhs.m_device, nullptr ); + m_device = VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange( rhs.m_device, {} ); m_pipeline = VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange( rhs.m_pipeline, {} ); - m_allocator = rhs.m_allocator; + m_allocator = VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange( rhs.m_allocator, {} ); m_dispatcher = VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange( rhs.m_dispatcher, nullptr ); } return *this; @@ -7788,7 +7548,7 @@ namespace VULKAN_HPP_NAMESPACE return m_constructorSuccessCode; } - VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::Device const * getDevice() const VULKAN_HPP_NOEXCEPT + VULKAN_HPP_NAMESPACE::Device getDevice() const { return m_device; } @@ -7838,9 +7598,9 @@ namespace VULKAN_HPP_NAMESPACE uint32_t group, VULKAN_HPP_NAMESPACE::ShaderGroupShaderKHR groupShader ) const VULKAN_HPP_NOEXCEPT; private: - VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::Device const * m_device = nullptr; - VULKAN_HPP_NAMESPACE::Pipeline m_pipeline; - const VkAllocationCallbacks * m_allocator = nullptr; + VULKAN_HPP_NAMESPACE::Device m_device = {}; + VULKAN_HPP_NAMESPACE::Pipeline m_pipeline = {}; + const VULKAN_HPP_NAMESPACE::AllocationCallbacks * m_allocator = nullptr; VULKAN_HPP_NAMESPACE::Result m_constructorSuccessCode; VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::DeviceDispatcher const * m_dispatcher = nullptr; }; @@ -8007,16 +7767,15 @@ namespace VULKAN_HPP_NAMESPACE VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::Device const & device, VULKAN_HPP_NAMESPACE::PipelineLayoutCreateInfo const & createInfo, VULKAN_HPP_NAMESPACE::Optional allocator = nullptr ) - : m_device( &device ) - , m_allocator( reinterpret_cast( - static_cast( allocator ) ) ) + : m_device( *device ) + , m_allocator( static_cast( allocator ) ) , m_dispatcher( device.getDispatcher() ) { VULKAN_HPP_NAMESPACE::Result result = static_cast( device.getDispatcher()->vkCreatePipelineLayout( static_cast( *device ), reinterpret_cast( &createInfo ), - m_allocator, + reinterpret_cast( m_allocator ), reinterpret_cast( &m_pipelineLayout ) ) ); if ( result != VULKAN_HPP_NAMESPACE::Result::eSuccess ) { @@ -8028,10 +7787,9 @@ namespace VULKAN_HPP_NAMESPACE VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::Device const & device, VkPipelineLayout pipelineLayout, VULKAN_HPP_NAMESPACE::Optional allocator = nullptr ) - : m_device( &device ) + : m_device( *device ) , m_pipelineLayout( pipelineLayout ) - , m_allocator( reinterpret_cast( - static_cast( allocator ) ) ) + , m_allocator( static_cast( allocator ) ) , m_dispatcher( device.getDispatcher() ) {} @@ -8041,17 +7799,18 @@ namespace VULKAN_HPP_NAMESPACE { if ( m_pipelineLayout ) { - getDispatcher()->vkDestroyPipelineLayout( - static_cast( **m_device ), static_cast( m_pipelineLayout ), m_allocator ); + getDispatcher()->vkDestroyPipelineLayout( static_cast( m_device ), + static_cast( m_pipelineLayout ), + reinterpret_cast( m_allocator ) ); } } PipelineLayout() = delete; PipelineLayout( PipelineLayout const & ) = delete; PipelineLayout( PipelineLayout && rhs ) VULKAN_HPP_NOEXCEPT - : m_device( VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange( rhs.m_device, nullptr ) ) + : m_device( VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange( rhs.m_device, {} ) ) , m_pipelineLayout( VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange( rhs.m_pipelineLayout, {} ) ) - , m_allocator( rhs.m_allocator ) + , m_allocator( VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange( rhs.m_allocator, {} ) ) , m_dispatcher( VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange( rhs.m_dispatcher, nullptr ) ) {} PipelineLayout & operator=( PipelineLayout const & ) = delete; @@ -8059,14 +7818,9 @@ namespace VULKAN_HPP_NAMESPACE { if ( this != &rhs ) { - if ( m_pipelineLayout ) - { - getDispatcher()->vkDestroyPipelineLayout( - static_cast( **m_device ), static_cast( m_pipelineLayout ), m_allocator ); - } - m_device = VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange( rhs.m_device, nullptr ); + m_device = VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange( rhs.m_device, {} ); m_pipelineLayout = VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange( rhs.m_pipelineLayout, {} ); - m_allocator = rhs.m_allocator; + m_allocator = VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange( rhs.m_allocator, {} ); m_dispatcher = VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange( rhs.m_dispatcher, nullptr ); } return *this; @@ -8077,7 +7831,7 @@ namespace VULKAN_HPP_NAMESPACE return m_pipelineLayout; } - VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::Device const * getDevice() const VULKAN_HPP_NOEXCEPT + VULKAN_HPP_NAMESPACE::Device getDevice() const { return m_device; } @@ -8089,10 +7843,10 @@ namespace VULKAN_HPP_NAMESPACE } private: - VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::Device const * m_device = nullptr; - VULKAN_HPP_NAMESPACE::PipelineLayout m_pipelineLayout; - const VkAllocationCallbacks * m_allocator = nullptr; - VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::DeviceDispatcher const * m_dispatcher = nullptr; + VULKAN_HPP_NAMESPACE::Device m_device = {}; + VULKAN_HPP_NAMESPACE::PipelineLayout m_pipelineLayout = {}; + const VULKAN_HPP_NAMESPACE::AllocationCallbacks * m_allocator = nullptr; + VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::DeviceDispatcher const * m_dispatcher = nullptr; }; class PrivateDataSlotEXT @@ -8110,17 +7864,16 @@ namespace VULKAN_HPP_NAMESPACE VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::Device const & device, VULKAN_HPP_NAMESPACE::PrivateDataSlotCreateInfoEXT const & createInfo, VULKAN_HPP_NAMESPACE::Optional allocator = nullptr ) - : m_device( &device ) - , m_allocator( reinterpret_cast( - static_cast( allocator ) ) ) + : m_device( *device ) + , m_allocator( static_cast( allocator ) ) , m_dispatcher( device.getDispatcher() ) { VULKAN_HPP_NAMESPACE::Result result = static_cast( device.getDispatcher()->vkCreatePrivateDataSlotEXT( static_cast( *device ), reinterpret_cast( &createInfo ), - m_allocator, - reinterpret_cast( &m_privateDataSlotEXT ) ) ); + reinterpret_cast( m_allocator ), + reinterpret_cast( &m_privateDataSlot ) ) ); if ( result != VULKAN_HPP_NAMESPACE::Result::eSuccess ) { throwResultException( result, "vkCreatePrivateDataSlotEXT" ); @@ -8129,12 +7882,11 @@ namespace VULKAN_HPP_NAMESPACE PrivateDataSlotEXT( VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::Device const & device, - VkPrivateDataSlotEXT privateDataSlotEXT, + VkPrivateDataSlotEXT privateDataSlot, VULKAN_HPP_NAMESPACE::Optional allocator = nullptr ) - : m_device( &device ) - , m_privateDataSlotEXT( privateDataSlotEXT ) - , m_allocator( reinterpret_cast( - static_cast( allocator ) ) ) + : m_device( *device ) + , m_privateDataSlot( privateDataSlot ) + , m_allocator( static_cast( allocator ) ) , m_dispatcher( device.getDispatcher() ) {} @@ -8142,21 +7894,21 @@ namespace VULKAN_HPP_NAMESPACE ~PrivateDataSlotEXT() { - if ( m_privateDataSlotEXT ) + if ( m_privateDataSlot ) { - getDispatcher()->vkDestroyPrivateDataSlotEXT( static_cast( **m_device ), - static_cast( m_privateDataSlotEXT ), - m_allocator ); + getDispatcher()->vkDestroyPrivateDataSlotEXT( + static_cast( m_device ), + static_cast( m_privateDataSlot ), + reinterpret_cast( m_allocator ) ); } } PrivateDataSlotEXT() = delete; PrivateDataSlotEXT( PrivateDataSlotEXT const & ) = delete; PrivateDataSlotEXT( PrivateDataSlotEXT && rhs ) VULKAN_HPP_NOEXCEPT - : m_device( VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange( rhs.m_device, nullptr ) ) - , m_privateDataSlotEXT( VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange( rhs.m_privateDataSlotEXT, - {} ) ) - , m_allocator( rhs.m_allocator ) + : m_device( VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange( rhs.m_device, {} ) ) + , m_privateDataSlot( VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange( rhs.m_privateDataSlot, {} ) ) + , m_allocator( VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange( rhs.m_allocator, {} ) ) , m_dispatcher( VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange( rhs.m_dispatcher, nullptr ) ) {} PrivateDataSlotEXT & operator=( PrivateDataSlotEXT const & ) = delete; @@ -8164,27 +7916,20 @@ namespace VULKAN_HPP_NAMESPACE { if ( this != &rhs ) { - if ( m_privateDataSlotEXT ) - { - getDispatcher()->vkDestroyPrivateDataSlotEXT( static_cast( **m_device ), - static_cast( m_privateDataSlotEXT ), - m_allocator ); - } - m_device = VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange( rhs.m_device, nullptr ); - m_privateDataSlotEXT = - VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange( rhs.m_privateDataSlotEXT, {} ); - m_allocator = rhs.m_allocator; - m_dispatcher = VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange( rhs.m_dispatcher, nullptr ); + m_device = VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange( rhs.m_device, {} ); + m_privateDataSlot = VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange( rhs.m_privateDataSlot, {} ); + m_allocator = VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange( rhs.m_allocator, {} ); + m_dispatcher = VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange( rhs.m_dispatcher, nullptr ); } return *this; } VULKAN_HPP_NAMESPACE::PrivateDataSlotEXT const & operator*() const VULKAN_HPP_NOEXCEPT { - return m_privateDataSlotEXT; + return m_privateDataSlot; } - VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::Device const * getDevice() const VULKAN_HPP_NOEXCEPT + VULKAN_HPP_NAMESPACE::Device getDevice() const { return m_device; } @@ -8196,10 +7941,10 @@ namespace VULKAN_HPP_NAMESPACE } private: - VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::Device const * m_device = nullptr; - VULKAN_HPP_NAMESPACE::PrivateDataSlotEXT m_privateDataSlotEXT; - const VkAllocationCallbacks * m_allocator = nullptr; - VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::DeviceDispatcher const * m_dispatcher = nullptr; + VULKAN_HPP_NAMESPACE::Device m_device = {}; + VULKAN_HPP_NAMESPACE::PrivateDataSlotEXT m_privateDataSlot = {}; + const VULKAN_HPP_NAMESPACE::AllocationCallbacks * m_allocator = nullptr; + VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::DeviceDispatcher const * m_dispatcher = nullptr; }; class QueryPool @@ -8216,15 +7961,14 @@ namespace VULKAN_HPP_NAMESPACE QueryPool( VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::Device const & device, VULKAN_HPP_NAMESPACE::QueryPoolCreateInfo const & createInfo, VULKAN_HPP_NAMESPACE::Optional allocator = nullptr ) - : m_device( &device ) - , m_allocator( reinterpret_cast( - static_cast( allocator ) ) ) + : m_device( *device ) + , m_allocator( static_cast( allocator ) ) , m_dispatcher( device.getDispatcher() ) { VULKAN_HPP_NAMESPACE::Result result = static_cast( device.getDispatcher()->vkCreateQueryPool( static_cast( *device ), reinterpret_cast( &createInfo ), - m_allocator, + reinterpret_cast( m_allocator ), reinterpret_cast( &m_queryPool ) ) ); if ( result != VULKAN_HPP_NAMESPACE::Result::eSuccess ) { @@ -8235,10 +7979,9 @@ namespace VULKAN_HPP_NAMESPACE QueryPool( VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::Device const & device, VkQueryPool queryPool, VULKAN_HPP_NAMESPACE::Optional allocator = nullptr ) - : m_device( &device ) + : m_device( *device ) , m_queryPool( queryPool ) - , m_allocator( reinterpret_cast( - static_cast( allocator ) ) ) + , m_allocator( static_cast( allocator ) ) , m_dispatcher( device.getDispatcher() ) {} @@ -8248,17 +7991,18 @@ namespace VULKAN_HPP_NAMESPACE { if ( m_queryPool ) { - getDispatcher()->vkDestroyQueryPool( - static_cast( **m_device ), static_cast( m_queryPool ), m_allocator ); + getDispatcher()->vkDestroyQueryPool( static_cast( m_device ), + static_cast( m_queryPool ), + reinterpret_cast( m_allocator ) ); } } QueryPool() = delete; QueryPool( QueryPool const & ) = delete; QueryPool( QueryPool && rhs ) VULKAN_HPP_NOEXCEPT - : m_device( VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange( rhs.m_device, nullptr ) ) + : m_device( VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange( rhs.m_device, {} ) ) , m_queryPool( VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange( rhs.m_queryPool, {} ) ) - , m_allocator( rhs.m_allocator ) + , m_allocator( VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange( rhs.m_allocator, {} ) ) , m_dispatcher( VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange( rhs.m_dispatcher, nullptr ) ) {} QueryPool & operator=( QueryPool const & ) = delete; @@ -8266,14 +8010,9 @@ namespace VULKAN_HPP_NAMESPACE { if ( this != &rhs ) { - if ( m_queryPool ) - { - getDispatcher()->vkDestroyQueryPool( - static_cast( **m_device ), static_cast( m_queryPool ), m_allocator ); - } - m_device = VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange( rhs.m_device, nullptr ); + m_device = VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange( rhs.m_device, {} ); m_queryPool = VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange( rhs.m_queryPool, {} ); - m_allocator = rhs.m_allocator; + m_allocator = VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange( rhs.m_allocator, {} ); m_dispatcher = VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange( rhs.m_dispatcher, nullptr ); } return *this; @@ -8284,7 +8023,7 @@ namespace VULKAN_HPP_NAMESPACE return m_queryPool; } - VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::Device const * getDevice() const VULKAN_HPP_NOEXCEPT + VULKAN_HPP_NAMESPACE::Device getDevice() const { return m_device; } @@ -8321,9 +8060,9 @@ namespace VULKAN_HPP_NAMESPACE void resetEXT( uint32_t firstQuery, uint32_t queryCount ) const VULKAN_HPP_NOEXCEPT; private: - VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::Device const * m_device = nullptr; - VULKAN_HPP_NAMESPACE::QueryPool m_queryPool; - const VkAllocationCallbacks * m_allocator = nullptr; + VULKAN_HPP_NAMESPACE::Device m_device = {}; + VULKAN_HPP_NAMESPACE::QueryPool m_queryPool = {}; + const VULKAN_HPP_NAMESPACE::AllocationCallbacks * m_allocator = nullptr; VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::DeviceDispatcher const * m_dispatcher = nullptr; }; @@ -8341,7 +8080,7 @@ namespace VULKAN_HPP_NAMESPACE Queue( VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::Device const & device, uint32_t queueFamilyIndex, uint32_t queueIndex ) - : m_device( &device ), m_dispatcher( device.getDispatcher() ) + : m_dispatcher( device.getDispatcher() ) { getDispatcher()->vkGetDeviceQueue( static_cast( *device ), queueFamilyIndex, queueIndex, reinterpret_cast( &m_queue ) ); @@ -8349,7 +8088,7 @@ namespace VULKAN_HPP_NAMESPACE Queue( VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::Device const & device, VULKAN_HPP_NAMESPACE::DeviceQueueInfo2 const & queueInfo ) - : m_device( &device ), m_dispatcher( device.getDispatcher() ) + : m_dispatcher( device.getDispatcher() ) { getDispatcher()->vkGetDeviceQueue2( static_cast( *device ), reinterpret_cast( &queueInfo ), @@ -8357,7 +8096,7 @@ namespace VULKAN_HPP_NAMESPACE } Queue( VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::Device const & device, VkQueue queue ) - : m_device( &device ), m_queue( queue ), m_dispatcher( device.getDispatcher() ) + : m_queue( queue ), m_dispatcher( device.getDispatcher() ) {} Queue( std::nullptr_t ) {} @@ -8365,8 +8104,7 @@ namespace VULKAN_HPP_NAMESPACE Queue() = delete; Queue( Queue const & ) = delete; Queue( Queue && rhs ) VULKAN_HPP_NOEXCEPT - : m_device( VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange( rhs.m_device, nullptr ) ) - , m_queue( VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange( rhs.m_queue, {} ) ) + : m_queue( VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange( rhs.m_queue, {} ) ) , m_dispatcher( VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange( rhs.m_dispatcher, nullptr ) ) {} Queue & operator=( Queue const & ) = delete; @@ -8374,7 +8112,6 @@ namespace VULKAN_HPP_NAMESPACE { if ( this != &rhs ) { - m_device = VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange( rhs.m_device, nullptr ); m_queue = VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange( rhs.m_queue, {} ); m_dispatcher = VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange( rhs.m_dispatcher, nullptr ); } @@ -8386,11 +8123,6 @@ namespace VULKAN_HPP_NAMESPACE return m_queue; } - VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::Device const * getDevice() const VULKAN_HPP_NOEXCEPT - { - return m_device; - } - VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::DeviceDispatcher const * getDispatcher() const { VULKAN_HPP_ASSERT( m_dispatcher->getVkHeaderVersion() == VK_HEADER_VERSION ); @@ -8440,8 +8172,7 @@ namespace VULKAN_HPP_NAMESPACE getCheckpointData2NV() const VULKAN_HPP_NOEXCEPT; private: - VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::Device const * m_device = nullptr; - VULKAN_HPP_NAMESPACE::Queue m_queue; + VULKAN_HPP_NAMESPACE::Queue m_queue = {}; VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::DeviceDispatcher const * m_dispatcher = nullptr; }; @@ -8459,15 +8190,14 @@ namespace VULKAN_HPP_NAMESPACE RenderPass( VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::Device const & device, VULKAN_HPP_NAMESPACE::RenderPassCreateInfo const & createInfo, VULKAN_HPP_NAMESPACE::Optional allocator = nullptr ) - : m_device( &device ) - , m_allocator( reinterpret_cast( - static_cast( allocator ) ) ) + : m_device( *device ) + , m_allocator( static_cast( allocator ) ) , m_dispatcher( device.getDispatcher() ) { VULKAN_HPP_NAMESPACE::Result result = static_cast( device.getDispatcher()->vkCreateRenderPass( static_cast( *device ), reinterpret_cast( &createInfo ), - m_allocator, + reinterpret_cast( m_allocator ), reinterpret_cast( &m_renderPass ) ) ); if ( result != VULKAN_HPP_NAMESPACE::Result::eSuccess ) { @@ -8478,15 +8208,14 @@ namespace VULKAN_HPP_NAMESPACE RenderPass( VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::Device const & device, VULKAN_HPP_NAMESPACE::RenderPassCreateInfo2 const & createInfo, VULKAN_HPP_NAMESPACE::Optional allocator = nullptr ) - : m_device( &device ) - , m_allocator( reinterpret_cast( - static_cast( allocator ) ) ) + : m_device( *device ) + , m_allocator( static_cast( allocator ) ) , m_dispatcher( device.getDispatcher() ) { VULKAN_HPP_NAMESPACE::Result result = static_cast( device.getDispatcher()->vkCreateRenderPass2( static_cast( *device ), reinterpret_cast( &createInfo ), - m_allocator, + reinterpret_cast( m_allocator ), reinterpret_cast( &m_renderPass ) ) ); if ( result != VULKAN_HPP_NAMESPACE::Result::eSuccess ) { @@ -8497,10 +8226,9 @@ namespace VULKAN_HPP_NAMESPACE RenderPass( VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::Device const & device, VkRenderPass renderPass, VULKAN_HPP_NAMESPACE::Optional allocator = nullptr ) - : m_device( &device ) + : m_device( *device ) , m_renderPass( renderPass ) - , m_allocator( reinterpret_cast( - static_cast( allocator ) ) ) + , m_allocator( static_cast( allocator ) ) , m_dispatcher( device.getDispatcher() ) {} @@ -8510,17 +8238,18 @@ namespace VULKAN_HPP_NAMESPACE { if ( m_renderPass ) { - getDispatcher()->vkDestroyRenderPass( - static_cast( **m_device ), static_cast( m_renderPass ), m_allocator ); + getDispatcher()->vkDestroyRenderPass( static_cast( m_device ), + static_cast( m_renderPass ), + reinterpret_cast( m_allocator ) ); } } RenderPass() = delete; RenderPass( RenderPass const & ) = delete; RenderPass( RenderPass && rhs ) VULKAN_HPP_NOEXCEPT - : m_device( VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange( rhs.m_device, nullptr ) ) + : m_device( VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange( rhs.m_device, {} ) ) , m_renderPass( VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange( rhs.m_renderPass, {} ) ) - , m_allocator( rhs.m_allocator ) + , m_allocator( VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange( rhs.m_allocator, {} ) ) , m_dispatcher( VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange( rhs.m_dispatcher, nullptr ) ) {} RenderPass & operator=( RenderPass const & ) = delete; @@ -8528,14 +8257,9 @@ namespace VULKAN_HPP_NAMESPACE { if ( this != &rhs ) { - if ( m_renderPass ) - { - getDispatcher()->vkDestroyRenderPass( - static_cast( **m_device ), static_cast( m_renderPass ), m_allocator ); - } - m_device = VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange( rhs.m_device, nullptr ); + m_device = VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange( rhs.m_device, {} ); m_renderPass = VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange( rhs.m_renderPass, {} ); - m_allocator = rhs.m_allocator; + m_allocator = VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange( rhs.m_allocator, {} ); m_dispatcher = VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange( rhs.m_dispatcher, nullptr ); } return *this; @@ -8546,7 +8270,7 @@ namespace VULKAN_HPP_NAMESPACE return m_renderPass; } - VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::Device const * getDevice() const VULKAN_HPP_NOEXCEPT + VULKAN_HPP_NAMESPACE::Device getDevice() const { return m_device; } @@ -8567,9 +8291,9 @@ namespace VULKAN_HPP_NAMESPACE getSubpassShadingMaxWorkgroupSizeHUAWEI() const; private: - VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::Device const * m_device = nullptr; - VULKAN_HPP_NAMESPACE::RenderPass m_renderPass; - const VkAllocationCallbacks * m_allocator = nullptr; + VULKAN_HPP_NAMESPACE::Device m_device = {}; + VULKAN_HPP_NAMESPACE::RenderPass m_renderPass = {}; + const VULKAN_HPP_NAMESPACE::AllocationCallbacks * m_allocator = nullptr; VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::DeviceDispatcher const * m_dispatcher = nullptr; }; @@ -8587,15 +8311,14 @@ namespace VULKAN_HPP_NAMESPACE Sampler( VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::Device const & device, VULKAN_HPP_NAMESPACE::SamplerCreateInfo const & createInfo, VULKAN_HPP_NAMESPACE::Optional allocator = nullptr ) - : m_device( &device ) - , m_allocator( reinterpret_cast( - static_cast( allocator ) ) ) + : m_device( *device ) + , m_allocator( static_cast( allocator ) ) , m_dispatcher( device.getDispatcher() ) { VULKAN_HPP_NAMESPACE::Result result = static_cast( device.getDispatcher()->vkCreateSampler( static_cast( *device ), reinterpret_cast( &createInfo ), - m_allocator, + reinterpret_cast( m_allocator ), reinterpret_cast( &m_sampler ) ) ); if ( result != VULKAN_HPP_NAMESPACE::Result::eSuccess ) { @@ -8606,10 +8329,9 @@ namespace VULKAN_HPP_NAMESPACE Sampler( VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::Device const & device, VkSampler sampler, VULKAN_HPP_NAMESPACE::Optional allocator = nullptr ) - : m_device( &device ) + : m_device( *device ) , m_sampler( sampler ) - , m_allocator( reinterpret_cast( - static_cast( allocator ) ) ) + , m_allocator( static_cast( allocator ) ) , m_dispatcher( device.getDispatcher() ) {} @@ -8619,17 +8341,18 @@ namespace VULKAN_HPP_NAMESPACE { if ( m_sampler ) { - getDispatcher()->vkDestroySampler( - static_cast( **m_device ), static_cast( m_sampler ), m_allocator ); + getDispatcher()->vkDestroySampler( static_cast( m_device ), + static_cast( m_sampler ), + reinterpret_cast( m_allocator ) ); } } Sampler() = delete; Sampler( Sampler const & ) = delete; Sampler( Sampler && rhs ) VULKAN_HPP_NOEXCEPT - : m_device( VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange( rhs.m_device, nullptr ) ) + : m_device( VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange( rhs.m_device, {} ) ) , m_sampler( VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange( rhs.m_sampler, {} ) ) - , m_allocator( rhs.m_allocator ) + , m_allocator( VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange( rhs.m_allocator, {} ) ) , m_dispatcher( VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange( rhs.m_dispatcher, nullptr ) ) {} Sampler & operator=( Sampler const & ) = delete; @@ -8637,14 +8360,9 @@ namespace VULKAN_HPP_NAMESPACE { if ( this != &rhs ) { - if ( m_sampler ) - { - getDispatcher()->vkDestroySampler( - static_cast( **m_device ), static_cast( m_sampler ), m_allocator ); - } - m_device = VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange( rhs.m_device, nullptr ); + m_device = VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange( rhs.m_device, {} ); m_sampler = VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange( rhs.m_sampler, {} ); - m_allocator = rhs.m_allocator; + m_allocator = VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange( rhs.m_allocator, {} ); m_dispatcher = VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange( rhs.m_dispatcher, nullptr ); } return *this; @@ -8655,7 +8373,7 @@ namespace VULKAN_HPP_NAMESPACE return m_sampler; } - VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::Device const * getDevice() const VULKAN_HPP_NOEXCEPT + VULKAN_HPP_NAMESPACE::Device getDevice() const { return m_device; } @@ -8667,9 +8385,9 @@ namespace VULKAN_HPP_NAMESPACE } private: - VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::Device const * m_device = nullptr; - VULKAN_HPP_NAMESPACE::Sampler m_sampler; - const VkAllocationCallbacks * m_allocator = nullptr; + VULKAN_HPP_NAMESPACE::Device m_device = {}; + VULKAN_HPP_NAMESPACE::Sampler m_sampler = {}; + const VULKAN_HPP_NAMESPACE::AllocationCallbacks * m_allocator = nullptr; VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::DeviceDispatcher const * m_dispatcher = nullptr; }; @@ -8688,17 +8406,16 @@ namespace VULKAN_HPP_NAMESPACE VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::Device const & device, VULKAN_HPP_NAMESPACE::SamplerYcbcrConversionCreateInfo const & createInfo, VULKAN_HPP_NAMESPACE::Optional allocator = nullptr ) - : m_device( &device ) - , m_allocator( reinterpret_cast( - static_cast( allocator ) ) ) + : m_device( *device ) + , m_allocator( static_cast( allocator ) ) , m_dispatcher( device.getDispatcher() ) { VULKAN_HPP_NAMESPACE::Result result = static_cast( device.getDispatcher()->vkCreateSamplerYcbcrConversion( static_cast( *device ), reinterpret_cast( &createInfo ), - m_allocator, - reinterpret_cast( &m_samplerYcbcrConversion ) ) ); + reinterpret_cast( m_allocator ), + reinterpret_cast( &m_ycbcrConversion ) ) ); if ( result != VULKAN_HPP_NAMESPACE::Result::eSuccess ) { throwResultException( result, "vkCreateSamplerYcbcrConversion" ); @@ -8707,12 +8424,11 @@ namespace VULKAN_HPP_NAMESPACE SamplerYcbcrConversion( VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::Device const & device, - VkSamplerYcbcrConversion samplerYcbcrConversion, + VkSamplerYcbcrConversion ycbcrConversion, VULKAN_HPP_NAMESPACE::Optional allocator = nullptr ) - : m_device( &device ) - , m_samplerYcbcrConversion( samplerYcbcrConversion ) - , m_allocator( reinterpret_cast( - static_cast( allocator ) ) ) + : m_device( *device ) + , m_ycbcrConversion( ycbcrConversion ) + , m_allocator( static_cast( allocator ) ) , m_dispatcher( device.getDispatcher() ) {} @@ -8720,22 +8436,21 @@ namespace VULKAN_HPP_NAMESPACE ~SamplerYcbcrConversion() { - if ( m_samplerYcbcrConversion ) + if ( m_ycbcrConversion ) { getDispatcher()->vkDestroySamplerYcbcrConversion( - static_cast( **m_device ), - static_cast( m_samplerYcbcrConversion ), - m_allocator ); + static_cast( m_device ), + static_cast( m_ycbcrConversion ), + reinterpret_cast( m_allocator ) ); } } SamplerYcbcrConversion() = delete; SamplerYcbcrConversion( SamplerYcbcrConversion const & ) = delete; SamplerYcbcrConversion( SamplerYcbcrConversion && rhs ) VULKAN_HPP_NOEXCEPT - : m_device( VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange( rhs.m_device, nullptr ) ) - , m_samplerYcbcrConversion( - VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange( rhs.m_samplerYcbcrConversion, {} ) ) - , m_allocator( rhs.m_allocator ) + : m_device( VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange( rhs.m_device, {} ) ) + , m_ycbcrConversion( VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange( rhs.m_ycbcrConversion, {} ) ) + , m_allocator( VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange( rhs.m_allocator, {} ) ) , m_dispatcher( VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange( rhs.m_dispatcher, nullptr ) ) {} SamplerYcbcrConversion & operator=( SamplerYcbcrConversion const & ) = delete; @@ -8743,28 +8458,20 @@ namespace VULKAN_HPP_NAMESPACE { if ( this != &rhs ) { - if ( m_samplerYcbcrConversion ) - { - getDispatcher()->vkDestroySamplerYcbcrConversion( - static_cast( **m_device ), - static_cast( m_samplerYcbcrConversion ), - m_allocator ); - } - m_device = VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange( rhs.m_device, nullptr ); - m_samplerYcbcrConversion = - VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange( rhs.m_samplerYcbcrConversion, {} ); - m_allocator = rhs.m_allocator; - m_dispatcher = VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange( rhs.m_dispatcher, nullptr ); + m_device = VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange( rhs.m_device, {} ); + m_ycbcrConversion = VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange( rhs.m_ycbcrConversion, {} ); + m_allocator = VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange( rhs.m_allocator, {} ); + m_dispatcher = VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange( rhs.m_dispatcher, nullptr ); } return *this; } VULKAN_HPP_NAMESPACE::SamplerYcbcrConversion const & operator*() const VULKAN_HPP_NOEXCEPT { - return m_samplerYcbcrConversion; + return m_ycbcrConversion; } - VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::Device const * getDevice() const VULKAN_HPP_NOEXCEPT + VULKAN_HPP_NAMESPACE::Device getDevice() const { return m_device; } @@ -8776,10 +8483,10 @@ namespace VULKAN_HPP_NAMESPACE } private: - VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::Device const * m_device = nullptr; - VULKAN_HPP_NAMESPACE::SamplerYcbcrConversion m_samplerYcbcrConversion; - const VkAllocationCallbacks * m_allocator = nullptr; - VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::DeviceDispatcher const * m_dispatcher = nullptr; + VULKAN_HPP_NAMESPACE::Device m_device = {}; + VULKAN_HPP_NAMESPACE::SamplerYcbcrConversion m_ycbcrConversion = {}; + const VULKAN_HPP_NAMESPACE::AllocationCallbacks * m_allocator = nullptr; + VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::DeviceDispatcher const * m_dispatcher = nullptr; }; class Semaphore @@ -8796,15 +8503,14 @@ namespace VULKAN_HPP_NAMESPACE Semaphore( VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::Device const & device, VULKAN_HPP_NAMESPACE::SemaphoreCreateInfo const & createInfo, VULKAN_HPP_NAMESPACE::Optional allocator = nullptr ) - : m_device( &device ) - , m_allocator( reinterpret_cast( - static_cast( allocator ) ) ) + : m_device( *device ) + , m_allocator( static_cast( allocator ) ) , m_dispatcher( device.getDispatcher() ) { VULKAN_HPP_NAMESPACE::Result result = static_cast( device.getDispatcher()->vkCreateSemaphore( static_cast( *device ), reinterpret_cast( &createInfo ), - m_allocator, + reinterpret_cast( m_allocator ), reinterpret_cast( &m_semaphore ) ) ); if ( result != VULKAN_HPP_NAMESPACE::Result::eSuccess ) { @@ -8815,10 +8521,9 @@ namespace VULKAN_HPP_NAMESPACE Semaphore( VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::Device const & device, VkSemaphore semaphore, VULKAN_HPP_NAMESPACE::Optional allocator = nullptr ) - : m_device( &device ) + : m_device( *device ) , m_semaphore( semaphore ) - , m_allocator( reinterpret_cast( - static_cast( allocator ) ) ) + , m_allocator( static_cast( allocator ) ) , m_dispatcher( device.getDispatcher() ) {} @@ -8828,17 +8533,18 @@ namespace VULKAN_HPP_NAMESPACE { if ( m_semaphore ) { - getDispatcher()->vkDestroySemaphore( - static_cast( **m_device ), static_cast( m_semaphore ), m_allocator ); + getDispatcher()->vkDestroySemaphore( static_cast( m_device ), + static_cast( m_semaphore ), + reinterpret_cast( m_allocator ) ); } } Semaphore() = delete; Semaphore( Semaphore const & ) = delete; Semaphore( Semaphore && rhs ) VULKAN_HPP_NOEXCEPT - : m_device( VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange( rhs.m_device, nullptr ) ) + : m_device( VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange( rhs.m_device, {} ) ) , m_semaphore( VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange( rhs.m_semaphore, {} ) ) - , m_allocator( rhs.m_allocator ) + , m_allocator( VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange( rhs.m_allocator, {} ) ) , m_dispatcher( VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange( rhs.m_dispatcher, nullptr ) ) {} Semaphore & operator=( Semaphore const & ) = delete; @@ -8846,14 +8552,9 @@ namespace VULKAN_HPP_NAMESPACE { if ( this != &rhs ) { - if ( m_semaphore ) - { - getDispatcher()->vkDestroySemaphore( - static_cast( **m_device ), static_cast( m_semaphore ), m_allocator ); - } - m_device = VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange( rhs.m_device, nullptr ); + m_device = VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange( rhs.m_device, {} ); m_semaphore = VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange( rhs.m_semaphore, {} ); - m_allocator = rhs.m_allocator; + m_allocator = VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange( rhs.m_allocator, {} ); m_dispatcher = VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange( rhs.m_dispatcher, nullptr ); } return *this; @@ -8864,7 +8565,7 @@ namespace VULKAN_HPP_NAMESPACE return m_semaphore; } - VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::Device const * getDevice() const VULKAN_HPP_NOEXCEPT + VULKAN_HPP_NAMESPACE::Device getDevice() const { return m_device; } @@ -8884,9 +8585,9 @@ namespace VULKAN_HPP_NAMESPACE VULKAN_HPP_NODISCARD uint64_t getCounterValueKHR() const; private: - VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::Device const * m_device = nullptr; - VULKAN_HPP_NAMESPACE::Semaphore m_semaphore; - const VkAllocationCallbacks * m_allocator = nullptr; + VULKAN_HPP_NAMESPACE::Device m_device = {}; + VULKAN_HPP_NAMESPACE::Semaphore m_semaphore = {}; + const VULKAN_HPP_NAMESPACE::AllocationCallbacks * m_allocator = nullptr; VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::DeviceDispatcher const * m_dispatcher = nullptr; }; @@ -8905,16 +8606,15 @@ namespace VULKAN_HPP_NAMESPACE VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::Device const & device, VULKAN_HPP_NAMESPACE::ShaderModuleCreateInfo const & createInfo, VULKAN_HPP_NAMESPACE::Optional allocator = nullptr ) - : m_device( &device ) - , m_allocator( reinterpret_cast( - static_cast( allocator ) ) ) + : m_device( *device ) + , m_allocator( static_cast( allocator ) ) , m_dispatcher( device.getDispatcher() ) { VULKAN_HPP_NAMESPACE::Result result = static_cast( device.getDispatcher()->vkCreateShaderModule( static_cast( *device ), reinterpret_cast( &createInfo ), - m_allocator, + reinterpret_cast( m_allocator ), reinterpret_cast( &m_shaderModule ) ) ); if ( result != VULKAN_HPP_NAMESPACE::Result::eSuccess ) { @@ -8926,10 +8626,9 @@ namespace VULKAN_HPP_NAMESPACE VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::Device const & device, VkShaderModule shaderModule, VULKAN_HPP_NAMESPACE::Optional allocator = nullptr ) - : m_device( &device ) + : m_device( *device ) , m_shaderModule( shaderModule ) - , m_allocator( reinterpret_cast( - static_cast( allocator ) ) ) + , m_allocator( static_cast( allocator ) ) , m_dispatcher( device.getDispatcher() ) {} @@ -8939,17 +8638,18 @@ namespace VULKAN_HPP_NAMESPACE { if ( m_shaderModule ) { - getDispatcher()->vkDestroyShaderModule( - static_cast( **m_device ), static_cast( m_shaderModule ), m_allocator ); + getDispatcher()->vkDestroyShaderModule( static_cast( m_device ), + static_cast( m_shaderModule ), + reinterpret_cast( m_allocator ) ); } } ShaderModule() = delete; ShaderModule( ShaderModule const & ) = delete; ShaderModule( ShaderModule && rhs ) VULKAN_HPP_NOEXCEPT - : m_device( VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange( rhs.m_device, nullptr ) ) + : m_device( VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange( rhs.m_device, {} ) ) , m_shaderModule( VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange( rhs.m_shaderModule, {} ) ) - , m_allocator( rhs.m_allocator ) + , m_allocator( VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange( rhs.m_allocator, {} ) ) , m_dispatcher( VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange( rhs.m_dispatcher, nullptr ) ) {} ShaderModule & operator=( ShaderModule const & ) = delete; @@ -8957,14 +8657,9 @@ namespace VULKAN_HPP_NAMESPACE { if ( this != &rhs ) { - if ( m_shaderModule ) - { - getDispatcher()->vkDestroyShaderModule( - static_cast( **m_device ), static_cast( m_shaderModule ), m_allocator ); - } - m_device = VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange( rhs.m_device, nullptr ); + m_device = VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange( rhs.m_device, {} ); m_shaderModule = VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange( rhs.m_shaderModule, {} ); - m_allocator = rhs.m_allocator; + m_allocator = VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange( rhs.m_allocator, {} ); m_dispatcher = VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange( rhs.m_dispatcher, nullptr ); } return *this; @@ -8975,7 +8670,7 @@ namespace VULKAN_HPP_NAMESPACE return m_shaderModule; } - VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::Device const * getDevice() const VULKAN_HPP_NOEXCEPT + VULKAN_HPP_NAMESPACE::Device getDevice() const { return m_device; } @@ -8987,10 +8682,10 @@ namespace VULKAN_HPP_NAMESPACE } private: - VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::Device const * m_device = nullptr; - VULKAN_HPP_NAMESPACE::ShaderModule m_shaderModule; - const VkAllocationCallbacks * m_allocator = nullptr; - VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::DeviceDispatcher const * m_dispatcher = nullptr; + VULKAN_HPP_NAMESPACE::Device m_device = {}; + VULKAN_HPP_NAMESPACE::ShaderModule m_shaderModule = {}; + const VULKAN_HPP_NAMESPACE::AllocationCallbacks * m_allocator = nullptr; + VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::DeviceDispatcher const * m_dispatcher = nullptr; }; class SurfaceKHR @@ -9008,17 +8703,16 @@ namespace VULKAN_HPP_NAMESPACE SurfaceKHR( VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::Instance const & instance, VULKAN_HPP_NAMESPACE::AndroidSurfaceCreateInfoKHR const & createInfo, VULKAN_HPP_NAMESPACE::Optional allocator = nullptr ) - : m_instance( &instance ) - , m_allocator( reinterpret_cast( - static_cast( allocator ) ) ) + : m_instance( *instance ) + , m_allocator( static_cast( allocator ) ) , m_dispatcher( instance.getDispatcher() ) { VULKAN_HPP_NAMESPACE::Result result = static_cast( instance.getDispatcher()->vkCreateAndroidSurfaceKHR( static_cast( *instance ), reinterpret_cast( &createInfo ), - m_allocator, - reinterpret_cast( &m_surfaceKHR ) ) ); + reinterpret_cast( m_allocator ), + reinterpret_cast( &m_surface ) ) ); if ( result != VULKAN_HPP_NAMESPACE::Result::eSuccess ) { throwResultException( result, "vkCreateAndroidSurfaceKHR" ); @@ -9030,17 +8724,16 @@ namespace VULKAN_HPP_NAMESPACE SurfaceKHR( VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::Instance const & instance, VULKAN_HPP_NAMESPACE::DirectFBSurfaceCreateInfoEXT const & createInfo, VULKAN_HPP_NAMESPACE::Optional allocator = nullptr ) - : m_instance( &instance ) - , m_allocator( reinterpret_cast( - static_cast( allocator ) ) ) + : m_instance( *instance ) + , m_allocator( static_cast( allocator ) ) , m_dispatcher( instance.getDispatcher() ) { VULKAN_HPP_NAMESPACE::Result result = static_cast( instance.getDispatcher()->vkCreateDirectFBSurfaceEXT( static_cast( *instance ), reinterpret_cast( &createInfo ), - m_allocator, - reinterpret_cast( &m_surfaceKHR ) ) ); + reinterpret_cast( m_allocator ), + reinterpret_cast( &m_surface ) ) ); if ( result != VULKAN_HPP_NAMESPACE::Result::eSuccess ) { throwResultException( result, "vkCreateDirectFBSurfaceEXT" ); @@ -9051,17 +8744,16 @@ namespace VULKAN_HPP_NAMESPACE SurfaceKHR( VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::Instance const & instance, VULKAN_HPP_NAMESPACE::DisplaySurfaceCreateInfoKHR const & createInfo, VULKAN_HPP_NAMESPACE::Optional allocator = nullptr ) - : m_instance( &instance ) - , m_allocator( reinterpret_cast( - static_cast( allocator ) ) ) + : m_instance( *instance ) + , m_allocator( static_cast( allocator ) ) , m_dispatcher( instance.getDispatcher() ) { VULKAN_HPP_NAMESPACE::Result result = static_cast( instance.getDispatcher()->vkCreateDisplayPlaneSurfaceKHR( static_cast( *instance ), reinterpret_cast( &createInfo ), - m_allocator, - reinterpret_cast( &m_surfaceKHR ) ) ); + reinterpret_cast( m_allocator ), + reinterpret_cast( &m_surface ) ) ); if ( result != VULKAN_HPP_NAMESPACE::Result::eSuccess ) { throwResultException( result, "vkCreateDisplayPlaneSurfaceKHR" ); @@ -9071,17 +8763,16 @@ namespace VULKAN_HPP_NAMESPACE SurfaceKHR( VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::Instance const & instance, VULKAN_HPP_NAMESPACE::HeadlessSurfaceCreateInfoEXT const & createInfo, VULKAN_HPP_NAMESPACE::Optional allocator = nullptr ) - : m_instance( &instance ) - , m_allocator( reinterpret_cast( - static_cast( allocator ) ) ) + : m_instance( *instance ) + , m_allocator( static_cast( allocator ) ) , m_dispatcher( instance.getDispatcher() ) { VULKAN_HPP_NAMESPACE::Result result = static_cast( instance.getDispatcher()->vkCreateHeadlessSurfaceEXT( static_cast( *instance ), reinterpret_cast( &createInfo ), - m_allocator, - reinterpret_cast( &m_surfaceKHR ) ) ); + reinterpret_cast( m_allocator ), + reinterpret_cast( &m_surface ) ) ); if ( result != VULKAN_HPP_NAMESPACE::Result::eSuccess ) { throwResultException( result, "vkCreateHeadlessSurfaceEXT" ); @@ -9092,17 +8783,16 @@ namespace VULKAN_HPP_NAMESPACE SurfaceKHR( VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::Instance const & instance, VULKAN_HPP_NAMESPACE::IOSSurfaceCreateInfoMVK const & createInfo, VULKAN_HPP_NAMESPACE::Optional allocator = nullptr ) - : m_instance( &instance ) - , m_allocator( reinterpret_cast( - static_cast( allocator ) ) ) + : m_instance( *instance ) + , m_allocator( static_cast( allocator ) ) , m_dispatcher( instance.getDispatcher() ) { VULKAN_HPP_NAMESPACE::Result result = static_cast( instance.getDispatcher()->vkCreateIOSSurfaceMVK( static_cast( *instance ), reinterpret_cast( &createInfo ), - m_allocator, - reinterpret_cast( &m_surfaceKHR ) ) ); + reinterpret_cast( m_allocator ), + reinterpret_cast( &m_surface ) ) ); if ( result != VULKAN_HPP_NAMESPACE::Result::eSuccess ) { throwResultException( result, "vkCreateIOSSurfaceMVK" ); @@ -9114,17 +8804,16 @@ namespace VULKAN_HPP_NAMESPACE SurfaceKHR( VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::Instance const & instance, VULKAN_HPP_NAMESPACE::ImagePipeSurfaceCreateInfoFUCHSIA const & createInfo, VULKAN_HPP_NAMESPACE::Optional allocator = nullptr ) - : m_instance( &instance ) - , m_allocator( reinterpret_cast( - static_cast( allocator ) ) ) + : m_instance( *instance ) + , m_allocator( static_cast( allocator ) ) , m_dispatcher( instance.getDispatcher() ) { VULKAN_HPP_NAMESPACE::Result result = static_cast( instance.getDispatcher()->vkCreateImagePipeSurfaceFUCHSIA( static_cast( *instance ), reinterpret_cast( &createInfo ), - m_allocator, - reinterpret_cast( &m_surfaceKHR ) ) ); + reinterpret_cast( m_allocator ), + reinterpret_cast( &m_surface ) ) ); if ( result != VULKAN_HPP_NAMESPACE::Result::eSuccess ) { throwResultException( result, "vkCreateImagePipeSurfaceFUCHSIA" ); @@ -9136,17 +8825,16 @@ namespace VULKAN_HPP_NAMESPACE SurfaceKHR( VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::Instance const & instance, VULKAN_HPP_NAMESPACE::MacOSSurfaceCreateInfoMVK const & createInfo, VULKAN_HPP_NAMESPACE::Optional allocator = nullptr ) - : m_instance( &instance ) - , m_allocator( reinterpret_cast( - static_cast( allocator ) ) ) + : m_instance( *instance ) + , m_allocator( static_cast( allocator ) ) , m_dispatcher( instance.getDispatcher() ) { VULKAN_HPP_NAMESPACE::Result result = static_cast( instance.getDispatcher()->vkCreateMacOSSurfaceMVK( static_cast( *instance ), reinterpret_cast( &createInfo ), - m_allocator, - reinterpret_cast( &m_surfaceKHR ) ) ); + reinterpret_cast( m_allocator ), + reinterpret_cast( &m_surface ) ) ); if ( result != VULKAN_HPP_NAMESPACE::Result::eSuccess ) { throwResultException( result, "vkCreateMacOSSurfaceMVK" ); @@ -9158,17 +8846,16 @@ namespace VULKAN_HPP_NAMESPACE SurfaceKHR( VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::Instance const & instance, VULKAN_HPP_NAMESPACE::MetalSurfaceCreateInfoEXT const & createInfo, VULKAN_HPP_NAMESPACE::Optional allocator = nullptr ) - : m_instance( &instance ) - , m_allocator( reinterpret_cast( - static_cast( allocator ) ) ) + : m_instance( *instance ) + , m_allocator( static_cast( allocator ) ) , m_dispatcher( instance.getDispatcher() ) { VULKAN_HPP_NAMESPACE::Result result = static_cast( instance.getDispatcher()->vkCreateMetalSurfaceEXT( static_cast( *instance ), reinterpret_cast( &createInfo ), - m_allocator, - reinterpret_cast( &m_surfaceKHR ) ) ); + reinterpret_cast( m_allocator ), + reinterpret_cast( &m_surface ) ) ); if ( result != VULKAN_HPP_NAMESPACE::Result::eSuccess ) { throwResultException( result, "vkCreateMetalSurfaceEXT" ); @@ -9180,17 +8867,16 @@ namespace VULKAN_HPP_NAMESPACE SurfaceKHR( VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::Instance const & instance, VULKAN_HPP_NAMESPACE::ScreenSurfaceCreateInfoQNX const & createInfo, VULKAN_HPP_NAMESPACE::Optional allocator = nullptr ) - : m_instance( &instance ) - , m_allocator( reinterpret_cast( - static_cast( allocator ) ) ) + : m_instance( *instance ) + , m_allocator( static_cast( allocator ) ) , m_dispatcher( instance.getDispatcher() ) { VULKAN_HPP_NAMESPACE::Result result = static_cast( instance.getDispatcher()->vkCreateScreenSurfaceQNX( static_cast( *instance ), reinterpret_cast( &createInfo ), - m_allocator, - reinterpret_cast( &m_surfaceKHR ) ) ); + reinterpret_cast( m_allocator ), + reinterpret_cast( &m_surface ) ) ); if ( result != VULKAN_HPP_NAMESPACE::Result::eSuccess ) { throwResultException( result, "vkCreateScreenSurfaceQNX" ); @@ -9202,17 +8888,16 @@ namespace VULKAN_HPP_NAMESPACE SurfaceKHR( VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::Instance const & instance, VULKAN_HPP_NAMESPACE::StreamDescriptorSurfaceCreateInfoGGP const & createInfo, VULKAN_HPP_NAMESPACE::Optional allocator = nullptr ) - : m_instance( &instance ) - , m_allocator( reinterpret_cast( - static_cast( allocator ) ) ) + : m_instance( *instance ) + , m_allocator( static_cast( allocator ) ) , m_dispatcher( instance.getDispatcher() ) { VULKAN_HPP_NAMESPACE::Result result = static_cast( instance.getDispatcher()->vkCreateStreamDescriptorSurfaceGGP( static_cast( *instance ), reinterpret_cast( &createInfo ), - m_allocator, - reinterpret_cast( &m_surfaceKHR ) ) ); + reinterpret_cast( m_allocator ), + reinterpret_cast( &m_surface ) ) ); if ( result != VULKAN_HPP_NAMESPACE::Result::eSuccess ) { throwResultException( result, "vkCreateStreamDescriptorSurfaceGGP" ); @@ -9224,17 +8909,16 @@ namespace VULKAN_HPP_NAMESPACE SurfaceKHR( VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::Instance const & instance, VULKAN_HPP_NAMESPACE::ViSurfaceCreateInfoNN const & createInfo, VULKAN_HPP_NAMESPACE::Optional allocator = nullptr ) - : m_instance( &instance ) - , m_allocator( reinterpret_cast( - static_cast( allocator ) ) ) + : m_instance( *instance ) + , m_allocator( static_cast( allocator ) ) , m_dispatcher( instance.getDispatcher() ) { VULKAN_HPP_NAMESPACE::Result result = static_cast( instance.getDispatcher()->vkCreateViSurfaceNN( static_cast( *instance ), reinterpret_cast( &createInfo ), - m_allocator, - reinterpret_cast( &m_surfaceKHR ) ) ); + reinterpret_cast( m_allocator ), + reinterpret_cast( &m_surface ) ) ); if ( result != VULKAN_HPP_NAMESPACE::Result::eSuccess ) { throwResultException( result, "vkCreateViSurfaceNN" ); @@ -9246,17 +8930,16 @@ namespace VULKAN_HPP_NAMESPACE SurfaceKHR( VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::Instance const & instance, VULKAN_HPP_NAMESPACE::WaylandSurfaceCreateInfoKHR const & createInfo, VULKAN_HPP_NAMESPACE::Optional allocator = nullptr ) - : m_instance( &instance ) - , m_allocator( reinterpret_cast( - static_cast( allocator ) ) ) + : m_instance( *instance ) + , m_allocator( static_cast( allocator ) ) , m_dispatcher( instance.getDispatcher() ) { VULKAN_HPP_NAMESPACE::Result result = static_cast( instance.getDispatcher()->vkCreateWaylandSurfaceKHR( static_cast( *instance ), reinterpret_cast( &createInfo ), - m_allocator, - reinterpret_cast( &m_surfaceKHR ) ) ); + reinterpret_cast( m_allocator ), + reinterpret_cast( &m_surface ) ) ); if ( result != VULKAN_HPP_NAMESPACE::Result::eSuccess ) { throwResultException( result, "vkCreateWaylandSurfaceKHR" ); @@ -9268,17 +8951,16 @@ namespace VULKAN_HPP_NAMESPACE SurfaceKHR( VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::Instance const & instance, VULKAN_HPP_NAMESPACE::Win32SurfaceCreateInfoKHR const & createInfo, VULKAN_HPP_NAMESPACE::Optional allocator = nullptr ) - : m_instance( &instance ) - , m_allocator( reinterpret_cast( - static_cast( allocator ) ) ) + : m_instance( *instance ) + , m_allocator( static_cast( allocator ) ) , m_dispatcher( instance.getDispatcher() ) { VULKAN_HPP_NAMESPACE::Result result = static_cast( instance.getDispatcher()->vkCreateWin32SurfaceKHR( static_cast( *instance ), reinterpret_cast( &createInfo ), - m_allocator, - reinterpret_cast( &m_surfaceKHR ) ) ); + reinterpret_cast( m_allocator ), + reinterpret_cast( &m_surface ) ) ); if ( result != VULKAN_HPP_NAMESPACE::Result::eSuccess ) { throwResultException( result, "vkCreateWin32SurfaceKHR" ); @@ -9290,17 +8972,16 @@ namespace VULKAN_HPP_NAMESPACE SurfaceKHR( VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::Instance const & instance, VULKAN_HPP_NAMESPACE::XcbSurfaceCreateInfoKHR const & createInfo, VULKAN_HPP_NAMESPACE::Optional allocator = nullptr ) - : m_instance( &instance ) - , m_allocator( reinterpret_cast( - static_cast( allocator ) ) ) + : m_instance( *instance ) + , m_allocator( static_cast( allocator ) ) , m_dispatcher( instance.getDispatcher() ) { VULKAN_HPP_NAMESPACE::Result result = static_cast( instance.getDispatcher()->vkCreateXcbSurfaceKHR( static_cast( *instance ), reinterpret_cast( &createInfo ), - m_allocator, - reinterpret_cast( &m_surfaceKHR ) ) ); + reinterpret_cast( m_allocator ), + reinterpret_cast( &m_surface ) ) ); if ( result != VULKAN_HPP_NAMESPACE::Result::eSuccess ) { throwResultException( result, "vkCreateXcbSurfaceKHR" ); @@ -9312,17 +8993,16 @@ namespace VULKAN_HPP_NAMESPACE SurfaceKHR( VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::Instance const & instance, VULKAN_HPP_NAMESPACE::XlibSurfaceCreateInfoKHR const & createInfo, VULKAN_HPP_NAMESPACE::Optional allocator = nullptr ) - : m_instance( &instance ) - , m_allocator( reinterpret_cast( - static_cast( allocator ) ) ) + : m_instance( *instance ) + , m_allocator( static_cast( allocator ) ) , m_dispatcher( instance.getDispatcher() ) { VULKAN_HPP_NAMESPACE::Result result = static_cast( instance.getDispatcher()->vkCreateXlibSurfaceKHR( static_cast( *instance ), reinterpret_cast( &createInfo ), - m_allocator, - reinterpret_cast( &m_surfaceKHR ) ) ); + reinterpret_cast( m_allocator ), + reinterpret_cast( &m_surface ) ) ); if ( result != VULKAN_HPP_NAMESPACE::Result::eSuccess ) { throwResultException( result, "vkCreateXlibSurfaceKHR" ); @@ -9331,12 +9011,11 @@ namespace VULKAN_HPP_NAMESPACE # endif /*VK_USE_PLATFORM_XLIB_KHR*/ SurfaceKHR( VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::Instance const & instance, - VkSurfaceKHR surfaceKHR, + VkSurfaceKHR surface, VULKAN_HPP_NAMESPACE::Optional allocator = nullptr ) - : m_instance( &instance ) - , m_surfaceKHR( surfaceKHR ) - , m_allocator( reinterpret_cast( - static_cast( allocator ) ) ) + : m_instance( *instance ) + , m_surface( surface ) + , m_allocator( static_cast( allocator ) ) , m_dispatcher( instance.getDispatcher() ) {} @@ -9344,19 +9023,20 @@ namespace VULKAN_HPP_NAMESPACE ~SurfaceKHR() { - if ( m_surfaceKHR ) + if ( m_surface ) { - getDispatcher()->vkDestroySurfaceKHR( - static_cast( **m_instance ), static_cast( m_surfaceKHR ), m_allocator ); + getDispatcher()->vkDestroySurfaceKHR( static_cast( m_instance ), + static_cast( m_surface ), + reinterpret_cast( m_allocator ) ); } } SurfaceKHR() = delete; SurfaceKHR( SurfaceKHR const & ) = delete; SurfaceKHR( SurfaceKHR && rhs ) VULKAN_HPP_NOEXCEPT - : m_instance( VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange( rhs.m_instance, nullptr ) ) - , m_surfaceKHR( VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange( rhs.m_surfaceKHR, {} ) ) - , m_allocator( rhs.m_allocator ) + : m_instance( VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange( rhs.m_instance, {} ) ) + , m_surface( VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange( rhs.m_surface, {} ) ) + , m_allocator( VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange( rhs.m_allocator, {} ) ) , m_dispatcher( VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange( rhs.m_dispatcher, nullptr ) ) {} SurfaceKHR & operator=( SurfaceKHR const & ) = delete; @@ -9364,14 +9044,9 @@ namespace VULKAN_HPP_NAMESPACE { if ( this != &rhs ) { - if ( m_surfaceKHR ) - { - getDispatcher()->vkDestroySurfaceKHR( - static_cast( **m_instance ), static_cast( m_surfaceKHR ), m_allocator ); - } - m_instance = VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange( rhs.m_instance, nullptr ); - m_surfaceKHR = VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange( rhs.m_surfaceKHR, {} ); - m_allocator = rhs.m_allocator; + m_instance = VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange( rhs.m_instance, {} ); + m_surface = VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange( rhs.m_surface, {} ); + m_allocator = VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange( rhs.m_allocator, {} ); m_dispatcher = VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange( rhs.m_dispatcher, nullptr ); } return *this; @@ -9379,10 +9054,10 @@ namespace VULKAN_HPP_NAMESPACE VULKAN_HPP_NAMESPACE::SurfaceKHR const & operator*() const VULKAN_HPP_NOEXCEPT { - return m_surfaceKHR; + return m_surface; } - VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::Instance const * getInstance() const VULKAN_HPP_NOEXCEPT + VULKAN_HPP_NAMESPACE::Instance getInstance() const { return m_instance; } @@ -9394,9 +9069,9 @@ namespace VULKAN_HPP_NAMESPACE } private: - VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::Instance const * m_instance = nullptr; - VULKAN_HPP_NAMESPACE::SurfaceKHR m_surfaceKHR; - const VkAllocationCallbacks * m_allocator = nullptr; + VULKAN_HPP_NAMESPACE::Instance m_instance = {}; + VULKAN_HPP_NAMESPACE::SurfaceKHR m_surface = {}; + const VULKAN_HPP_NAMESPACE::AllocationCallbacks * m_allocator = nullptr; VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::InstanceDispatcher const * m_dispatcher = nullptr; }; @@ -9415,17 +9090,16 @@ namespace VULKAN_HPP_NAMESPACE VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::Device const & device, VULKAN_HPP_NAMESPACE::SwapchainCreateInfoKHR const & createInfo, VULKAN_HPP_NAMESPACE::Optional allocator = nullptr ) - : m_device( &device ) - , m_allocator( reinterpret_cast( - static_cast( allocator ) ) ) + : m_device( *device ) + , m_allocator( static_cast( allocator ) ) , m_dispatcher( device.getDispatcher() ) { VULKAN_HPP_NAMESPACE::Result result = static_cast( device.getDispatcher()->vkCreateSwapchainKHR( static_cast( *device ), reinterpret_cast( &createInfo ), - m_allocator, - reinterpret_cast( &m_swapchainKHR ) ) ); + reinterpret_cast( m_allocator ), + reinterpret_cast( &m_swapchain ) ) ); if ( result != VULKAN_HPP_NAMESPACE::Result::eSuccess ) { throwResultException( result, "vkCreateSwapchainKHR" ); @@ -9434,12 +9108,11 @@ namespace VULKAN_HPP_NAMESPACE SwapchainKHR( VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::Device const & device, - VkSwapchainKHR swapchainKHR, + VkSwapchainKHR swapchain, VULKAN_HPP_NAMESPACE::Optional allocator = nullptr ) - : m_device( &device ) - , m_swapchainKHR( swapchainKHR ) - , m_allocator( reinterpret_cast( - static_cast( allocator ) ) ) + : m_device( *device ) + , m_swapchain( swapchain ) + , m_allocator( static_cast( allocator ) ) , m_dispatcher( device.getDispatcher() ) {} @@ -9447,19 +9120,20 @@ namespace VULKAN_HPP_NAMESPACE ~SwapchainKHR() { - if ( m_swapchainKHR ) + if ( m_swapchain ) { - getDispatcher()->vkDestroySwapchainKHR( - static_cast( **m_device ), static_cast( m_swapchainKHR ), m_allocator ); + getDispatcher()->vkDestroySwapchainKHR( static_cast( m_device ), + static_cast( m_swapchain ), + reinterpret_cast( m_allocator ) ); } } SwapchainKHR() = delete; SwapchainKHR( SwapchainKHR const & ) = delete; SwapchainKHR( SwapchainKHR && rhs ) VULKAN_HPP_NOEXCEPT - : m_device( VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange( rhs.m_device, nullptr ) ) - , m_swapchainKHR( VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange( rhs.m_swapchainKHR, {} ) ) - , m_allocator( rhs.m_allocator ) + : m_device( VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange( rhs.m_device, {} ) ) + , m_swapchain( VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange( rhs.m_swapchain, {} ) ) + , m_allocator( VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange( rhs.m_allocator, {} ) ) , m_dispatcher( VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange( rhs.m_dispatcher, nullptr ) ) {} SwapchainKHR & operator=( SwapchainKHR const & ) = delete; @@ -9467,25 +9141,20 @@ namespace VULKAN_HPP_NAMESPACE { if ( this != &rhs ) { - if ( m_swapchainKHR ) - { - getDispatcher()->vkDestroySwapchainKHR( - static_cast( **m_device ), static_cast( m_swapchainKHR ), m_allocator ); - } - m_device = VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange( rhs.m_device, nullptr ); - m_swapchainKHR = VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange( rhs.m_swapchainKHR, {} ); - m_allocator = rhs.m_allocator; - m_dispatcher = VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange( rhs.m_dispatcher, nullptr ); + m_device = VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange( rhs.m_device, {} ); + m_swapchain = VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange( rhs.m_swapchain, {} ); + m_allocator = VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange( rhs.m_allocator, {} ); + m_dispatcher = VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange( rhs.m_dispatcher, nullptr ); } return *this; } VULKAN_HPP_NAMESPACE::SwapchainKHR const & operator*() const VULKAN_HPP_NOEXCEPT { - return m_swapchainKHR; + return m_swapchain; } - VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::Device const * getDevice() const VULKAN_HPP_NOEXCEPT + VULKAN_HPP_NAMESPACE::Device getDevice() const { return m_device; } @@ -9537,9 +9206,9 @@ namespace VULKAN_HPP_NAMESPACE # endif /*VK_USE_PLATFORM_WIN32_KHR*/ private: - VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::Device const * m_device = nullptr; - VULKAN_HPP_NAMESPACE::SwapchainKHR m_swapchainKHR; - const VkAllocationCallbacks * m_allocator = nullptr; + VULKAN_HPP_NAMESPACE::Device m_device = {}; + VULKAN_HPP_NAMESPACE::SwapchainKHR m_swapchain = {}; + const VULKAN_HPP_NAMESPACE::AllocationCallbacks * m_allocator = nullptr; VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::DeviceDispatcher const * m_dispatcher = nullptr; }; @@ -9597,17 +9266,16 @@ namespace VULKAN_HPP_NAMESPACE VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::Device const & device, VULKAN_HPP_NAMESPACE::ValidationCacheCreateInfoEXT const & createInfo, VULKAN_HPP_NAMESPACE::Optional allocator = nullptr ) - : m_device( &device ) - , m_allocator( reinterpret_cast( - static_cast( allocator ) ) ) + : m_device( *device ) + , m_allocator( static_cast( allocator ) ) , m_dispatcher( device.getDispatcher() ) { VULKAN_HPP_NAMESPACE::Result result = static_cast( device.getDispatcher()->vkCreateValidationCacheEXT( static_cast( *device ), reinterpret_cast( &createInfo ), - m_allocator, - reinterpret_cast( &m_validationCacheEXT ) ) ); + reinterpret_cast( m_allocator ), + reinterpret_cast( &m_validationCache ) ) ); if ( result != VULKAN_HPP_NAMESPACE::Result::eSuccess ) { throwResultException( result, "vkCreateValidationCacheEXT" ); @@ -9616,12 +9284,11 @@ namespace VULKAN_HPP_NAMESPACE ValidationCacheEXT( VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::Device const & device, - VkValidationCacheEXT validationCacheEXT, + VkValidationCacheEXT validationCache, VULKAN_HPP_NAMESPACE::Optional allocator = nullptr ) - : m_device( &device ) - , m_validationCacheEXT( validationCacheEXT ) - , m_allocator( reinterpret_cast( - static_cast( allocator ) ) ) + : m_device( *device ) + , m_validationCache( validationCache ) + , m_allocator( static_cast( allocator ) ) , m_dispatcher( device.getDispatcher() ) {} @@ -9629,21 +9296,21 @@ namespace VULKAN_HPP_NAMESPACE ~ValidationCacheEXT() { - if ( m_validationCacheEXT ) + if ( m_validationCache ) { - getDispatcher()->vkDestroyValidationCacheEXT( static_cast( **m_device ), - static_cast( m_validationCacheEXT ), - m_allocator ); + getDispatcher()->vkDestroyValidationCacheEXT( + static_cast( m_device ), + static_cast( m_validationCache ), + reinterpret_cast( m_allocator ) ); } } ValidationCacheEXT() = delete; ValidationCacheEXT( ValidationCacheEXT const & ) = delete; ValidationCacheEXT( ValidationCacheEXT && rhs ) VULKAN_HPP_NOEXCEPT - : m_device( VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange( rhs.m_device, nullptr ) ) - , m_validationCacheEXT( VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange( rhs.m_validationCacheEXT, - {} ) ) - , m_allocator( rhs.m_allocator ) + : m_device( VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange( rhs.m_device, {} ) ) + , m_validationCache( VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange( rhs.m_validationCache, {} ) ) + , m_allocator( VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange( rhs.m_allocator, {} ) ) , m_dispatcher( VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange( rhs.m_dispatcher, nullptr ) ) {} ValidationCacheEXT & operator=( ValidationCacheEXT const & ) = delete; @@ -9651,27 +9318,20 @@ namespace VULKAN_HPP_NAMESPACE { if ( this != &rhs ) { - if ( m_validationCacheEXT ) - { - getDispatcher()->vkDestroyValidationCacheEXT( static_cast( **m_device ), - static_cast( m_validationCacheEXT ), - m_allocator ); - } - m_device = VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange( rhs.m_device, nullptr ); - m_validationCacheEXT = - VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange( rhs.m_validationCacheEXT, {} ); - m_allocator = rhs.m_allocator; - m_dispatcher = VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange( rhs.m_dispatcher, nullptr ); + m_device = VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange( rhs.m_device, {} ); + m_validationCache = VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange( rhs.m_validationCache, {} ); + m_allocator = VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange( rhs.m_allocator, {} ); + m_dispatcher = VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange( rhs.m_dispatcher, nullptr ); } return *this; } VULKAN_HPP_NAMESPACE::ValidationCacheEXT const & operator*() const VULKAN_HPP_NOEXCEPT { - return m_validationCacheEXT; + return m_validationCache; } - VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::Device const * getDevice() const VULKAN_HPP_NOEXCEPT + VULKAN_HPP_NAMESPACE::Device getDevice() const { return m_device; } @@ -9689,10 +9349,10 @@ namespace VULKAN_HPP_NAMESPACE VULKAN_HPP_NODISCARD std::vector getData() const; private: - VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::Device const * m_device = nullptr; - VULKAN_HPP_NAMESPACE::ValidationCacheEXT m_validationCacheEXT; - const VkAllocationCallbacks * m_allocator = nullptr; - VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::DeviceDispatcher const * m_dispatcher = nullptr; + VULKAN_HPP_NAMESPACE::Device m_device = {}; + VULKAN_HPP_NAMESPACE::ValidationCacheEXT m_validationCache = {}; + const VULKAN_HPP_NAMESPACE::AllocationCallbacks * m_allocator = nullptr; + VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::DeviceDispatcher const * m_dispatcher = nullptr; }; # if defined( VK_ENABLE_BETA_EXTENSIONS ) @@ -9711,17 +9371,16 @@ namespace VULKAN_HPP_NAMESPACE VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::Device const & device, VULKAN_HPP_NAMESPACE::VideoSessionCreateInfoKHR const & createInfo, VULKAN_HPP_NAMESPACE::Optional allocator = nullptr ) - : m_device( &device ) - , m_allocator( reinterpret_cast( - static_cast( allocator ) ) ) + : m_device( *device ) + , m_allocator( static_cast( allocator ) ) , m_dispatcher( device.getDispatcher() ) { VULKAN_HPP_NAMESPACE::Result result = static_cast( device.getDispatcher()->vkCreateVideoSessionKHR( static_cast( *device ), reinterpret_cast( &createInfo ), - m_allocator, - reinterpret_cast( &m_videoSessionKHR ) ) ); + reinterpret_cast( m_allocator ), + reinterpret_cast( &m_videoSession ) ) ); if ( result != VULKAN_HPP_NAMESPACE::Result::eSuccess ) { throwResultException( result, "vkCreateVideoSessionKHR" ); @@ -9730,12 +9389,11 @@ namespace VULKAN_HPP_NAMESPACE VideoSessionKHR( VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::Device const & device, - VkVideoSessionKHR videoSessionKHR, + VkVideoSessionKHR videoSession, VULKAN_HPP_NAMESPACE::Optional allocator = nullptr ) - : m_device( &device ) - , m_videoSessionKHR( videoSessionKHR ) - , m_allocator( reinterpret_cast( - static_cast( allocator ) ) ) + : m_device( *device ) + , m_videoSession( videoSession ) + , m_allocator( static_cast( allocator ) ) , m_dispatcher( device.getDispatcher() ) {} @@ -9743,19 +9401,20 @@ namespace VULKAN_HPP_NAMESPACE ~VideoSessionKHR() { - if ( m_videoSessionKHR ) + if ( m_videoSession ) { - getDispatcher()->vkDestroyVideoSessionKHR( - static_cast( **m_device ), static_cast( m_videoSessionKHR ), m_allocator ); + getDispatcher()->vkDestroyVideoSessionKHR( static_cast( m_device ), + static_cast( m_videoSession ), + reinterpret_cast( m_allocator ) ); } } VideoSessionKHR() = delete; VideoSessionKHR( VideoSessionKHR const & ) = delete; VideoSessionKHR( VideoSessionKHR && rhs ) VULKAN_HPP_NOEXCEPT - : m_device( VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange( rhs.m_device, nullptr ) ) - , m_videoSessionKHR( VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange( rhs.m_videoSessionKHR, {} ) ) - , m_allocator( rhs.m_allocator ) + : m_device( VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange( rhs.m_device, {} ) ) + , m_videoSession( VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange( rhs.m_videoSession, {} ) ) + , m_allocator( VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange( rhs.m_allocator, {} ) ) , m_dispatcher( VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange( rhs.m_dispatcher, nullptr ) ) {} VideoSessionKHR & operator=( VideoSessionKHR const & ) = delete; @@ -9763,25 +9422,20 @@ namespace VULKAN_HPP_NAMESPACE { if ( this != &rhs ) { - if ( m_videoSessionKHR ) - { - getDispatcher()->vkDestroyVideoSessionKHR( - static_cast( **m_device ), static_cast( m_videoSessionKHR ), m_allocator ); - } - m_device = VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange( rhs.m_device, nullptr ); - m_videoSessionKHR = VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange( rhs.m_videoSessionKHR, {} ); - m_allocator = rhs.m_allocator; - m_dispatcher = VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange( rhs.m_dispatcher, nullptr ); + m_device = VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange( rhs.m_device, {} ); + m_videoSession = VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange( rhs.m_videoSession, {} ); + m_allocator = VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange( rhs.m_allocator, {} ); + m_dispatcher = VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange( rhs.m_dispatcher, nullptr ); } return *this; } VULKAN_HPP_NAMESPACE::VideoSessionKHR const & operator*() const VULKAN_HPP_NOEXCEPT { - return m_videoSessionKHR; + return m_videoSession; } - VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::Device const * getDevice() const VULKAN_HPP_NOEXCEPT + VULKAN_HPP_NAMESPACE::Device getDevice() const { return m_device; } @@ -9800,10 +9454,10 @@ namespace VULKAN_HPP_NAMESPACE bindMemory( ArrayProxy const & videoSessionBindMemories ) const; private: - VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::Device const * m_device = nullptr; - VULKAN_HPP_NAMESPACE::VideoSessionKHR m_videoSessionKHR; - const VkAllocationCallbacks * m_allocator = nullptr; - VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::DeviceDispatcher const * m_dispatcher = nullptr; + VULKAN_HPP_NAMESPACE::Device m_device = {}; + VULKAN_HPP_NAMESPACE::VideoSessionKHR m_videoSession = {}; + const VULKAN_HPP_NAMESPACE::AllocationCallbacks * m_allocator = nullptr; + VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::DeviceDispatcher const * m_dispatcher = nullptr; }; # endif /*VK_ENABLE_BETA_EXTENSIONS*/ @@ -9823,17 +9477,16 @@ namespace VULKAN_HPP_NAMESPACE VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::Device const & device, VULKAN_HPP_NAMESPACE::VideoSessionParametersCreateInfoKHR const & createInfo, VULKAN_HPP_NAMESPACE::Optional allocator = nullptr ) - : m_device( &device ) - , m_allocator( reinterpret_cast( - static_cast( allocator ) ) ) + : m_device( *device ) + , m_allocator( static_cast( allocator ) ) , m_dispatcher( device.getDispatcher() ) { VULKAN_HPP_NAMESPACE::Result result = static_cast( device.getDispatcher()->vkCreateVideoSessionParametersKHR( static_cast( *device ), reinterpret_cast( &createInfo ), - m_allocator, - reinterpret_cast( &m_videoSessionParametersKHR ) ) ); + reinterpret_cast( m_allocator ), + reinterpret_cast( &m_videoSessionParameters ) ) ); if ( result != VULKAN_HPP_NAMESPACE::Result::eSuccess ) { throwResultException( result, "vkCreateVideoSessionParametersKHR" ); @@ -9842,12 +9495,11 @@ namespace VULKAN_HPP_NAMESPACE VideoSessionParametersKHR( VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::Device const & device, - VkVideoSessionParametersKHR videoSessionParametersKHR, + VkVideoSessionParametersKHR videoSessionParameters, VULKAN_HPP_NAMESPACE::Optional allocator = nullptr ) - : m_device( &device ) - , m_videoSessionParametersKHR( videoSessionParametersKHR ) - , m_allocator( reinterpret_cast( - static_cast( allocator ) ) ) + : m_device( *device ) + , m_videoSessionParameters( videoSessionParameters ) + , m_allocator( static_cast( allocator ) ) , m_dispatcher( device.getDispatcher() ) {} @@ -9855,22 +9507,22 @@ namespace VULKAN_HPP_NAMESPACE ~VideoSessionParametersKHR() { - if ( m_videoSessionParametersKHR ) + if ( m_videoSessionParameters ) { getDispatcher()->vkDestroyVideoSessionParametersKHR( - static_cast( **m_device ), - static_cast( m_videoSessionParametersKHR ), - m_allocator ); + static_cast( m_device ), + static_cast( m_videoSessionParameters ), + reinterpret_cast( m_allocator ) ); } } VideoSessionParametersKHR() = delete; VideoSessionParametersKHR( VideoSessionParametersKHR const & ) = delete; VideoSessionParametersKHR( VideoSessionParametersKHR && rhs ) VULKAN_HPP_NOEXCEPT - : m_device( VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange( rhs.m_device, nullptr ) ) - , m_videoSessionParametersKHR( - VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange( rhs.m_videoSessionParametersKHR, {} ) ) - , m_allocator( rhs.m_allocator ) + : m_device( VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange( rhs.m_device, {} ) ) + , m_videoSessionParameters( + VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange( rhs.m_videoSessionParameters, {} ) ) + , m_allocator( VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange( rhs.m_allocator, {} ) ) , m_dispatcher( VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange( rhs.m_dispatcher, nullptr ) ) {} VideoSessionParametersKHR & operator=( VideoSessionParametersKHR const & ) = delete; @@ -9878,17 +9530,10 @@ namespace VULKAN_HPP_NAMESPACE { if ( this != &rhs ) { - if ( m_videoSessionParametersKHR ) - { - getDispatcher()->vkDestroyVideoSessionParametersKHR( - static_cast( **m_device ), - static_cast( m_videoSessionParametersKHR ), - m_allocator ); - } - m_device = VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange( rhs.m_device, nullptr ); - m_videoSessionParametersKHR = - VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange( rhs.m_videoSessionParametersKHR, {} ); - m_allocator = rhs.m_allocator; + m_device = VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange( rhs.m_device, {} ); + m_videoSessionParameters = + VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange( rhs.m_videoSessionParameters, {} ); + m_allocator = VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange( rhs.m_allocator, {} ); m_dispatcher = VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange( rhs.m_dispatcher, nullptr ); } return *this; @@ -9896,10 +9541,10 @@ namespace VULKAN_HPP_NAMESPACE VULKAN_HPP_NAMESPACE::VideoSessionParametersKHR const & operator*() const VULKAN_HPP_NOEXCEPT { - return m_videoSessionParametersKHR; + return m_videoSessionParameters; } - VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::Device const * getDevice() const VULKAN_HPP_NOEXCEPT + VULKAN_HPP_NAMESPACE::Device getDevice() const { return m_device; } @@ -9915,10 +9560,10 @@ namespace VULKAN_HPP_NAMESPACE void update( const VULKAN_HPP_NAMESPACE::VideoSessionParametersUpdateInfoKHR & updateInfo ) const; private: - VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::Device const * m_device = nullptr; - VULKAN_HPP_NAMESPACE::VideoSessionParametersKHR m_videoSessionParametersKHR; - const VkAllocationCallbacks * m_allocator = nullptr; - VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::DeviceDispatcher const * m_dispatcher = nullptr; + VULKAN_HPP_NAMESPACE::Device m_device = {}; + VULKAN_HPP_NAMESPACE::VideoSessionParametersKHR m_videoSessionParameters = {}; + const VULKAN_HPP_NAMESPACE::AllocationCallbacks * m_allocator = nullptr; + VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::DeviceDispatcher const * m_dispatcher = nullptr; }; # endif /*VK_ENABLE_BETA_EXTENSIONS*/ @@ -10219,8 +9864,8 @@ namespace VULKAN_HPP_NAMESPACE { void * pData; VULKAN_HPP_NAMESPACE::Result result = static_cast( - getDispatcher()->vkMapMemory( static_cast( **m_device ), - static_cast( m_deviceMemory ), + getDispatcher()->vkMapMemory( static_cast( m_device ), + static_cast( m_memory ), static_cast( offset ), static_cast( size ), static_cast( flags ), @@ -10234,8 +9879,7 @@ namespace VULKAN_HPP_NAMESPACE VULKAN_HPP_INLINE void DeviceMemory::unmapMemory() const VULKAN_HPP_NOEXCEPT { - getDispatcher()->vkUnmapMemory( static_cast( **m_device ), - static_cast( m_deviceMemory ) ); + getDispatcher()->vkUnmapMemory( static_cast( m_device ), static_cast( m_memory ) ); } VULKAN_HPP_INLINE void Device::flushMappedMemoryRanges( @@ -10270,8 +9914,8 @@ namespace VULKAN_HPP_NAMESPACE DeviceMemory::getCommitment() const VULKAN_HPP_NOEXCEPT { VULKAN_HPP_NAMESPACE::DeviceSize committedMemoryInBytes; - getDispatcher()->vkGetDeviceMemoryCommitment( static_cast( **m_device ), - static_cast( m_deviceMemory ), + getDispatcher()->vkGetDeviceMemoryCommitment( static_cast( m_device ), + static_cast( m_memory ), reinterpret_cast( &committedMemoryInBytes ) ); return committedMemoryInBytes; } @@ -10280,7 +9924,7 @@ namespace VULKAN_HPP_NAMESPACE VULKAN_HPP_NAMESPACE::DeviceSize memoryOffset ) const { VULKAN_HPP_NAMESPACE::Result result = static_cast( - getDispatcher()->vkBindBufferMemory( static_cast( **m_device ), + getDispatcher()->vkBindBufferMemory( static_cast( m_device ), static_cast( m_buffer ), static_cast( memory ), static_cast( memoryOffset ) ) ); @@ -10294,7 +9938,7 @@ namespace VULKAN_HPP_NAMESPACE VULKAN_HPP_NAMESPACE::DeviceSize memoryOffset ) const { VULKAN_HPP_NAMESPACE::Result result = static_cast( - getDispatcher()->vkBindImageMemory( static_cast( **m_device ), + getDispatcher()->vkBindImageMemory( static_cast( m_device ), static_cast( m_image ), static_cast( memory ), static_cast( memoryOffset ) ) ); @@ -10308,7 +9952,7 @@ namespace VULKAN_HPP_NAMESPACE Buffer::getMemoryRequirements() const VULKAN_HPP_NOEXCEPT { VULKAN_HPP_NAMESPACE::MemoryRequirements memoryRequirements; - getDispatcher()->vkGetBufferMemoryRequirements( static_cast( **m_device ), + getDispatcher()->vkGetBufferMemoryRequirements( static_cast( m_device ), static_cast( m_buffer ), reinterpret_cast( &memoryRequirements ) ); return memoryRequirements; @@ -10318,7 +9962,7 @@ namespace VULKAN_HPP_NAMESPACE Image::getMemoryRequirements() const VULKAN_HPP_NOEXCEPT { VULKAN_HPP_NAMESPACE::MemoryRequirements memoryRequirements; - getDispatcher()->vkGetImageMemoryRequirements( static_cast( **m_device ), + getDispatcher()->vkGetImageMemoryRequirements( static_cast( m_device ), static_cast( m_image ), reinterpret_cast( &memoryRequirements ) ); return memoryRequirements; @@ -10329,11 +9973,11 @@ namespace VULKAN_HPP_NAMESPACE { uint32_t sparseMemoryRequirementCount; getDispatcher()->vkGetImageSparseMemoryRequirements( - static_cast( **m_device ), static_cast( m_image ), &sparseMemoryRequirementCount, nullptr ); + static_cast( m_device ), static_cast( m_image ), &sparseMemoryRequirementCount, nullptr ); std::vector sparseMemoryRequirements( sparseMemoryRequirementCount ); getDispatcher()->vkGetImageSparseMemoryRequirements( - static_cast( **m_device ), + static_cast( m_device ), static_cast( m_image ), &sparseMemoryRequirementCount, reinterpret_cast( sparseMemoryRequirements.data() ) ); @@ -10407,7 +10051,7 @@ namespace VULKAN_HPP_NAMESPACE VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE VULKAN_HPP_NAMESPACE::Result Fence::getStatus() const { VULKAN_HPP_NAMESPACE::Result result = static_cast( - getDispatcher()->vkGetFenceStatus( static_cast( **m_device ), static_cast( m_fence ) ) ); + getDispatcher()->vkGetFenceStatus( static_cast( m_device ), static_cast( m_fence ) ) ); if ( ( result != VULKAN_HPP_NAMESPACE::Result::eSuccess ) && ( result != VULKAN_HPP_NAMESPACE::Result::eNotReady ) ) { @@ -10452,7 +10096,7 @@ namespace VULKAN_HPP_NAMESPACE VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE VULKAN_HPP_NAMESPACE::Result Event::getStatus() const { VULKAN_HPP_NAMESPACE::Result result = static_cast( - getDispatcher()->vkGetEventStatus( static_cast( **m_device ), static_cast( m_event ) ) ); + getDispatcher()->vkGetEventStatus( static_cast( m_device ), static_cast( m_event ) ) ); if ( ( result != VULKAN_HPP_NAMESPACE::Result::eEventSet ) && ( result != VULKAN_HPP_NAMESPACE::Result::eEventReset ) ) { @@ -10464,7 +10108,7 @@ namespace VULKAN_HPP_NAMESPACE VULKAN_HPP_INLINE void Event::set() const { VULKAN_HPP_NAMESPACE::Result result = static_cast( - getDispatcher()->vkSetEvent( static_cast( **m_device ), static_cast( m_event ) ) ); + getDispatcher()->vkSetEvent( static_cast( m_device ), static_cast( m_event ) ) ); if ( result != VULKAN_HPP_NAMESPACE::Result::eSuccess ) { throwResultException( result, VULKAN_HPP_NAMESPACE_STRING "::Event::set" ); @@ -10474,7 +10118,7 @@ namespace VULKAN_HPP_NAMESPACE VULKAN_HPP_INLINE void Event::reset() const { VULKAN_HPP_NAMESPACE::Result result = static_cast( - getDispatcher()->vkResetEvent( static_cast( **m_device ), static_cast( m_event ) ) ); + getDispatcher()->vkResetEvent( static_cast( m_device ), static_cast( m_event ) ) ); if ( result != VULKAN_HPP_NAMESPACE::Result::eSuccess ) { throwResultException( result, VULKAN_HPP_NAMESPACE_STRING "::Event::reset" ); @@ -10499,7 +10143,7 @@ namespace VULKAN_HPP_NAMESPACE VULKAN_HPP_ASSERT( dataSize % sizeof( T ) == 0 ); std::vector data( dataSize / sizeof( T ) ); Result result = - static_cast( getDispatcher()->vkGetQueryPoolResults( static_cast( **m_device ), + static_cast( getDispatcher()->vkGetQueryPoolResults( static_cast( m_device ), static_cast( m_queryPool ), firstQuery, queryCount, @@ -10524,7 +10168,7 @@ namespace VULKAN_HPP_NAMESPACE { T data; Result result = - static_cast( getDispatcher()->vkGetQueryPoolResults( static_cast( **m_device ), + static_cast( getDispatcher()->vkGetQueryPoolResults( static_cast( m_device ), static_cast( m_queryPool ), firstQuery, queryCount, @@ -10565,7 +10209,7 @@ namespace VULKAN_HPP_NAMESPACE const VULKAN_HPP_NAMESPACE::ImageSubresource & subresource ) const VULKAN_HPP_NOEXCEPT { VULKAN_HPP_NAMESPACE::SubresourceLayout layout; - getDispatcher()->vkGetImageSubresourceLayout( static_cast( **m_device ), + getDispatcher()->vkGetImageSubresourceLayout( static_cast( m_device ), static_cast( m_image ), reinterpret_cast( &subresource ), reinterpret_cast( &layout ) ); @@ -10601,12 +10245,12 @@ namespace VULKAN_HPP_NAMESPACE do { result = static_cast( getDispatcher()->vkGetPipelineCacheData( - static_cast( **m_device ), static_cast( m_pipelineCache ), &dataSize, nullptr ) ); + static_cast( m_device ), static_cast( m_pipelineCache ), &dataSize, nullptr ) ); if ( ( result == VULKAN_HPP_NAMESPACE::Result::eSuccess ) && dataSize ) { data.resize( dataSize ); result = static_cast( - getDispatcher()->vkGetPipelineCacheData( static_cast( **m_device ), + getDispatcher()->vkGetPipelineCacheData( static_cast( m_device ), static_cast( m_pipelineCache ), &dataSize, reinterpret_cast( data.data() ) ) ); @@ -10628,7 +10272,7 @@ namespace VULKAN_HPP_NAMESPACE PipelineCache::merge( ArrayProxy const & srcCaches ) const { VULKAN_HPP_NAMESPACE::Result result = static_cast( - getDispatcher()->vkMergePipelineCaches( static_cast( **m_device ), + getDispatcher()->vkMergePipelineCaches( static_cast( m_device ), static_cast( m_pipelineCache ), srcCaches.size(), reinterpret_cast( srcCaches.data() ) ) ); @@ -10708,7 +10352,7 @@ namespace VULKAN_HPP_NAMESPACE VULKAN_HPP_INLINE void DescriptorPool::reset( VULKAN_HPP_NAMESPACE::DescriptorPoolResetFlags flags ) const VULKAN_HPP_NOEXCEPT { - getDispatcher()->vkResetDescriptorPool( static_cast( **m_device ), + getDispatcher()->vkResetDescriptorPool( static_cast( m_device ), static_cast( m_descriptorPool ), static_cast( flags ) ); } @@ -10749,7 +10393,7 @@ namespace VULKAN_HPP_NAMESPACE RenderPass::getRenderAreaGranularity() const VULKAN_HPP_NOEXCEPT { VULKAN_HPP_NAMESPACE::Extent2D granularity; - getDispatcher()->vkGetRenderAreaGranularity( static_cast( **m_device ), + getDispatcher()->vkGetRenderAreaGranularity( static_cast( m_device ), static_cast( m_renderPass ), reinterpret_cast( &granularity ) ); return granularity; @@ -10765,7 +10409,7 @@ namespace VULKAN_HPP_NAMESPACE VULKAN_HPP_INLINE void CommandPool::reset( VULKAN_HPP_NAMESPACE::CommandPoolResetFlags flags ) const { VULKAN_HPP_NAMESPACE::Result result = static_cast( - getDispatcher()->vkResetCommandPool( static_cast( **m_device ), + getDispatcher()->vkResetCommandPool( static_cast( m_device ), static_cast( m_commandPool ), static_cast( flags ) ) ); if ( result != VULKAN_HPP_NAMESPACE::Result::eSuccess ) @@ -11685,7 +11329,7 @@ namespace VULKAN_HPP_NAMESPACE VULKAN_HPP_INLINE void CommandPool::trim( VULKAN_HPP_NAMESPACE::CommandPoolTrimFlags flags ) const VULKAN_HPP_NOEXCEPT { - getDispatcher()->vkTrimCommandPool( static_cast( **m_device ), + getDispatcher()->vkTrimCommandPool( static_cast( m_device ), static_cast( m_commandPool ), static_cast( flags ) ); } @@ -11717,7 +11361,7 @@ namespace VULKAN_HPP_NAMESPACE const void * pData ) const VULKAN_HPP_NOEXCEPT { getDispatcher()->vkUpdateDescriptorSetWithTemplate( - static_cast( **m_device ), + static_cast( m_device ), static_cast( m_descriptorSet ), static_cast( descriptorUpdateTemplate ), pData ); @@ -11854,7 +11498,7 @@ namespace VULKAN_HPP_NAMESPACE VULKAN_HPP_INLINE void QueryPool::reset( uint32_t firstQuery, uint32_t queryCount ) const VULKAN_HPP_NOEXCEPT { getDispatcher()->vkResetQueryPool( - static_cast( **m_device ), static_cast( m_queryPool ), firstQuery, queryCount ); + static_cast( m_device ), static_cast( m_queryPool ), firstQuery, queryCount ); } VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE uint64_t Semaphore::getCounterValue() const @@ -11862,7 +11506,7 @@ namespace VULKAN_HPP_NAMESPACE uint64_t value; VULKAN_HPP_NAMESPACE::Result result = static_cast( getDispatcher()->vkGetSemaphoreCounterValue( - static_cast( **m_device ), static_cast( m_semaphore ), &value ) ); + static_cast( m_device ), static_cast( m_semaphore ), &value ) ); if ( result != VULKAN_HPP_NAMESPACE::Result::eSuccess ) { throwResultException( result, VULKAN_HPP_NAMESPACE_STRING "::Semaphore::getCounterValue" ); @@ -12055,16 +11699,16 @@ namespace VULKAN_HPP_NAMESPACE do { result = static_cast( - getDispatcher()->vkGetSwapchainImagesKHR( static_cast( **m_device ), - static_cast( m_swapchainKHR ), + getDispatcher()->vkGetSwapchainImagesKHR( static_cast( m_device ), + static_cast( m_swapchain ), &swapchainImageCount, nullptr ) ); if ( ( result == VULKAN_HPP_NAMESPACE::Result::eSuccess ) && swapchainImageCount ) { swapchainImages.resize( swapchainImageCount ); result = static_cast( - getDispatcher()->vkGetSwapchainImagesKHR( static_cast( **m_device ), - static_cast( m_swapchainKHR ), + getDispatcher()->vkGetSwapchainImagesKHR( static_cast( m_device ), + static_cast( m_swapchain ), &swapchainImageCount, swapchainImages.data() ) ); VULKAN_HPP_ASSERT( swapchainImageCount <= swapchainImages.size() ); @@ -12091,8 +11735,8 @@ namespace VULKAN_HPP_NAMESPACE uint32_t imageIndex; VULKAN_HPP_NAMESPACE::Result result = static_cast( - getDispatcher()->vkAcquireNextImageKHR( static_cast( **m_device ), - static_cast( m_swapchainKHR ), + getDispatcher()->vkAcquireNextImageKHR( static_cast( m_device ), + static_cast( m_swapchain ), timeout, static_cast( semaphore ), static_cast( fence ), @@ -12315,16 +11959,16 @@ namespace VULKAN_HPP_NAMESPACE do { result = static_cast( - getDispatcher()->vkGetDisplayModePropertiesKHR( static_cast( **m_physicalDevice ), - static_cast( m_displayKHR ), + getDispatcher()->vkGetDisplayModePropertiesKHR( static_cast( m_physicalDevice ), + static_cast( m_display ), &propertyCount, nullptr ) ); if ( ( result == VULKAN_HPP_NAMESPACE::Result::eSuccess ) && propertyCount ) { properties.resize( propertyCount ); result = static_cast( getDispatcher()->vkGetDisplayModePropertiesKHR( - static_cast( **m_physicalDevice ), - static_cast( m_displayKHR ), + static_cast( m_physicalDevice ), + static_cast( m_display ), &propertyCount, reinterpret_cast( properties.data() ) ) ); VULKAN_HPP_ASSERT( propertyCount <= properties.size() ); @@ -12357,7 +12001,7 @@ namespace VULKAN_HPP_NAMESPACE VULKAN_HPP_NAMESPACE::DisplayPlaneCapabilitiesKHR capabilities; VULKAN_HPP_NAMESPACE::Result result = static_cast( getDispatcher()->vkGetDisplayPlaneCapabilitiesKHR( - static_cast( **m_display->getPhysicalDevice() ), + static_cast( m_physicalDevice ), static_cast( m_displayModeKHR ), planeIndex, reinterpret_cast( &capabilities ) ) ); @@ -12689,16 +12333,16 @@ namespace VULKAN_HPP_NAMESPACE do { result = static_cast( - getDispatcher()->vkGetVideoSessionMemoryRequirementsKHR( static_cast( **m_device ), - static_cast( m_videoSessionKHR ), + getDispatcher()->vkGetVideoSessionMemoryRequirementsKHR( static_cast( m_device ), + static_cast( m_videoSession ), &videoSessionMemoryRequirementsCount, nullptr ) ); if ( ( result == VULKAN_HPP_NAMESPACE::Result::eSuccess ) && videoSessionMemoryRequirementsCount ) { videoSessionMemoryRequirements.resize( videoSessionMemoryRequirementsCount ); result = static_cast( getDispatcher()->vkGetVideoSessionMemoryRequirementsKHR( - static_cast( **m_device ), - static_cast( m_videoSessionKHR ), + static_cast( m_device ), + static_cast( m_videoSession ), &videoSessionMemoryRequirementsCount, reinterpret_cast( videoSessionMemoryRequirements.data() ) ) ); VULKAN_HPP_ASSERT( videoSessionMemoryRequirementsCount <= videoSessionMemoryRequirements.size() ); @@ -12724,8 +12368,8 @@ namespace VULKAN_HPP_NAMESPACE VULKAN_HPP_NAMESPACE::Result result = static_cast( getDispatcher()->vkBindVideoSessionMemoryKHR( - static_cast( **m_device ), - static_cast( m_videoSessionKHR ), + static_cast( m_device ), + static_cast( m_videoSession ), videoSessionBindMemories.size(), reinterpret_cast( videoSessionBindMemories.data() ) ) ); if ( result != VULKAN_HPP_NAMESPACE::Result::eSuccess ) @@ -12750,8 +12394,8 @@ namespace VULKAN_HPP_NAMESPACE VULKAN_HPP_NAMESPACE::Result result = static_cast( getDispatcher()->vkUpdateVideoSessionParametersKHR( - static_cast( **m_device ), - static_cast( m_videoSessionParametersKHR ), + static_cast( m_device ), + static_cast( m_videoSessionParameters ), reinterpret_cast( &updateInfo ) ) ); if ( result != VULKAN_HPP_NAMESPACE::Result::eSuccess ) { @@ -12993,7 +12637,7 @@ namespace VULKAN_HPP_NAMESPACE VULKAN_HPP_NAMESPACE::ImageViewAddressPropertiesNVX properties; VULKAN_HPP_NAMESPACE::Result result = static_cast( getDispatcher()->vkGetImageViewAddressNVX( - static_cast( **m_device ), + static_cast( m_device ), static_cast( m_imageView ), reinterpret_cast( &properties ) ) ); if ( result != VULKAN_HPP_NAMESPACE::Result::eSuccess ) @@ -13060,7 +12704,7 @@ namespace VULKAN_HPP_NAMESPACE do { result = static_cast( - getDispatcher()->vkGetShaderInfoAMD( static_cast( **m_device ), + getDispatcher()->vkGetShaderInfoAMD( static_cast( m_device ), static_cast( m_pipeline ), static_cast( shaderStage ), static_cast( infoType ), @@ -13070,7 +12714,7 @@ namespace VULKAN_HPP_NAMESPACE { info.resize( infoSize ); result = static_cast( - getDispatcher()->vkGetShaderInfoAMD( static_cast( **m_device ), + getDispatcher()->vkGetShaderInfoAMD( static_cast( m_device ), static_cast( m_pipeline ), static_cast( shaderStage ), static_cast( infoType ), @@ -13167,8 +12811,8 @@ namespace VULKAN_HPP_NAMESPACE HANDLE handle; VULKAN_HPP_NAMESPACE::Result result = static_cast( - getDispatcher()->vkGetMemoryWin32HandleNV( static_cast( **m_device ), - static_cast( m_deviceMemory ), + getDispatcher()->vkGetMemoryWin32HandleNV( static_cast( m_device ), + static_cast( m_memory ), static_cast( handleType ), &handle ) ); if ( result != VULKAN_HPP_NAMESPACE::Result::eSuccess ) @@ -13485,7 +13129,7 @@ namespace VULKAN_HPP_NAMESPACE VULKAN_HPP_ASSERT( getDispatcher()->vkTrimCommandPoolKHR && "Function needs extension enabled!" ); - getDispatcher()->vkTrimCommandPoolKHR( static_cast( **m_device ), + getDispatcher()->vkTrimCommandPoolKHR( static_cast( m_device ), static_cast( m_commandPool ), static_cast( flags ) ); } @@ -13823,7 +13467,7 @@ namespace VULKAN_HPP_NAMESPACE "Function needs extension enabled!" ); getDispatcher()->vkUpdateDescriptorSetWithTemplateKHR( - static_cast( **m_device ), + static_cast( m_device ), static_cast( m_descriptorSet ), static_cast( descriptorUpdateTemplate ), pData ); @@ -13936,8 +13580,8 @@ namespace VULKAN_HPP_NAMESPACE uint64_t counterValue; VULKAN_HPP_NAMESPACE::Result result = static_cast( - getDispatcher()->vkGetSwapchainCounterEXT( static_cast( **m_device ), - static_cast( m_swapchainKHR ), + getDispatcher()->vkGetSwapchainCounterEXT( static_cast( m_device ), + static_cast( m_swapchain ), static_cast( counter ), &counterValue ) ); if ( result != VULKAN_HPP_NAMESPACE::Result::eSuccess ) @@ -13959,8 +13603,8 @@ namespace VULKAN_HPP_NAMESPACE VULKAN_HPP_NAMESPACE::RefreshCycleDurationGOOGLE displayTimingProperties; VULKAN_HPP_NAMESPACE::Result result = static_cast( getDispatcher()->vkGetRefreshCycleDurationGOOGLE( - static_cast( **m_device ), - static_cast( m_swapchainKHR ), + static_cast( m_device ), + static_cast( m_swapchain ), reinterpret_cast( &displayTimingProperties ) ) ); if ( result != VULKAN_HPP_NAMESPACE::Result::eSuccess ) { @@ -13982,16 +13626,16 @@ namespace VULKAN_HPP_NAMESPACE do { result = static_cast( - getDispatcher()->vkGetPastPresentationTimingGOOGLE( static_cast( **m_device ), - static_cast( m_swapchainKHR ), + getDispatcher()->vkGetPastPresentationTimingGOOGLE( static_cast( m_device ), + static_cast( m_swapchain ), &presentationTimingCount, nullptr ) ); if ( ( result == VULKAN_HPP_NAMESPACE::Result::eSuccess ) && presentationTimingCount ) { presentationTimings.resize( presentationTimingCount ); result = static_cast( getDispatcher()->vkGetPastPresentationTimingGOOGLE( - static_cast( **m_device ), - static_cast( m_swapchainKHR ), + static_cast( m_device ), + static_cast( m_swapchain ), &presentationTimingCount, reinterpret_cast( presentationTimings.data() ) ) ); VULKAN_HPP_ASSERT( presentationTimingCount <= presentationTimings.size() ); @@ -14104,7 +13748,7 @@ namespace VULKAN_HPP_NAMESPACE VULKAN_HPP_NAMESPACE::Result result = static_cast( getDispatcher()->vkGetSwapchainStatusKHR( - static_cast( **m_device ), static_cast( m_swapchainKHR ) ) ); + static_cast( m_device ), static_cast( m_swapchain ) ) ); if ( ( result != VULKAN_HPP_NAMESPACE::Result::eSuccess ) && ( result != VULKAN_HPP_NAMESPACE::Result::eSuboptimalKHR ) ) { @@ -14459,16 +14103,16 @@ namespace VULKAN_HPP_NAMESPACE do { result = static_cast( - getDispatcher()->vkGetDisplayModeProperties2KHR( static_cast( **m_physicalDevice ), - static_cast( m_displayKHR ), + getDispatcher()->vkGetDisplayModeProperties2KHR( static_cast( m_physicalDevice ), + static_cast( m_display ), &propertyCount, nullptr ) ); if ( ( result == VULKAN_HPP_NAMESPACE::Result::eSuccess ) && propertyCount ) { properties.resize( propertyCount ); result = static_cast( getDispatcher()->vkGetDisplayModeProperties2KHR( - static_cast( **m_physicalDevice ), - static_cast( m_displayKHR ), + static_cast( m_physicalDevice ), + static_cast( m_display ), &propertyCount, reinterpret_cast( properties.data() ) ) ); VULKAN_HPP_ASSERT( propertyCount <= properties.size() ); @@ -15233,7 +14877,7 @@ namespace VULKAN_HPP_NAMESPACE VULKAN_HPP_NAMESPACE::ImageDrmFormatModifierPropertiesEXT properties; VULKAN_HPP_NAMESPACE::Result result = static_cast( getDispatcher()->vkGetImageDrmFormatModifierPropertiesEXT( - static_cast( **m_device ), + static_cast( m_device ), static_cast( m_image ), reinterpret_cast( &properties ) ) ); if ( result != VULKAN_HPP_NAMESPACE::Result::eSuccess ) @@ -15261,8 +14905,8 @@ namespace VULKAN_HPP_NAMESPACE VULKAN_HPP_NAMESPACE::Result result = static_cast( getDispatcher()->vkMergeValidationCachesEXT( - static_cast( **m_device ), - static_cast( m_validationCacheEXT ), + static_cast( m_device ), + static_cast( m_validationCache ), srcCaches.size(), reinterpret_cast( srcCaches.data() ) ) ); if ( result != VULKAN_HPP_NAMESPACE::Result::eSuccess ) @@ -15282,16 +14926,16 @@ namespace VULKAN_HPP_NAMESPACE do { result = static_cast( - getDispatcher()->vkGetValidationCacheDataEXT( static_cast( **m_device ), - static_cast( m_validationCacheEXT ), + getDispatcher()->vkGetValidationCacheDataEXT( static_cast( m_device ), + static_cast( m_validationCache ), &dataSize, nullptr ) ); if ( ( result == VULKAN_HPP_NAMESPACE::Result::eSuccess ) && dataSize ) { data.resize( dataSize ); result = static_cast( - getDispatcher()->vkGetValidationCacheDataEXT( static_cast( **m_device ), - static_cast( m_validationCacheEXT ), + getDispatcher()->vkGetValidationCacheDataEXT( static_cast( m_device ), + static_cast( m_validationCache ), &dataSize, reinterpret_cast( data.data() ) ) ); VULKAN_HPP_ASSERT( dataSize <= data.size() ); @@ -15519,7 +15163,7 @@ namespace VULKAN_HPP_NAMESPACE VULKAN_HPP_ASSERT( dataSize % sizeof( T ) == 0 ); std::vector data( dataSize / sizeof( T ) ); Result result = static_cast( - getDispatcher()->vkGetRayTracingShaderGroupHandlesNV( static_cast( **m_device ), + getDispatcher()->vkGetRayTracingShaderGroupHandlesNV( static_cast( m_device ), static_cast( m_pipeline ), firstGroup, groupCount, @@ -15537,7 +15181,7 @@ namespace VULKAN_HPP_NAMESPACE { T data; Result result = static_cast( - getDispatcher()->vkGetRayTracingShaderGroupHandlesNV( static_cast( **m_device ), + getDispatcher()->vkGetRayTracingShaderGroupHandlesNV( static_cast( m_device ), static_cast( m_pipeline ), firstGroup, groupCount, @@ -15559,8 +15203,8 @@ namespace VULKAN_HPP_NAMESPACE VULKAN_HPP_ASSERT( dataSize % sizeof( T ) == 0 ); std::vector data( dataSize / sizeof( T ) ); Result result = static_cast( getDispatcher()->vkGetAccelerationStructureHandleNV( - static_cast( **m_device ), - static_cast( m_accelerationStructureNV ), + static_cast( m_device ), + static_cast( m_accelerationStructure ), data.size() * sizeof( T ), reinterpret_cast( data.data() ) ) ); if ( result != VULKAN_HPP_NAMESPACE::Result::eSuccess ) @@ -15575,8 +15219,8 @@ namespace VULKAN_HPP_NAMESPACE { T data; Result result = static_cast( getDispatcher()->vkGetAccelerationStructureHandleNV( - static_cast( **m_device ), - static_cast( m_accelerationStructureNV ), + static_cast( m_device ), + static_cast( m_accelerationStructure ), sizeof( T ), reinterpret_cast( &data ) ) ); if ( result != VULKAN_HPP_NAMESPACE::Result::eSuccess ) @@ -15612,7 +15256,7 @@ namespace VULKAN_HPP_NAMESPACE VULKAN_HPP_NAMESPACE::Result result = static_cast( getDispatcher()->vkCompileDeferredNV( - static_cast( **m_device ), static_cast( m_pipeline ), shader ) ); + static_cast( m_device ), static_cast( m_pipeline ), shader ) ); if ( result != VULKAN_HPP_NAMESPACE::Result::eSuccess ) { throwResultException( result, VULKAN_HPP_NAMESPACE_STRING "::Pipeline::compileDeferredNV" ); @@ -15928,7 +15572,7 @@ namespace VULKAN_HPP_NAMESPACE uint64_t value; VULKAN_HPP_NAMESPACE::Result result = static_cast( getDispatcher()->vkGetSemaphoreCounterValueKHR( - static_cast( **m_device ), static_cast( m_semaphore ), &value ) ); + static_cast( m_device ), static_cast( m_semaphore ), &value ) ); if ( result != VULKAN_HPP_NAMESPACE::Result::eSuccess ) { throwResultException( result, VULKAN_HPP_NAMESPACE_STRING "::Semaphore::getCounterValueKHR" ); @@ -16097,8 +15741,8 @@ namespace VULKAN_HPP_NAMESPACE VULKAN_HPP_ASSERT( getDispatcher()->vkSetLocalDimmingAMD && "Function needs extension enabled!" ); - getDispatcher()->vkSetLocalDimmingAMD( static_cast( **m_device ), - static_cast( m_swapchainKHR ), + getDispatcher()->vkSetLocalDimmingAMD( static_cast( m_device ), + static_cast( m_swapchain ), static_cast( localDimmingEnable ) ); } @@ -16238,7 +15882,7 @@ namespace VULKAN_HPP_NAMESPACE VULKAN_HPP_NAMESPACE::Result result = static_cast( getDispatcher()->vkWaitForPresentKHR( - static_cast( **m_device ), static_cast( m_swapchainKHR ), presentId, timeout ) ); + static_cast( m_device ), static_cast( m_swapchain ), presentId, timeout ) ); if ( ( result != VULKAN_HPP_NAMESPACE::Result::eSuccess ) && ( result != VULKAN_HPP_NAMESPACE::Result::eTimeout ) ) { @@ -16379,7 +16023,7 @@ namespace VULKAN_HPP_NAMESPACE VULKAN_HPP_NAMESPACE::Result result = static_cast( getDispatcher()->vkAcquireFullScreenExclusiveModeEXT( - static_cast( **m_device ), static_cast( m_swapchainKHR ) ) ); + static_cast( m_device ), static_cast( m_swapchain ) ) ); if ( result != VULKAN_HPP_NAMESPACE::Result::eSuccess ) { throwResultException( result, VULKAN_HPP_NAMESPACE_STRING "::SwapchainKHR::acquireFullScreenExclusiveModeEXT" ); @@ -16394,7 +16038,7 @@ namespace VULKAN_HPP_NAMESPACE VULKAN_HPP_NAMESPACE::Result result = static_cast( getDispatcher()->vkReleaseFullScreenExclusiveModeEXT( - static_cast( **m_device ), static_cast( m_swapchainKHR ) ) ); + static_cast( m_device ), static_cast( m_swapchain ) ) ); if ( result != VULKAN_HPP_NAMESPACE::Result::eSuccess ) { throwResultException( result, VULKAN_HPP_NAMESPACE_STRING "::SwapchainKHR::releaseFullScreenExclusiveModeEXT" ); @@ -16487,7 +16131,7 @@ namespace VULKAN_HPP_NAMESPACE "Function needs extension enabled!" ); getDispatcher()->vkResetQueryPoolEXT( - static_cast( **m_device ), static_cast( m_queryPool ), firstQuery, queryCount ); + static_cast( m_device ), static_cast( m_queryPool ), firstQuery, queryCount ); } //=== VK_EXT_extended_dynamic_state === @@ -16678,7 +16322,7 @@ namespace VULKAN_HPP_NAMESPACE "Function needs extension enabled!" ); return getDispatcher()->vkGetDeferredOperationMaxConcurrencyKHR( - static_cast( **m_device ), static_cast( m_deferredOperationKHR ) ); + static_cast( m_device ), static_cast( m_operation ) ); } VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE VULKAN_HPP_NAMESPACE::Result @@ -16689,7 +16333,7 @@ namespace VULKAN_HPP_NAMESPACE "Function needs extension enabled!" ); return static_cast( getDispatcher()->vkGetDeferredOperationResultKHR( - static_cast( **m_device ), static_cast( m_deferredOperationKHR ) ) ); + static_cast( m_device ), static_cast( m_operation ) ) ); } VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE VULKAN_HPP_NAMESPACE::Result DeferredOperationKHR::join() const @@ -16700,7 +16344,7 @@ namespace VULKAN_HPP_NAMESPACE VULKAN_HPP_NAMESPACE::Result result = static_cast( getDispatcher()->vkDeferredOperationJoinKHR( - static_cast( **m_device ), static_cast( m_deferredOperationKHR ) ) ); + static_cast( m_device ), static_cast( m_operation ) ) ); if ( ( result != VULKAN_HPP_NAMESPACE::Result::eSuccess ) && ( result != VULKAN_HPP_NAMESPACE::Result::eThreadDoneKHR ) && ( result != VULKAN_HPP_NAMESPACE::Result::eThreadIdleKHR ) ) @@ -17216,7 +16860,7 @@ namespace VULKAN_HPP_NAMESPACE VULKAN_HPP_NAMESPACE::Result result = static_cast( getDispatcher()->vkAcquireWinrtDisplayNV( - static_cast( **m_physicalDevice ), static_cast( m_displayKHR ) ) ); + static_cast( m_physicalDevice ), static_cast( m_display ) ) ); if ( result != VULKAN_HPP_NAMESPACE::Result::eSuccess ) { throwResultException( result, VULKAN_HPP_NAMESPACE_STRING "::DisplayKHR::acquireWinrtNV" ); @@ -17313,7 +16957,7 @@ namespace VULKAN_HPP_NAMESPACE VULKAN_HPP_ASSERT( dataSize % sizeof( T ) == 0 ); std::vector data( dataSize / sizeof( T ) ); Result result = static_cast( - getDispatcher()->vkGetRayTracingShaderGroupHandlesKHR( static_cast( **m_device ), + getDispatcher()->vkGetRayTracingShaderGroupHandlesKHR( static_cast( m_device ), static_cast( m_pipeline ), firstGroup, groupCount, @@ -17331,7 +16975,7 @@ namespace VULKAN_HPP_NAMESPACE { T data; Result result = static_cast( - getDispatcher()->vkGetRayTracingShaderGroupHandlesKHR( static_cast( **m_device ), + getDispatcher()->vkGetRayTracingShaderGroupHandlesKHR( static_cast( m_device ), static_cast( m_pipeline ), firstGroup, groupCount, @@ -17355,7 +16999,7 @@ namespace VULKAN_HPP_NAMESPACE VULKAN_HPP_ASSERT( dataSize % sizeof( T ) == 0 ); std::vector data( dataSize / sizeof( T ) ); Result result = static_cast( - getDispatcher()->vkGetRayTracingCaptureReplayShaderGroupHandlesKHR( static_cast( **m_device ), + getDispatcher()->vkGetRayTracingCaptureReplayShaderGroupHandlesKHR( static_cast( m_device ), static_cast( m_pipeline ), firstGroup, groupCount, @@ -17375,7 +17019,7 @@ namespace VULKAN_HPP_NAMESPACE { T data; Result result = static_cast( - getDispatcher()->vkGetRayTracingCaptureReplayShaderGroupHandlesKHR( static_cast( **m_device ), + getDispatcher()->vkGetRayTracingCaptureReplayShaderGroupHandlesKHR( static_cast( m_device ), static_cast( m_pipeline ), firstGroup, groupCount, @@ -17418,7 +17062,7 @@ namespace VULKAN_HPP_NAMESPACE "Function needs extension enabled!" ); return static_cast( - getDispatcher()->vkGetRayTracingShaderGroupStackSizeKHR( static_cast( **m_device ), + getDispatcher()->vkGetRayTracingShaderGroupStackSizeKHR( static_cast( m_device ), static_cast( m_pipeline ), group, static_cast( groupShader ) ) ); @@ -17561,8 +17205,8 @@ namespace VULKAN_HPP_NAMESPACE VULKAN_HPP_NAMESPACE::Result result = static_cast( getDispatcher()->vkSetBufferCollectionImageConstraintsFUCHSIA( - static_cast( **m_device ), - static_cast( m_bufferCollectionFUCHSIA ), + static_cast( m_device ), + static_cast( m_collection ), reinterpret_cast( &imageConstraintsInfo ) ) ); if ( result != VULKAN_HPP_NAMESPACE::Result::eSuccess ) { @@ -17579,8 +17223,8 @@ namespace VULKAN_HPP_NAMESPACE VULKAN_HPP_NAMESPACE::Result result = static_cast( getDispatcher()->vkSetBufferCollectionBufferConstraintsFUCHSIA( - static_cast( **m_device ), - static_cast( m_bufferCollectionFUCHSIA ), + static_cast( m_device ), + static_cast( m_collection ), reinterpret_cast( &bufferConstraintsInfo ) ) ); if ( result != VULKAN_HPP_NAMESPACE::Result::eSuccess ) { @@ -17598,8 +17242,8 @@ namespace VULKAN_HPP_NAMESPACE VULKAN_HPP_NAMESPACE::BufferCollectionPropertiesFUCHSIA properties; VULKAN_HPP_NAMESPACE::Result result = static_cast( getDispatcher()->vkGetBufferCollectionPropertiesFUCHSIA( - static_cast( **m_device ), - static_cast( m_bufferCollectionFUCHSIA ), + static_cast( m_device ), + static_cast( m_collection ), reinterpret_cast( &properties ) ) ); if ( result != VULKAN_HPP_NAMESPACE::Result::eSuccess ) { @@ -17621,7 +17265,7 @@ namespace VULKAN_HPP_NAMESPACE VULKAN_HPP_NAMESPACE::Extent2D maxWorkgroupSize; VULKAN_HPP_NAMESPACE::Result result = static_cast( getDispatcher()->vkGetDeviceSubpassShadingMaxWorkgroupSizeHUAWEI( - static_cast( **m_device ), + static_cast( m_device ), static_cast( m_renderPass ), reinterpret_cast( &maxWorkgroupSize ) ) ); if ( ( result != VULKAN_HPP_NAMESPACE::Result::eSuccess ) && @@ -17820,7 +17464,7 @@ namespace VULKAN_HPP_NAMESPACE "Function needs extension enabled!" ); getDispatcher()->vkSetDeviceMemoryPriorityEXT( - static_cast( **m_device ), static_cast( m_deviceMemory ), priority ); + static_cast( m_device ), static_cast( m_memory ), priority ); } //=== VK_KHR_maintenance4 ===