diff --git a/CMakeLists.txt b/CMakeLists.txt index e3de8ae..283982a 100644 --- a/CMakeLists.txt +++ b/CMakeLists.txt @@ -24,14 +24,26 @@ # (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE # OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. -cmake_minimum_required(VERSION 3.12) +if( VULKAN_HPP_ENABLE_EXPERIMENTAL_CPP20_MODULES ) + cmake_minimum_required( VERSION 3.25 ) + if ( ${CMAKE_VERSION} VERSION_GREATER_EQUAL 3.26 ) + # CMake 3.26; need to handle future versions here + set( CMAKE_EXPERIMENTAL_CXX_MODULE_CMAKE_API 2182bf5c-ef0d-489a-91da-49dbc3090d2a ) + else() + # CMake 3.25 + set( CMAKE_EXPERIMENTAL_CXX_MODULE_CMAKE_API 3c375311-a3c9-4396-a187-3227ef642046 ) + endif() + set( CMAKE_EXPERIMENTAL_CXX_MODULE_DYNDEP 1 ) +else() + cmake_minimum_required( VERSION 3.12 ) +endif() function( vulkan_hpp__setup_platform ) set( options ) set( oneValueArgs NAME ) set( multiValueArgs ) cmake_parse_arguments( TARGET "{options}" "${oneValueArgs}" "${multiValueArgs}" ${ARGN} ) - + if( WIN32 ) target_compile_definitions( ${TARGET_NAME} PUBLIC NOMINMAX VK_USE_PLATFORM_WIN32_KHR ) elseif( APPLE ) @@ -65,7 +77,7 @@ function( vulkan_hpp__setup_warning_level ) set( oneValueArgs NAME ) set( multiValueArgs ) cmake_parse_arguments( TARGET "{options}" "${oneValueArgs}" "${multiValueArgs}" ${ARGN} ) - + if( MSVC ) target_compile_options(${TARGET_NAME} PRIVATE /W4 /WX ) if( MSVC_VER GREATER_EQUAL 1910 ) @@ -90,9 +102,9 @@ function( vulkan_hpp__setup_library ) set( oneValueArgs FOLDER NAME ) set( multiValueArgs HEADERS SOURCES ) cmake_parse_arguments( TARGET "${options}" "${oneValueArgs}" "${multiValueArgs}" ${ARGN} ) - + vulkan_hpp__setup_project( NAME ${TARGET_NAME} ) - + if( "${TARGET_SOURCES}" STREQUAL "" ) add_library( ${TARGET_NAME} INTERFACE ${TARGET_HEADERS} ) else() @@ -123,7 +135,7 @@ function( vulkan_hpp__setup_sample ) vulkan_hpp__setup_project( NAME ${TARGET_NAME} ) add_executable( ${TARGET_NAME} ${TARGET_HEADERS} ${TARGET_SOURCES} ) - + vulkan_hpp__setup_platform( NAME ${TARGET_NAME} ) vulkan_hpp__setup_vulkan_include( NAME ${TARGET_NAME} ) vulkan_hpp__setup_warning_level( NAME ${TARGET_NAME} ) @@ -133,15 +145,15 @@ function( vulkan_hpp__setup_sample ) if( TARGET_FOLDER ) set_target_properties( ${TARGET_NAME} PROPERTIES FOLDER "${TARGET_FOLDER}" ) endif() - + if( TARGET_INCLUDE_DIRS ) target_include_directories( ${TARGET_NAME} PUBLIC ${TARGET_INCLUDE_DIRS} ) endif() - + if( TARGET_LIBS ) target_link_libraries( ${TARGET_NAME} PRIVATE "${TARGET_LIBS}" ) endif() - + if( VULKAN_HPP_PRECOMPILE ) if( TARGET_PCH_REUSE ) target_precompile_headers( ${TARGET_NAME} REUSE_FROM "${TARGET_PCH_REUSE}" ) @@ -241,7 +253,7 @@ function( vulkan_hpp__setup_test ) vulkan_hpp__setup_project( NAME ${TARGET_NAME} ) add_executable( ${TARGET_NAME} ${TARGET_NAME}.cpp ) - + vulkan_hpp__setup_platform( NAME ${TARGET_NAME} ) vulkan_hpp__setup_vulkan_include( NAME ${TARGET_NAME} ) vulkan_hpp__setup_warning_level( NAME ${TARGET_NAME} ) @@ -300,6 +312,7 @@ option( VULKAN_HPP_TESTS_BUILD "Build tests" OFF ) option( VULKAN_HPP_SAMPLES_BUILD_ONLY_DYNAMIC "Build only dynamic. Required in case the Vulkan SDK is not available" OFF ) option( VULKAN_HPP_TESTS_BUILD_ONLY_DYNAMIC "Build only dynamic" OFF ) option( VULKAN_HPP_BUILD_WITH_LOCAL_VULKAN_HPP "Build with local Vulkan headers" ON ) +option( VULKAN_HPP_ENABLE_EXPERIMENTAL_CPP20_MODULES "Build Vulkan-Hpp as C++20 module" OFF ) # look for the file vk.xml, the ultimate source of truth for vulkan, to generate the headers from if( NOT DEFINED VulkanRegistry_DIR ) @@ -387,6 +400,23 @@ if( ${VULKAN_HPP_INSTALL} ) ${VulkanHeaders_INCLUDE_DIR}/vulkan/vulkan_static_assertions.hpp ${VulkanHeaders_INCLUDE_DIR}/vulkan/vulkan_structs.hpp ${VulkanHeaders_INCLUDE_DIR}/vulkan/vulkan_to_string.hpp + ${VulkanHeaders_INCLUDE_DIR}/vulkan/vulkan.cppm ) install( FILES ${VK_GENERATED_VULKAN_HEADERS} DESTINATION ${CMAKE_INSTALL_INCLUDEDIR}/vulkan ) + +endif() + +# Build Vulkan-Hpp as a module +if( VULKAN_HPP_ENABLE_EXPERIMENTAL_CPP20_MODULES ) + # create a target to provide VulkanHpp as C++20 module + add_library( VulkanHppModule ) + set_target_properties( VulkanHppModule PROPERTIES + CXX_STANDARD_REQUIRED ON + CXX_EXTENSIONS OFF ) + target_compile_features( VulkanHppModule PUBLIC cxx_std_20 ) + target_sources( VulkanHppModule + PUBLIC + FILE_SET vulkan_module_file BASE_DIRS ${CMAKE_SOURCE_DIR} TYPE CXX_MODULES FILES vulkan/vulkan.cppm ) + target_include_directories( VulkanHppModule PUBLIC ${CMAKE_SOURCE_DIR} ) + target_include_directories( VulkanHppModule PUBLIC "${CMAKE_SOURCE_DIR}/Vulkan-Headers/include" ) endif() diff --git a/README.md b/README.md index e40ec1a..eba5c29 100644 --- a/README.md +++ b/README.md @@ -169,7 +169,7 @@ vk::ApplicationInfo applicationInfo{ .pApplicationName = AppName, .pEngineName = EngineName, .engineVersion = 1, .apiVersion = VK_API_VERSION_1_1 }; - + // initialize the vk::InstanceCreateInfo vk::InstanceCreateInfo instanceCreateInfo{ .pApplicationInfo = & applicationInfo }; ``` @@ -177,7 +177,7 @@ instead of ```c++ // initialize the vk::ApplicationInfo structure vk::ApplicationInfo applicationInfo( AppName, 1, EngineName, 1, VK_API_VERSION_1_1 ); - + // initialize the vk::InstanceCreateInfo vk::InstanceCreateInfo instanceCreateInfo( {}, &applicationInfo ); ``` @@ -600,6 +600,117 @@ Some functions might provide information that depends on the vulkan version. As - `VULKAN_HPP_CONSTEXPR_20 bool isPromotedExtension( std::string const & extension );` Returns `true` if the given extension is promoted to some other extension or vulkan version. +### C++20 standard module + +#### Overview + + +Vulkan-Hpp now provides a [C++ standard module](https://en.cppreference.com/w/cpp/language/modules) in [`vulkan.cppm`](vulkan/vulkan.cppm). +C++ modules are intended to supersede headers so that declarations and definitions may be easily shared across translation units without repeatedly parsing headers; therefore, they can potentially drastically improve compile times for large projects. +In particular, Vulkan-Hpp has some extremely long headers (e.g. [`vulkan_structs.hpp`](vulkan/vulkan_structs.hpp)), and it is hoped that the C++ module will shorten compile times for projects currently using it. + +#### Compiler support + +This feature requires a recent compiler with complete C++20 support: + +* Visual Studio 2019 16.10 or later (providing `cl.exe` 19.28 or later) +* Clang 15.0.0 or later + +If you intend to use CMake's [experimental C++ module support](https://www.kitware.com/import-cmake-c20-modules/) (and possibly Ninja), then more recent tools are required: + +* Visual Studio 17.4 or later (providing `cl.exe` 19.34 or later) +* Clang 16.0.0 or later +* CMake 3.25 or later +* Ninja 1.10.2 or later + +Either way, GCC does not completely support C++ modules, is therefore not recommended for use. + +##### Usage with CMake + +CMake is recommended for use with the Vulkan C++ module, as it provides a convenient platform-agnostic way to configure your project. +As mentioned above, note that CMake's module support is experimental, and usage may change in the future. +Consult the blog post at the link above for more information. + +CMake provides the [FindVulkan module](https://cmake.org/cmake/help/latest/module/FindVulkan.html), which may be used to source the Vulkan SDK and Vulkan headers on your system. +**Note that this module does not yet provide an IMPORTED target for the Vulkan C++ module, so you must set it up manually.** + +To use CMake with C++ modules, you must first enable its experimental support, set up `vulkan.cppm` as the source for a library target with `FILE_SET` configured `TYPE = CXX_MODULES`, and then link it into your project. + +```cmake +# enable C++ module support +cmake_minimum_required( VERSION 3.25 ) +# test if CMake version is ≥ 3.26 +if ( ${CMAKE_VERSION} VERSION_GREATER_EQUAL 3.26 ) + # CMake 3.26; need to handle future versions here + set( CMAKE_EXPERIMENTAL_CXX_MODULE_CMAKE_API 2182bf5c-ef0d-489a-91da-49dbc3090d2a ) +else() + # CMake 3.25 + set( CMAKE_EXPERIMENTAL_CXX_MODULE_CMAKE_API 3c375311-a3c9-4396-a187-3227ef642046 ) +endif() +set( CMAKE_EXPERIMENTAL_CXX_MODULE_DYNDEP 1 ) + +... + +# find Vulkan SDK +find_package( Vulkan REQUIRED ) + +# set up Vulkan C++ module +add_library(VulkanCppModule) +target_sources(VulkanCppModule PRIVATE + FILE_SET CXX_MODULES + FILES ${Vulkan_INCLUDE_DIR}/vulkan.cppm +) + +# link Vulkan C++ module into your project +add_executable(YourProject main.cpp) +target_link_libraries(YourProject VulkanCppModule) +``` + +Once this is done, in `main.cpp`, simply import the Vulkan module. An example is provided in [`tests/Cpp20Modules/Cpp20Modules.cpp`](tests/Cpp20Modules/Cpp20Modules.cpp). Note that the module is imported as `vulkan`, not `vulkan.hpp`. + +```cpp +import vulkan; + +auto main(int argc, char* const argv[]) -> int +{ + auto appInfo = vk::ApplicationInfo( "My App", 1, "My Engine", 1, vk::makeApiVersion( 1, 0, 0, 0 ) ); + // ... +} +``` + +Finally, you can configure and build your project as usual. +Note that CMake currently only supports the Ninja and Visual Studio generators for C++ modules. +Furthermore, the C++ module also pre-defines `VULKAN_HPP_DEFAULT_DISPATCHER_DYNAMIC_STORAGE` by default. +Therefore, if you wish to use dynamic dispatch with the Vulkan-Hpp C++ module, all that is necessary is to define the macro ` VULKAN_HPP_DISPATCH_LOADER_DYNAMIC=1` in your project. + + +##### Command-line usage + +If you want to use the Vulkan-Hpp C++ module without CMake, you must first pre-compile it, and then import it into your project. +You will also need to define any macros that control various features of Vulkan-Hpp, such as `VULKAN_HPP_NO_EXCEPTIONS` and `VULKAN_HPP_NO_SMART_HANDLE`. +Different compilers have different command-lines for module pre-compilation; however, for initial use, some examples are provided below, assuming the same `main.cpp` consumer as above. + +For MSVC, source `vcvars64.bat` or use a Developer Command Prompt/PowerShell instance, and run the following: + +```cmd +cl.exe /std:c++20 /interface /TP \vulkan.cppm +cl.exe /std:c++20 /reference vulkan=vulkan.ifc main.cpp vulkan.obj +.\main.exe +``` + +For Clang, run the following: + +```shell +clang++ -std=c++20 /vulkan.cppm -precompile -o vulkan.pcm +clang++ -std=c++20 -fprebuilt-module-path=. main.cpp vulkan.pcm -o main +./main +``` + +More information about module compilation may be found at the respective compiler's documentation: + +* [MSVC](https://learn.microsoft.com/en-us/cpp/cpp/modules-cpp?view=msvc-170) +* [Clang](https://clang.llvm.org/docs/StandardCPlusPlusModules.html) + ### Samples and Tests When you configure your project using CMake, you can enable SAMPLES_BUILD to add some sample projects to your solution. Most of them are ports from the LunarG samples, but there are some more, like CreateDebugUtilsMessenger, InstanceVersion, PhysicalDeviceDisplayProperties, PhysicalDeviceExtensions, PhysicalDeviceFeatures, PhysicalDeviceGroups, PhysicalDeviceMemoryProperties, PhysicalDeviceProperties, PhysicalDeviceQueueFamilyProperties, and RayTracing. All those samples should just compile and run. @@ -721,7 +832,7 @@ With this define you can include a reflection mechanism on the vk-structures. It Feel free to submit a PR to add to this list. -- [Examples](https://github.com/jherico/vulkan) A port of Sascha Willems [examples](https://github.com/SaschaWillems/Vulkan) to Vulkan-Hpp +- [Examples](https://github.com/jherico/vulkan) A port of Sascha Willems [examples](https://github.com/SaschaWillems/Vulkan) to Vulkan-Hpp - [Vookoo](https://github.com/andy-thomason/Vookoo/) Stateful helper classes for Vulkan-Hpp, [Introduction Article](https://accu.org/journals/overload/25/139/overload139.pdf#page=14). ## License diff --git a/VulkanHppGenerator.cpp b/VulkanHppGenerator.cpp index e085159..3592fdb 100644 --- a/VulkanHppGenerator.cpp +++ b/VulkanHppGenerator.cpp @@ -15,11 +15,20 @@ #include "VulkanHppGenerator.hpp" #include +#include #include #include #include #include +struct MacroData +{ + std::string deprecatedComment = {}; + std::string calleeMacro = {}; + std::vector params = {}; + std::string definition = {}; +}; + void checkAttributes( int line, std::map const & attributes, std::map> const & required, @@ -55,6 +64,7 @@ std::string toString( tinyxml2::XMLError er std::string trim( std::string const & input ); std::string trimEnd( std::string const & input ); std::string trimStars( std::string const & input ); +MacroData parseMacro( std::vector const & completeMacro ); void writeToFile( std::string const & str, std::string const & fileName ); const std::set specialPointerTypes = { "Display", "IDirectFB", "wl_display", "xcb_connection_t", "_screen_window" }; @@ -90,6 +100,8 @@ VulkanHppGenerator::VulkanHppGenerator( tinyxml2::XMLDocument const & document, addCommandsToHandle( extension.requireData ); addMissingFlagBits( extension.requireData, extension.name ); } + + m_definesPartition = partitionDefines( m_defines ); } void VulkanHppGenerator::generateEnumsHppFile() const @@ -492,6 +504,7 @@ ${throwResultException} ${ResultValue} ${resultChecks} +${constexprDefines} } // namespace VULKAN_HPP_NAMESPACE // clang-format off @@ -519,6 +532,7 @@ ${DispatchLoaderDynamic} { "ArrayWrapper1D", readSnippet( "ArrayWrapper1D.hpp" ) }, { "ArrayWrapper2D", readSnippet( "ArrayWrapper2D.hpp" ) }, { "baseTypes", generateBaseTypes() }, + { "constexprDefines", generateConstexprDefines() }, { "defines", readSnippet( "defines.hpp" ) }, { "DispatchLoaderBase", readSnippet( "DispatchLoaderBase.hpp" ) }, { "DispatchLoaderDefault", readSnippet( "DispatchLoaderDefault.hpp" ) }, @@ -682,6 +696,43 @@ ${enumsToString} writeToFile( str, vulkan_to_string_hpp ); } +void VulkanHppGenerator::generateCppModuleFile() const +{ + std::string const vulkan_cppm = std::string( BASE_PATH ) + "/vulkan/" + m_api + ".cppm"; + std::cout << "VulkanHppGenerator: Generating " << vulkan_cppm << "..." << std::endl; + + std::string const vulkanCppmTemplate = R"(${licenseHeader} +module; + +#include +#include +#include +#include +#include + +export module ${api}; + +VULKAN_HPP_DEFAULT_DISPATCH_LOADER_DYNAMIC_STORAGE + +export namespace VULKAN_HPP_NAMESPACE +{ + ${usings} + + export namespace VULKAN_HPP_RAII_NAMESPACE { + ${raiiUsings} + } // namespace VULKAN_HPP_RAII_NAMESPACE +} // namespace VULKAN_HPP_NAMESPACE +)"; + + auto const str = replaceWithMap( vulkanCppmTemplate, + { { "licenseHeader", m_vulkanLicenseHeader }, + { "api", m_api }, + { "usings", generateCppModuleUsings() }, + { "raiiUsings", generateCppModuleRaiiUsings() } } ); + + writeToFile( str, vulkan_cppm ); +} + void VulkanHppGenerator::prepareRAIIHandles() { // filter out functions that are not usefull on this level of abstraction (like vkGetInstanceProcAddr) @@ -4676,6 +4727,651 @@ std::string VulkanHppGenerator::generateConstexprString( std::string const & str return isConstExpression ? ( std::string( "VULKAN_HPP_CONSTEXPR" ) + ( ( containsUnion( structName ) || containsArray( structName ) ) ? "_14 " : " " ) ) : ""; } +std::string VulkanHppGenerator::generateConstexprDefines() const +{ + auto const constexprFunctionTemplate = std::string{ R"( template ::value>::type> + ${deprecated}VULKAN_HPP_CONSTEXPR uint32_t ${constName}( ${arguments} ) + { + return ${implementation}; + } +)" }; + auto const constexprCallTemplate = std::string{ R"( ${deprecated}VULKAN_HPP_CONSTEXPR auto ${constName} = ${callee}( ${arguments} ); +)" }; + auto const constexprValueTemplate = std::string{ R"( ${deprecated}VULKAN_HPP_CONSTEXPR ${type} ${constName} = ${value}; +)" }; + auto const deprecatedAttribute = std::string{ R"(VULKAN_HPP_DEPRECATED("${reason}") )" }; + + auto constexprDefines = std::string{ R"( + //========================================= + //=== CONSTEXPR CONSTANTs AND FUNCTIONs === + //========================================= +)" }; + + // handle the value and callee macros first so they are visible for use in functions below. + + // hardcoded constants. + for ( auto const & [macro, data] : m_constants ) + { + // make `macro` PascalCase, and strip the `Vk` prefix + auto const constName = stripPrefix( toCamelCase( macro ), "Vk" ); + + constexprDefines += + replaceWithMap( constexprValueTemplate, { { "type", data.type }, { "constName", constName }, { "deprecated", "" }, { "value", macro } } ); + } + + // values + for ( auto const & [macro, data] : m_definesPartition.values ) + { + auto const deprecated = data.deprecated ? replaceWithMap( deprecatedAttribute, { { "reason", data.deprecationReason } } ) : ""; + + // make `macro` PascalCase and strip the `Vk` prefix + auto const constName = stripPrefix( toCamelCase( macro ), "Vk" ); + auto const valueString = + replaceWithMap( constexprValueTemplate, { { "type", "uint32_t" }, { "constName", constName }, { "deprecated", deprecated }, { "value", macro } } ); + + constexprDefines += valueString; + } + + // functions + for ( auto const & [macro, data] : m_definesPartition.callees ) + { + auto const deprecated = data.deprecated ? replaceWithMap( deprecatedAttribute, { { "reason", data.deprecationReason } } ) : ""; + // make `macro` camelCase and strip the `Vk` prefix + auto const constName = startLowerCase( stripPrefix( toCamelCase( macro ), "Vk" ) ); + // for every parameter, need to use auto const and append a comma if needed (i.e. has more than one parameter, and not for the last one) + auto parametersString = std::string{}; + for ( auto const & paramString : data.params ) + { + parametersString += "T const " + paramString + ", "; + } + // trim the last two characters (i.e. the last comma and the space) + parametersString.resize( parametersString.size() - 2 ); + + auto const functionString = replaceWithMap( + constexprFunctionTemplate, + { { "arguments", parametersString }, { "constName", constName }, { "deprecated", deprecated }, { "implementation", data.possibleDefinition } } ); + + constexprDefines += functionString; + } + + // callers + for ( auto const & [macro, data] : m_definesPartition.callers ) + { + auto const deprecated = data.deprecated ? replaceWithMap( deprecatedAttribute, { { "reason", data.deprecationReason } } ) : ""; + // make `macro` PascalCase and strip the `Vk` prefix + auto const constName = stripPrefix( toCamelCase( macro ), "Vk" ); + auto argumentsString = std::string{}; + + // for every argument, append a comma if needed (i.e. has more than one parameter, and not for the last one) + for ( auto const & argString : data.params ) + { + argumentsString += argString + ", "; + } + // trim the last two characters (i.e. the last comma and the space) + argumentsString.resize( argumentsString.size() - 2 ); + + auto const callerString = replaceWithMap( + constexprCallTemplate, + { { "arguments", argumentsString }, { "callee", startLowerCase( data.possibleCallee ) }, { "constName", constName }, { "deprecated", deprecated } } ); + constexprDefines += callerString; + } + + return constexprDefines; +} + +std::string VulkanHppGenerator::generateConstexprUsings() const +{ + auto constexprUsings = std::string{ R"( + //========================================= + //=== CONSTEXPR CONSTANTs AND FUNCTIONs === + //========================================= +)" }; + + auto const constexprUsingTemplate = std::string{ R"( using VULKAN_HPP_NAMESPACE::${constName}; +)" }; + + auto const pascalCasePrefixStrip = []( std::string const & macro ) { return stripPrefix( toCamelCase( macro ), "Vk" ); }; + auto const camelCasePrefixStrip = []( std::string const & macro ) { return startLowerCase( stripPrefix( toCamelCase( macro ), "Vk" ) ); }; + + // constants + for ( auto const & macro : m_constants ) + { + // make `macro` PascalCase and strip the `Vk` prefix + auto const constName = pascalCasePrefixStrip( macro.first ); + constexprUsings += replaceWithMap( constexprUsingTemplate, { { "constName", constName } } ); + } + + // values + for ( auto const & macro : m_definesPartition.values ) + { + // make `macro` PascalCase and strip the `Vk` prefix + auto const constName = pascalCasePrefixStrip( macro.first ); + constexprUsings += replaceWithMap( constexprUsingTemplate, { { "constName", constName } } ); + } + + // callees + for ( auto const & macro : m_definesPartition.callees ) + { + // make `macro` camelCase and strip the `Vk` prefix + auto const constName = camelCasePrefixStrip( macro.first ); + constexprUsings += replaceWithMap( constexprUsingTemplate, { { "constName", constName } } ); + } + + // callers + for ( auto const & macro : m_definesPartition.callers ) + { + // make `macro` PascalCase and strip the `Vk` prefix + auto const constName = pascalCasePrefixStrip( macro.first ); + constexprUsings += replaceWithMap( constexprUsingTemplate, { { "constName", constName } } ); + } + + return constexprUsings; +} + +std::string VulkanHppGenerator::generateCppModuleHandleUsings() const +{ + auto const usingTemplate = std::string{ R"( using VULKAN_HPP_NAMESPACE::${className}; +)" }; + + auto handleUsings = std::string{ R"( + //=============== + //=== HANDLEs === + //=============== + + using VULKAN_HPP_NAMESPACE::isVulkanHandleType; +)" }; + + auto const generateUsingsAndProtection = [&usingTemplate, this]( std::vector const & requireData, std::string const & title ) + { + auto usings = std::string{}; + for ( auto const & require : requireData ) + { + for ( auto const & type : require.types ) + { + if ( auto const & handleIt = m_handles.find( type ); handleIt != m_handles.end() ) + { + usings += replaceWithMap( usingTemplate, { { "className", stripPrefix( handleIt->first, "Vk" ) } } ); + } + } + } + return addTitleAndProtection( title, usings ); + }; + + for ( auto const & feature : m_features ) + { + handleUsings += generateUsingsAndProtection( feature.requireData, feature.name ); + } + + for ( auto const & extension : m_extensions ) + { + handleUsings += generateUsingsAndProtection( extension.requireData, extension.name ); + } + + return handleUsings; +} + +std::string VulkanHppGenerator::generateCppModuleStructUsings() const +{ + auto const usingTemplate = std::string{ R"( using VULKAN_HPP_NAMESPACE::${structName}; +)" }; + + auto structUsings = std::string{ R"( + //=============== + //=== STRUCTs === + //=============== +)" }; + auto listedStructs = std::set{}; + + auto const generateUsingsAndProtection = [&listedStructs, &usingTemplate, this]( std::vector const & requireData, std::string const & title ) + { + auto localUsings = std::string{}; + for ( auto const & require : requireData ) + { + for ( auto const & type : require.types ) + { + if ( auto const & structIt = m_structs.find( type ); structIt != m_structs.end() && listedStructs.insert( type ).second ) + { + auto const structureType = stripPrefix( structIt->first, "Vk" ); + localUsings += replaceWithMap( usingTemplate, { { "structName", structureType } } ); + + // replace the findAlias call with the contents, because it includes an assert that breaks in Debug mode, which shouldn't break. There are multiple + // aliases for a given struct, and that's ok. Maybe we should refactor + for ( auto const & [alias, aliasData] : m_structAliases ) + { + if ( aliasData.name == structIt->first ) + { + auto const aliasName = stripPrefix( alias, "Vk" ); + localUsings += replaceWithMap( usingTemplate, { { "structName", aliasName } } ); + } + } + } + } + } + return addTitleAndProtection( title, localUsings ); + }; + + for ( auto const & feature : m_features ) + { + structUsings += generateUsingsAndProtection( feature.requireData, feature.name ); + } + + for ( auto const & extension : m_extensions ) + { + structUsings += generateUsingsAndProtection( extension.requireData, extension.name ); + } + + return structUsings; +} + +std::string VulkanHppGenerator::generateCppModuleUniqueHandleUsings() const +{ + auto const usingTemplate = std::string{ R"( using VULKAN_HPP_NAMESPACE::Unique${handleName}; +)" }; + auto uniqueHandleUsings = std::string{ R"( + //====================== + //=== UNIQUE HANDLEs === + //====================== +)" }; + auto const [smartHandleEnter, smartHandleLeave] = generateProtection( "VULKAN_HPP_NO_SMART_HANDLE", false ); + + uniqueHandleUsings += "\n" + smartHandleEnter; + + auto const generateUsingsAndProtection = [&usingTemplate, this]( std::vector const & requireData, std::string const & title ) + { + auto usings = std::string{}; + for ( auto const & require : requireData ) + { + for ( auto const & type : require.types ) + { + if ( auto const & handleIt = m_handles.find( type ); handleIt != m_handles.end() && !handleIt->second.deleteCommand.empty() ) + { + usings += replaceWithMap( usingTemplate, { { "handleName", stripPrefix( handleIt->first, "Vk" ) } } ); + } + } + } + return addTitleAndProtection( title, usings ); + }; + + for ( auto const & feature : m_features ) + { + uniqueHandleUsings += generateUsingsAndProtection( feature.requireData, feature.name ); + } + + for ( auto const & extension : m_extensions ) + { + uniqueHandleUsings += generateUsingsAndProtection( extension.requireData, extension.name ); + } + + uniqueHandleUsings += R"( using VULKAN_HPP_NAMESPACE::UniqueHandleTraits; +)"; + + uniqueHandleUsings += smartHandleLeave + "\n"; + + return uniqueHandleUsings; +} + +std::string VulkanHppGenerator::generateCppModuleFuncsUsings() const +{ + auto const usingTemplate = std::string{ R"( using VULKAN_HPP_NAMESPACE::${funcName}; +)" }; + + auto funcUsings = std::string{ R"( + //=========================== + //=== COMMAND Definitions === + //=========================== +)" }; + + for ( auto const & func : m_handles.at( "" ).commands ) + { + funcUsings += replaceWithMap( usingTemplate, { { "funcName", startLowerCase( stripPrefix( func, "vk" ) ) } } ); + } + + auto const [enter, leave] = generateProtection( "VULKAN_HPP_NO_SMART_HANDLE", false ); + funcUsings += "\n" + enter + replaceWithMap( usingTemplate, { { "funcName", "createInstanceUnique" } } ) + leave + "\n"; + + return funcUsings; +} + +std::string VulkanHppGenerator::generateCppModuleEnumUsings() const +{ + auto const usingTemplate = std::string{ R"( using VULKAN_HPP_NAMESPACE::${enumName}; +)" }; + + auto enumUsings = std::string{ R"( + //============= + //=== ENUMs === + //============= +)" }; + auto listedEnums = std::set{}; + + // insert CppType first + enumUsings += replaceWithMap( usingTemplate, { { "enumName", "CppType" } } ); + + auto const generateUsingsAndProtection = [&listedEnums, &usingTemplate, this]( std::vector const & requireData, std::string const & title ) + { + auto localUsings = std::string{}; + for ( auto const & require : requireData ) + { + for ( auto const & type : require.types ) + { + if ( auto const & enumIt = m_enums.find( type ); enumIt != m_enums.end() && listedEnums.insert( type ).second ) + { + auto const enumName = stripPrefix( enumIt->first, "Vk" ); + localUsings += replaceWithMap( usingTemplate, { { "enumName", enumName } } ); + + if ( auto const aliasIt = findAlias( enumIt->first, m_enumAliases ); aliasIt != m_enumAliases.end() ) + { + localUsings += replaceWithMap( usingTemplate, { { "enumName", stripPrefix( aliasIt->first, "Vk" ) } } ); + } + + if ( auto const bitmaskIt = + std::find_if( m_bitmasks.begin(), + m_bitmasks.end(), + [&enumIt]( std::pair const & bitmask ) { return bitmask.second.require == enumIt->first; } ); + bitmaskIt != m_bitmasks.end() ) + { + localUsings += replaceWithMap( usingTemplate, { { "enumName", stripPrefix( bitmaskIt->first, "Vk" ) } } ); + } + } + } + } + return addTitleAndProtection( title, localUsings ); + }; + + for ( auto const & feature : m_features ) + { + enumUsings += generateUsingsAndProtection( feature.requireData, feature.name ); + } + + for ( auto const & extension : m_extensions ) + { + enumUsings += generateUsingsAndProtection( extension.requireData, extension.name ); + } + + // finally insert IndexTypeValue + auto const indexTypeComment = R"( + //========================= + //=== Index Type Traits === + //========================= +)"; + enumUsings += indexTypeComment + replaceWithMap( usingTemplate, { { "enumName", "IndexTypeValue" } } ); + + return enumUsings; +} + +std::string VulkanHppGenerator::generateCppModuleFormatTraitsUsings() const +{ + // everything is hardcoded, so things are very easy... + auto formatTraitsUsings = std::string{ R"( + //===================== + //=== Format Traits === + //===================== +)" }; + + auto const usingTemplate = std::string{ R"( using VULKAN_HPP_NAMESPACE::${function}; +)" }; + auto const formatTraitFunctions = std::array{ "blockExtent", + "blockSize", + "compatibilityClass", + "componentBits", + "componentCount", + "componentName", + "componentNumericFormat", + "componentPlaneIndex", + "componentsAreCompressed", + "compressionScheme", + "isCompressed", + "packed", + "planeCompatibleFormat", + "planeCount", + "planeHeightDivisor", + "planeWidthDivisor", + "texelsPerBlock" }; + + for ( auto const & func : formatTraitFunctions ) + { + formatTraitsUsings += replaceWithMap( usingTemplate, { { "function", func } } ); + } + + return formatTraitsUsings; +} + +std::string VulkanHppGenerator::generateCppModuleExtensionInspectionUsings() const +{ + auto const usingTemplate = std::string{ R"( using VULKAN_HPP_NAMESPACE::${function}; +)" }; + + auto extensionInspectionsUsings = std::string{ R"( + //====================================== + //=== Extension inspection functions === + //====================================== +)" }; + + auto const extensionInspectionFunctions = + std::array{ "getDeviceExtensions", "getInstanceExtensions", "getDeprecatedExtensions", "getExtensionDepends", "getExtensionDepends", + "getObsoletedExtensions", "getPromotedExtensions", "getExtensionDeprecatedBy", "getExtensionObsoletedBy", "getExtensionPromotedTo", + "isDeprecatedExtension", "isDeviceExtension", "isInstanceExtension", "isObsoletedExtension", "isPromotedExtension" }; + + for ( auto const & func : extensionInspectionFunctions ) + { + extensionInspectionsUsings += replaceWithMap( usingTemplate, { { "function", func } } ); + } + + return extensionInspectionsUsings; +} + +std::string VulkanHppGenerator::generateCppModuleUsings() const +{ + auto const usingTemplate = std::string{ R"( using VULKAN_HPP_NAMESPACE::${className}; +)" }; + + auto const hardCodedTypes = std::array{ "ArrayWrapper1D", "ArrayWrapper2D", "FlagTraits", "Flags", "DispatchLoaderBase" }; + auto const hardCodedEnhancedModeTypes = + std::array{ "ArrayProxy", "ArrayProxyNoTemporaries", "StridedArrayProxy", "Optional", "StructureChain", "UniqueHandle" }; + auto const hardCodedSmartHandleTypes = std::array{ "ObjectDestroy", "ObjectFree", "ObjectRelease", "PoolFree" }; + + auto usings = std::string{ R"( //===================================== + //=== HARDCODED TYPEs AND FUNCTIONs === + //===================================== +)" }; + + for ( auto const & className : hardCodedTypes ) + { + usings += replaceWithMap( usingTemplate, { { "className", className } } ); + } + + auto const & [noPrototypesEnter, noPrototypesLeave] = generateProtection( "VK_NO_PROTOTYPES", false ); + + usings += "\n" + noPrototypesEnter + replaceWithMap( usingTemplate, { { "className", "DispatchLoaderStatic" } } ) + noPrototypesLeave + "\n"; + + // insert the Flags bitwise operators + auto const flagsBitWiseOperatorsUsings = std::array{ "operator&", "operator|", "operator^", "operator~" }; + for ( auto const & operatorName : flagsBitWiseOperatorsUsings ) + { + usings += replaceWithMap( usingTemplate, { { "className", operatorName } } ); + } + + // delete the namespace declaration for the default dispatcher macro using statement + usings += R"(using VULKAN_HPP_DEFAULT_DISPATCHER_TYPE; +)"; + + auto enhancedModeUsings = std::string{}; + for ( auto const & className : hardCodedEnhancedModeTypes ) + { + enhancedModeUsings += replaceWithMap( usingTemplate, { { "className", std::string{ className } } } ); + } + // protect the enhanced-mode usings with a macro + auto [enterEnhancedMode, leaveEnhancedMode] = generateProtection( "VULKAN_HPP_DISABLE_ENHANCED_MODE", false ); + usings += "\n" + enterEnhancedMode + enhancedModeUsings + leaveEnhancedMode + "\n"; + + auto noSmartHandleUsings = std::string{}; + for ( auto const & className : hardCodedSmartHandleTypes ) + { + noSmartHandleUsings += replaceWithMap( usingTemplate, { { "className", std::string{ className } } } ); + } + // likewise for the smart-handle usings + auto [enterNoSmartHandle, leaveNoSmartHandle] = generateProtection( "VULKAN_HPP_NO_SMART_HANDLE", false ); + usings += "\n" + enterNoSmartHandle + noSmartHandleUsings + leaveNoSmartHandle + "\n"; + + // now generate baseTypes + auto baseTypes = std::string{ R"( + //================== + //=== BASE TYPEs === + //================== +)" }; + for ( auto const & baseType : m_baseTypes ) + { + if ( baseType.first != "VkFlags" && baseType.first != "VkFlags64" && !baseType.second.typeInfo.type.empty() ) + { + baseTypes += replaceWithMap( usingTemplate, { { "className", stripPrefix( baseType.first, "Vk" ) } } ); + } + } + usings += baseTypes; + + // generate Enums + usings += generateCppModuleEnumUsings(); + + // to_string, toHexString + auto const toString = std::array{ "to_string", "toHexString" }; + auto const [toStringEnter, toStringLeave] = generateProtection( "VULKAN_HPP_NO_TO_STRING", false ); + + usings += R"( + //====================== + //=== ENUM to_string === + //====================== +)" + toStringEnter; + for ( auto const & name : toString ) + { + usings += replaceWithMap( usingTemplate, { { "className", name } } ); + } + usings += toStringLeave + "\n"; + + // hardcoded exceptions and functions + auto const hardCodedExceptionTypesAndFunctions = + std::array{ "ErrorCategoryImpl", "Error", "LogicError", "SystemError", "errorCategory", "make_error_code", "make_error_condition" }; + auto [exceptionsEnter, exceptionsLeave] = generateProtection( "VULKAN_HPP_NO_EXCEPTIONS", false ); + + auto exceptionsUsings = std::string{ R"( + //============================= + //=== EXCEPTIONs AND ERRORs === + //============================= +)" } + exceptionsEnter; + + for ( auto const & name : hardCodedExceptionTypesAndFunctions ) + { + exceptionsUsings += replaceWithMap( usingTemplate, { { "className", name } } ); + } + + usings += exceptionsUsings; + + // result Exceptions + auto resultExceptionsUsings = std::string{}; + auto const & [name, data] = *m_enums.find( "VkResult" ); + for ( auto const & [alias, bitpos, enumName, protect, value, xmlLine] : data.values ) + { + if ( alias.empty() && enumName.starts_with( "VK_ERROR" ) ) + { + auto [enter, leave] = generateProtection( protect ); + enter = enter.empty() ? enter : "\n" + enter; + leave = leave.empty() ? leave : leave + "\n"; + + auto const valueName = generateEnumValueName( name, enumName, false ); + auto const className = stripPrefix( valueName, "eError" ) + "Error"; + + resultExceptionsUsings += enter + replaceWithMap( usingTemplate, { { "className", className } } ) + leave; + } + } + usings += resultExceptionsUsings; + + usings += exceptionsLeave + "\n"; + + // ResultValue + auto const hardCodedResultValueTypes = std::array{ "ignore", "ResultValue", "ResultValueType", "createResultValueType" }; + for ( auto const & className : hardCodedResultValueTypes ) + { + usings += replaceWithMap( usingTemplate, { { "className", className } } ); + } + + // resultCheck + usings += replaceWithMap( usingTemplate, { { "className", "resultCheck" } } ) + "\n"; + + usings += generateConstexprUsings() + "\n"; + + // structs, handles, UniqueHandles, etc + usings += generateCppModuleStructUsings(); + usings += generateCppModuleHandleUsings(); + usings += generateCppModuleUniqueHandleUsings(); + usings += generateCppModuleFuncsUsings(); + + auto const [enterDisableEnhanced, leaveDisableEnhanced] = generateProtection( "VULKAN_HPP_DISABLE_ENHANCED_MODE", false ); + usings += "\n" + enterDisableEnhanced + replaceWithMap( usingTemplate, { { "className", "StructExtends" } } ) + leaveDisableEnhanced + "\n"; + + auto const [enterDynamicLoader, leaveDynamicLoader] = generateProtection( "VULKAN_HPP_DYNAMIC_LOADER_TOOL" ); + usings += "\n" + enterDynamicLoader + replaceWithMap( usingTemplate, { { "className", "DynamicLoader" } } ) + leaveDynamicLoader + "\n"; + + usings += replaceWithMap( usingTemplate, { { "className", "DispatchLoaderDynamic" } } ) + "\n"; + + usings += generateCppModuleFormatTraitsUsings(); + usings += generateCppModuleExtensionInspectionUsings(); + + return usings; +} + +std::string VulkanHppGenerator::generateCppModuleRaiiUsings() const +{ + auto const raiiUsingTemplate = std::string{ R"( using VULKAN_HPP_RAII_NAMESPACE::${className}; +)" }; + auto usings = std::string{ R"( //====================== + //=== RAII HARDCODED === + //====================== + + using VULKAN_HPP_RAII_NAMESPACE::exchange; + using VULKAN_HPP_RAII_NAMESPACE::Context; + using VULKAN_HPP_RAII_NAMESPACE::ContextDispatcher; + using VULKAN_HPP_RAII_NAMESPACE::InstanceDispatcher; + using VULKAN_HPP_RAII_NAMESPACE::DeviceDispatcher; + + //==================== + //=== RAII HANDLEs === + //==================== +)" }; + + auto const generateUsingsAndProtection = [&raiiUsingTemplate, this]( std::vector const & requireData, std::string const & title ) + { + auto usings = std::string{}; + for ( auto const & require : requireData ) + { + for ( auto const & type : require.types ) + { + if ( auto const & handleIt = m_handles.find( type ); handleIt != m_handles.end() ) + { + usings += replaceWithMap( raiiUsingTemplate, { { "className", stripPrefix( handleIt->first, "Vk" ) } } ); + + // if there is an array constructor, generate the plural type also + if ( !generateRAIIHandleConstructors( *handleIt ).second.empty() ) + { + usings += replaceWithMap( raiiUsingTemplate, { { "className", stripPrefix( type, "Vk" ) + "s" } } ); + } + } + } + } + return addTitleAndProtection( title, usings ); + }; + + // now, insert features and extensions with protection, and strip Vk prefix + for ( auto const & feature : m_features ) + { + usings += generateUsingsAndProtection( feature.requireData, feature.name ); + } + + for ( auto const & extension : m_extensions ) + { + usings += generateUsingsAndProtection( extension.requireData, extension.name ); + } + + return usings; +} + std::string VulkanHppGenerator::generateDataDeclarations( CommandData const & commandData, std::vector const & returnParams, std::map const & vectorParams, @@ -5954,7 +6650,8 @@ std::string VulkanHppGenerator::generateExtensionTypeTest( std::string const & t if ( extension.type == type ) { auto [enter, leave] = generateProtection( getProtectFromTitle( extension.name ) ); - typeTest += ( ( previousEnter != enter ) ? ( "\n" + previousLeave + enter ) : "\n" ) + ( first ? "" : " || ") + "( extension == \"" + extension.name + "\" )"; + typeTest += + ( ( previousEnter != enter ) ? ( "\n" + previousLeave + enter ) : "\n" ) + ( first ? "" : " || " ) + "( extension == \"" + extension.name + "\" )"; previousEnter = enter; previousLeave = leave; first = false; @@ -6925,9 +7622,10 @@ std::string VulkanHppGenerator::generateObjectDeleter( std::string const & comma return objectDeleter + "<" + parentName + ", Dispatch>( " + ( ( parentName == "NoParent" ) ? "" : "*this, " ) + allocator + "d )"; } -std::pair VulkanHppGenerator::generateProtection( std::string const & protect ) const +std::pair VulkanHppGenerator::generateProtection( std::string const & protect, bool defined ) const { - return protect.empty() ? std::make_pair( "", "" ) : std::make_pair( "#if defined( " + protect + " )\n", "#endif /*" + protect + "*/\n" ); + auto const openProtect = defined ? "#if defined( " : "#if !defined( "; + return protect.empty() ? std::make_pair( "", "" ) : std::make_pair( openProtect + protect + " )\n", "#endif /*" + protect + "*/\n" ); } std::string VulkanHppGenerator::generateRAIICommandDefinitions() const @@ -7858,7 +8556,7 @@ ${enter} ${handleType}s( ${constructorArguments} ) } else { - throwResultException( result, "${constructorCall}" ); + detail::throwResultException( result, "${constructorCall}" ); } } ${leave})"; @@ -8147,7 +8845,7 @@ ${enter} ${handleType}( ${constructorArguments} ) VULKAN_HPP_NAMESPACE::Result result = static_cast( ${getDispatcher}->${constructorCall}( ${callArguments} ) ); if ( ${failureCheck} ) { - throwResultException( result, "${constructorCall}" ); + detail::throwResultException( result, "${constructorCall}" ); }${dispatcherInit} } ${leave})"; @@ -8279,7 +8977,7 @@ ${enter} ${handleType}s( ${constructorArguments} ) } else { - throwResultException( result, "${constructorCall}" ); + detail::throwResultException( result, "${constructorCall}" ); } } ${leave})"; @@ -8333,7 +9031,7 @@ ${enter} ${handleType}( ${constructorArguments} ) ${resultVariable} = static_cast( getDispatcher()->${constructorCall}( ${callArguments} ) ); if ( ${failureCheck} ) { - throwResultException( ${result}, "${constructorCall}" ); + detail::throwResultException( ${result}, "${constructorCall}" ); } } ${leave})"; @@ -10523,9 +11221,9 @@ std::string VulkanHppGenerator::generateThrowResultException() const cases.pop_back(); // remove last newline const std::string throwTemplate = R"( - namespace + namespace detail { - [[noreturn]] void throwResultException( Result result, char const * message ) + [[noreturn]] VULKAN_HPP_INLINE void throwResultException( Result result, char const * message ) { switch ( result ) { @@ -13493,6 +14191,46 @@ void VulkanHppGenerator::readTypeBitmask( tinyxml2::XMLElement const * element, } } +VulkanHppGenerator::DefinesPartition VulkanHppGenerator::partitionDefines( std::map const & defines ) +{ + DefinesPartition partition{}; + for ( auto const & define : defines ) + { + // VK_DEFINE_HANDLE is macro magic that cannot be constexpr-ed + // Also filter out the VKSC_ macros, as although they are in the spec, they are not defined in any header. + if ( define.first.starts_with( "VK_" ) && ( define.first != "VK_DEFINE_HANDLE" ) ) + { + if ( define.second.possibleCallee.empty() ) + { + if ( define.second.possibleDefinition.empty() ) + { +#if !defined( NDEBUG ) + const std::set ignoredDefines{ "VK_DEFINE_NON_DISPATCHABLE_HANDLE", "VK_NULL_HANDLE", "VK_USE_64_BIT_PTR_DEFINES" }; +#endif + assert( ignoredDefines.find( define.first ) != ignoredDefines.end() ); + } + else + { + if ( define.second.params.empty() ) + { + partition.values.insert( define ); + } + else + { + partition.callees.insert( define ); + } + } + } + else + { + assert( !define.second.params.empty() && define.second.possibleDefinition.empty() ); + partition.callers.insert( define ); + } + } + } + return partition; +} + void VulkanHppGenerator::readTypeDefine( tinyxml2::XMLElement const * element, std::map const & attributes ) { int line = element->GetLineNum(); @@ -13583,9 +14321,13 @@ void VulkanHppGenerator::readTypeDefine( tinyxml2::XMLElement const * element, s if ( api.empty() || ( api == m_api ) ) { + MacroVisitor definesVisitor{}; + element->Accept( &definesVisitor ); + auto const & [deprecatedReason, possibleCallee, params, possibleDefinition] = parseMacro( definesVisitor.macro ); + checkForError( m_types.insert( { name, TypeData{ TypeCategory::Define, {}, line } } ).second, line, "define <" + name + "> already specified" ); assert( m_defines.find( name ) == m_defines.end() ); - m_defines[name] = { deprecated, require, line }; + m_defines[name] = { deprecated, require, line, deprecatedReason, possibleCallee, params, possibleDefinition }; } } @@ -14616,6 +15358,60 @@ std::string trimStars( std::string const & input ) return result; } +// function to take three or four-vector of strings containing a macro definition, and return +// a tuple with possibly the deprecation reason, possibly the called macro, the macro parameters, and possibly the definition +MacroData parseMacro( std::vector const & completeMacro ) +{ + // #define macro definition + // #define macro( params ) definition + // #define macro1 macro2( params ) + auto const paramsRegex = std::regex{ R"((\(.*?\)))" }; + auto const commentRegex = std::regex{ R"(\s*//.*)" }; + + auto rawComment = completeMacro[0]; + std::erase( rawComment, '/' ); + auto const strippedComment = trim( stripPostfix( stripPrefix( rawComment, " DEPRECATED:" ), "#define " ) ); + + // macro with parameters and implementation + if ( completeMacro.size() == 3 ) + { + auto const & paramsAndDefinitionAndTrailingComment = completeMacro[2]; + + if ( paramsAndDefinitionAndTrailingComment.find( '(' ) == std::string::npos ) + { + // no opening parenthesis found => no parameters + return { strippedComment, {}, {}, std::regex_replace( paramsAndDefinitionAndTrailingComment, commentRegex, "" ) }; + } + + // match the first set of parentheses only + auto paramsMatch = std::smatch{}; + std::regex_search( paramsAndDefinitionAndTrailingComment, paramsMatch, paramsRegex ); + + // remove the leading and trailing parentheses and tokenise the remaining string + auto params = tokenize( stripPrefix( stripPostfix( paramsMatch[1].str(), ")" ), "(" ), "," ); + + // replace the parameters with empty string, leaving behind the implementation and (possibly) a trailing comment + auto implementation = std::regex_replace( paramsAndDefinitionAndTrailingComment, paramsRegex, "", std::regex_constants::format_first_only ); + implementation = implementation.substr( 0, implementation.find( "//" ) ); + std::erase( implementation, '\\' ); + implementation = trim( implementation ); + + return { strippedComment, {}, params, implementation }; + } + if ( completeMacro.size() == 4 ) + { + auto const & calledMacro = toCamelCase( stripPrefix( completeMacro[2], "VK_" ) ); + auto const & argsAndTrailingComment = completeMacro[3]; + + auto argsMatch = std::smatch{}; + std::regex_search( argsAndTrailingComment, argsMatch, paramsRegex ); + auto args = tokenize( stripPrefix( stripPostfix( argsMatch[1].str(), ")" ), "(" ), "," ); + + return { strippedComment, calledMacro, args, {} }; + } + return {}; +} + void writeToFile( std::string const & str, std::string const & fileName ) { std::ofstream ofs( fileName ); @@ -14733,6 +15529,7 @@ int main( int argc, char ** argv ) generator.generateStaticAssertionsHppFile(); generator.generateStructsHppFile(); generator.generateToStringHppFile(); + generator.generateCppModuleFile(); #if !defined( CLANG_FORMAT_EXECUTABLE ) std::cout << "VulkanHppGenerator: could not find clang-format. The generated files will not be formatted accordingly.\n"; diff --git a/VulkanHppGenerator.hpp b/VulkanHppGenerator.hpp index 1bc5fdf..6263640 100644 --- a/VulkanHppGenerator.hpp +++ b/VulkanHppGenerator.hpp @@ -89,6 +89,7 @@ public: void generateStaticAssertionsHppFile() const; void generateStructsHppFile() const; void generateToStringHppFile() const; + void generateCppModuleFile() const; void prepareRAIIHandles(); void prepareVulkanFuncs(); @@ -189,9 +190,20 @@ private: struct DefineData { - bool deprecated = false; - std::string require = {}; - int xmlLine = {}; + bool deprecated = false; + std::string require = {}; + int xmlLine = {}; + std::string deprecationReason = {}; + std::string possibleCallee = {}; + std::vector params = {}; + std::string possibleDefinition = {}; + }; + + struct DefinesPartition + { + std::map callees = {}; + std::map callers = {}; + std::map values = {}; }; struct EnumValueData @@ -401,6 +413,22 @@ private: size_t strideParam = INVALID_INDEX; }; + struct MacroVisitor final : tinyxml2::XMLVisitor + { + // comments, then name, then parameters and definition together, because that's how they appear in the xml! + // guaranteed to be 3 elements long + std::vector macro; + + bool Visit( tinyxml2::XMLText const & text ) override + { + if ( auto const nodeText = text.Value(); nodeText != nullptr ) + { + macro.emplace_back( nodeText ); + } + return true; + } + }; + private: void addCommand( std::string const & name, CommandData & commandData ); void addCommandsToHandle( std::vector const & requireData ); @@ -635,6 +663,17 @@ private: std::vector const & returnParamIndices, bool raii ) const; std::string generateConstexprString( std::string const & structName ) const; + std::string generateConstexprDefines() const; + std::string generateConstexprUsings() const; + std::string generateCppModuleHandleUsings() const; + std::string generateCppModuleStructUsings() const; + std::string generateCppModuleUniqueHandleUsings() const; + std::string generateCppModuleFuncsUsings() const; + std::string generateCppModuleEnumUsings() const; + std::string generateCppModuleFormatTraitsUsings() const; + std::string generateCppModuleExtensionInspectionUsings() const; + std::string generateCppModuleUsings() const; + std::string generateCppModuleRaiiUsings() const; std::string generateDataDeclarations( CommandData const & commandData, std::vector const & returnParams, std::map const & vectorParams, @@ -733,7 +772,7 @@ private: bool vectorSizeCheck, bool raii ) const; std::string generateObjectDeleter( std::string const & commandName, CommandData const & commandData, size_t initialSkipCount, size_t returnParam ) const; - std::pair generateProtection( std::string const & protect ) const; + std::pair generateProtection( std::string const & protect, bool defined = true ) const; std::string generateRAIICommandDefinitions() const; std::string generateRAIICommandDefinitions( std::vector const & requireData, std::set & listedCommands, std::string const & title ) const; @@ -968,47 +1007,48 @@ private: void readPlatforms( tinyxml2::XMLElement const * element ); void readRegistry( tinyxml2::XMLElement const * element ); std::string readRequireCommand( tinyxml2::XMLElement const * element, std::string const & requiredBy ); - void readRequireEnum( tinyxml2::XMLElement const * element, std::string const & requiredBy, std::string const & platform, bool supported ); - std::string readRequireType( tinyxml2::XMLElement const * element, std::string const & requiredBy ); - void readSPIRVCapability( tinyxml2::XMLElement const * element ); - void readSPIRVCapabilityEnable( tinyxml2::XMLElement const * element ); - void readSPIRVCapabilities( tinyxml2::XMLElement const * element ); - void readSPIRVExtension( tinyxml2::XMLElement const * element ); - void readSPIRVExtensionEnable( tinyxml2::XMLElement const * element ); - void readSPIRVExtensions( tinyxml2::XMLElement const * element ); - void readStructMember( tinyxml2::XMLElement const * element, std::vector & members, bool isUnion ); - void readSync( tinyxml2::XMLElement const * element ); - void readSyncAccess( tinyxml2::XMLElement const * element, - std::map::const_iterator accessFlagBitsIt, - std::map::const_iterator accessFlagBits2It, - std::map::const_iterator stageFlagBits2It ); - void readSyncAccessEquivalent( tinyxml2::XMLElement const * element, std::map::const_iterator accessFlagBits2It ); - void readSyncAccessSupport( tinyxml2::XMLElement const * element, std::map::const_iterator stageFlagBits2It ); - void readSyncPipeline( tinyxml2::XMLElement const * element ); - void readSyncStage( tinyxml2::XMLElement const * element, - std::map::const_iterator stageFlagBitsIt, - std::map::const_iterator stageFlagBits2It ); - void readSyncStageEquivalent( tinyxml2::XMLElement const * element, std::map::const_iterator stageFlagBits2It ); - void readSyncStageSupport( tinyxml2::XMLElement const * element ); - void readTag( tinyxml2::XMLElement const * element ); - void readTags( tinyxml2::XMLElement const * element ); - void readTypeBasetype( tinyxml2::XMLElement const * element, std::map const & attributes ); - void readTypeBitmask( tinyxml2::XMLElement const * element, std::map const & attributes ); - void readTypeDefine( tinyxml2::XMLElement const * element, std::map const & attributes ); - void readTypeEnum( tinyxml2::XMLElement const * element, std::map const & attributes ); - void readTypeFuncpointer( tinyxml2::XMLElement const * element, std::map const & attributes ); - void readTypeHandle( tinyxml2::XMLElement const * element, std::map const & attributes ); - void readTypeInclude( tinyxml2::XMLElement const * element, std::map const & attributes ); - void readTypeRequires( tinyxml2::XMLElement const * element, std::map const & attributes ); - void readTypeStruct( tinyxml2::XMLElement const * element, bool isUnion, std::map const & attributes ); - void readTypes( tinyxml2::XMLElement const * element ); - void readTypesType( tinyxml2::XMLElement const * element ); - TypeInfo readTypeInfo( tinyxml2::XMLElement const * element ) const; - void registerDeleter( std::string const & commandName, CommandData const & commandData ); - void rescheduleRAIIHandle( std::string & str, - std::pair const & handle, - std::set & listedHandles, - std::set const & specialFunctions ) const; + void readRequireEnum( tinyxml2::XMLElement const * element, std::string const & requiredBy, std::string const & platform, bool supported ); + std::string readRequireType( tinyxml2::XMLElement const * element, std::string const & requiredBy ); + void readSPIRVCapability( tinyxml2::XMLElement const * element ); + void readSPIRVCapabilityEnable( tinyxml2::XMLElement const * element ); + void readSPIRVCapabilities( tinyxml2::XMLElement const * element ); + void readSPIRVExtension( tinyxml2::XMLElement const * element ); + void readSPIRVExtensionEnable( tinyxml2::XMLElement const * element ); + void readSPIRVExtensions( tinyxml2::XMLElement const * element ); + void readStructMember( tinyxml2::XMLElement const * element, std::vector & members, bool isUnion ); + void readSync( tinyxml2::XMLElement const * element ); + void readSyncAccess( tinyxml2::XMLElement const * element, + std::map::const_iterator accessFlagBitsIt, + std::map::const_iterator accessFlagBits2It, + std::map::const_iterator stageFlagBits2It ); + void readSyncAccessEquivalent( tinyxml2::XMLElement const * element, std::map::const_iterator accessFlagBits2It ); + void readSyncAccessSupport( tinyxml2::XMLElement const * element, std::map::const_iterator stageFlagBits2It ); + void readSyncPipeline( tinyxml2::XMLElement const * element ); + void readSyncStage( tinyxml2::XMLElement const * element, + std::map::const_iterator stageFlagBitsIt, + std::map::const_iterator stageFlagBits2It ); + void readSyncStageEquivalent( tinyxml2::XMLElement const * element, std::map::const_iterator stageFlagBits2It ); + void readSyncStageSupport( tinyxml2::XMLElement const * element ); + void readTag( tinyxml2::XMLElement const * element ); + void readTags( tinyxml2::XMLElement const * element ); + void readTypeBasetype( tinyxml2::XMLElement const * element, std::map const & attributes ); + void readTypeBitmask( tinyxml2::XMLElement const * element, std::map const & attributes ); + DefinesPartition partitionDefines( std::map const & defines ); + void readTypeDefine( tinyxml2::XMLElement const * element, std::map const & attributes ); + void readTypeEnum( tinyxml2::XMLElement const * element, std::map const & attributes ); + void readTypeFuncpointer( tinyxml2::XMLElement const * element, std::map const & attributes ); + void readTypeHandle( tinyxml2::XMLElement const * element, std::map const & attributes ); + void readTypeInclude( tinyxml2::XMLElement const * element, std::map const & attributes ); + void readTypeRequires( tinyxml2::XMLElement const * element, std::map const & attributes ); + void readTypeStruct( tinyxml2::XMLElement const * element, bool isUnion, std::map const & attributes ); + void readTypes( tinyxml2::XMLElement const * element ); + void readTypesType( tinyxml2::XMLElement const * element ); + TypeInfo readTypeInfo( tinyxml2::XMLElement const * element ) const; + void registerDeleter( std::string const & commandName, CommandData const & commandData ); + void rescheduleRAIIHandle( std::string & str, + std::pair const & handle, + std::set & listedHandles, + std::set const & specialFunctions ) const; std::vector selectCommandsByHandle( std::vector const & requireData, std::set const & handleCommands, std::set & listedCommands ) const; @@ -1027,6 +1067,7 @@ private: std::map m_constantAliases; std::map m_constants; std::map m_defines; + DefinesPartition m_definesPartition; // partition defined macros into mutually-exclusive sets of callees, callers, and values std::map m_enumAliases; std::map m_enums; std::set m_extendedStructs; // structs which are referenced by the structextends tag diff --git a/snippets/DispatchLoaderDefault.hpp b/snippets/DispatchLoaderDefault.hpp index 6086348..913f378 100644 --- a/snippets/DispatchLoaderDefault.hpp +++ b/snippets/DispatchLoaderDefault.hpp @@ -40,7 +40,7 @@ } extern VULKAN_HPP_STORAGE_API DispatchLoaderDynamic defaultDispatchLoaderDynamic; # else - static inline ::VULKAN_HPP_NAMESPACE::DispatchLoaderStatic & getDispatchLoaderStatic() + inline ::VULKAN_HPP_NAMESPACE::DispatchLoaderStatic & getDispatchLoaderStatic() { static ::VULKAN_HPP_NAMESPACE::DispatchLoaderStatic dls; return dls; diff --git a/snippets/resultChecks.hpp b/snippets/resultChecks.hpp index d82305e..b01745b 100644 --- a/snippets/resultChecks.hpp +++ b/snippets/resultChecks.hpp @@ -7,7 +7,7 @@ #else if ( result != Result::eSuccess ) { - throwResultException( result, message ); + detail::throwResultException( result, message ); } #endif } @@ -22,7 +22,7 @@ #else if ( std::find( successCodes.begin(), successCodes.end(), result ) == successCodes.end() ) { - throwResultException( result, message ); + detail::throwResultException( result, message ); } #endif } \ No newline at end of file diff --git a/tests/CMakeLists.txt b/tests/CMakeLists.txt index a41906b..1f51d4a 100644 --- a/tests/CMakeLists.txt +++ b/tests/CMakeLists.txt @@ -31,3 +31,6 @@ add_subdirectory( StridedArrayProxy ) add_subdirectory( StructureChain ) add_subdirectory( UniqueHandle ) add_subdirectory( UniqueHandleDefaultArguments ) +if( VULKAN_HPP_ENABLE_EXPERIMENTAL_CPP20_MODULES ) + add_subdirectory( Cpp20Modules ) +endif() diff --git a/tests/Cpp20Modules/CMakeLists.txt b/tests/Cpp20Modules/CMakeLists.txt new file mode 100644 index 0000000..1a1cea3 --- /dev/null +++ b/tests/Cpp20Modules/CMakeLists.txt @@ -0,0 +1,7 @@ +cmake_minimum_required( VERSION 3.25 ) + +vulkan_hpp__setup_test( NAME Cpp20Modules CXX_STANDARD 20 LIBRARIES VulkanHppModule ) + +if( NOT ( VULKAN_HPP_SAMPLES_BUILD_ONLY_DYNAMIC AND VULKAN_HPP_SAMPLES_BUILD_WITH_LOCAL_VULKAN_HPP ) ) + target_link_libraries( Cpp20Modules PRIVATE Vulkan::Vulkan ) +endif() \ No newline at end of file diff --git a/tests/Cpp20Modules/Cpp20Modules.cpp b/tests/Cpp20Modules/Cpp20Modules.cpp new file mode 100644 index 0000000..1debd24 --- /dev/null +++ b/tests/Cpp20Modules/Cpp20Modules.cpp @@ -0,0 +1,44 @@ +import vulkan; + +#include + +static std::string AppName = "01_InitInstance"; +static std::string EngineName = "Vulkan.hpp"; + +int main( int /*argc*/, char ** /*argv*/ ) +{ + /* VULKAN_HPP_KEY_START */ + try + { + // initialize the vk::ApplicationInfo structure + vk::ApplicationInfo applicationInfo( AppName.c_str(), 1, EngineName.c_str(), 1, vk::makeApiVersion( 1, 0, 0, 0 ) ); + + // initialize the vk::InstanceCreateInfo + vk::InstanceCreateInfo instanceCreateInfo( {}, &applicationInfo ); + + // create an Instance + vk::Instance instance = vk::createInstance( instanceCreateInfo ); + + // destroy it again + instance.destroy(); + } + catch ( vk::SystemError & err ) + { + std::cout << "vk::SystemError: " << err.what() << std::endl; + exit( -1 ); + } + catch ( std::exception & err ) + { + std::cout << "std::exception: " << err.what() << std::endl; + exit( -1 ); + } + catch ( ... ) + { + std::cout << "unknown error\n"; + exit( -1 ); + } + + /* VULKAN_HPP_KEY_END */ + + return 0; +} diff --git a/vulkan/vulkan.cppm b/vulkan/vulkan.cppm new file mode 100644 index 0000000..43b9c4e --- /dev/null +++ b/vulkan/vulkan.cppm @@ -0,0 +1,2926 @@ +// Copyright 2015-2023 The Khronos Group Inc. +// +// SPDX-License-Identifier: Apache-2.0 OR MIT +// + +// This header is generated from the Khronos Vulkan XML API Registry. + +module; + +#include +#include +#include +#include +#include + +export module vulkan; + +VULKAN_HPP_DEFAULT_DISPATCH_LOADER_DYNAMIC_STORAGE + +export namespace VULKAN_HPP_NAMESPACE +{ + //===================================== + //=== HARDCODED TYPEs AND FUNCTIONs === + //===================================== + using VULKAN_HPP_NAMESPACE::ArrayWrapper1D; + using VULKAN_HPP_NAMESPACE::ArrayWrapper2D; + using VULKAN_HPP_NAMESPACE::DispatchLoaderBase; + using VULKAN_HPP_NAMESPACE::Flags; + using VULKAN_HPP_NAMESPACE::FlagTraits; + +#if !defined( VK_NO_PROTOTYPES ) + using VULKAN_HPP_NAMESPACE::DispatchLoaderStatic; +#endif /*VK_NO_PROTOTYPES*/ + + using VULKAN_HPP_NAMESPACE::operator&; + using VULKAN_HPP_NAMESPACE::operator|; + using VULKAN_HPP_NAMESPACE::operator^; + using VULKAN_HPP_NAMESPACE::operator~; + using VULKAN_HPP_DEFAULT_DISPATCHER_TYPE; + +#if !defined( VULKAN_HPP_DISABLE_ENHANCED_MODE ) + using VULKAN_HPP_NAMESPACE::ArrayProxy; + using VULKAN_HPP_NAMESPACE::ArrayProxyNoTemporaries; + using VULKAN_HPP_NAMESPACE::Optional; + using VULKAN_HPP_NAMESPACE::StridedArrayProxy; + using VULKAN_HPP_NAMESPACE::StructureChain; + using VULKAN_HPP_NAMESPACE::UniqueHandle; +#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ + +#if !defined( VULKAN_HPP_NO_SMART_HANDLE ) + using VULKAN_HPP_NAMESPACE::ObjectDestroy; + using VULKAN_HPP_NAMESPACE::ObjectFree; + using VULKAN_HPP_NAMESPACE::ObjectRelease; + using VULKAN_HPP_NAMESPACE::PoolFree; +#endif /*VULKAN_HPP_NO_SMART_HANDLE*/ + + //================== + //=== BASE TYPEs === + //================== + using VULKAN_HPP_NAMESPACE::Bool32; + using VULKAN_HPP_NAMESPACE::DeviceAddress; + using VULKAN_HPP_NAMESPACE::DeviceSize; + using VULKAN_HPP_NAMESPACE::RemoteAddressNV; + using VULKAN_HPP_NAMESPACE::SampleMask; + + //============= + //=== ENUMs === + //============= + using VULKAN_HPP_NAMESPACE::CppType; + + //=== VK_VERSION_1_0 === + using VULKAN_HPP_NAMESPACE::AccessFlagBits; + using VULKAN_HPP_NAMESPACE::AccessFlags; + using VULKAN_HPP_NAMESPACE::AttachmentDescriptionFlagBits; + using VULKAN_HPP_NAMESPACE::AttachmentDescriptionFlags; + using VULKAN_HPP_NAMESPACE::AttachmentLoadOp; + using VULKAN_HPP_NAMESPACE::AttachmentStoreOp; + using VULKAN_HPP_NAMESPACE::BlendFactor; + using VULKAN_HPP_NAMESPACE::BlendOp; + using VULKAN_HPP_NAMESPACE::BorderColor; + using VULKAN_HPP_NAMESPACE::BufferCreateFlagBits; + using VULKAN_HPP_NAMESPACE::BufferCreateFlags; + using VULKAN_HPP_NAMESPACE::BufferUsageFlagBits; + using VULKAN_HPP_NAMESPACE::BufferUsageFlags; + using VULKAN_HPP_NAMESPACE::BufferViewCreateFlagBits; + using VULKAN_HPP_NAMESPACE::BufferViewCreateFlags; + using VULKAN_HPP_NAMESPACE::ColorComponentFlagBits; + using VULKAN_HPP_NAMESPACE::ColorComponentFlags; + using VULKAN_HPP_NAMESPACE::CommandBufferLevel; + using VULKAN_HPP_NAMESPACE::CommandBufferResetFlagBits; + using VULKAN_HPP_NAMESPACE::CommandBufferResetFlags; + using VULKAN_HPP_NAMESPACE::CommandBufferUsageFlagBits; + using VULKAN_HPP_NAMESPACE::CommandBufferUsageFlags; + using VULKAN_HPP_NAMESPACE::CommandPoolCreateFlagBits; + using VULKAN_HPP_NAMESPACE::CommandPoolCreateFlags; + using VULKAN_HPP_NAMESPACE::CommandPoolResetFlagBits; + using VULKAN_HPP_NAMESPACE::CommandPoolResetFlags; + using VULKAN_HPP_NAMESPACE::CompareOp; + using VULKAN_HPP_NAMESPACE::ComponentSwizzle; + using VULKAN_HPP_NAMESPACE::CullModeFlagBits; + using VULKAN_HPP_NAMESPACE::CullModeFlags; + using VULKAN_HPP_NAMESPACE::DependencyFlagBits; + using VULKAN_HPP_NAMESPACE::DependencyFlags; + using VULKAN_HPP_NAMESPACE::DescriptorPoolCreateFlagBits; + using VULKAN_HPP_NAMESPACE::DescriptorPoolCreateFlags; + using VULKAN_HPP_NAMESPACE::DescriptorPoolResetFlagBits; + using VULKAN_HPP_NAMESPACE::DescriptorPoolResetFlags; + using VULKAN_HPP_NAMESPACE::DescriptorSetLayoutCreateFlagBits; + using VULKAN_HPP_NAMESPACE::DescriptorSetLayoutCreateFlags; + using VULKAN_HPP_NAMESPACE::DescriptorType; + using VULKAN_HPP_NAMESPACE::DeviceCreateFlagBits; + using VULKAN_HPP_NAMESPACE::DeviceCreateFlags; + using VULKAN_HPP_NAMESPACE::DynamicState; + using VULKAN_HPP_NAMESPACE::EventCreateFlagBits; + using VULKAN_HPP_NAMESPACE::EventCreateFlags; + using VULKAN_HPP_NAMESPACE::FenceCreateFlagBits; + using VULKAN_HPP_NAMESPACE::FenceCreateFlags; + using VULKAN_HPP_NAMESPACE::Filter; + using VULKAN_HPP_NAMESPACE::Format; + using VULKAN_HPP_NAMESPACE::FormatFeatureFlagBits; + using VULKAN_HPP_NAMESPACE::FormatFeatureFlags; + using VULKAN_HPP_NAMESPACE::FramebufferCreateFlagBits; + using VULKAN_HPP_NAMESPACE::FramebufferCreateFlags; + using VULKAN_HPP_NAMESPACE::FrontFace; + using VULKAN_HPP_NAMESPACE::ImageAspectFlagBits; + using VULKAN_HPP_NAMESPACE::ImageAspectFlags; + using VULKAN_HPP_NAMESPACE::ImageCreateFlagBits; + using VULKAN_HPP_NAMESPACE::ImageCreateFlags; + using VULKAN_HPP_NAMESPACE::ImageLayout; + using VULKAN_HPP_NAMESPACE::ImageTiling; + using VULKAN_HPP_NAMESPACE::ImageType; + using VULKAN_HPP_NAMESPACE::ImageUsageFlagBits; + using VULKAN_HPP_NAMESPACE::ImageUsageFlags; + using VULKAN_HPP_NAMESPACE::ImageViewCreateFlagBits; + using VULKAN_HPP_NAMESPACE::ImageViewCreateFlags; + using VULKAN_HPP_NAMESPACE::ImageViewType; + using VULKAN_HPP_NAMESPACE::IndexType; + using VULKAN_HPP_NAMESPACE::InstanceCreateFlagBits; + using VULKAN_HPP_NAMESPACE::InstanceCreateFlags; + using VULKAN_HPP_NAMESPACE::InternalAllocationType; + using VULKAN_HPP_NAMESPACE::LogicOp; + using VULKAN_HPP_NAMESPACE::MemoryHeapFlagBits; + using VULKAN_HPP_NAMESPACE::MemoryHeapFlags; + using VULKAN_HPP_NAMESPACE::MemoryMapFlagBits; + using VULKAN_HPP_NAMESPACE::MemoryMapFlags; + using VULKAN_HPP_NAMESPACE::MemoryPropertyFlagBits; + using VULKAN_HPP_NAMESPACE::MemoryPropertyFlags; + using VULKAN_HPP_NAMESPACE::ObjectType; + using VULKAN_HPP_NAMESPACE::PhysicalDeviceType; + using VULKAN_HPP_NAMESPACE::PipelineBindPoint; + using VULKAN_HPP_NAMESPACE::PipelineCacheHeaderVersion; + using VULKAN_HPP_NAMESPACE::PipelineCreateFlagBits; + using VULKAN_HPP_NAMESPACE::PipelineCreateFlags; + using VULKAN_HPP_NAMESPACE::PipelineDynamicStateCreateFlagBits; + using VULKAN_HPP_NAMESPACE::PipelineDynamicStateCreateFlags; + using VULKAN_HPP_NAMESPACE::PipelineInputAssemblyStateCreateFlagBits; + using VULKAN_HPP_NAMESPACE::PipelineInputAssemblyStateCreateFlags; + using VULKAN_HPP_NAMESPACE::PipelineMultisampleStateCreateFlagBits; + using VULKAN_HPP_NAMESPACE::PipelineMultisampleStateCreateFlags; + using VULKAN_HPP_NAMESPACE::PipelineRasterizationStateCreateFlagBits; + using VULKAN_HPP_NAMESPACE::PipelineRasterizationStateCreateFlags; + using VULKAN_HPP_NAMESPACE::PipelineShaderStageCreateFlagBits; + using VULKAN_HPP_NAMESPACE::PipelineShaderStageCreateFlags; + using VULKAN_HPP_NAMESPACE::PipelineStageFlagBits; + using VULKAN_HPP_NAMESPACE::PipelineStageFlags; + using VULKAN_HPP_NAMESPACE::PipelineTessellationStateCreateFlagBits; + using VULKAN_HPP_NAMESPACE::PipelineTessellationStateCreateFlags; + using VULKAN_HPP_NAMESPACE::PipelineVertexInputStateCreateFlagBits; + using VULKAN_HPP_NAMESPACE::PipelineVertexInputStateCreateFlags; + using VULKAN_HPP_NAMESPACE::PipelineViewportStateCreateFlagBits; + using VULKAN_HPP_NAMESPACE::PipelineViewportStateCreateFlags; + using VULKAN_HPP_NAMESPACE::PolygonMode; + using VULKAN_HPP_NAMESPACE::PrimitiveTopology; + using VULKAN_HPP_NAMESPACE::QueryControlFlagBits; + using VULKAN_HPP_NAMESPACE::QueryControlFlags; + using VULKAN_HPP_NAMESPACE::QueryPipelineStatisticFlagBits; + using VULKAN_HPP_NAMESPACE::QueryPipelineStatisticFlags; + using VULKAN_HPP_NAMESPACE::QueryPoolCreateFlagBits; + using VULKAN_HPP_NAMESPACE::QueryPoolCreateFlags; + using VULKAN_HPP_NAMESPACE::QueryResultFlagBits; + using VULKAN_HPP_NAMESPACE::QueryResultFlags; + using VULKAN_HPP_NAMESPACE::QueryType; + using VULKAN_HPP_NAMESPACE::QueueFlagBits; + using VULKAN_HPP_NAMESPACE::QueueFlags; + using VULKAN_HPP_NAMESPACE::RenderPassCreateFlagBits; + using VULKAN_HPP_NAMESPACE::RenderPassCreateFlags; + using VULKAN_HPP_NAMESPACE::Result; + using VULKAN_HPP_NAMESPACE::SampleCountFlagBits; + using VULKAN_HPP_NAMESPACE::SampleCountFlags; + using VULKAN_HPP_NAMESPACE::SamplerAddressMode; + using VULKAN_HPP_NAMESPACE::SamplerCreateFlagBits; + using VULKAN_HPP_NAMESPACE::SamplerCreateFlags; + using VULKAN_HPP_NAMESPACE::SamplerMipmapMode; + using VULKAN_HPP_NAMESPACE::SemaphoreCreateFlagBits; + using VULKAN_HPP_NAMESPACE::SemaphoreCreateFlags; + using VULKAN_HPP_NAMESPACE::ShaderModuleCreateFlagBits; + using VULKAN_HPP_NAMESPACE::ShaderModuleCreateFlags; + using VULKAN_HPP_NAMESPACE::ShaderStageFlagBits; + using VULKAN_HPP_NAMESPACE::ShaderStageFlags; + using VULKAN_HPP_NAMESPACE::SharingMode; + using VULKAN_HPP_NAMESPACE::SparseImageFormatFlagBits; + using VULKAN_HPP_NAMESPACE::SparseImageFormatFlags; + using VULKAN_HPP_NAMESPACE::SparseMemoryBindFlagBits; + using VULKAN_HPP_NAMESPACE::SparseMemoryBindFlags; + using VULKAN_HPP_NAMESPACE::StencilFaceFlagBits; + using VULKAN_HPP_NAMESPACE::StencilFaceFlags; + using VULKAN_HPP_NAMESPACE::StencilOp; + using VULKAN_HPP_NAMESPACE::StructureType; + using VULKAN_HPP_NAMESPACE::SubpassContents; + using VULKAN_HPP_NAMESPACE::SubpassDescriptionFlagBits; + using VULKAN_HPP_NAMESPACE::SubpassDescriptionFlags; + using VULKAN_HPP_NAMESPACE::SystemAllocationScope; + using VULKAN_HPP_NAMESPACE::VendorId; + using VULKAN_HPP_NAMESPACE::VertexInputRate; + + //=== VK_VERSION_1_1 === + using VULKAN_HPP_NAMESPACE::ChromaLocation; + using VULKAN_HPP_NAMESPACE::ChromaLocationKHR; + using VULKAN_HPP_NAMESPACE::CommandPoolTrimFlagBits; + using VULKAN_HPP_NAMESPACE::CommandPoolTrimFlags; + using VULKAN_HPP_NAMESPACE::DescriptorUpdateTemplateCreateFlagBits; + using VULKAN_HPP_NAMESPACE::DescriptorUpdateTemplateCreateFlags; + using VULKAN_HPP_NAMESPACE::DescriptorUpdateTemplateType; + using VULKAN_HPP_NAMESPACE::DescriptorUpdateTemplateTypeKHR; + using VULKAN_HPP_NAMESPACE::DeviceQueueCreateFlagBits; + using VULKAN_HPP_NAMESPACE::DeviceQueueCreateFlags; + using VULKAN_HPP_NAMESPACE::ExternalFenceFeatureFlagBits; + using VULKAN_HPP_NAMESPACE::ExternalFenceFeatureFlagBitsKHR; + using VULKAN_HPP_NAMESPACE::ExternalFenceFeatureFlags; + using VULKAN_HPP_NAMESPACE::ExternalFenceHandleTypeFlagBits; + using VULKAN_HPP_NAMESPACE::ExternalFenceHandleTypeFlagBitsKHR; + using VULKAN_HPP_NAMESPACE::ExternalFenceHandleTypeFlags; + using VULKAN_HPP_NAMESPACE::ExternalMemoryFeatureFlagBits; + using VULKAN_HPP_NAMESPACE::ExternalMemoryFeatureFlagBitsKHR; + using VULKAN_HPP_NAMESPACE::ExternalMemoryFeatureFlags; + using VULKAN_HPP_NAMESPACE::ExternalMemoryHandleTypeFlagBits; + using VULKAN_HPP_NAMESPACE::ExternalMemoryHandleTypeFlagBitsKHR; + using VULKAN_HPP_NAMESPACE::ExternalMemoryHandleTypeFlags; + using VULKAN_HPP_NAMESPACE::ExternalSemaphoreFeatureFlagBits; + using VULKAN_HPP_NAMESPACE::ExternalSemaphoreFeatureFlagBitsKHR; + using VULKAN_HPP_NAMESPACE::ExternalSemaphoreFeatureFlags; + using VULKAN_HPP_NAMESPACE::ExternalSemaphoreHandleTypeFlagBits; + using VULKAN_HPP_NAMESPACE::ExternalSemaphoreHandleTypeFlagBitsKHR; + using VULKAN_HPP_NAMESPACE::ExternalSemaphoreHandleTypeFlags; + using VULKAN_HPP_NAMESPACE::FenceImportFlagBits; + using VULKAN_HPP_NAMESPACE::FenceImportFlagBitsKHR; + using VULKAN_HPP_NAMESPACE::FenceImportFlags; + using VULKAN_HPP_NAMESPACE::MemoryAllocateFlagBits; + using VULKAN_HPP_NAMESPACE::MemoryAllocateFlagBitsKHR; + using VULKAN_HPP_NAMESPACE::MemoryAllocateFlags; + using VULKAN_HPP_NAMESPACE::PeerMemoryFeatureFlagBits; + using VULKAN_HPP_NAMESPACE::PeerMemoryFeatureFlagBitsKHR; + using VULKAN_HPP_NAMESPACE::PeerMemoryFeatureFlags; + using VULKAN_HPP_NAMESPACE::PointClippingBehavior; + using VULKAN_HPP_NAMESPACE::PointClippingBehaviorKHR; + using VULKAN_HPP_NAMESPACE::SamplerYcbcrModelConversion; + using VULKAN_HPP_NAMESPACE::SamplerYcbcrModelConversionKHR; + using VULKAN_HPP_NAMESPACE::SamplerYcbcrRange; + using VULKAN_HPP_NAMESPACE::SamplerYcbcrRangeKHR; + using VULKAN_HPP_NAMESPACE::SemaphoreImportFlagBits; + using VULKAN_HPP_NAMESPACE::SemaphoreImportFlagBitsKHR; + using VULKAN_HPP_NAMESPACE::SemaphoreImportFlags; + using VULKAN_HPP_NAMESPACE::SubgroupFeatureFlagBits; + using VULKAN_HPP_NAMESPACE::SubgroupFeatureFlags; + using VULKAN_HPP_NAMESPACE::TessellationDomainOrigin; + using VULKAN_HPP_NAMESPACE::TessellationDomainOriginKHR; + + //=== VK_VERSION_1_2 === + using VULKAN_HPP_NAMESPACE::DescriptorBindingFlagBits; + using VULKAN_HPP_NAMESPACE::DescriptorBindingFlagBitsEXT; + using VULKAN_HPP_NAMESPACE::DescriptorBindingFlags; + using VULKAN_HPP_NAMESPACE::DriverId; + using VULKAN_HPP_NAMESPACE::DriverIdKHR; + using VULKAN_HPP_NAMESPACE::ResolveModeFlagBits; + using VULKAN_HPP_NAMESPACE::ResolveModeFlagBitsKHR; + using VULKAN_HPP_NAMESPACE::ResolveModeFlags; + using VULKAN_HPP_NAMESPACE::SamplerReductionMode; + using VULKAN_HPP_NAMESPACE::SamplerReductionModeEXT; + using VULKAN_HPP_NAMESPACE::SemaphoreType; + using VULKAN_HPP_NAMESPACE::SemaphoreTypeKHR; + using VULKAN_HPP_NAMESPACE::SemaphoreWaitFlagBits; + using VULKAN_HPP_NAMESPACE::SemaphoreWaitFlagBitsKHR; + using VULKAN_HPP_NAMESPACE::SemaphoreWaitFlags; + using VULKAN_HPP_NAMESPACE::ShaderFloatControlsIndependence; + using VULKAN_HPP_NAMESPACE::ShaderFloatControlsIndependenceKHR; + + //=== VK_VERSION_1_3 === + using VULKAN_HPP_NAMESPACE::AccessFlagBits2; + using VULKAN_HPP_NAMESPACE::AccessFlagBits2KHR; + using VULKAN_HPP_NAMESPACE::AccessFlags2; + using VULKAN_HPP_NAMESPACE::FormatFeatureFlagBits2; + using VULKAN_HPP_NAMESPACE::FormatFeatureFlagBits2KHR; + using VULKAN_HPP_NAMESPACE::FormatFeatureFlags2; + using VULKAN_HPP_NAMESPACE::PipelineCreationFeedbackFlagBits; + using VULKAN_HPP_NAMESPACE::PipelineCreationFeedbackFlagBitsEXT; + using VULKAN_HPP_NAMESPACE::PipelineCreationFeedbackFlags; + using VULKAN_HPP_NAMESPACE::PipelineStageFlagBits2; + using VULKAN_HPP_NAMESPACE::PipelineStageFlagBits2KHR; + using VULKAN_HPP_NAMESPACE::PipelineStageFlags2; + using VULKAN_HPP_NAMESPACE::PrivateDataSlotCreateFlagBits; + using VULKAN_HPP_NAMESPACE::PrivateDataSlotCreateFlagBitsEXT; + using VULKAN_HPP_NAMESPACE::PrivateDataSlotCreateFlags; + using VULKAN_HPP_NAMESPACE::RenderingFlagBits; + using VULKAN_HPP_NAMESPACE::RenderingFlagBitsKHR; + using VULKAN_HPP_NAMESPACE::RenderingFlags; + using VULKAN_HPP_NAMESPACE::SubmitFlagBits; + using VULKAN_HPP_NAMESPACE::SubmitFlagBitsKHR; + using VULKAN_HPP_NAMESPACE::SubmitFlags; + using VULKAN_HPP_NAMESPACE::ToolPurposeFlagBits; + using VULKAN_HPP_NAMESPACE::ToolPurposeFlagBitsEXT; + using VULKAN_HPP_NAMESPACE::ToolPurposeFlags; + + //=== VK_KHR_surface === + using VULKAN_HPP_NAMESPACE::ColorSpaceKHR; + using VULKAN_HPP_NAMESPACE::CompositeAlphaFlagBitsKHR; + using VULKAN_HPP_NAMESPACE::CompositeAlphaFlagsKHR; + using VULKAN_HPP_NAMESPACE::PresentModeKHR; + using VULKAN_HPP_NAMESPACE::SurfaceTransformFlagBitsKHR; + using VULKAN_HPP_NAMESPACE::SurfaceTransformFlagsKHR; + + //=== VK_KHR_swapchain === + using VULKAN_HPP_NAMESPACE::DeviceGroupPresentModeFlagBitsKHR; + using VULKAN_HPP_NAMESPACE::DeviceGroupPresentModeFlagsKHR; + using VULKAN_HPP_NAMESPACE::SwapchainCreateFlagBitsKHR; + using VULKAN_HPP_NAMESPACE::SwapchainCreateFlagsKHR; + + //=== VK_KHR_display === + using VULKAN_HPP_NAMESPACE::DisplayModeCreateFlagBitsKHR; + using VULKAN_HPP_NAMESPACE::DisplayModeCreateFlagsKHR; + using VULKAN_HPP_NAMESPACE::DisplayPlaneAlphaFlagBitsKHR; + using VULKAN_HPP_NAMESPACE::DisplayPlaneAlphaFlagsKHR; + using VULKAN_HPP_NAMESPACE::DisplaySurfaceCreateFlagBitsKHR; + using VULKAN_HPP_NAMESPACE::DisplaySurfaceCreateFlagsKHR; + +#if defined( VK_USE_PLATFORM_XLIB_KHR ) + //=== VK_KHR_xlib_surface === + using VULKAN_HPP_NAMESPACE::XlibSurfaceCreateFlagBitsKHR; + using VULKAN_HPP_NAMESPACE::XlibSurfaceCreateFlagsKHR; +#endif /*VK_USE_PLATFORM_XLIB_KHR*/ + +#if defined( VK_USE_PLATFORM_XCB_KHR ) + //=== VK_KHR_xcb_surface === + using VULKAN_HPP_NAMESPACE::XcbSurfaceCreateFlagBitsKHR; + using VULKAN_HPP_NAMESPACE::XcbSurfaceCreateFlagsKHR; +#endif /*VK_USE_PLATFORM_XCB_KHR*/ + +#if defined( VK_USE_PLATFORM_WAYLAND_KHR ) + //=== VK_KHR_wayland_surface === + using VULKAN_HPP_NAMESPACE::WaylandSurfaceCreateFlagBitsKHR; + using VULKAN_HPP_NAMESPACE::WaylandSurfaceCreateFlagsKHR; +#endif /*VK_USE_PLATFORM_WAYLAND_KHR*/ + +#if defined( VK_USE_PLATFORM_ANDROID_KHR ) + //=== VK_KHR_android_surface === + using VULKAN_HPP_NAMESPACE::AndroidSurfaceCreateFlagBitsKHR; + using VULKAN_HPP_NAMESPACE::AndroidSurfaceCreateFlagsKHR; +#endif /*VK_USE_PLATFORM_ANDROID_KHR*/ + +#if defined( VK_USE_PLATFORM_WIN32_KHR ) + //=== VK_KHR_win32_surface === + using VULKAN_HPP_NAMESPACE::Win32SurfaceCreateFlagBitsKHR; + using VULKAN_HPP_NAMESPACE::Win32SurfaceCreateFlagsKHR; +#endif /*VK_USE_PLATFORM_WIN32_KHR*/ + + //=== VK_EXT_debug_report === + using VULKAN_HPP_NAMESPACE::DebugReportFlagBitsEXT; + using VULKAN_HPP_NAMESPACE::DebugReportFlagsEXT; + using VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT; + + //=== VK_AMD_rasterization_order === + using VULKAN_HPP_NAMESPACE::RasterizationOrderAMD; + + //=== VK_KHR_video_queue === + using VULKAN_HPP_NAMESPACE::QueryResultStatusKHR; + using VULKAN_HPP_NAMESPACE::VideoBeginCodingFlagBitsKHR; + using VULKAN_HPP_NAMESPACE::VideoBeginCodingFlagsKHR; + using VULKAN_HPP_NAMESPACE::VideoCapabilityFlagBitsKHR; + using VULKAN_HPP_NAMESPACE::VideoCapabilityFlagsKHR; + using VULKAN_HPP_NAMESPACE::VideoChromaSubsamplingFlagBitsKHR; + using VULKAN_HPP_NAMESPACE::VideoChromaSubsamplingFlagsKHR; + using VULKAN_HPP_NAMESPACE::VideoCodecOperationFlagBitsKHR; + using VULKAN_HPP_NAMESPACE::VideoCodecOperationFlagsKHR; + using VULKAN_HPP_NAMESPACE::VideoCodingControlFlagBitsKHR; + using VULKAN_HPP_NAMESPACE::VideoCodingControlFlagsKHR; + using VULKAN_HPP_NAMESPACE::VideoComponentBitDepthFlagBitsKHR; + using VULKAN_HPP_NAMESPACE::VideoComponentBitDepthFlagsKHR; + using VULKAN_HPP_NAMESPACE::VideoEndCodingFlagBitsKHR; + using VULKAN_HPP_NAMESPACE::VideoEndCodingFlagsKHR; + using VULKAN_HPP_NAMESPACE::VideoSessionCreateFlagBitsKHR; + using VULKAN_HPP_NAMESPACE::VideoSessionCreateFlagsKHR; + using VULKAN_HPP_NAMESPACE::VideoSessionParametersCreateFlagBitsKHR; + using VULKAN_HPP_NAMESPACE::VideoSessionParametersCreateFlagsKHR; + + //=== VK_KHR_video_decode_queue === + using VULKAN_HPP_NAMESPACE::VideoDecodeCapabilityFlagBitsKHR; + using VULKAN_HPP_NAMESPACE::VideoDecodeCapabilityFlagsKHR; + using VULKAN_HPP_NAMESPACE::VideoDecodeFlagBitsKHR; + using VULKAN_HPP_NAMESPACE::VideoDecodeFlagsKHR; + using VULKAN_HPP_NAMESPACE::VideoDecodeUsageFlagBitsKHR; + using VULKAN_HPP_NAMESPACE::VideoDecodeUsageFlagsKHR; + + //=== VK_EXT_transform_feedback === + using VULKAN_HPP_NAMESPACE::PipelineRasterizationStateStreamCreateFlagBitsEXT; + using VULKAN_HPP_NAMESPACE::PipelineRasterizationStateStreamCreateFlagsEXT; + +#if defined( VK_ENABLE_BETA_EXTENSIONS ) + //=== VK_EXT_video_encode_h264 === + using VULKAN_HPP_NAMESPACE::VideoEncodeH264CapabilityFlagBitsEXT; + using VULKAN_HPP_NAMESPACE::VideoEncodeH264CapabilityFlagsEXT; + using VULKAN_HPP_NAMESPACE::VideoEncodeH264RateControlFlagBitsEXT; + using VULKAN_HPP_NAMESPACE::VideoEncodeH264RateControlFlagsEXT; + using VULKAN_HPP_NAMESPACE::VideoEncodeH264StdFlagBitsEXT; + using VULKAN_HPP_NAMESPACE::VideoEncodeH264StdFlagsEXT; +#endif /*VK_ENABLE_BETA_EXTENSIONS*/ + +#if defined( VK_ENABLE_BETA_EXTENSIONS ) + //=== VK_EXT_video_encode_h265 === + using VULKAN_HPP_NAMESPACE::VideoEncodeH265CapabilityFlagBitsEXT; + using VULKAN_HPP_NAMESPACE::VideoEncodeH265CapabilityFlagsEXT; + using VULKAN_HPP_NAMESPACE::VideoEncodeH265CtbSizeFlagBitsEXT; + using VULKAN_HPP_NAMESPACE::VideoEncodeH265CtbSizeFlagsEXT; + using VULKAN_HPP_NAMESPACE::VideoEncodeH265RateControlFlagBitsEXT; + using VULKAN_HPP_NAMESPACE::VideoEncodeH265RateControlFlagsEXT; + using VULKAN_HPP_NAMESPACE::VideoEncodeH265StdFlagBitsEXT; + using VULKAN_HPP_NAMESPACE::VideoEncodeH265StdFlagsEXT; + using VULKAN_HPP_NAMESPACE::VideoEncodeH265TransformBlockSizeFlagBitsEXT; + using VULKAN_HPP_NAMESPACE::VideoEncodeH265TransformBlockSizeFlagsEXT; +#endif /*VK_ENABLE_BETA_EXTENSIONS*/ + + //=== VK_KHR_video_decode_h264 === + using VULKAN_HPP_NAMESPACE::VideoDecodeH264PictureLayoutFlagBitsKHR; + using VULKAN_HPP_NAMESPACE::VideoDecodeH264PictureLayoutFlagsKHR; + + //=== VK_AMD_shader_info === + using VULKAN_HPP_NAMESPACE::ShaderInfoTypeAMD; + +#if defined( VK_USE_PLATFORM_GGP ) + //=== VK_GGP_stream_descriptor_surface === + using VULKAN_HPP_NAMESPACE::StreamDescriptorSurfaceCreateFlagBitsGGP; + using VULKAN_HPP_NAMESPACE::StreamDescriptorSurfaceCreateFlagsGGP; +#endif /*VK_USE_PLATFORM_GGP*/ + + //=== VK_NV_external_memory_capabilities === + using VULKAN_HPP_NAMESPACE::ExternalMemoryFeatureFlagBitsNV; + using VULKAN_HPP_NAMESPACE::ExternalMemoryFeatureFlagsNV; + using VULKAN_HPP_NAMESPACE::ExternalMemoryHandleTypeFlagBitsNV; + using VULKAN_HPP_NAMESPACE::ExternalMemoryHandleTypeFlagsNV; + + //=== VK_EXT_validation_flags === + using VULKAN_HPP_NAMESPACE::ValidationCheckEXT; + +#if defined( VK_USE_PLATFORM_VI_NN ) + //=== VK_NN_vi_surface === + using VULKAN_HPP_NAMESPACE::ViSurfaceCreateFlagBitsNN; + using VULKAN_HPP_NAMESPACE::ViSurfaceCreateFlagsNN; +#endif /*VK_USE_PLATFORM_VI_NN*/ + + //=== VK_EXT_pipeline_robustness === + using VULKAN_HPP_NAMESPACE::PipelineRobustnessBufferBehaviorEXT; + using VULKAN_HPP_NAMESPACE::PipelineRobustnessImageBehaviorEXT; + + //=== VK_EXT_conditional_rendering === + using VULKAN_HPP_NAMESPACE::ConditionalRenderingFlagBitsEXT; + using VULKAN_HPP_NAMESPACE::ConditionalRenderingFlagsEXT; + + //=== VK_EXT_display_surface_counter === + using VULKAN_HPP_NAMESPACE::SurfaceCounterFlagBitsEXT; + using VULKAN_HPP_NAMESPACE::SurfaceCounterFlagsEXT; + + //=== VK_EXT_display_control === + using VULKAN_HPP_NAMESPACE::DeviceEventTypeEXT; + using VULKAN_HPP_NAMESPACE::DisplayEventTypeEXT; + using VULKAN_HPP_NAMESPACE::DisplayPowerStateEXT; + + //=== VK_NV_viewport_swizzle === + using VULKAN_HPP_NAMESPACE::PipelineViewportSwizzleStateCreateFlagBitsNV; + using VULKAN_HPP_NAMESPACE::PipelineViewportSwizzleStateCreateFlagsNV; + using VULKAN_HPP_NAMESPACE::ViewportCoordinateSwizzleNV; + + //=== VK_EXT_discard_rectangles === + using VULKAN_HPP_NAMESPACE::DiscardRectangleModeEXT; + using VULKAN_HPP_NAMESPACE::PipelineDiscardRectangleStateCreateFlagBitsEXT; + using VULKAN_HPP_NAMESPACE::PipelineDiscardRectangleStateCreateFlagsEXT; + + //=== VK_EXT_conservative_rasterization === + using VULKAN_HPP_NAMESPACE::ConservativeRasterizationModeEXT; + using VULKAN_HPP_NAMESPACE::PipelineRasterizationConservativeStateCreateFlagBitsEXT; + using VULKAN_HPP_NAMESPACE::PipelineRasterizationConservativeStateCreateFlagsEXT; + + //=== VK_EXT_depth_clip_enable === + using VULKAN_HPP_NAMESPACE::PipelineRasterizationDepthClipStateCreateFlagBitsEXT; + using VULKAN_HPP_NAMESPACE::PipelineRasterizationDepthClipStateCreateFlagsEXT; + + //=== VK_KHR_performance_query === + using VULKAN_HPP_NAMESPACE::AcquireProfilingLockFlagBitsKHR; + using VULKAN_HPP_NAMESPACE::AcquireProfilingLockFlagsKHR; + using VULKAN_HPP_NAMESPACE::PerformanceCounterDescriptionFlagBitsKHR; + using VULKAN_HPP_NAMESPACE::PerformanceCounterDescriptionFlagsKHR; + using VULKAN_HPP_NAMESPACE::PerformanceCounterScopeKHR; + using VULKAN_HPP_NAMESPACE::PerformanceCounterStorageKHR; + using VULKAN_HPP_NAMESPACE::PerformanceCounterUnitKHR; + +#if defined( VK_USE_PLATFORM_IOS_MVK ) + //=== VK_MVK_ios_surface === + using VULKAN_HPP_NAMESPACE::IOSSurfaceCreateFlagBitsMVK; + using VULKAN_HPP_NAMESPACE::IOSSurfaceCreateFlagsMVK; +#endif /*VK_USE_PLATFORM_IOS_MVK*/ + +#if defined( VK_USE_PLATFORM_MACOS_MVK ) + //=== VK_MVK_macos_surface === + using VULKAN_HPP_NAMESPACE::MacOSSurfaceCreateFlagBitsMVK; + using VULKAN_HPP_NAMESPACE::MacOSSurfaceCreateFlagsMVK; +#endif /*VK_USE_PLATFORM_MACOS_MVK*/ + + //=== VK_EXT_debug_utils === + using VULKAN_HPP_NAMESPACE::DebugUtilsMessageSeverityFlagBitsEXT; + using VULKAN_HPP_NAMESPACE::DebugUtilsMessageSeverityFlagsEXT; + using VULKAN_HPP_NAMESPACE::DebugUtilsMessageTypeFlagBitsEXT; + using VULKAN_HPP_NAMESPACE::DebugUtilsMessageTypeFlagsEXT; + using VULKAN_HPP_NAMESPACE::DebugUtilsMessengerCallbackDataFlagBitsEXT; + using VULKAN_HPP_NAMESPACE::DebugUtilsMessengerCallbackDataFlagsEXT; + using VULKAN_HPP_NAMESPACE::DebugUtilsMessengerCreateFlagBitsEXT; + using VULKAN_HPP_NAMESPACE::DebugUtilsMessengerCreateFlagsEXT; + + //=== VK_EXT_blend_operation_advanced === + using VULKAN_HPP_NAMESPACE::BlendOverlapEXT; + + //=== VK_NV_fragment_coverage_to_color === + using VULKAN_HPP_NAMESPACE::PipelineCoverageToColorStateCreateFlagBitsNV; + using VULKAN_HPP_NAMESPACE::PipelineCoverageToColorStateCreateFlagsNV; + + //=== VK_KHR_acceleration_structure === + using VULKAN_HPP_NAMESPACE::AccelerationStructureBuildTypeKHR; + using VULKAN_HPP_NAMESPACE::AccelerationStructureCompatibilityKHR; + using VULKAN_HPP_NAMESPACE::AccelerationStructureCreateFlagBitsKHR; + using VULKAN_HPP_NAMESPACE::AccelerationStructureCreateFlagsKHR; + using VULKAN_HPP_NAMESPACE::AccelerationStructureTypeKHR; + using VULKAN_HPP_NAMESPACE::AccelerationStructureTypeNV; + using VULKAN_HPP_NAMESPACE::BuildAccelerationStructureFlagBitsKHR; + using VULKAN_HPP_NAMESPACE::BuildAccelerationStructureFlagBitsNV; + using VULKAN_HPP_NAMESPACE::BuildAccelerationStructureFlagsKHR; + using VULKAN_HPP_NAMESPACE::BuildAccelerationStructureModeKHR; + using VULKAN_HPP_NAMESPACE::CopyAccelerationStructureModeKHR; + using VULKAN_HPP_NAMESPACE::CopyAccelerationStructureModeNV; + using VULKAN_HPP_NAMESPACE::GeometryFlagBitsKHR; + using VULKAN_HPP_NAMESPACE::GeometryFlagBitsNV; + using VULKAN_HPP_NAMESPACE::GeometryFlagsKHR; + using VULKAN_HPP_NAMESPACE::GeometryInstanceFlagBitsKHR; + using VULKAN_HPP_NAMESPACE::GeometryInstanceFlagBitsNV; + using VULKAN_HPP_NAMESPACE::GeometryInstanceFlagsKHR; + using VULKAN_HPP_NAMESPACE::GeometryTypeKHR; + using VULKAN_HPP_NAMESPACE::GeometryTypeNV; + + //=== VK_KHR_ray_tracing_pipeline === + using VULKAN_HPP_NAMESPACE::RayTracingShaderGroupTypeKHR; + using VULKAN_HPP_NAMESPACE::RayTracingShaderGroupTypeNV; + using VULKAN_HPP_NAMESPACE::ShaderGroupShaderKHR; + + //=== VK_NV_framebuffer_mixed_samples === + using VULKAN_HPP_NAMESPACE::CoverageModulationModeNV; + using VULKAN_HPP_NAMESPACE::PipelineCoverageModulationStateCreateFlagBitsNV; + using VULKAN_HPP_NAMESPACE::PipelineCoverageModulationStateCreateFlagsNV; + + //=== VK_EXT_validation_cache === + using VULKAN_HPP_NAMESPACE::ValidationCacheCreateFlagBitsEXT; + using VULKAN_HPP_NAMESPACE::ValidationCacheCreateFlagsEXT; + using VULKAN_HPP_NAMESPACE::ValidationCacheHeaderVersionEXT; + + //=== VK_NV_shading_rate_image === + using VULKAN_HPP_NAMESPACE::CoarseSampleOrderTypeNV; + using VULKAN_HPP_NAMESPACE::ShadingRatePaletteEntryNV; + + //=== VK_NV_ray_tracing === + using VULKAN_HPP_NAMESPACE::AccelerationStructureMemoryRequirementsTypeNV; + + //=== VK_AMD_pipeline_compiler_control === + using VULKAN_HPP_NAMESPACE::PipelineCompilerControlFlagBitsAMD; + using VULKAN_HPP_NAMESPACE::PipelineCompilerControlFlagsAMD; + + //=== VK_EXT_calibrated_timestamps === + using VULKAN_HPP_NAMESPACE::TimeDomainEXT; + + //=== VK_KHR_global_priority === + using VULKAN_HPP_NAMESPACE::QueueGlobalPriorityEXT; + using VULKAN_HPP_NAMESPACE::QueueGlobalPriorityKHR; + + //=== VK_AMD_memory_overallocation_behavior === + using VULKAN_HPP_NAMESPACE::MemoryOverallocationBehaviorAMD; + + //=== VK_INTEL_performance_query === + using VULKAN_HPP_NAMESPACE::PerformanceConfigurationTypeINTEL; + using VULKAN_HPP_NAMESPACE::PerformanceOverrideTypeINTEL; + using VULKAN_HPP_NAMESPACE::PerformanceParameterTypeINTEL; + using VULKAN_HPP_NAMESPACE::PerformanceValueTypeINTEL; + using VULKAN_HPP_NAMESPACE::QueryPoolSamplingModeINTEL; + +#if defined( VK_USE_PLATFORM_FUCHSIA ) + //=== VK_FUCHSIA_imagepipe_surface === + using VULKAN_HPP_NAMESPACE::ImagePipeSurfaceCreateFlagBitsFUCHSIA; + using VULKAN_HPP_NAMESPACE::ImagePipeSurfaceCreateFlagsFUCHSIA; +#endif /*VK_USE_PLATFORM_FUCHSIA*/ + +#if defined( VK_USE_PLATFORM_METAL_EXT ) + //=== VK_EXT_metal_surface === + using VULKAN_HPP_NAMESPACE::MetalSurfaceCreateFlagBitsEXT; + using VULKAN_HPP_NAMESPACE::MetalSurfaceCreateFlagsEXT; +#endif /*VK_USE_PLATFORM_METAL_EXT*/ + + //=== VK_KHR_fragment_shading_rate === + using VULKAN_HPP_NAMESPACE::FragmentShadingRateCombinerOpKHR; + + //=== VK_AMD_shader_core_properties2 === + using VULKAN_HPP_NAMESPACE::ShaderCorePropertiesFlagBitsAMD; + using VULKAN_HPP_NAMESPACE::ShaderCorePropertiesFlagsAMD; + + //=== VK_EXT_validation_features === + using VULKAN_HPP_NAMESPACE::ValidationFeatureDisableEXT; + using VULKAN_HPP_NAMESPACE::ValidationFeatureEnableEXT; + + //=== VK_NV_cooperative_matrix === + using VULKAN_HPP_NAMESPACE::ComponentTypeNV; + using VULKAN_HPP_NAMESPACE::ScopeNV; + + //=== VK_NV_coverage_reduction_mode === + using VULKAN_HPP_NAMESPACE::CoverageReductionModeNV; + using VULKAN_HPP_NAMESPACE::PipelineCoverageReductionStateCreateFlagBitsNV; + using VULKAN_HPP_NAMESPACE::PipelineCoverageReductionStateCreateFlagsNV; + + //=== VK_EXT_provoking_vertex === + using VULKAN_HPP_NAMESPACE::ProvokingVertexModeEXT; + +#if defined( VK_USE_PLATFORM_WIN32_KHR ) + //=== VK_EXT_full_screen_exclusive === + using VULKAN_HPP_NAMESPACE::FullScreenExclusiveEXT; +#endif /*VK_USE_PLATFORM_WIN32_KHR*/ + + //=== VK_EXT_headless_surface === + using VULKAN_HPP_NAMESPACE::HeadlessSurfaceCreateFlagBitsEXT; + using VULKAN_HPP_NAMESPACE::HeadlessSurfaceCreateFlagsEXT; + + //=== VK_EXT_line_rasterization === + using VULKAN_HPP_NAMESPACE::LineRasterizationModeEXT; + + //=== VK_KHR_pipeline_executable_properties === + using VULKAN_HPP_NAMESPACE::PipelineExecutableStatisticFormatKHR; + + //=== VK_KHR_map_memory2 === + using VULKAN_HPP_NAMESPACE::MemoryUnmapFlagBitsKHR; + using VULKAN_HPP_NAMESPACE::MemoryUnmapFlagsKHR; + + //=== VK_EXT_surface_maintenance1 === + using VULKAN_HPP_NAMESPACE::PresentGravityFlagBitsEXT; + using VULKAN_HPP_NAMESPACE::PresentGravityFlagsEXT; + using VULKAN_HPP_NAMESPACE::PresentScalingFlagBitsEXT; + using VULKAN_HPP_NAMESPACE::PresentScalingFlagsEXT; + + //=== VK_NV_device_generated_commands === + using VULKAN_HPP_NAMESPACE::IndirectCommandsLayoutUsageFlagBitsNV; + using VULKAN_HPP_NAMESPACE::IndirectCommandsLayoutUsageFlagsNV; + using VULKAN_HPP_NAMESPACE::IndirectCommandsTokenTypeNV; + using VULKAN_HPP_NAMESPACE::IndirectStateFlagBitsNV; + using VULKAN_HPP_NAMESPACE::IndirectStateFlagsNV; + + //=== VK_EXT_depth_bias_control === + using VULKAN_HPP_NAMESPACE::DepthBiasRepresentationEXT; + + //=== VK_EXT_device_memory_report === + using VULKAN_HPP_NAMESPACE::DeviceMemoryReportEventTypeEXT; + using VULKAN_HPP_NAMESPACE::DeviceMemoryReportFlagBitsEXT; + using VULKAN_HPP_NAMESPACE::DeviceMemoryReportFlagsEXT; + + //=== VK_EXT_pipeline_creation_cache_control === + using VULKAN_HPP_NAMESPACE::PipelineCacheCreateFlagBits; + using VULKAN_HPP_NAMESPACE::PipelineCacheCreateFlags; + +#if defined( VK_ENABLE_BETA_EXTENSIONS ) + //=== VK_KHR_video_encode_queue === + using VULKAN_HPP_NAMESPACE::VideoEncodeCapabilityFlagBitsKHR; + using VULKAN_HPP_NAMESPACE::VideoEncodeCapabilityFlagsKHR; + using VULKAN_HPP_NAMESPACE::VideoEncodeContentFlagBitsKHR; + using VULKAN_HPP_NAMESPACE::VideoEncodeContentFlagsKHR; + using VULKAN_HPP_NAMESPACE::VideoEncodeFeedbackFlagBitsKHR; + using VULKAN_HPP_NAMESPACE::VideoEncodeFeedbackFlagsKHR; + using VULKAN_HPP_NAMESPACE::VideoEncodeFlagBitsKHR; + using VULKAN_HPP_NAMESPACE::VideoEncodeFlagsKHR; + using VULKAN_HPP_NAMESPACE::VideoEncodeRateControlFlagBitsKHR; + using VULKAN_HPP_NAMESPACE::VideoEncodeRateControlFlagsKHR; + using VULKAN_HPP_NAMESPACE::VideoEncodeRateControlModeFlagBitsKHR; + using VULKAN_HPP_NAMESPACE::VideoEncodeRateControlModeFlagsKHR; + using VULKAN_HPP_NAMESPACE::VideoEncodeTuningModeKHR; + using VULKAN_HPP_NAMESPACE::VideoEncodeUsageFlagBitsKHR; + using VULKAN_HPP_NAMESPACE::VideoEncodeUsageFlagsKHR; +#endif /*VK_ENABLE_BETA_EXTENSIONS*/ + + //=== VK_NV_device_diagnostics_config === + using VULKAN_HPP_NAMESPACE::DeviceDiagnosticsConfigFlagBitsNV; + using VULKAN_HPP_NAMESPACE::DeviceDiagnosticsConfigFlagsNV; + +#if defined( VK_USE_PLATFORM_METAL_EXT ) + //=== VK_EXT_metal_objects === + using VULKAN_HPP_NAMESPACE::ExportMetalObjectTypeFlagBitsEXT; + using VULKAN_HPP_NAMESPACE::ExportMetalObjectTypeFlagsEXT; +#endif /*VK_USE_PLATFORM_METAL_EXT*/ + + //=== VK_EXT_graphics_pipeline_library === + using VULKAN_HPP_NAMESPACE::GraphicsPipelineLibraryFlagBitsEXT; + using VULKAN_HPP_NAMESPACE::GraphicsPipelineLibraryFlagsEXT; + using VULKAN_HPP_NAMESPACE::PipelineLayoutCreateFlagBits; + using VULKAN_HPP_NAMESPACE::PipelineLayoutCreateFlags; + + //=== VK_NV_fragment_shading_rate_enums === + using VULKAN_HPP_NAMESPACE::FragmentShadingRateNV; + using VULKAN_HPP_NAMESPACE::FragmentShadingRateTypeNV; + + //=== VK_NV_ray_tracing_motion_blur === + using VULKAN_HPP_NAMESPACE::AccelerationStructureMotionInfoFlagBitsNV; + using VULKAN_HPP_NAMESPACE::AccelerationStructureMotionInfoFlagsNV; + using VULKAN_HPP_NAMESPACE::AccelerationStructureMotionInstanceFlagBitsNV; + using VULKAN_HPP_NAMESPACE::AccelerationStructureMotionInstanceFlagsNV; + using VULKAN_HPP_NAMESPACE::AccelerationStructureMotionInstanceTypeNV; + + //=== VK_EXT_image_compression_control === + using VULKAN_HPP_NAMESPACE::ImageCompressionFixedRateFlagBitsEXT; + using VULKAN_HPP_NAMESPACE::ImageCompressionFixedRateFlagsEXT; + using VULKAN_HPP_NAMESPACE::ImageCompressionFlagBitsEXT; + using VULKAN_HPP_NAMESPACE::ImageCompressionFlagsEXT; + + //=== VK_EXT_device_fault === + using VULKAN_HPP_NAMESPACE::DeviceFaultAddressTypeEXT; + using VULKAN_HPP_NAMESPACE::DeviceFaultVendorBinaryHeaderVersionEXT; + +#if defined( VK_USE_PLATFORM_DIRECTFB_EXT ) + //=== VK_EXT_directfb_surface === + using VULKAN_HPP_NAMESPACE::DirectFBSurfaceCreateFlagBitsEXT; + using VULKAN_HPP_NAMESPACE::DirectFBSurfaceCreateFlagsEXT; +#endif /*VK_USE_PLATFORM_DIRECTFB_EXT*/ + + //=== VK_EXT_device_address_binding_report === + using VULKAN_HPP_NAMESPACE::DeviceAddressBindingFlagBitsEXT; + using VULKAN_HPP_NAMESPACE::DeviceAddressBindingFlagsEXT; + using VULKAN_HPP_NAMESPACE::DeviceAddressBindingTypeEXT; + +#if defined( VK_USE_PLATFORM_FUCHSIA ) + //=== VK_FUCHSIA_buffer_collection === + using VULKAN_HPP_NAMESPACE::ImageConstraintsInfoFlagBitsFUCHSIA; + using VULKAN_HPP_NAMESPACE::ImageConstraintsInfoFlagsFUCHSIA; + using VULKAN_HPP_NAMESPACE::ImageFormatConstraintsFlagBitsFUCHSIA; + using VULKAN_HPP_NAMESPACE::ImageFormatConstraintsFlagsFUCHSIA; +#endif /*VK_USE_PLATFORM_FUCHSIA*/ + +#if defined( VK_USE_PLATFORM_SCREEN_QNX ) + //=== VK_QNX_screen_surface === + using VULKAN_HPP_NAMESPACE::ScreenSurfaceCreateFlagBitsQNX; + using VULKAN_HPP_NAMESPACE::ScreenSurfaceCreateFlagsQNX; +#endif /*VK_USE_PLATFORM_SCREEN_QNX*/ + + //=== VK_EXT_opacity_micromap === + using VULKAN_HPP_NAMESPACE::BuildMicromapFlagBitsEXT; + using VULKAN_HPP_NAMESPACE::BuildMicromapFlagsEXT; + using VULKAN_HPP_NAMESPACE::BuildMicromapModeEXT; + using VULKAN_HPP_NAMESPACE::CopyMicromapModeEXT; + using VULKAN_HPP_NAMESPACE::MicromapCreateFlagBitsEXT; + using VULKAN_HPP_NAMESPACE::MicromapCreateFlagsEXT; + using VULKAN_HPP_NAMESPACE::MicromapTypeEXT; + using VULKAN_HPP_NAMESPACE::OpacityMicromapFormatEXT; + using VULKAN_HPP_NAMESPACE::OpacityMicromapSpecialIndexEXT; + +#if defined( VK_ENABLE_BETA_EXTENSIONS ) + //=== VK_NV_displacement_micromap === + using VULKAN_HPP_NAMESPACE::DisplacementMicromapFormatNV; +#endif /*VK_ENABLE_BETA_EXTENSIONS*/ + + //=== VK_NV_memory_decompression === + using VULKAN_HPP_NAMESPACE::MemoryDecompressionMethodFlagBitsNV; + using VULKAN_HPP_NAMESPACE::MemoryDecompressionMethodFlagsNV; + + //=== VK_EXT_subpass_merge_feedback === + using VULKAN_HPP_NAMESPACE::SubpassMergeStatusEXT; + + //=== VK_LUNARG_direct_driver_loading === + using VULKAN_HPP_NAMESPACE::DirectDriverLoadingFlagBitsLUNARG; + using VULKAN_HPP_NAMESPACE::DirectDriverLoadingFlagsLUNARG; + using VULKAN_HPP_NAMESPACE::DirectDriverLoadingModeLUNARG; + + //=== VK_EXT_rasterization_order_attachment_access === + using VULKAN_HPP_NAMESPACE::PipelineColorBlendStateCreateFlagBits; + using VULKAN_HPP_NAMESPACE::PipelineColorBlendStateCreateFlags; + using VULKAN_HPP_NAMESPACE::PipelineDepthStencilStateCreateFlagBits; + using VULKAN_HPP_NAMESPACE::PipelineDepthStencilStateCreateFlags; + + //=== VK_NV_optical_flow === + using VULKAN_HPP_NAMESPACE::OpticalFlowExecuteFlagBitsNV; + using VULKAN_HPP_NAMESPACE::OpticalFlowExecuteFlagsNV; + using VULKAN_HPP_NAMESPACE::OpticalFlowGridSizeFlagBitsNV; + using VULKAN_HPP_NAMESPACE::OpticalFlowGridSizeFlagsNV; + using VULKAN_HPP_NAMESPACE::OpticalFlowPerformanceLevelNV; + using VULKAN_HPP_NAMESPACE::OpticalFlowSessionBindingPointNV; + using VULKAN_HPP_NAMESPACE::OpticalFlowSessionCreateFlagBitsNV; + using VULKAN_HPP_NAMESPACE::OpticalFlowSessionCreateFlagsNV; + using VULKAN_HPP_NAMESPACE::OpticalFlowUsageFlagBitsNV; + using VULKAN_HPP_NAMESPACE::OpticalFlowUsageFlagsNV; + + //=== VK_EXT_shader_object === + using VULKAN_HPP_NAMESPACE::ShaderCodeTypeEXT; + using VULKAN_HPP_NAMESPACE::ShaderCreateFlagBitsEXT; + using VULKAN_HPP_NAMESPACE::ShaderCreateFlagsEXT; + + //=== VK_NV_ray_tracing_invocation_reorder === + using VULKAN_HPP_NAMESPACE::RayTracingInvocationReorderModeNV; + + //=== VK_KHR_cooperative_matrix === + using VULKAN_HPP_NAMESPACE::ComponentTypeKHR; + using VULKAN_HPP_NAMESPACE::ScopeKHR; + + //========================= + //=== Index Type Traits === + //========================= + using VULKAN_HPP_NAMESPACE::IndexTypeValue; + + //====================== + //=== ENUM to_string === + //====================== +#if !defined( VULKAN_HPP_NO_TO_STRING ) + using VULKAN_HPP_NAMESPACE::to_string; + using VULKAN_HPP_NAMESPACE::toHexString; +#endif /*VULKAN_HPP_NO_TO_STRING*/ + + //============================= + //=== EXCEPTIONs AND ERRORs === + //============================= +#if !defined( VULKAN_HPP_NO_EXCEPTIONS ) + using VULKAN_HPP_NAMESPACE::DeviceLostError; + using VULKAN_HPP_NAMESPACE::Error; + using VULKAN_HPP_NAMESPACE::errorCategory; + using VULKAN_HPP_NAMESPACE::ErrorCategoryImpl; + using VULKAN_HPP_NAMESPACE::ExtensionNotPresentError; + using VULKAN_HPP_NAMESPACE::FeatureNotPresentError; + using VULKAN_HPP_NAMESPACE::FormatNotSupportedError; + using VULKAN_HPP_NAMESPACE::FragmentationError; + using VULKAN_HPP_NAMESPACE::FragmentedPoolError; + using VULKAN_HPP_NAMESPACE::ImageUsageNotSupportedKHRError; + using VULKAN_HPP_NAMESPACE::IncompatibleDisplayKHRError; + using VULKAN_HPP_NAMESPACE::IncompatibleDriverError; + using VULKAN_HPP_NAMESPACE::InitializationFailedError; + using VULKAN_HPP_NAMESPACE::InvalidDrmFormatModifierPlaneLayoutEXTError; + using VULKAN_HPP_NAMESPACE::InvalidExternalHandleError; + using VULKAN_HPP_NAMESPACE::InvalidOpaqueCaptureAddressError; + using VULKAN_HPP_NAMESPACE::InvalidShaderNVError; + using VULKAN_HPP_NAMESPACE::LayerNotPresentError; + using VULKAN_HPP_NAMESPACE::LogicError; + using VULKAN_HPP_NAMESPACE::make_error_code; + using VULKAN_HPP_NAMESPACE::make_error_condition; + using VULKAN_HPP_NAMESPACE::MemoryMapFailedError; + using VULKAN_HPP_NAMESPACE::NativeWindowInUseKHRError; + using VULKAN_HPP_NAMESPACE::NotPermittedKHRError; + using VULKAN_HPP_NAMESPACE::OutOfDateKHRError; + using VULKAN_HPP_NAMESPACE::OutOfDeviceMemoryError; + using VULKAN_HPP_NAMESPACE::OutOfHostMemoryError; + using VULKAN_HPP_NAMESPACE::OutOfPoolMemoryError; + using VULKAN_HPP_NAMESPACE::SurfaceLostKHRError; + using VULKAN_HPP_NAMESPACE::SystemError; + using VULKAN_HPP_NAMESPACE::TooManyObjectsError; + using VULKAN_HPP_NAMESPACE::UnknownError; + using VULKAN_HPP_NAMESPACE::ValidationFailedEXTError; + using VULKAN_HPP_NAMESPACE::VideoPictureLayoutNotSupportedKHRError; + using VULKAN_HPP_NAMESPACE::VideoProfileCodecNotSupportedKHRError; + using VULKAN_HPP_NAMESPACE::VideoProfileFormatNotSupportedKHRError; + using VULKAN_HPP_NAMESPACE::VideoProfileOperationNotSupportedKHRError; + using VULKAN_HPP_NAMESPACE::VideoStdVersionNotSupportedKHRError; + +# if defined( VK_USE_PLATFORM_WIN32_KHR ) + using VULKAN_HPP_NAMESPACE::FullScreenExclusiveModeLostEXTError; +# endif /*VK_USE_PLATFORM_WIN32_KHR*/ + +# if defined( VK_ENABLE_BETA_EXTENSIONS ) + using VULKAN_HPP_NAMESPACE::InvalidVideoStdParametersKHRError; +# endif /*VK_ENABLE_BETA_EXTENSIONS*/ + + using VULKAN_HPP_NAMESPACE::CompressionExhaustedEXTError; + using VULKAN_HPP_NAMESPACE::IncompatibleShaderBinaryEXTError; +#endif /*VULKAN_HPP_NO_EXCEPTIONS*/ + + using VULKAN_HPP_NAMESPACE::createResultValueType; + using VULKAN_HPP_NAMESPACE::ignore; + using VULKAN_HPP_NAMESPACE::resultCheck; + using VULKAN_HPP_NAMESPACE::ResultValue; + using VULKAN_HPP_NAMESPACE::ResultValueType; + + //========================================= + //=== CONSTEXPR CONSTANTs AND FUNCTIONs === + //========================================= + using VULKAN_HPP_NAMESPACE::ApiVersion; + using VULKAN_HPP_NAMESPACE::ApiVersion10; + using VULKAN_HPP_NAMESPACE::ApiVersion11; + using VULKAN_HPP_NAMESPACE::ApiVersion12; + using VULKAN_HPP_NAMESPACE::ApiVersion13; + using VULKAN_HPP_NAMESPACE::apiVersionMajor; + using VULKAN_HPP_NAMESPACE::apiVersionMinor; + using VULKAN_HPP_NAMESPACE::apiVersionPatch; + using VULKAN_HPP_NAMESPACE::apiVersionVariant; + using VULKAN_HPP_NAMESPACE::AttachmentUnused; + using VULKAN_HPP_NAMESPACE::False; + using VULKAN_HPP_NAMESPACE::HeaderVersion; + using VULKAN_HPP_NAMESPACE::HeaderVersionComplete; + using VULKAN_HPP_NAMESPACE::LodClampNone; + using VULKAN_HPP_NAMESPACE::LuidSize; + using VULKAN_HPP_NAMESPACE::makeApiVersion; + using VULKAN_HPP_NAMESPACE::makeVersion; + using VULKAN_HPP_NAMESPACE::MaxDescriptionSize; + using VULKAN_HPP_NAMESPACE::MaxDeviceGroupSize; + using VULKAN_HPP_NAMESPACE::MaxDriverInfoSize; + using VULKAN_HPP_NAMESPACE::MaxDriverNameSize; + using VULKAN_HPP_NAMESPACE::MaxExtensionNameSize; + using VULKAN_HPP_NAMESPACE::MaxGlobalPrioritySizeKhr; + using VULKAN_HPP_NAMESPACE::MaxMemoryHeaps; + using VULKAN_HPP_NAMESPACE::MaxMemoryTypes; + using VULKAN_HPP_NAMESPACE::MaxPhysicalDeviceNameSize; + using VULKAN_HPP_NAMESPACE::MaxShaderModuleIdentifierSizeExt; + using VULKAN_HPP_NAMESPACE::QueueFamilyExternal; + using VULKAN_HPP_NAMESPACE::QueueFamilyForeignExt; + using VULKAN_HPP_NAMESPACE::QueueFamilyIgnored; + using VULKAN_HPP_NAMESPACE::Remaining3DSlicesExt; + using VULKAN_HPP_NAMESPACE::RemainingArrayLayers; + using VULKAN_HPP_NAMESPACE::RemainingMipLevels; + using VULKAN_HPP_NAMESPACE::ShaderUnusedKhr; + using VULKAN_HPP_NAMESPACE::SubpassExternal; + using VULKAN_HPP_NAMESPACE::True; + using VULKAN_HPP_NAMESPACE::UuidSize; + using VULKAN_HPP_NAMESPACE::versionMajor; + using VULKAN_HPP_NAMESPACE::versionMinor; + using VULKAN_HPP_NAMESPACE::versionPatch; + using VULKAN_HPP_NAMESPACE::WholeSize; + + //=============== + //=== STRUCTs === + //=============== + + //=== VK_VERSION_1_0 === + using VULKAN_HPP_NAMESPACE::AllocationCallbacks; + using VULKAN_HPP_NAMESPACE::ApplicationInfo; + using VULKAN_HPP_NAMESPACE::AttachmentDescription; + using VULKAN_HPP_NAMESPACE::AttachmentReference; + using VULKAN_HPP_NAMESPACE::BaseInStructure; + using VULKAN_HPP_NAMESPACE::BaseOutStructure; + using VULKAN_HPP_NAMESPACE::BindSparseInfo; + using VULKAN_HPP_NAMESPACE::BufferCopy; + using VULKAN_HPP_NAMESPACE::BufferCreateInfo; + using VULKAN_HPP_NAMESPACE::BufferImageCopy; + using VULKAN_HPP_NAMESPACE::BufferMemoryBarrier; + using VULKAN_HPP_NAMESPACE::BufferViewCreateInfo; + using VULKAN_HPP_NAMESPACE::ClearAttachment; + using VULKAN_HPP_NAMESPACE::ClearColorValue; + using VULKAN_HPP_NAMESPACE::ClearDepthStencilValue; + using VULKAN_HPP_NAMESPACE::ClearRect; + using VULKAN_HPP_NAMESPACE::ClearValue; + using VULKAN_HPP_NAMESPACE::CommandBufferAllocateInfo; + using VULKAN_HPP_NAMESPACE::CommandBufferBeginInfo; + using VULKAN_HPP_NAMESPACE::CommandBufferInheritanceInfo; + using VULKAN_HPP_NAMESPACE::CommandPoolCreateInfo; + using VULKAN_HPP_NAMESPACE::ComponentMapping; + using VULKAN_HPP_NAMESPACE::ComputePipelineCreateInfo; + using VULKAN_HPP_NAMESPACE::CopyDescriptorSet; + using VULKAN_HPP_NAMESPACE::DescriptorBufferInfo; + using VULKAN_HPP_NAMESPACE::DescriptorImageInfo; + using VULKAN_HPP_NAMESPACE::DescriptorPoolCreateInfo; + using VULKAN_HPP_NAMESPACE::DescriptorPoolSize; + using VULKAN_HPP_NAMESPACE::DescriptorSetAllocateInfo; + using VULKAN_HPP_NAMESPACE::DescriptorSetLayoutBinding; + using VULKAN_HPP_NAMESPACE::DescriptorSetLayoutCreateInfo; + using VULKAN_HPP_NAMESPACE::DeviceCreateInfo; + using VULKAN_HPP_NAMESPACE::DeviceQueueCreateInfo; + using VULKAN_HPP_NAMESPACE::DispatchIndirectCommand; + using VULKAN_HPP_NAMESPACE::DrawIndexedIndirectCommand; + using VULKAN_HPP_NAMESPACE::DrawIndirectCommand; + using VULKAN_HPP_NAMESPACE::EventCreateInfo; + using VULKAN_HPP_NAMESPACE::ExtensionProperties; + using VULKAN_HPP_NAMESPACE::Extent2D; + using VULKAN_HPP_NAMESPACE::Extent3D; + using VULKAN_HPP_NAMESPACE::FenceCreateInfo; + using VULKAN_HPP_NAMESPACE::FormatProperties; + using VULKAN_HPP_NAMESPACE::FramebufferCreateInfo; + using VULKAN_HPP_NAMESPACE::GraphicsPipelineCreateInfo; + using VULKAN_HPP_NAMESPACE::ImageBlit; + using VULKAN_HPP_NAMESPACE::ImageCopy; + using VULKAN_HPP_NAMESPACE::ImageCreateInfo; + using VULKAN_HPP_NAMESPACE::ImageFormatProperties; + using VULKAN_HPP_NAMESPACE::ImageMemoryBarrier; + using VULKAN_HPP_NAMESPACE::ImageResolve; + using VULKAN_HPP_NAMESPACE::ImageSubresource; + using VULKAN_HPP_NAMESPACE::ImageSubresourceLayers; + using VULKAN_HPP_NAMESPACE::ImageSubresourceRange; + using VULKAN_HPP_NAMESPACE::ImageViewCreateInfo; + using VULKAN_HPP_NAMESPACE::InstanceCreateInfo; + using VULKAN_HPP_NAMESPACE::LayerProperties; + using VULKAN_HPP_NAMESPACE::MappedMemoryRange; + using VULKAN_HPP_NAMESPACE::MemoryAllocateInfo; + using VULKAN_HPP_NAMESPACE::MemoryBarrier; + using VULKAN_HPP_NAMESPACE::MemoryHeap; + using VULKAN_HPP_NAMESPACE::MemoryRequirements; + using VULKAN_HPP_NAMESPACE::MemoryType; + using VULKAN_HPP_NAMESPACE::Offset2D; + using VULKAN_HPP_NAMESPACE::Offset3D; + using VULKAN_HPP_NAMESPACE::PhysicalDeviceFeatures; + using VULKAN_HPP_NAMESPACE::PhysicalDeviceLimits; + using VULKAN_HPP_NAMESPACE::PhysicalDeviceMemoryProperties; + using VULKAN_HPP_NAMESPACE::PhysicalDeviceProperties; + using VULKAN_HPP_NAMESPACE::PhysicalDeviceSparseProperties; + using VULKAN_HPP_NAMESPACE::PipelineCacheCreateInfo; + using VULKAN_HPP_NAMESPACE::PipelineCacheHeaderVersionOne; + using VULKAN_HPP_NAMESPACE::PipelineColorBlendAttachmentState; + using VULKAN_HPP_NAMESPACE::PipelineColorBlendStateCreateInfo; + using VULKAN_HPP_NAMESPACE::PipelineDepthStencilStateCreateInfo; + using VULKAN_HPP_NAMESPACE::PipelineDynamicStateCreateInfo; + using VULKAN_HPP_NAMESPACE::PipelineInputAssemblyStateCreateInfo; + using VULKAN_HPP_NAMESPACE::PipelineLayoutCreateInfo; + using VULKAN_HPP_NAMESPACE::PipelineMultisampleStateCreateInfo; + using VULKAN_HPP_NAMESPACE::PipelineRasterizationStateCreateInfo; + using VULKAN_HPP_NAMESPACE::PipelineShaderStageCreateInfo; + using VULKAN_HPP_NAMESPACE::PipelineTessellationStateCreateInfo; + using VULKAN_HPP_NAMESPACE::PipelineVertexInputStateCreateInfo; + using VULKAN_HPP_NAMESPACE::PipelineViewportStateCreateInfo; + using VULKAN_HPP_NAMESPACE::PushConstantRange; + using VULKAN_HPP_NAMESPACE::QueryPoolCreateInfo; + using VULKAN_HPP_NAMESPACE::QueueFamilyProperties; + using VULKAN_HPP_NAMESPACE::Rect2D; + using VULKAN_HPP_NAMESPACE::RenderPassBeginInfo; + using VULKAN_HPP_NAMESPACE::RenderPassCreateInfo; + using VULKAN_HPP_NAMESPACE::SamplerCreateInfo; + using VULKAN_HPP_NAMESPACE::SemaphoreCreateInfo; + using VULKAN_HPP_NAMESPACE::ShaderModuleCreateInfo; + using VULKAN_HPP_NAMESPACE::SparseBufferMemoryBindInfo; + using VULKAN_HPP_NAMESPACE::SparseImageFormatProperties; + using VULKAN_HPP_NAMESPACE::SparseImageMemoryBind; + using VULKAN_HPP_NAMESPACE::SparseImageMemoryBindInfo; + using VULKAN_HPP_NAMESPACE::SparseImageMemoryRequirements; + using VULKAN_HPP_NAMESPACE::SparseImageOpaqueMemoryBindInfo; + using VULKAN_HPP_NAMESPACE::SparseMemoryBind; + using VULKAN_HPP_NAMESPACE::SpecializationInfo; + using VULKAN_HPP_NAMESPACE::SpecializationMapEntry; + using VULKAN_HPP_NAMESPACE::StencilOpState; + using VULKAN_HPP_NAMESPACE::SubmitInfo; + using VULKAN_HPP_NAMESPACE::SubpassDependency; + using VULKAN_HPP_NAMESPACE::SubpassDescription; + using VULKAN_HPP_NAMESPACE::SubresourceLayout; + using VULKAN_HPP_NAMESPACE::VertexInputAttributeDescription; + using VULKAN_HPP_NAMESPACE::VertexInputBindingDescription; + using VULKAN_HPP_NAMESPACE::Viewport; + using VULKAN_HPP_NAMESPACE::WriteDescriptorSet; + + //=== VK_VERSION_1_1 === + using VULKAN_HPP_NAMESPACE::BindBufferMemoryDeviceGroupInfo; + using VULKAN_HPP_NAMESPACE::BindBufferMemoryDeviceGroupInfoKHR; + using VULKAN_HPP_NAMESPACE::BindBufferMemoryInfo; + using VULKAN_HPP_NAMESPACE::BindBufferMemoryInfoKHR; + using VULKAN_HPP_NAMESPACE::BindImageMemoryDeviceGroupInfo; + using VULKAN_HPP_NAMESPACE::BindImageMemoryDeviceGroupInfoKHR; + using VULKAN_HPP_NAMESPACE::BindImageMemoryInfo; + using VULKAN_HPP_NAMESPACE::BindImageMemoryInfoKHR; + using VULKAN_HPP_NAMESPACE::BindImagePlaneMemoryInfo; + using VULKAN_HPP_NAMESPACE::BindImagePlaneMemoryInfoKHR; + using VULKAN_HPP_NAMESPACE::BufferMemoryRequirementsInfo2; + using VULKAN_HPP_NAMESPACE::BufferMemoryRequirementsInfo2KHR; + using VULKAN_HPP_NAMESPACE::DescriptorSetLayoutSupport; + using VULKAN_HPP_NAMESPACE::DescriptorSetLayoutSupportKHR; + using VULKAN_HPP_NAMESPACE::DescriptorUpdateTemplateCreateInfo; + using VULKAN_HPP_NAMESPACE::DescriptorUpdateTemplateCreateInfoKHR; + using VULKAN_HPP_NAMESPACE::DescriptorUpdateTemplateEntry; + using VULKAN_HPP_NAMESPACE::DescriptorUpdateTemplateEntryKHR; + using VULKAN_HPP_NAMESPACE::DeviceGroupBindSparseInfo; + using VULKAN_HPP_NAMESPACE::DeviceGroupBindSparseInfoKHR; + using VULKAN_HPP_NAMESPACE::DeviceGroupCommandBufferBeginInfo; + using VULKAN_HPP_NAMESPACE::DeviceGroupCommandBufferBeginInfoKHR; + using VULKAN_HPP_NAMESPACE::DeviceGroupDeviceCreateInfo; + using VULKAN_HPP_NAMESPACE::DeviceGroupDeviceCreateInfoKHR; + using VULKAN_HPP_NAMESPACE::DeviceGroupRenderPassBeginInfo; + using VULKAN_HPP_NAMESPACE::DeviceGroupRenderPassBeginInfoKHR; + using VULKAN_HPP_NAMESPACE::DeviceGroupSubmitInfo; + using VULKAN_HPP_NAMESPACE::DeviceGroupSubmitInfoKHR; + using VULKAN_HPP_NAMESPACE::DeviceQueueInfo2; + using VULKAN_HPP_NAMESPACE::ExportFenceCreateInfo; + using VULKAN_HPP_NAMESPACE::ExportFenceCreateInfoKHR; + using VULKAN_HPP_NAMESPACE::ExportMemoryAllocateInfo; + using VULKAN_HPP_NAMESPACE::ExportMemoryAllocateInfoKHR; + using VULKAN_HPP_NAMESPACE::ExportSemaphoreCreateInfo; + using VULKAN_HPP_NAMESPACE::ExportSemaphoreCreateInfoKHR; + using VULKAN_HPP_NAMESPACE::ExternalBufferProperties; + using VULKAN_HPP_NAMESPACE::ExternalBufferPropertiesKHR; + using VULKAN_HPP_NAMESPACE::ExternalFenceProperties; + using VULKAN_HPP_NAMESPACE::ExternalFencePropertiesKHR; + using VULKAN_HPP_NAMESPACE::ExternalImageFormatProperties; + using VULKAN_HPP_NAMESPACE::ExternalImageFormatPropertiesKHR; + using VULKAN_HPP_NAMESPACE::ExternalMemoryBufferCreateInfo; + using VULKAN_HPP_NAMESPACE::ExternalMemoryBufferCreateInfoKHR; + using VULKAN_HPP_NAMESPACE::ExternalMemoryImageCreateInfo; + using VULKAN_HPP_NAMESPACE::ExternalMemoryImageCreateInfoKHR; + using VULKAN_HPP_NAMESPACE::ExternalMemoryProperties; + using VULKAN_HPP_NAMESPACE::ExternalMemoryPropertiesKHR; + using VULKAN_HPP_NAMESPACE::ExternalSemaphoreProperties; + using VULKAN_HPP_NAMESPACE::ExternalSemaphorePropertiesKHR; + using VULKAN_HPP_NAMESPACE::FormatProperties2; + using VULKAN_HPP_NAMESPACE::FormatProperties2KHR; + using VULKAN_HPP_NAMESPACE::ImageFormatProperties2; + using VULKAN_HPP_NAMESPACE::ImageFormatProperties2KHR; + using VULKAN_HPP_NAMESPACE::ImageMemoryRequirementsInfo2; + using VULKAN_HPP_NAMESPACE::ImageMemoryRequirementsInfo2KHR; + using VULKAN_HPP_NAMESPACE::ImagePlaneMemoryRequirementsInfo; + using VULKAN_HPP_NAMESPACE::ImagePlaneMemoryRequirementsInfoKHR; + using VULKAN_HPP_NAMESPACE::ImageSparseMemoryRequirementsInfo2; + using VULKAN_HPP_NAMESPACE::ImageSparseMemoryRequirementsInfo2KHR; + using VULKAN_HPP_NAMESPACE::ImageViewUsageCreateInfo; + using VULKAN_HPP_NAMESPACE::ImageViewUsageCreateInfoKHR; + using VULKAN_HPP_NAMESPACE::InputAttachmentAspectReference; + using VULKAN_HPP_NAMESPACE::InputAttachmentAspectReferenceKHR; + using VULKAN_HPP_NAMESPACE::MemoryAllocateFlagsInfo; + using VULKAN_HPP_NAMESPACE::MemoryAllocateFlagsInfoKHR; + using VULKAN_HPP_NAMESPACE::MemoryDedicatedAllocateInfo; + using VULKAN_HPP_NAMESPACE::MemoryDedicatedAllocateInfoKHR; + using VULKAN_HPP_NAMESPACE::MemoryDedicatedRequirements; + using VULKAN_HPP_NAMESPACE::MemoryDedicatedRequirementsKHR; + using VULKAN_HPP_NAMESPACE::MemoryRequirements2; + using VULKAN_HPP_NAMESPACE::MemoryRequirements2KHR; + using VULKAN_HPP_NAMESPACE::PhysicalDevice16BitStorageFeatures; + using VULKAN_HPP_NAMESPACE::PhysicalDevice16BitStorageFeaturesKHR; + using VULKAN_HPP_NAMESPACE::PhysicalDeviceExternalBufferInfo; + using VULKAN_HPP_NAMESPACE::PhysicalDeviceExternalBufferInfoKHR; + using VULKAN_HPP_NAMESPACE::PhysicalDeviceExternalFenceInfo; + using VULKAN_HPP_NAMESPACE::PhysicalDeviceExternalFenceInfoKHR; + using VULKAN_HPP_NAMESPACE::PhysicalDeviceExternalImageFormatInfo; + using VULKAN_HPP_NAMESPACE::PhysicalDeviceExternalImageFormatInfoKHR; + using VULKAN_HPP_NAMESPACE::PhysicalDeviceExternalSemaphoreInfo; + using VULKAN_HPP_NAMESPACE::PhysicalDeviceExternalSemaphoreInfoKHR; + using VULKAN_HPP_NAMESPACE::PhysicalDeviceFeatures2; + using VULKAN_HPP_NAMESPACE::PhysicalDeviceFeatures2KHR; + using VULKAN_HPP_NAMESPACE::PhysicalDeviceGroupProperties; + using VULKAN_HPP_NAMESPACE::PhysicalDeviceGroupPropertiesKHR; + using VULKAN_HPP_NAMESPACE::PhysicalDeviceIDProperties; + using VULKAN_HPP_NAMESPACE::PhysicalDeviceIDPropertiesKHR; + using VULKAN_HPP_NAMESPACE::PhysicalDeviceImageFormatInfo2; + using VULKAN_HPP_NAMESPACE::PhysicalDeviceImageFormatInfo2KHR; + using VULKAN_HPP_NAMESPACE::PhysicalDeviceMaintenance3Properties; + using VULKAN_HPP_NAMESPACE::PhysicalDeviceMaintenance3PropertiesKHR; + using VULKAN_HPP_NAMESPACE::PhysicalDeviceMemoryProperties2; + using VULKAN_HPP_NAMESPACE::PhysicalDeviceMemoryProperties2KHR; + using VULKAN_HPP_NAMESPACE::PhysicalDeviceMultiviewFeatures; + using VULKAN_HPP_NAMESPACE::PhysicalDeviceMultiviewFeaturesKHR; + using VULKAN_HPP_NAMESPACE::PhysicalDeviceMultiviewProperties; + using VULKAN_HPP_NAMESPACE::PhysicalDeviceMultiviewPropertiesKHR; + using VULKAN_HPP_NAMESPACE::PhysicalDevicePointClippingProperties; + using VULKAN_HPP_NAMESPACE::PhysicalDevicePointClippingPropertiesKHR; + using VULKAN_HPP_NAMESPACE::PhysicalDeviceProperties2; + using VULKAN_HPP_NAMESPACE::PhysicalDeviceProperties2KHR; + using VULKAN_HPP_NAMESPACE::PhysicalDeviceProtectedMemoryFeatures; + using VULKAN_HPP_NAMESPACE::PhysicalDeviceProtectedMemoryProperties; + using VULKAN_HPP_NAMESPACE::PhysicalDeviceSamplerYcbcrConversionFeatures; + using VULKAN_HPP_NAMESPACE::PhysicalDeviceSamplerYcbcrConversionFeaturesKHR; + using VULKAN_HPP_NAMESPACE::PhysicalDeviceShaderDrawParameterFeatures; + using VULKAN_HPP_NAMESPACE::PhysicalDeviceShaderDrawParametersFeatures; + using VULKAN_HPP_NAMESPACE::PhysicalDeviceSparseImageFormatInfo2; + using VULKAN_HPP_NAMESPACE::PhysicalDeviceSparseImageFormatInfo2KHR; + using VULKAN_HPP_NAMESPACE::PhysicalDeviceSubgroupProperties; + using VULKAN_HPP_NAMESPACE::PhysicalDeviceVariablePointerFeatures; + using VULKAN_HPP_NAMESPACE::PhysicalDeviceVariablePointerFeaturesKHR; + using VULKAN_HPP_NAMESPACE::PhysicalDeviceVariablePointersFeatures; + using VULKAN_HPP_NAMESPACE::PhysicalDeviceVariablePointersFeaturesKHR; + using VULKAN_HPP_NAMESPACE::PipelineTessellationDomainOriginStateCreateInfo; + using VULKAN_HPP_NAMESPACE::PipelineTessellationDomainOriginStateCreateInfoKHR; + using VULKAN_HPP_NAMESPACE::ProtectedSubmitInfo; + using VULKAN_HPP_NAMESPACE::QueueFamilyProperties2; + using VULKAN_HPP_NAMESPACE::QueueFamilyProperties2KHR; + using VULKAN_HPP_NAMESPACE::RenderPassInputAttachmentAspectCreateInfo; + using VULKAN_HPP_NAMESPACE::RenderPassInputAttachmentAspectCreateInfoKHR; + using VULKAN_HPP_NAMESPACE::RenderPassMultiviewCreateInfo; + using VULKAN_HPP_NAMESPACE::RenderPassMultiviewCreateInfoKHR; + using VULKAN_HPP_NAMESPACE::SamplerYcbcrConversionCreateInfo; + using VULKAN_HPP_NAMESPACE::SamplerYcbcrConversionCreateInfoKHR; + using VULKAN_HPP_NAMESPACE::SamplerYcbcrConversionImageFormatProperties; + using VULKAN_HPP_NAMESPACE::SamplerYcbcrConversionImageFormatPropertiesKHR; + using VULKAN_HPP_NAMESPACE::SamplerYcbcrConversionInfo; + using VULKAN_HPP_NAMESPACE::SamplerYcbcrConversionInfoKHR; + using VULKAN_HPP_NAMESPACE::SparseImageFormatProperties2; + using VULKAN_HPP_NAMESPACE::SparseImageFormatProperties2KHR; + using VULKAN_HPP_NAMESPACE::SparseImageMemoryRequirements2; + using VULKAN_HPP_NAMESPACE::SparseImageMemoryRequirements2KHR; + + //=== VK_VERSION_1_2 === + using VULKAN_HPP_NAMESPACE::AttachmentDescription2; + using VULKAN_HPP_NAMESPACE::AttachmentDescription2KHR; + using VULKAN_HPP_NAMESPACE::AttachmentDescriptionStencilLayout; + using VULKAN_HPP_NAMESPACE::AttachmentDescriptionStencilLayoutKHR; + using VULKAN_HPP_NAMESPACE::AttachmentReference2; + using VULKAN_HPP_NAMESPACE::AttachmentReference2KHR; + using VULKAN_HPP_NAMESPACE::AttachmentReferenceStencilLayout; + using VULKAN_HPP_NAMESPACE::AttachmentReferenceStencilLayoutKHR; + using VULKAN_HPP_NAMESPACE::BufferDeviceAddressInfo; + using VULKAN_HPP_NAMESPACE::BufferDeviceAddressInfoEXT; + using VULKAN_HPP_NAMESPACE::BufferDeviceAddressInfoKHR; + using VULKAN_HPP_NAMESPACE::BufferOpaqueCaptureAddressCreateInfo; + using VULKAN_HPP_NAMESPACE::BufferOpaqueCaptureAddressCreateInfoKHR; + using VULKAN_HPP_NAMESPACE::ConformanceVersion; + using VULKAN_HPP_NAMESPACE::ConformanceVersionKHR; + using VULKAN_HPP_NAMESPACE::DescriptorSetLayoutBindingFlagsCreateInfo; + using VULKAN_HPP_NAMESPACE::DescriptorSetLayoutBindingFlagsCreateInfoEXT; + using VULKAN_HPP_NAMESPACE::DescriptorSetVariableDescriptorCountAllocateInfo; + using VULKAN_HPP_NAMESPACE::DescriptorSetVariableDescriptorCountAllocateInfoEXT; + using VULKAN_HPP_NAMESPACE::DescriptorSetVariableDescriptorCountLayoutSupport; + using VULKAN_HPP_NAMESPACE::DescriptorSetVariableDescriptorCountLayoutSupportEXT; + using VULKAN_HPP_NAMESPACE::DeviceMemoryOpaqueCaptureAddressInfo; + using VULKAN_HPP_NAMESPACE::DeviceMemoryOpaqueCaptureAddressInfoKHR; + using VULKAN_HPP_NAMESPACE::FramebufferAttachmentImageInfo; + using VULKAN_HPP_NAMESPACE::FramebufferAttachmentImageInfoKHR; + using VULKAN_HPP_NAMESPACE::FramebufferAttachmentsCreateInfo; + using VULKAN_HPP_NAMESPACE::FramebufferAttachmentsCreateInfoKHR; + using VULKAN_HPP_NAMESPACE::ImageFormatListCreateInfo; + using VULKAN_HPP_NAMESPACE::ImageFormatListCreateInfoKHR; + using VULKAN_HPP_NAMESPACE::ImageStencilUsageCreateInfo; + using VULKAN_HPP_NAMESPACE::ImageStencilUsageCreateInfoEXT; + using VULKAN_HPP_NAMESPACE::MemoryOpaqueCaptureAddressAllocateInfo; + using VULKAN_HPP_NAMESPACE::MemoryOpaqueCaptureAddressAllocateInfoKHR; + using VULKAN_HPP_NAMESPACE::PhysicalDevice8BitStorageFeatures; + using VULKAN_HPP_NAMESPACE::PhysicalDevice8BitStorageFeaturesKHR; + using VULKAN_HPP_NAMESPACE::PhysicalDeviceBufferDeviceAddressFeatures; + using VULKAN_HPP_NAMESPACE::PhysicalDeviceBufferDeviceAddressFeaturesKHR; + using VULKAN_HPP_NAMESPACE::PhysicalDeviceDepthStencilResolveProperties; + using VULKAN_HPP_NAMESPACE::PhysicalDeviceDepthStencilResolvePropertiesKHR; + using VULKAN_HPP_NAMESPACE::PhysicalDeviceDescriptorIndexingFeatures; + using VULKAN_HPP_NAMESPACE::PhysicalDeviceDescriptorIndexingFeaturesEXT; + using VULKAN_HPP_NAMESPACE::PhysicalDeviceDescriptorIndexingProperties; + using VULKAN_HPP_NAMESPACE::PhysicalDeviceDescriptorIndexingPropertiesEXT; + using VULKAN_HPP_NAMESPACE::PhysicalDeviceDriverProperties; + using VULKAN_HPP_NAMESPACE::PhysicalDeviceDriverPropertiesKHR; + using VULKAN_HPP_NAMESPACE::PhysicalDeviceFloat16Int8FeaturesKHR; + using VULKAN_HPP_NAMESPACE::PhysicalDeviceFloatControlsProperties; + using VULKAN_HPP_NAMESPACE::PhysicalDeviceFloatControlsPropertiesKHR; + using VULKAN_HPP_NAMESPACE::PhysicalDeviceHostQueryResetFeatures; + using VULKAN_HPP_NAMESPACE::PhysicalDeviceHostQueryResetFeaturesEXT; + using VULKAN_HPP_NAMESPACE::PhysicalDeviceImagelessFramebufferFeatures; + using VULKAN_HPP_NAMESPACE::PhysicalDeviceImagelessFramebufferFeaturesKHR; + using VULKAN_HPP_NAMESPACE::PhysicalDeviceSamplerFilterMinmaxProperties; + using VULKAN_HPP_NAMESPACE::PhysicalDeviceSamplerFilterMinmaxPropertiesEXT; + using VULKAN_HPP_NAMESPACE::PhysicalDeviceScalarBlockLayoutFeatures; + using VULKAN_HPP_NAMESPACE::PhysicalDeviceScalarBlockLayoutFeaturesEXT; + using VULKAN_HPP_NAMESPACE::PhysicalDeviceSeparateDepthStencilLayoutsFeatures; + using VULKAN_HPP_NAMESPACE::PhysicalDeviceSeparateDepthStencilLayoutsFeaturesKHR; + using VULKAN_HPP_NAMESPACE::PhysicalDeviceShaderAtomicInt64Features; + using VULKAN_HPP_NAMESPACE::PhysicalDeviceShaderAtomicInt64FeaturesKHR; + using VULKAN_HPP_NAMESPACE::PhysicalDeviceShaderFloat16Int8Features; + using VULKAN_HPP_NAMESPACE::PhysicalDeviceShaderFloat16Int8FeaturesKHR; + using VULKAN_HPP_NAMESPACE::PhysicalDeviceShaderSubgroupExtendedTypesFeatures; + using VULKAN_HPP_NAMESPACE::PhysicalDeviceShaderSubgroupExtendedTypesFeaturesKHR; + using VULKAN_HPP_NAMESPACE::PhysicalDeviceTimelineSemaphoreFeatures; + using VULKAN_HPP_NAMESPACE::PhysicalDeviceTimelineSemaphoreFeaturesKHR; + using VULKAN_HPP_NAMESPACE::PhysicalDeviceTimelineSemaphoreProperties; + using VULKAN_HPP_NAMESPACE::PhysicalDeviceTimelineSemaphorePropertiesKHR; + using VULKAN_HPP_NAMESPACE::PhysicalDeviceUniformBufferStandardLayoutFeatures; + using VULKAN_HPP_NAMESPACE::PhysicalDeviceUniformBufferStandardLayoutFeaturesKHR; + using VULKAN_HPP_NAMESPACE::PhysicalDeviceVulkan11Features; + using VULKAN_HPP_NAMESPACE::PhysicalDeviceVulkan11Properties; + using VULKAN_HPP_NAMESPACE::PhysicalDeviceVulkan12Features; + using VULKAN_HPP_NAMESPACE::PhysicalDeviceVulkan12Properties; + using VULKAN_HPP_NAMESPACE::PhysicalDeviceVulkanMemoryModelFeatures; + using VULKAN_HPP_NAMESPACE::PhysicalDeviceVulkanMemoryModelFeaturesKHR; + using VULKAN_HPP_NAMESPACE::RenderPassAttachmentBeginInfo; + using VULKAN_HPP_NAMESPACE::RenderPassAttachmentBeginInfoKHR; + using VULKAN_HPP_NAMESPACE::RenderPassCreateInfo2; + using VULKAN_HPP_NAMESPACE::RenderPassCreateInfo2KHR; + using VULKAN_HPP_NAMESPACE::SamplerReductionModeCreateInfo; + using VULKAN_HPP_NAMESPACE::SamplerReductionModeCreateInfoEXT; + using VULKAN_HPP_NAMESPACE::SemaphoreSignalInfo; + using VULKAN_HPP_NAMESPACE::SemaphoreSignalInfoKHR; + using VULKAN_HPP_NAMESPACE::SemaphoreTypeCreateInfo; + using VULKAN_HPP_NAMESPACE::SemaphoreTypeCreateInfoKHR; + using VULKAN_HPP_NAMESPACE::SemaphoreWaitInfo; + using VULKAN_HPP_NAMESPACE::SemaphoreWaitInfoKHR; + using VULKAN_HPP_NAMESPACE::SubpassBeginInfo; + using VULKAN_HPP_NAMESPACE::SubpassBeginInfoKHR; + using VULKAN_HPP_NAMESPACE::SubpassDependency2; + using VULKAN_HPP_NAMESPACE::SubpassDependency2KHR; + using VULKAN_HPP_NAMESPACE::SubpassDescription2; + using VULKAN_HPP_NAMESPACE::SubpassDescription2KHR; + using VULKAN_HPP_NAMESPACE::SubpassDescriptionDepthStencilResolve; + using VULKAN_HPP_NAMESPACE::SubpassDescriptionDepthStencilResolveKHR; + using VULKAN_HPP_NAMESPACE::SubpassEndInfo; + using VULKAN_HPP_NAMESPACE::SubpassEndInfoKHR; + using VULKAN_HPP_NAMESPACE::TimelineSemaphoreSubmitInfo; + using VULKAN_HPP_NAMESPACE::TimelineSemaphoreSubmitInfoKHR; + + //=== VK_VERSION_1_3 === + using VULKAN_HPP_NAMESPACE::BlitImageInfo2; + using VULKAN_HPP_NAMESPACE::BlitImageInfo2KHR; + using VULKAN_HPP_NAMESPACE::BufferCopy2; + using VULKAN_HPP_NAMESPACE::BufferCopy2KHR; + using VULKAN_HPP_NAMESPACE::BufferImageCopy2; + using VULKAN_HPP_NAMESPACE::BufferImageCopy2KHR; + using VULKAN_HPP_NAMESPACE::BufferMemoryBarrier2; + using VULKAN_HPP_NAMESPACE::BufferMemoryBarrier2KHR; + using VULKAN_HPP_NAMESPACE::CommandBufferInheritanceRenderingInfo; + using VULKAN_HPP_NAMESPACE::CommandBufferInheritanceRenderingInfoKHR; + using VULKAN_HPP_NAMESPACE::CommandBufferSubmitInfo; + using VULKAN_HPP_NAMESPACE::CommandBufferSubmitInfoKHR; + using VULKAN_HPP_NAMESPACE::CopyBufferInfo2; + using VULKAN_HPP_NAMESPACE::CopyBufferInfo2KHR; + using VULKAN_HPP_NAMESPACE::CopyBufferToImageInfo2; + using VULKAN_HPP_NAMESPACE::CopyBufferToImageInfo2KHR; + using VULKAN_HPP_NAMESPACE::CopyImageInfo2; + using VULKAN_HPP_NAMESPACE::CopyImageInfo2KHR; + using VULKAN_HPP_NAMESPACE::CopyImageToBufferInfo2; + using VULKAN_HPP_NAMESPACE::CopyImageToBufferInfo2KHR; + using VULKAN_HPP_NAMESPACE::DependencyInfo; + using VULKAN_HPP_NAMESPACE::DependencyInfoKHR; + using VULKAN_HPP_NAMESPACE::DescriptorPoolInlineUniformBlockCreateInfo; + using VULKAN_HPP_NAMESPACE::DescriptorPoolInlineUniformBlockCreateInfoEXT; + using VULKAN_HPP_NAMESPACE::DeviceBufferMemoryRequirements; + using VULKAN_HPP_NAMESPACE::DeviceBufferMemoryRequirementsKHR; + using VULKAN_HPP_NAMESPACE::DeviceImageMemoryRequirements; + using VULKAN_HPP_NAMESPACE::DeviceImageMemoryRequirementsKHR; + using VULKAN_HPP_NAMESPACE::DevicePrivateDataCreateInfo; + using VULKAN_HPP_NAMESPACE::DevicePrivateDataCreateInfoEXT; + using VULKAN_HPP_NAMESPACE::FormatProperties3; + using VULKAN_HPP_NAMESPACE::FormatProperties3KHR; + using VULKAN_HPP_NAMESPACE::ImageBlit2; + using VULKAN_HPP_NAMESPACE::ImageBlit2KHR; + using VULKAN_HPP_NAMESPACE::ImageCopy2; + using VULKAN_HPP_NAMESPACE::ImageCopy2KHR; + using VULKAN_HPP_NAMESPACE::ImageMemoryBarrier2; + using VULKAN_HPP_NAMESPACE::ImageMemoryBarrier2KHR; + using VULKAN_HPP_NAMESPACE::ImageResolve2; + using VULKAN_HPP_NAMESPACE::ImageResolve2KHR; + using VULKAN_HPP_NAMESPACE::MemoryBarrier2; + using VULKAN_HPP_NAMESPACE::MemoryBarrier2KHR; + using VULKAN_HPP_NAMESPACE::PhysicalDeviceDynamicRenderingFeatures; + using VULKAN_HPP_NAMESPACE::PhysicalDeviceDynamicRenderingFeaturesKHR; + using VULKAN_HPP_NAMESPACE::PhysicalDeviceImageRobustnessFeatures; + using VULKAN_HPP_NAMESPACE::PhysicalDeviceImageRobustnessFeaturesEXT; + using VULKAN_HPP_NAMESPACE::PhysicalDeviceInlineUniformBlockFeatures; + using VULKAN_HPP_NAMESPACE::PhysicalDeviceInlineUniformBlockFeaturesEXT; + using VULKAN_HPP_NAMESPACE::PhysicalDeviceInlineUniformBlockProperties; + using VULKAN_HPP_NAMESPACE::PhysicalDeviceInlineUniformBlockPropertiesEXT; + using VULKAN_HPP_NAMESPACE::PhysicalDeviceMaintenance4Features; + using VULKAN_HPP_NAMESPACE::PhysicalDeviceMaintenance4FeaturesKHR; + using VULKAN_HPP_NAMESPACE::PhysicalDeviceMaintenance4Properties; + using VULKAN_HPP_NAMESPACE::PhysicalDeviceMaintenance4PropertiesKHR; + using VULKAN_HPP_NAMESPACE::PhysicalDevicePipelineCreationCacheControlFeatures; + using VULKAN_HPP_NAMESPACE::PhysicalDevicePipelineCreationCacheControlFeaturesEXT; + using VULKAN_HPP_NAMESPACE::PhysicalDevicePrivateDataFeatures; + using VULKAN_HPP_NAMESPACE::PhysicalDevicePrivateDataFeaturesEXT; + using VULKAN_HPP_NAMESPACE::PhysicalDeviceShaderDemoteToHelperInvocationFeatures; + using VULKAN_HPP_NAMESPACE::PhysicalDeviceShaderDemoteToHelperInvocationFeaturesEXT; + using VULKAN_HPP_NAMESPACE::PhysicalDeviceShaderIntegerDotProductFeatures; + using VULKAN_HPP_NAMESPACE::PhysicalDeviceShaderIntegerDotProductFeaturesKHR; + using VULKAN_HPP_NAMESPACE::PhysicalDeviceShaderIntegerDotProductProperties; + using VULKAN_HPP_NAMESPACE::PhysicalDeviceShaderIntegerDotProductPropertiesKHR; + using VULKAN_HPP_NAMESPACE::PhysicalDeviceShaderTerminateInvocationFeatures; + using VULKAN_HPP_NAMESPACE::PhysicalDeviceShaderTerminateInvocationFeaturesKHR; + using VULKAN_HPP_NAMESPACE::PhysicalDeviceSubgroupSizeControlFeatures; + using VULKAN_HPP_NAMESPACE::PhysicalDeviceSubgroupSizeControlFeaturesEXT; + using VULKAN_HPP_NAMESPACE::PhysicalDeviceSubgroupSizeControlProperties; + using VULKAN_HPP_NAMESPACE::PhysicalDeviceSubgroupSizeControlPropertiesEXT; + using VULKAN_HPP_NAMESPACE::PhysicalDeviceSynchronization2Features; + using VULKAN_HPP_NAMESPACE::PhysicalDeviceSynchronization2FeaturesKHR; + using VULKAN_HPP_NAMESPACE::PhysicalDeviceTexelBufferAlignmentProperties; + using VULKAN_HPP_NAMESPACE::PhysicalDeviceTexelBufferAlignmentPropertiesEXT; + using VULKAN_HPP_NAMESPACE::PhysicalDeviceTextureCompressionASTCHDRFeatures; + using VULKAN_HPP_NAMESPACE::PhysicalDeviceTextureCompressionASTCHDRFeaturesEXT; + using VULKAN_HPP_NAMESPACE::PhysicalDeviceToolProperties; + using VULKAN_HPP_NAMESPACE::PhysicalDeviceToolPropertiesEXT; + using VULKAN_HPP_NAMESPACE::PhysicalDeviceVulkan13Features; + using VULKAN_HPP_NAMESPACE::PhysicalDeviceVulkan13Properties; + using VULKAN_HPP_NAMESPACE::PhysicalDeviceZeroInitializeWorkgroupMemoryFeatures; + using VULKAN_HPP_NAMESPACE::PhysicalDeviceZeroInitializeWorkgroupMemoryFeaturesKHR; + using VULKAN_HPP_NAMESPACE::PipelineCreationFeedback; + using VULKAN_HPP_NAMESPACE::PipelineCreationFeedbackCreateInfo; + using VULKAN_HPP_NAMESPACE::PipelineCreationFeedbackCreateInfoEXT; + using VULKAN_HPP_NAMESPACE::PipelineCreationFeedbackEXT; + using VULKAN_HPP_NAMESPACE::PipelineRenderingCreateInfo; + using VULKAN_HPP_NAMESPACE::PipelineRenderingCreateInfoKHR; + using VULKAN_HPP_NAMESPACE::PipelineShaderStageRequiredSubgroupSizeCreateInfo; + using VULKAN_HPP_NAMESPACE::PipelineShaderStageRequiredSubgroupSizeCreateInfoEXT; + using VULKAN_HPP_NAMESPACE::PrivateDataSlotCreateInfo; + using VULKAN_HPP_NAMESPACE::PrivateDataSlotCreateInfoEXT; + using VULKAN_HPP_NAMESPACE::RenderingAttachmentInfo; + using VULKAN_HPP_NAMESPACE::RenderingAttachmentInfoKHR; + using VULKAN_HPP_NAMESPACE::RenderingInfo; + using VULKAN_HPP_NAMESPACE::RenderingInfoKHR; + using VULKAN_HPP_NAMESPACE::ResolveImageInfo2; + using VULKAN_HPP_NAMESPACE::ResolveImageInfo2KHR; + using VULKAN_HPP_NAMESPACE::SemaphoreSubmitInfo; + using VULKAN_HPP_NAMESPACE::SemaphoreSubmitInfoKHR; + using VULKAN_HPP_NAMESPACE::ShaderRequiredSubgroupSizeCreateInfoEXT; + using VULKAN_HPP_NAMESPACE::SubmitInfo2; + using VULKAN_HPP_NAMESPACE::SubmitInfo2KHR; + using VULKAN_HPP_NAMESPACE::WriteDescriptorSetInlineUniformBlock; + using VULKAN_HPP_NAMESPACE::WriteDescriptorSetInlineUniformBlockEXT; + + //=== VK_KHR_surface === + using VULKAN_HPP_NAMESPACE::SurfaceCapabilitiesKHR; + using VULKAN_HPP_NAMESPACE::SurfaceFormatKHR; + + //=== VK_KHR_swapchain === + using VULKAN_HPP_NAMESPACE::AcquireNextImageInfoKHR; + using VULKAN_HPP_NAMESPACE::BindImageMemorySwapchainInfoKHR; + using VULKAN_HPP_NAMESPACE::DeviceGroupPresentCapabilitiesKHR; + using VULKAN_HPP_NAMESPACE::DeviceGroupPresentInfoKHR; + using VULKAN_HPP_NAMESPACE::DeviceGroupSwapchainCreateInfoKHR; + using VULKAN_HPP_NAMESPACE::ImageSwapchainCreateInfoKHR; + using VULKAN_HPP_NAMESPACE::PresentInfoKHR; + using VULKAN_HPP_NAMESPACE::SwapchainCreateInfoKHR; + + //=== VK_KHR_display === + using VULKAN_HPP_NAMESPACE::DisplayModeCreateInfoKHR; + using VULKAN_HPP_NAMESPACE::DisplayModeParametersKHR; + using VULKAN_HPP_NAMESPACE::DisplayModePropertiesKHR; + using VULKAN_HPP_NAMESPACE::DisplayPlaneCapabilitiesKHR; + using VULKAN_HPP_NAMESPACE::DisplayPlanePropertiesKHR; + using VULKAN_HPP_NAMESPACE::DisplayPropertiesKHR; + using VULKAN_HPP_NAMESPACE::DisplaySurfaceCreateInfoKHR; + + //=== VK_KHR_display_swapchain === + using VULKAN_HPP_NAMESPACE::DisplayPresentInfoKHR; + +#if defined( VK_USE_PLATFORM_XLIB_KHR ) + //=== VK_KHR_xlib_surface === + using VULKAN_HPP_NAMESPACE::XlibSurfaceCreateInfoKHR; +#endif /*VK_USE_PLATFORM_XLIB_KHR*/ + +#if defined( VK_USE_PLATFORM_XCB_KHR ) + //=== VK_KHR_xcb_surface === + using VULKAN_HPP_NAMESPACE::XcbSurfaceCreateInfoKHR; +#endif /*VK_USE_PLATFORM_XCB_KHR*/ + +#if defined( VK_USE_PLATFORM_WAYLAND_KHR ) + //=== VK_KHR_wayland_surface === + using VULKAN_HPP_NAMESPACE::WaylandSurfaceCreateInfoKHR; +#endif /*VK_USE_PLATFORM_WAYLAND_KHR*/ + +#if defined( VK_USE_PLATFORM_ANDROID_KHR ) + //=== VK_KHR_android_surface === + using VULKAN_HPP_NAMESPACE::AndroidSurfaceCreateInfoKHR; +#endif /*VK_USE_PLATFORM_ANDROID_KHR*/ + +#if defined( VK_USE_PLATFORM_WIN32_KHR ) + //=== VK_KHR_win32_surface === + using VULKAN_HPP_NAMESPACE::Win32SurfaceCreateInfoKHR; +#endif /*VK_USE_PLATFORM_WIN32_KHR*/ + + //=== VK_EXT_debug_report === + using VULKAN_HPP_NAMESPACE::DebugReportCallbackCreateInfoEXT; + + //=== VK_AMD_rasterization_order === + using VULKAN_HPP_NAMESPACE::PipelineRasterizationStateRasterizationOrderAMD; + + //=== VK_EXT_debug_marker === + using VULKAN_HPP_NAMESPACE::DebugMarkerMarkerInfoEXT; + using VULKAN_HPP_NAMESPACE::DebugMarkerObjectNameInfoEXT; + using VULKAN_HPP_NAMESPACE::DebugMarkerObjectTagInfoEXT; + + //=== VK_KHR_video_queue === + using VULKAN_HPP_NAMESPACE::BindVideoSessionMemoryInfoKHR; + using VULKAN_HPP_NAMESPACE::PhysicalDeviceVideoFormatInfoKHR; + using VULKAN_HPP_NAMESPACE::QueueFamilyQueryResultStatusPropertiesKHR; + using VULKAN_HPP_NAMESPACE::QueueFamilyVideoPropertiesKHR; + using VULKAN_HPP_NAMESPACE::VideoBeginCodingInfoKHR; + using VULKAN_HPP_NAMESPACE::VideoCapabilitiesKHR; + using VULKAN_HPP_NAMESPACE::VideoCodingControlInfoKHR; + using VULKAN_HPP_NAMESPACE::VideoEndCodingInfoKHR; + using VULKAN_HPP_NAMESPACE::VideoFormatPropertiesKHR; + using VULKAN_HPP_NAMESPACE::VideoPictureResourceInfoKHR; + using VULKAN_HPP_NAMESPACE::VideoProfileInfoKHR; + using VULKAN_HPP_NAMESPACE::VideoProfileListInfoKHR; + using VULKAN_HPP_NAMESPACE::VideoReferenceSlotInfoKHR; + using VULKAN_HPP_NAMESPACE::VideoSessionCreateInfoKHR; + using VULKAN_HPP_NAMESPACE::VideoSessionMemoryRequirementsKHR; + using VULKAN_HPP_NAMESPACE::VideoSessionParametersCreateInfoKHR; + using VULKAN_HPP_NAMESPACE::VideoSessionParametersUpdateInfoKHR; + + //=== VK_KHR_video_decode_queue === + using VULKAN_HPP_NAMESPACE::VideoDecodeCapabilitiesKHR; + using VULKAN_HPP_NAMESPACE::VideoDecodeInfoKHR; + using VULKAN_HPP_NAMESPACE::VideoDecodeUsageInfoKHR; + + //=== VK_NV_dedicated_allocation === + using VULKAN_HPP_NAMESPACE::DedicatedAllocationBufferCreateInfoNV; + using VULKAN_HPP_NAMESPACE::DedicatedAllocationImageCreateInfoNV; + using VULKAN_HPP_NAMESPACE::DedicatedAllocationMemoryAllocateInfoNV; + + //=== VK_EXT_transform_feedback === + using VULKAN_HPP_NAMESPACE::PhysicalDeviceTransformFeedbackFeaturesEXT; + using VULKAN_HPP_NAMESPACE::PhysicalDeviceTransformFeedbackPropertiesEXT; + using VULKAN_HPP_NAMESPACE::PipelineRasterizationStateStreamCreateInfoEXT; + + //=== VK_NVX_binary_import === + using VULKAN_HPP_NAMESPACE::CuFunctionCreateInfoNVX; + using VULKAN_HPP_NAMESPACE::CuLaunchInfoNVX; + using VULKAN_HPP_NAMESPACE::CuModuleCreateInfoNVX; + + //=== VK_NVX_image_view_handle === + using VULKAN_HPP_NAMESPACE::ImageViewAddressPropertiesNVX; + using VULKAN_HPP_NAMESPACE::ImageViewHandleInfoNVX; + +#if defined( VK_ENABLE_BETA_EXTENSIONS ) + //=== VK_EXT_video_encode_h264 === + using VULKAN_HPP_NAMESPACE::VideoEncodeH264CapabilitiesEXT; + using VULKAN_HPP_NAMESPACE::VideoEncodeH264DpbSlotInfoEXT; + using VULKAN_HPP_NAMESPACE::VideoEncodeH264FrameSizeEXT; + using VULKAN_HPP_NAMESPACE::VideoEncodeH264GopRemainingFrameInfoEXT; + using VULKAN_HPP_NAMESPACE::VideoEncodeH264NaluSliceInfoEXT; + using VULKAN_HPP_NAMESPACE::VideoEncodeH264PictureInfoEXT; + using VULKAN_HPP_NAMESPACE::VideoEncodeH264ProfileInfoEXT; + using VULKAN_HPP_NAMESPACE::VideoEncodeH264QpEXT; + using VULKAN_HPP_NAMESPACE::VideoEncodeH264QualityLevelPropertiesEXT; + using VULKAN_HPP_NAMESPACE::VideoEncodeH264RateControlInfoEXT; + using VULKAN_HPP_NAMESPACE::VideoEncodeH264RateControlLayerInfoEXT; + using VULKAN_HPP_NAMESPACE::VideoEncodeH264SessionCreateInfoEXT; + using VULKAN_HPP_NAMESPACE::VideoEncodeH264SessionParametersAddInfoEXT; + using VULKAN_HPP_NAMESPACE::VideoEncodeH264SessionParametersCreateInfoEXT; + using VULKAN_HPP_NAMESPACE::VideoEncodeH264SessionParametersFeedbackInfoEXT; + using VULKAN_HPP_NAMESPACE::VideoEncodeH264SessionParametersGetInfoEXT; +#endif /*VK_ENABLE_BETA_EXTENSIONS*/ + +#if defined( VK_ENABLE_BETA_EXTENSIONS ) + //=== VK_EXT_video_encode_h265 === + using VULKAN_HPP_NAMESPACE::VideoEncodeH265CapabilitiesEXT; + using VULKAN_HPP_NAMESPACE::VideoEncodeH265DpbSlotInfoEXT; + using VULKAN_HPP_NAMESPACE::VideoEncodeH265FrameSizeEXT; + using VULKAN_HPP_NAMESPACE::VideoEncodeH265GopRemainingFrameInfoEXT; + using VULKAN_HPP_NAMESPACE::VideoEncodeH265NaluSliceSegmentInfoEXT; + using VULKAN_HPP_NAMESPACE::VideoEncodeH265PictureInfoEXT; + using VULKAN_HPP_NAMESPACE::VideoEncodeH265ProfileInfoEXT; + using VULKAN_HPP_NAMESPACE::VideoEncodeH265QpEXT; + using VULKAN_HPP_NAMESPACE::VideoEncodeH265QualityLevelPropertiesEXT; + using VULKAN_HPP_NAMESPACE::VideoEncodeH265RateControlInfoEXT; + using VULKAN_HPP_NAMESPACE::VideoEncodeH265RateControlLayerInfoEXT; + using VULKAN_HPP_NAMESPACE::VideoEncodeH265SessionCreateInfoEXT; + using VULKAN_HPP_NAMESPACE::VideoEncodeH265SessionParametersAddInfoEXT; + using VULKAN_HPP_NAMESPACE::VideoEncodeH265SessionParametersCreateInfoEXT; + using VULKAN_HPP_NAMESPACE::VideoEncodeH265SessionParametersFeedbackInfoEXT; + using VULKAN_HPP_NAMESPACE::VideoEncodeH265SessionParametersGetInfoEXT; +#endif /*VK_ENABLE_BETA_EXTENSIONS*/ + + //=== VK_KHR_video_decode_h264 === + using VULKAN_HPP_NAMESPACE::VideoDecodeH264CapabilitiesKHR; + using VULKAN_HPP_NAMESPACE::VideoDecodeH264DpbSlotInfoKHR; + using VULKAN_HPP_NAMESPACE::VideoDecodeH264PictureInfoKHR; + using VULKAN_HPP_NAMESPACE::VideoDecodeH264ProfileInfoKHR; + using VULKAN_HPP_NAMESPACE::VideoDecodeH264SessionParametersAddInfoKHR; + using VULKAN_HPP_NAMESPACE::VideoDecodeH264SessionParametersCreateInfoKHR; + + //=== VK_AMD_texture_gather_bias_lod === + using VULKAN_HPP_NAMESPACE::TextureLODGatherFormatPropertiesAMD; + + //=== VK_AMD_shader_info === + using VULKAN_HPP_NAMESPACE::ShaderResourceUsageAMD; + using VULKAN_HPP_NAMESPACE::ShaderStatisticsInfoAMD; + + //=== VK_KHR_dynamic_rendering === + using VULKAN_HPP_NAMESPACE::AttachmentSampleCountInfoAMD; + using VULKAN_HPP_NAMESPACE::AttachmentSampleCountInfoNV; + using VULKAN_HPP_NAMESPACE::MultiviewPerViewAttributesInfoNVX; + using VULKAN_HPP_NAMESPACE::RenderingFragmentDensityMapAttachmentInfoEXT; + using VULKAN_HPP_NAMESPACE::RenderingFragmentShadingRateAttachmentInfoKHR; + +#if defined( VK_USE_PLATFORM_GGP ) + //=== VK_GGP_stream_descriptor_surface === + using VULKAN_HPP_NAMESPACE::StreamDescriptorSurfaceCreateInfoGGP; +#endif /*VK_USE_PLATFORM_GGP*/ + + //=== VK_NV_corner_sampled_image === + using VULKAN_HPP_NAMESPACE::PhysicalDeviceCornerSampledImageFeaturesNV; + + //=== VK_NV_external_memory_capabilities === + using VULKAN_HPP_NAMESPACE::ExternalImageFormatPropertiesNV; + + //=== VK_NV_external_memory === + using VULKAN_HPP_NAMESPACE::ExportMemoryAllocateInfoNV; + using VULKAN_HPP_NAMESPACE::ExternalMemoryImageCreateInfoNV; + +#if defined( VK_USE_PLATFORM_WIN32_KHR ) + //=== VK_NV_external_memory_win32 === + using VULKAN_HPP_NAMESPACE::ExportMemoryWin32HandleInfoNV; + using VULKAN_HPP_NAMESPACE::ImportMemoryWin32HandleInfoNV; +#endif /*VK_USE_PLATFORM_WIN32_KHR*/ + +#if defined( VK_USE_PLATFORM_WIN32_KHR ) + //=== VK_NV_win32_keyed_mutex === + using VULKAN_HPP_NAMESPACE::Win32KeyedMutexAcquireReleaseInfoNV; +#endif /*VK_USE_PLATFORM_WIN32_KHR*/ + + //=== VK_EXT_validation_flags === + using VULKAN_HPP_NAMESPACE::ValidationFlagsEXT; + +#if defined( VK_USE_PLATFORM_VI_NN ) + //=== VK_NN_vi_surface === + using VULKAN_HPP_NAMESPACE::ViSurfaceCreateInfoNN; +#endif /*VK_USE_PLATFORM_VI_NN*/ + + //=== VK_EXT_astc_decode_mode === + using VULKAN_HPP_NAMESPACE::ImageViewASTCDecodeModeEXT; + using VULKAN_HPP_NAMESPACE::PhysicalDeviceASTCDecodeFeaturesEXT; + + //=== VK_EXT_pipeline_robustness === + using VULKAN_HPP_NAMESPACE::PhysicalDevicePipelineRobustnessFeaturesEXT; + using VULKAN_HPP_NAMESPACE::PhysicalDevicePipelineRobustnessPropertiesEXT; + using VULKAN_HPP_NAMESPACE::PipelineRobustnessCreateInfoEXT; + +#if defined( VK_USE_PLATFORM_WIN32_KHR ) + //=== VK_KHR_external_memory_win32 === + using VULKAN_HPP_NAMESPACE::ExportMemoryWin32HandleInfoKHR; + using VULKAN_HPP_NAMESPACE::ImportMemoryWin32HandleInfoKHR; + using VULKAN_HPP_NAMESPACE::MemoryGetWin32HandleInfoKHR; + using VULKAN_HPP_NAMESPACE::MemoryWin32HandlePropertiesKHR; +#endif /*VK_USE_PLATFORM_WIN32_KHR*/ + + //=== VK_KHR_external_memory_fd === + using VULKAN_HPP_NAMESPACE::ImportMemoryFdInfoKHR; + using VULKAN_HPP_NAMESPACE::MemoryFdPropertiesKHR; + using VULKAN_HPP_NAMESPACE::MemoryGetFdInfoKHR; + +#if defined( VK_USE_PLATFORM_WIN32_KHR ) + //=== VK_KHR_win32_keyed_mutex === + using VULKAN_HPP_NAMESPACE::Win32KeyedMutexAcquireReleaseInfoKHR; +#endif /*VK_USE_PLATFORM_WIN32_KHR*/ + +#if defined( VK_USE_PLATFORM_WIN32_KHR ) + //=== VK_KHR_external_semaphore_win32 === + using VULKAN_HPP_NAMESPACE::D3D12FenceSubmitInfoKHR; + using VULKAN_HPP_NAMESPACE::ExportSemaphoreWin32HandleInfoKHR; + using VULKAN_HPP_NAMESPACE::ImportSemaphoreWin32HandleInfoKHR; + using VULKAN_HPP_NAMESPACE::SemaphoreGetWin32HandleInfoKHR; +#endif /*VK_USE_PLATFORM_WIN32_KHR*/ + + //=== VK_KHR_external_semaphore_fd === + using VULKAN_HPP_NAMESPACE::ImportSemaphoreFdInfoKHR; + using VULKAN_HPP_NAMESPACE::SemaphoreGetFdInfoKHR; + + //=== VK_KHR_push_descriptor === + using VULKAN_HPP_NAMESPACE::PhysicalDevicePushDescriptorPropertiesKHR; + + //=== VK_EXT_conditional_rendering === + using VULKAN_HPP_NAMESPACE::CommandBufferInheritanceConditionalRenderingInfoEXT; + using VULKAN_HPP_NAMESPACE::ConditionalRenderingBeginInfoEXT; + using VULKAN_HPP_NAMESPACE::PhysicalDeviceConditionalRenderingFeaturesEXT; + + //=== VK_KHR_incremental_present === + using VULKAN_HPP_NAMESPACE::PresentRegionKHR; + using VULKAN_HPP_NAMESPACE::PresentRegionsKHR; + using VULKAN_HPP_NAMESPACE::RectLayerKHR; + + //=== VK_NV_clip_space_w_scaling === + using VULKAN_HPP_NAMESPACE::PipelineViewportWScalingStateCreateInfoNV; + using VULKAN_HPP_NAMESPACE::ViewportWScalingNV; + + //=== VK_EXT_display_surface_counter === + using VULKAN_HPP_NAMESPACE::SurfaceCapabilities2EXT; + + //=== VK_EXT_display_control === + using VULKAN_HPP_NAMESPACE::DeviceEventInfoEXT; + using VULKAN_HPP_NAMESPACE::DisplayEventInfoEXT; + using VULKAN_HPP_NAMESPACE::DisplayPowerInfoEXT; + using VULKAN_HPP_NAMESPACE::SwapchainCounterCreateInfoEXT; + + //=== VK_GOOGLE_display_timing === + using VULKAN_HPP_NAMESPACE::PastPresentationTimingGOOGLE; + using VULKAN_HPP_NAMESPACE::PresentTimeGOOGLE; + using VULKAN_HPP_NAMESPACE::PresentTimesInfoGOOGLE; + using VULKAN_HPP_NAMESPACE::RefreshCycleDurationGOOGLE; + + //=== VK_NVX_multiview_per_view_attributes === + using VULKAN_HPP_NAMESPACE::PhysicalDeviceMultiviewPerViewAttributesPropertiesNVX; + + //=== VK_NV_viewport_swizzle === + using VULKAN_HPP_NAMESPACE::PipelineViewportSwizzleStateCreateInfoNV; + using VULKAN_HPP_NAMESPACE::ViewportSwizzleNV; + + //=== VK_EXT_discard_rectangles === + using VULKAN_HPP_NAMESPACE::PhysicalDeviceDiscardRectanglePropertiesEXT; + using VULKAN_HPP_NAMESPACE::PipelineDiscardRectangleStateCreateInfoEXT; + + //=== VK_EXT_conservative_rasterization === + using VULKAN_HPP_NAMESPACE::PhysicalDeviceConservativeRasterizationPropertiesEXT; + using VULKAN_HPP_NAMESPACE::PipelineRasterizationConservativeStateCreateInfoEXT; + + //=== VK_EXT_depth_clip_enable === + using VULKAN_HPP_NAMESPACE::PhysicalDeviceDepthClipEnableFeaturesEXT; + using VULKAN_HPP_NAMESPACE::PipelineRasterizationDepthClipStateCreateInfoEXT; + + //=== VK_EXT_hdr_metadata === + using VULKAN_HPP_NAMESPACE::HdrMetadataEXT; + using VULKAN_HPP_NAMESPACE::XYColorEXT; + + //=== VK_KHR_shared_presentable_image === + using VULKAN_HPP_NAMESPACE::SharedPresentSurfaceCapabilitiesKHR; + +#if defined( VK_USE_PLATFORM_WIN32_KHR ) + //=== VK_KHR_external_fence_win32 === + using VULKAN_HPP_NAMESPACE::ExportFenceWin32HandleInfoKHR; + using VULKAN_HPP_NAMESPACE::FenceGetWin32HandleInfoKHR; + using VULKAN_HPP_NAMESPACE::ImportFenceWin32HandleInfoKHR; +#endif /*VK_USE_PLATFORM_WIN32_KHR*/ + + //=== VK_KHR_external_fence_fd === + using VULKAN_HPP_NAMESPACE::FenceGetFdInfoKHR; + using VULKAN_HPP_NAMESPACE::ImportFenceFdInfoKHR; + + //=== VK_KHR_performance_query === + using VULKAN_HPP_NAMESPACE::AcquireProfilingLockInfoKHR; + using VULKAN_HPP_NAMESPACE::PerformanceCounterDescriptionKHR; + using VULKAN_HPP_NAMESPACE::PerformanceCounterKHR; + using VULKAN_HPP_NAMESPACE::PerformanceCounterResultKHR; + using VULKAN_HPP_NAMESPACE::PerformanceQuerySubmitInfoKHR; + using VULKAN_HPP_NAMESPACE::PhysicalDevicePerformanceQueryFeaturesKHR; + using VULKAN_HPP_NAMESPACE::PhysicalDevicePerformanceQueryPropertiesKHR; + using VULKAN_HPP_NAMESPACE::QueryPoolPerformanceCreateInfoKHR; + + //=== VK_KHR_get_surface_capabilities2 === + using VULKAN_HPP_NAMESPACE::PhysicalDeviceSurfaceInfo2KHR; + using VULKAN_HPP_NAMESPACE::SurfaceCapabilities2KHR; + using VULKAN_HPP_NAMESPACE::SurfaceFormat2KHR; + + //=== VK_KHR_get_display_properties2 === + using VULKAN_HPP_NAMESPACE::DisplayModeProperties2KHR; + using VULKAN_HPP_NAMESPACE::DisplayPlaneCapabilities2KHR; + using VULKAN_HPP_NAMESPACE::DisplayPlaneInfo2KHR; + using VULKAN_HPP_NAMESPACE::DisplayPlaneProperties2KHR; + using VULKAN_HPP_NAMESPACE::DisplayProperties2KHR; + +#if defined( VK_USE_PLATFORM_IOS_MVK ) + //=== VK_MVK_ios_surface === + using VULKAN_HPP_NAMESPACE::IOSSurfaceCreateInfoMVK; +#endif /*VK_USE_PLATFORM_IOS_MVK*/ + +#if defined( VK_USE_PLATFORM_MACOS_MVK ) + //=== VK_MVK_macos_surface === + using VULKAN_HPP_NAMESPACE::MacOSSurfaceCreateInfoMVK; +#endif /*VK_USE_PLATFORM_MACOS_MVK*/ + + //=== VK_EXT_debug_utils === + using VULKAN_HPP_NAMESPACE::DebugUtilsLabelEXT; + using VULKAN_HPP_NAMESPACE::DebugUtilsMessengerCallbackDataEXT; + using VULKAN_HPP_NAMESPACE::DebugUtilsMessengerCreateInfoEXT; + using VULKAN_HPP_NAMESPACE::DebugUtilsObjectNameInfoEXT; + using VULKAN_HPP_NAMESPACE::DebugUtilsObjectTagInfoEXT; + +#if defined( VK_USE_PLATFORM_ANDROID_KHR ) + //=== VK_ANDROID_external_memory_android_hardware_buffer === + using VULKAN_HPP_NAMESPACE::AndroidHardwareBufferFormatProperties2ANDROID; + using VULKAN_HPP_NAMESPACE::AndroidHardwareBufferFormatPropertiesANDROID; + using VULKAN_HPP_NAMESPACE::AndroidHardwareBufferPropertiesANDROID; + using VULKAN_HPP_NAMESPACE::AndroidHardwareBufferUsageANDROID; + using VULKAN_HPP_NAMESPACE::ExternalFormatANDROID; + using VULKAN_HPP_NAMESPACE::ImportAndroidHardwareBufferInfoANDROID; + using VULKAN_HPP_NAMESPACE::MemoryGetAndroidHardwareBufferInfoANDROID; +#endif /*VK_USE_PLATFORM_ANDROID_KHR*/ + + //=== VK_EXT_sample_locations === + using VULKAN_HPP_NAMESPACE::AttachmentSampleLocationsEXT; + using VULKAN_HPP_NAMESPACE::MultisamplePropertiesEXT; + using VULKAN_HPP_NAMESPACE::PhysicalDeviceSampleLocationsPropertiesEXT; + using VULKAN_HPP_NAMESPACE::PipelineSampleLocationsStateCreateInfoEXT; + using VULKAN_HPP_NAMESPACE::RenderPassSampleLocationsBeginInfoEXT; + using VULKAN_HPP_NAMESPACE::SampleLocationEXT; + using VULKAN_HPP_NAMESPACE::SampleLocationsInfoEXT; + using VULKAN_HPP_NAMESPACE::SubpassSampleLocationsEXT; + + //=== VK_EXT_blend_operation_advanced === + using VULKAN_HPP_NAMESPACE::PhysicalDeviceBlendOperationAdvancedFeaturesEXT; + using VULKAN_HPP_NAMESPACE::PhysicalDeviceBlendOperationAdvancedPropertiesEXT; + using VULKAN_HPP_NAMESPACE::PipelineColorBlendAdvancedStateCreateInfoEXT; + + //=== VK_NV_fragment_coverage_to_color === + using VULKAN_HPP_NAMESPACE::PipelineCoverageToColorStateCreateInfoNV; + + //=== VK_KHR_acceleration_structure === + using VULKAN_HPP_NAMESPACE::AabbPositionsKHR; + using VULKAN_HPP_NAMESPACE::AabbPositionsNV; + using VULKAN_HPP_NAMESPACE::AccelerationStructureBuildGeometryInfoKHR; + using VULKAN_HPP_NAMESPACE::AccelerationStructureBuildRangeInfoKHR; + using VULKAN_HPP_NAMESPACE::AccelerationStructureBuildSizesInfoKHR; + using VULKAN_HPP_NAMESPACE::AccelerationStructureCreateInfoKHR; + using VULKAN_HPP_NAMESPACE::AccelerationStructureDeviceAddressInfoKHR; + using VULKAN_HPP_NAMESPACE::AccelerationStructureGeometryAabbsDataKHR; + using VULKAN_HPP_NAMESPACE::AccelerationStructureGeometryDataKHR; + using VULKAN_HPP_NAMESPACE::AccelerationStructureGeometryInstancesDataKHR; + using VULKAN_HPP_NAMESPACE::AccelerationStructureGeometryKHR; + using VULKAN_HPP_NAMESPACE::AccelerationStructureGeometryTrianglesDataKHR; + using VULKAN_HPP_NAMESPACE::AccelerationStructureInstanceKHR; + using VULKAN_HPP_NAMESPACE::AccelerationStructureInstanceNV; + using VULKAN_HPP_NAMESPACE::AccelerationStructureVersionInfoKHR; + using VULKAN_HPP_NAMESPACE::CopyAccelerationStructureInfoKHR; + using VULKAN_HPP_NAMESPACE::CopyAccelerationStructureToMemoryInfoKHR; + using VULKAN_HPP_NAMESPACE::CopyMemoryToAccelerationStructureInfoKHR; + using VULKAN_HPP_NAMESPACE::DeviceOrHostAddressConstKHR; + using VULKAN_HPP_NAMESPACE::DeviceOrHostAddressKHR; + using VULKAN_HPP_NAMESPACE::PhysicalDeviceAccelerationStructureFeaturesKHR; + using VULKAN_HPP_NAMESPACE::PhysicalDeviceAccelerationStructurePropertiesKHR; + using VULKAN_HPP_NAMESPACE::TransformMatrixKHR; + using VULKAN_HPP_NAMESPACE::TransformMatrixNV; + using VULKAN_HPP_NAMESPACE::WriteDescriptorSetAccelerationStructureKHR; + + //=== VK_KHR_ray_tracing_pipeline === + using VULKAN_HPP_NAMESPACE::PhysicalDeviceRayTracingPipelineFeaturesKHR; + using VULKAN_HPP_NAMESPACE::PhysicalDeviceRayTracingPipelinePropertiesKHR; + using VULKAN_HPP_NAMESPACE::RayTracingPipelineCreateInfoKHR; + using VULKAN_HPP_NAMESPACE::RayTracingPipelineInterfaceCreateInfoKHR; + using VULKAN_HPP_NAMESPACE::RayTracingShaderGroupCreateInfoKHR; + using VULKAN_HPP_NAMESPACE::StridedDeviceAddressRegionKHR; + using VULKAN_HPP_NAMESPACE::TraceRaysIndirectCommandKHR; + + //=== VK_KHR_ray_query === + using VULKAN_HPP_NAMESPACE::PhysicalDeviceRayQueryFeaturesKHR; + + //=== VK_NV_framebuffer_mixed_samples === + using VULKAN_HPP_NAMESPACE::PipelineCoverageModulationStateCreateInfoNV; + + //=== VK_NV_shader_sm_builtins === + using VULKAN_HPP_NAMESPACE::PhysicalDeviceShaderSMBuiltinsFeaturesNV; + using VULKAN_HPP_NAMESPACE::PhysicalDeviceShaderSMBuiltinsPropertiesNV; + + //=== VK_EXT_image_drm_format_modifier === + using VULKAN_HPP_NAMESPACE::DrmFormatModifierProperties2EXT; + using VULKAN_HPP_NAMESPACE::DrmFormatModifierPropertiesEXT; + using VULKAN_HPP_NAMESPACE::DrmFormatModifierPropertiesList2EXT; + using VULKAN_HPP_NAMESPACE::DrmFormatModifierPropertiesListEXT; + using VULKAN_HPP_NAMESPACE::ImageDrmFormatModifierExplicitCreateInfoEXT; + using VULKAN_HPP_NAMESPACE::ImageDrmFormatModifierListCreateInfoEXT; + using VULKAN_HPP_NAMESPACE::ImageDrmFormatModifierPropertiesEXT; + using VULKAN_HPP_NAMESPACE::PhysicalDeviceImageDrmFormatModifierInfoEXT; + + //=== VK_EXT_validation_cache === + using VULKAN_HPP_NAMESPACE::ShaderModuleValidationCacheCreateInfoEXT; + using VULKAN_HPP_NAMESPACE::ValidationCacheCreateInfoEXT; + +#if defined( VK_ENABLE_BETA_EXTENSIONS ) + //=== VK_KHR_portability_subset === + using VULKAN_HPP_NAMESPACE::PhysicalDevicePortabilitySubsetFeaturesKHR; + using VULKAN_HPP_NAMESPACE::PhysicalDevicePortabilitySubsetPropertiesKHR; +#endif /*VK_ENABLE_BETA_EXTENSIONS*/ + + //=== VK_NV_shading_rate_image === + using VULKAN_HPP_NAMESPACE::CoarseSampleLocationNV; + using VULKAN_HPP_NAMESPACE::CoarseSampleOrderCustomNV; + using VULKAN_HPP_NAMESPACE::PhysicalDeviceShadingRateImageFeaturesNV; + using VULKAN_HPP_NAMESPACE::PhysicalDeviceShadingRateImagePropertiesNV; + using VULKAN_HPP_NAMESPACE::PipelineViewportCoarseSampleOrderStateCreateInfoNV; + using VULKAN_HPP_NAMESPACE::PipelineViewportShadingRateImageStateCreateInfoNV; + using VULKAN_HPP_NAMESPACE::ShadingRatePaletteNV; + + //=== VK_NV_ray_tracing === + using VULKAN_HPP_NAMESPACE::AccelerationStructureCreateInfoNV; + using VULKAN_HPP_NAMESPACE::AccelerationStructureInfoNV; + using VULKAN_HPP_NAMESPACE::AccelerationStructureMemoryRequirementsInfoNV; + using VULKAN_HPP_NAMESPACE::BindAccelerationStructureMemoryInfoNV; + using VULKAN_HPP_NAMESPACE::GeometryAABBNV; + using VULKAN_HPP_NAMESPACE::GeometryDataNV; + using VULKAN_HPP_NAMESPACE::GeometryNV; + using VULKAN_HPP_NAMESPACE::GeometryTrianglesNV; + using VULKAN_HPP_NAMESPACE::PhysicalDeviceRayTracingPropertiesNV; + using VULKAN_HPP_NAMESPACE::RayTracingPipelineCreateInfoNV; + using VULKAN_HPP_NAMESPACE::RayTracingShaderGroupCreateInfoNV; + using VULKAN_HPP_NAMESPACE::WriteDescriptorSetAccelerationStructureNV; + + //=== VK_NV_representative_fragment_test === + using VULKAN_HPP_NAMESPACE::PhysicalDeviceRepresentativeFragmentTestFeaturesNV; + using VULKAN_HPP_NAMESPACE::PipelineRepresentativeFragmentTestStateCreateInfoNV; + + //=== VK_EXT_filter_cubic === + using VULKAN_HPP_NAMESPACE::FilterCubicImageViewImageFormatPropertiesEXT; + using VULKAN_HPP_NAMESPACE::PhysicalDeviceImageViewImageFormatInfoEXT; + + //=== VK_EXT_external_memory_host === + using VULKAN_HPP_NAMESPACE::ImportMemoryHostPointerInfoEXT; + using VULKAN_HPP_NAMESPACE::MemoryHostPointerPropertiesEXT; + using VULKAN_HPP_NAMESPACE::PhysicalDeviceExternalMemoryHostPropertiesEXT; + + //=== VK_KHR_shader_clock === + using VULKAN_HPP_NAMESPACE::PhysicalDeviceShaderClockFeaturesKHR; + + //=== VK_AMD_pipeline_compiler_control === + using VULKAN_HPP_NAMESPACE::PipelineCompilerControlCreateInfoAMD; + + //=== VK_EXT_calibrated_timestamps === + using VULKAN_HPP_NAMESPACE::CalibratedTimestampInfoEXT; + + //=== VK_AMD_shader_core_properties === + using VULKAN_HPP_NAMESPACE::PhysicalDeviceShaderCorePropertiesAMD; + + //=== VK_KHR_video_decode_h265 === + using VULKAN_HPP_NAMESPACE::VideoDecodeH265CapabilitiesKHR; + using VULKAN_HPP_NAMESPACE::VideoDecodeH265DpbSlotInfoKHR; + using VULKAN_HPP_NAMESPACE::VideoDecodeH265PictureInfoKHR; + using VULKAN_HPP_NAMESPACE::VideoDecodeH265ProfileInfoKHR; + using VULKAN_HPP_NAMESPACE::VideoDecodeH265SessionParametersAddInfoKHR; + using VULKAN_HPP_NAMESPACE::VideoDecodeH265SessionParametersCreateInfoKHR; + + //=== VK_KHR_global_priority === + using VULKAN_HPP_NAMESPACE::DeviceQueueGlobalPriorityCreateInfoEXT; + using VULKAN_HPP_NAMESPACE::DeviceQueueGlobalPriorityCreateInfoKHR; + using VULKAN_HPP_NAMESPACE::PhysicalDeviceGlobalPriorityQueryFeaturesEXT; + using VULKAN_HPP_NAMESPACE::PhysicalDeviceGlobalPriorityQueryFeaturesKHR; + using VULKAN_HPP_NAMESPACE::QueueFamilyGlobalPriorityPropertiesEXT; + using VULKAN_HPP_NAMESPACE::QueueFamilyGlobalPriorityPropertiesKHR; + + //=== VK_AMD_memory_overallocation_behavior === + using VULKAN_HPP_NAMESPACE::DeviceMemoryOverallocationCreateInfoAMD; + + //=== VK_EXT_vertex_attribute_divisor === + using VULKAN_HPP_NAMESPACE::PhysicalDeviceVertexAttributeDivisorFeaturesEXT; + using VULKAN_HPP_NAMESPACE::PhysicalDeviceVertexAttributeDivisorPropertiesEXT; + using VULKAN_HPP_NAMESPACE::PipelineVertexInputDivisorStateCreateInfoEXT; + using VULKAN_HPP_NAMESPACE::VertexInputBindingDivisorDescriptionEXT; + +#if defined( VK_USE_PLATFORM_GGP ) + //=== VK_GGP_frame_token === + using VULKAN_HPP_NAMESPACE::PresentFrameTokenGGP; +#endif /*VK_USE_PLATFORM_GGP*/ + + //=== VK_NV_compute_shader_derivatives === + using VULKAN_HPP_NAMESPACE::PhysicalDeviceComputeShaderDerivativesFeaturesNV; + + //=== VK_NV_mesh_shader === + using VULKAN_HPP_NAMESPACE::DrawMeshTasksIndirectCommandNV; + using VULKAN_HPP_NAMESPACE::PhysicalDeviceMeshShaderFeaturesNV; + using VULKAN_HPP_NAMESPACE::PhysicalDeviceMeshShaderPropertiesNV; + + //=== VK_NV_shader_image_footprint === + using VULKAN_HPP_NAMESPACE::PhysicalDeviceShaderImageFootprintFeaturesNV; + + //=== VK_NV_scissor_exclusive === + using VULKAN_HPP_NAMESPACE::PhysicalDeviceExclusiveScissorFeaturesNV; + using VULKAN_HPP_NAMESPACE::PipelineViewportExclusiveScissorStateCreateInfoNV; + + //=== VK_NV_device_diagnostic_checkpoints === + using VULKAN_HPP_NAMESPACE::CheckpointDataNV; + using VULKAN_HPP_NAMESPACE::QueueFamilyCheckpointPropertiesNV; + + //=== VK_INTEL_shader_integer_functions2 === + using VULKAN_HPP_NAMESPACE::PhysicalDeviceShaderIntegerFunctions2FeaturesINTEL; + + //=== VK_INTEL_performance_query === + using VULKAN_HPP_NAMESPACE::InitializePerformanceApiInfoINTEL; + using VULKAN_HPP_NAMESPACE::PerformanceConfigurationAcquireInfoINTEL; + using VULKAN_HPP_NAMESPACE::PerformanceMarkerInfoINTEL; + using VULKAN_HPP_NAMESPACE::PerformanceOverrideInfoINTEL; + using VULKAN_HPP_NAMESPACE::PerformanceStreamMarkerInfoINTEL; + using VULKAN_HPP_NAMESPACE::PerformanceValueDataINTEL; + using VULKAN_HPP_NAMESPACE::PerformanceValueINTEL; + using VULKAN_HPP_NAMESPACE::QueryPoolCreateInfoINTEL; + using VULKAN_HPP_NAMESPACE::QueryPoolPerformanceQueryCreateInfoINTEL; + + //=== VK_EXT_pci_bus_info === + using VULKAN_HPP_NAMESPACE::PhysicalDevicePCIBusInfoPropertiesEXT; + + //=== VK_AMD_display_native_hdr === + using VULKAN_HPP_NAMESPACE::DisplayNativeHdrSurfaceCapabilitiesAMD; + using VULKAN_HPP_NAMESPACE::SwapchainDisplayNativeHdrCreateInfoAMD; + +#if defined( VK_USE_PLATFORM_FUCHSIA ) + //=== VK_FUCHSIA_imagepipe_surface === + using VULKAN_HPP_NAMESPACE::ImagePipeSurfaceCreateInfoFUCHSIA; +#endif /*VK_USE_PLATFORM_FUCHSIA*/ + +#if defined( VK_USE_PLATFORM_METAL_EXT ) + //=== VK_EXT_metal_surface === + using VULKAN_HPP_NAMESPACE::MetalSurfaceCreateInfoEXT; +#endif /*VK_USE_PLATFORM_METAL_EXT*/ + + //=== VK_EXT_fragment_density_map === + using VULKAN_HPP_NAMESPACE::PhysicalDeviceFragmentDensityMapFeaturesEXT; + using VULKAN_HPP_NAMESPACE::PhysicalDeviceFragmentDensityMapPropertiesEXT; + using VULKAN_HPP_NAMESPACE::RenderPassFragmentDensityMapCreateInfoEXT; + + //=== VK_KHR_fragment_shading_rate === + using VULKAN_HPP_NAMESPACE::FragmentShadingRateAttachmentInfoKHR; + using VULKAN_HPP_NAMESPACE::PhysicalDeviceFragmentShadingRateFeaturesKHR; + using VULKAN_HPP_NAMESPACE::PhysicalDeviceFragmentShadingRateKHR; + using VULKAN_HPP_NAMESPACE::PhysicalDeviceFragmentShadingRatePropertiesKHR; + using VULKAN_HPP_NAMESPACE::PipelineFragmentShadingRateStateCreateInfoKHR; + + //=== VK_AMD_shader_core_properties2 === + using VULKAN_HPP_NAMESPACE::PhysicalDeviceShaderCoreProperties2AMD; + + //=== VK_AMD_device_coherent_memory === + using VULKAN_HPP_NAMESPACE::PhysicalDeviceCoherentMemoryFeaturesAMD; + + //=== VK_EXT_shader_image_atomic_int64 === + using VULKAN_HPP_NAMESPACE::PhysicalDeviceShaderImageAtomicInt64FeaturesEXT; + + //=== VK_EXT_memory_budget === + using VULKAN_HPP_NAMESPACE::PhysicalDeviceMemoryBudgetPropertiesEXT; + + //=== VK_EXT_memory_priority === + using VULKAN_HPP_NAMESPACE::MemoryPriorityAllocateInfoEXT; + using VULKAN_HPP_NAMESPACE::PhysicalDeviceMemoryPriorityFeaturesEXT; + + //=== VK_KHR_surface_protected_capabilities === + using VULKAN_HPP_NAMESPACE::SurfaceProtectedCapabilitiesKHR; + + //=== VK_NV_dedicated_allocation_image_aliasing === + using VULKAN_HPP_NAMESPACE::PhysicalDeviceDedicatedAllocationImageAliasingFeaturesNV; + + //=== VK_EXT_buffer_device_address === + using VULKAN_HPP_NAMESPACE::BufferDeviceAddressCreateInfoEXT; + using VULKAN_HPP_NAMESPACE::PhysicalDeviceBufferAddressFeaturesEXT; + using VULKAN_HPP_NAMESPACE::PhysicalDeviceBufferDeviceAddressFeaturesEXT; + + //=== VK_EXT_validation_features === + using VULKAN_HPP_NAMESPACE::ValidationFeaturesEXT; + + //=== VK_KHR_present_wait === + using VULKAN_HPP_NAMESPACE::PhysicalDevicePresentWaitFeaturesKHR; + + //=== VK_NV_cooperative_matrix === + using VULKAN_HPP_NAMESPACE::CooperativeMatrixPropertiesNV; + using VULKAN_HPP_NAMESPACE::PhysicalDeviceCooperativeMatrixFeaturesNV; + using VULKAN_HPP_NAMESPACE::PhysicalDeviceCooperativeMatrixPropertiesNV; + + //=== VK_NV_coverage_reduction_mode === + using VULKAN_HPP_NAMESPACE::FramebufferMixedSamplesCombinationNV; + using VULKAN_HPP_NAMESPACE::PhysicalDeviceCoverageReductionModeFeaturesNV; + using VULKAN_HPP_NAMESPACE::PipelineCoverageReductionStateCreateInfoNV; + + //=== VK_EXT_fragment_shader_interlock === + using VULKAN_HPP_NAMESPACE::PhysicalDeviceFragmentShaderInterlockFeaturesEXT; + + //=== VK_EXT_ycbcr_image_arrays === + using VULKAN_HPP_NAMESPACE::PhysicalDeviceYcbcrImageArraysFeaturesEXT; + + //=== VK_EXT_provoking_vertex === + using VULKAN_HPP_NAMESPACE::PhysicalDeviceProvokingVertexFeaturesEXT; + using VULKAN_HPP_NAMESPACE::PhysicalDeviceProvokingVertexPropertiesEXT; + using VULKAN_HPP_NAMESPACE::PipelineRasterizationProvokingVertexStateCreateInfoEXT; + +#if defined( VK_USE_PLATFORM_WIN32_KHR ) + //=== VK_EXT_full_screen_exclusive === + using VULKAN_HPP_NAMESPACE::SurfaceCapabilitiesFullScreenExclusiveEXT; + using VULKAN_HPP_NAMESPACE::SurfaceFullScreenExclusiveInfoEXT; + using VULKAN_HPP_NAMESPACE::SurfaceFullScreenExclusiveWin32InfoEXT; +#endif /*VK_USE_PLATFORM_WIN32_KHR*/ + + //=== VK_EXT_headless_surface === + using VULKAN_HPP_NAMESPACE::HeadlessSurfaceCreateInfoEXT; + + //=== VK_EXT_line_rasterization === + using VULKAN_HPP_NAMESPACE::PhysicalDeviceLineRasterizationFeaturesEXT; + using VULKAN_HPP_NAMESPACE::PhysicalDeviceLineRasterizationPropertiesEXT; + using VULKAN_HPP_NAMESPACE::PipelineRasterizationLineStateCreateInfoEXT; + + //=== VK_EXT_shader_atomic_float === + using VULKAN_HPP_NAMESPACE::PhysicalDeviceShaderAtomicFloatFeaturesEXT; + + //=== VK_EXT_index_type_uint8 === + using VULKAN_HPP_NAMESPACE::PhysicalDeviceIndexTypeUint8FeaturesEXT; + + //=== VK_EXT_extended_dynamic_state === + using VULKAN_HPP_NAMESPACE::PhysicalDeviceExtendedDynamicStateFeaturesEXT; + + //=== VK_KHR_pipeline_executable_properties === + using VULKAN_HPP_NAMESPACE::PhysicalDevicePipelineExecutablePropertiesFeaturesKHR; + using VULKAN_HPP_NAMESPACE::PipelineExecutableInfoKHR; + using VULKAN_HPP_NAMESPACE::PipelineExecutableInternalRepresentationKHR; + using VULKAN_HPP_NAMESPACE::PipelineExecutablePropertiesKHR; + using VULKAN_HPP_NAMESPACE::PipelineExecutableStatisticKHR; + using VULKAN_HPP_NAMESPACE::PipelineExecutableStatisticValueKHR; + using VULKAN_HPP_NAMESPACE::PipelineInfoEXT; + using VULKAN_HPP_NAMESPACE::PipelineInfoKHR; + + //=== VK_KHR_map_memory2 === + using VULKAN_HPP_NAMESPACE::MemoryMapInfoKHR; + using VULKAN_HPP_NAMESPACE::MemoryUnmapInfoKHR; + + //=== VK_EXT_shader_atomic_float2 === + using VULKAN_HPP_NAMESPACE::PhysicalDeviceShaderAtomicFloat2FeaturesEXT; + + //=== VK_EXT_surface_maintenance1 === + using VULKAN_HPP_NAMESPACE::SurfacePresentModeCompatibilityEXT; + using VULKAN_HPP_NAMESPACE::SurfacePresentModeEXT; + using VULKAN_HPP_NAMESPACE::SurfacePresentScalingCapabilitiesEXT; + + //=== VK_EXT_swapchain_maintenance1 === + using VULKAN_HPP_NAMESPACE::PhysicalDeviceSwapchainMaintenance1FeaturesEXT; + using VULKAN_HPP_NAMESPACE::ReleaseSwapchainImagesInfoEXT; + using VULKAN_HPP_NAMESPACE::SwapchainPresentFenceInfoEXT; + using VULKAN_HPP_NAMESPACE::SwapchainPresentModeInfoEXT; + using VULKAN_HPP_NAMESPACE::SwapchainPresentModesCreateInfoEXT; + using VULKAN_HPP_NAMESPACE::SwapchainPresentScalingCreateInfoEXT; + + //=== VK_NV_device_generated_commands === + using VULKAN_HPP_NAMESPACE::BindIndexBufferIndirectCommandNV; + using VULKAN_HPP_NAMESPACE::BindShaderGroupIndirectCommandNV; + using VULKAN_HPP_NAMESPACE::BindVertexBufferIndirectCommandNV; + using VULKAN_HPP_NAMESPACE::GeneratedCommandsInfoNV; + using VULKAN_HPP_NAMESPACE::GeneratedCommandsMemoryRequirementsInfoNV; + using VULKAN_HPP_NAMESPACE::GraphicsPipelineShaderGroupsCreateInfoNV; + using VULKAN_HPP_NAMESPACE::GraphicsShaderGroupCreateInfoNV; + using VULKAN_HPP_NAMESPACE::IndirectCommandsLayoutCreateInfoNV; + using VULKAN_HPP_NAMESPACE::IndirectCommandsLayoutTokenNV; + using VULKAN_HPP_NAMESPACE::IndirectCommandsStreamNV; + using VULKAN_HPP_NAMESPACE::PhysicalDeviceDeviceGeneratedCommandsFeaturesNV; + using VULKAN_HPP_NAMESPACE::PhysicalDeviceDeviceGeneratedCommandsPropertiesNV; + using VULKAN_HPP_NAMESPACE::SetStateFlagsIndirectCommandNV; + + //=== VK_NV_inherited_viewport_scissor === + using VULKAN_HPP_NAMESPACE::CommandBufferInheritanceViewportScissorInfoNV; + using VULKAN_HPP_NAMESPACE::PhysicalDeviceInheritedViewportScissorFeaturesNV; + + //=== VK_EXT_texel_buffer_alignment === + using VULKAN_HPP_NAMESPACE::PhysicalDeviceTexelBufferAlignmentFeaturesEXT; + + //=== VK_QCOM_render_pass_transform === + using VULKAN_HPP_NAMESPACE::CommandBufferInheritanceRenderPassTransformInfoQCOM; + using VULKAN_HPP_NAMESPACE::RenderPassTransformBeginInfoQCOM; + + //=== VK_EXT_depth_bias_control === + using VULKAN_HPP_NAMESPACE::DepthBiasInfoEXT; + using VULKAN_HPP_NAMESPACE::DepthBiasRepresentationInfoEXT; + using VULKAN_HPP_NAMESPACE::PhysicalDeviceDepthBiasControlFeaturesEXT; + + //=== VK_EXT_device_memory_report === + using VULKAN_HPP_NAMESPACE::DeviceDeviceMemoryReportCreateInfoEXT; + using VULKAN_HPP_NAMESPACE::DeviceMemoryReportCallbackDataEXT; + using VULKAN_HPP_NAMESPACE::PhysicalDeviceDeviceMemoryReportFeaturesEXT; + + //=== VK_EXT_robustness2 === + using VULKAN_HPP_NAMESPACE::PhysicalDeviceRobustness2FeaturesEXT; + using VULKAN_HPP_NAMESPACE::PhysicalDeviceRobustness2PropertiesEXT; + + //=== VK_EXT_custom_border_color === + using VULKAN_HPP_NAMESPACE::PhysicalDeviceCustomBorderColorFeaturesEXT; + using VULKAN_HPP_NAMESPACE::PhysicalDeviceCustomBorderColorPropertiesEXT; + using VULKAN_HPP_NAMESPACE::SamplerCustomBorderColorCreateInfoEXT; + + //=== VK_KHR_pipeline_library === + using VULKAN_HPP_NAMESPACE::PipelineLibraryCreateInfoKHR; + + //=== VK_NV_present_barrier === + using VULKAN_HPP_NAMESPACE::PhysicalDevicePresentBarrierFeaturesNV; + using VULKAN_HPP_NAMESPACE::SurfaceCapabilitiesPresentBarrierNV; + using VULKAN_HPP_NAMESPACE::SwapchainPresentBarrierCreateInfoNV; + + //=== VK_KHR_present_id === + using VULKAN_HPP_NAMESPACE::PhysicalDevicePresentIdFeaturesKHR; + using VULKAN_HPP_NAMESPACE::PresentIdKHR; + +#if defined( VK_ENABLE_BETA_EXTENSIONS ) + //=== VK_KHR_video_encode_queue === + using VULKAN_HPP_NAMESPACE::PhysicalDeviceVideoEncodeQualityLevelInfoKHR; + using VULKAN_HPP_NAMESPACE::QueryPoolVideoEncodeFeedbackCreateInfoKHR; + using VULKAN_HPP_NAMESPACE::VideoEncodeCapabilitiesKHR; + using VULKAN_HPP_NAMESPACE::VideoEncodeInfoKHR; + using VULKAN_HPP_NAMESPACE::VideoEncodeQualityLevelInfoKHR; + using VULKAN_HPP_NAMESPACE::VideoEncodeQualityLevelPropertiesKHR; + using VULKAN_HPP_NAMESPACE::VideoEncodeRateControlInfoKHR; + using VULKAN_HPP_NAMESPACE::VideoEncodeRateControlLayerInfoKHR; + using VULKAN_HPP_NAMESPACE::VideoEncodeSessionParametersFeedbackInfoKHR; + using VULKAN_HPP_NAMESPACE::VideoEncodeSessionParametersGetInfoKHR; + using VULKAN_HPP_NAMESPACE::VideoEncodeUsageInfoKHR; +#endif /*VK_ENABLE_BETA_EXTENSIONS*/ + + //=== VK_NV_device_diagnostics_config === + using VULKAN_HPP_NAMESPACE::DeviceDiagnosticsConfigCreateInfoNV; + using VULKAN_HPP_NAMESPACE::PhysicalDeviceDiagnosticsConfigFeaturesNV; + + //=== VK_NV_low_latency === + using VULKAN_HPP_NAMESPACE::QueryLowLatencySupportNV; + +#if defined( VK_USE_PLATFORM_METAL_EXT ) + //=== VK_EXT_metal_objects === + using VULKAN_HPP_NAMESPACE::ExportMetalBufferInfoEXT; + using VULKAN_HPP_NAMESPACE::ExportMetalCommandQueueInfoEXT; + using VULKAN_HPP_NAMESPACE::ExportMetalDeviceInfoEXT; + using VULKAN_HPP_NAMESPACE::ExportMetalIOSurfaceInfoEXT; + using VULKAN_HPP_NAMESPACE::ExportMetalObjectCreateInfoEXT; + using VULKAN_HPP_NAMESPACE::ExportMetalObjectsInfoEXT; + using VULKAN_HPP_NAMESPACE::ExportMetalSharedEventInfoEXT; + using VULKAN_HPP_NAMESPACE::ExportMetalTextureInfoEXT; + using VULKAN_HPP_NAMESPACE::ImportMetalBufferInfoEXT; + using VULKAN_HPP_NAMESPACE::ImportMetalIOSurfaceInfoEXT; + using VULKAN_HPP_NAMESPACE::ImportMetalSharedEventInfoEXT; + using VULKAN_HPP_NAMESPACE::ImportMetalTextureInfoEXT; +#endif /*VK_USE_PLATFORM_METAL_EXT*/ + + //=== VK_KHR_synchronization2 === + using VULKAN_HPP_NAMESPACE::CheckpointData2NV; + using VULKAN_HPP_NAMESPACE::QueueFamilyCheckpointProperties2NV; + + //=== VK_EXT_descriptor_buffer === + using VULKAN_HPP_NAMESPACE::AccelerationStructureCaptureDescriptorDataInfoEXT; + using VULKAN_HPP_NAMESPACE::BufferCaptureDescriptorDataInfoEXT; + using VULKAN_HPP_NAMESPACE::DescriptorAddressInfoEXT; + using VULKAN_HPP_NAMESPACE::DescriptorBufferBindingInfoEXT; + using VULKAN_HPP_NAMESPACE::DescriptorBufferBindingPushDescriptorBufferHandleEXT; + using VULKAN_HPP_NAMESPACE::DescriptorDataEXT; + using VULKAN_HPP_NAMESPACE::DescriptorGetInfoEXT; + using VULKAN_HPP_NAMESPACE::ImageCaptureDescriptorDataInfoEXT; + using VULKAN_HPP_NAMESPACE::ImageViewCaptureDescriptorDataInfoEXT; + using VULKAN_HPP_NAMESPACE::OpaqueCaptureDescriptorDataCreateInfoEXT; + using VULKAN_HPP_NAMESPACE::PhysicalDeviceDescriptorBufferDensityMapPropertiesEXT; + using VULKAN_HPP_NAMESPACE::PhysicalDeviceDescriptorBufferFeaturesEXT; + using VULKAN_HPP_NAMESPACE::PhysicalDeviceDescriptorBufferPropertiesEXT; + using VULKAN_HPP_NAMESPACE::SamplerCaptureDescriptorDataInfoEXT; + + //=== VK_EXT_graphics_pipeline_library === + using VULKAN_HPP_NAMESPACE::GraphicsPipelineLibraryCreateInfoEXT; + using VULKAN_HPP_NAMESPACE::PhysicalDeviceGraphicsPipelineLibraryFeaturesEXT; + using VULKAN_HPP_NAMESPACE::PhysicalDeviceGraphicsPipelineLibraryPropertiesEXT; + + //=== VK_AMD_shader_early_and_late_fragment_tests === + using VULKAN_HPP_NAMESPACE::PhysicalDeviceShaderEarlyAndLateFragmentTestsFeaturesAMD; + + //=== VK_KHR_fragment_shader_barycentric === + using VULKAN_HPP_NAMESPACE::PhysicalDeviceFragmentShaderBarycentricFeaturesKHR; + using VULKAN_HPP_NAMESPACE::PhysicalDeviceFragmentShaderBarycentricFeaturesNV; + using VULKAN_HPP_NAMESPACE::PhysicalDeviceFragmentShaderBarycentricPropertiesKHR; + + //=== VK_KHR_shader_subgroup_uniform_control_flow === + using VULKAN_HPP_NAMESPACE::PhysicalDeviceShaderSubgroupUniformControlFlowFeaturesKHR; + + //=== VK_NV_fragment_shading_rate_enums === + using VULKAN_HPP_NAMESPACE::PhysicalDeviceFragmentShadingRateEnumsFeaturesNV; + using VULKAN_HPP_NAMESPACE::PhysicalDeviceFragmentShadingRateEnumsPropertiesNV; + using VULKAN_HPP_NAMESPACE::PipelineFragmentShadingRateEnumStateCreateInfoNV; + + //=== VK_NV_ray_tracing_motion_blur === + using VULKAN_HPP_NAMESPACE::AccelerationStructureGeometryMotionTrianglesDataNV; + using VULKAN_HPP_NAMESPACE::AccelerationStructureMatrixMotionInstanceNV; + using VULKAN_HPP_NAMESPACE::AccelerationStructureMotionInfoNV; + using VULKAN_HPP_NAMESPACE::AccelerationStructureMotionInstanceDataNV; + using VULKAN_HPP_NAMESPACE::AccelerationStructureMotionInstanceNV; + using VULKAN_HPP_NAMESPACE::AccelerationStructureSRTMotionInstanceNV; + using VULKAN_HPP_NAMESPACE::PhysicalDeviceRayTracingMotionBlurFeaturesNV; + using VULKAN_HPP_NAMESPACE::SRTDataNV; + + //=== VK_EXT_mesh_shader === + using VULKAN_HPP_NAMESPACE::DrawMeshTasksIndirectCommandEXT; + using VULKAN_HPP_NAMESPACE::PhysicalDeviceMeshShaderFeaturesEXT; + using VULKAN_HPP_NAMESPACE::PhysicalDeviceMeshShaderPropertiesEXT; + + //=== VK_EXT_ycbcr_2plane_444_formats === + using VULKAN_HPP_NAMESPACE::PhysicalDeviceYcbcr2Plane444FormatsFeaturesEXT; + + //=== VK_EXT_fragment_density_map2 === + using VULKAN_HPP_NAMESPACE::PhysicalDeviceFragmentDensityMap2FeaturesEXT; + using VULKAN_HPP_NAMESPACE::PhysicalDeviceFragmentDensityMap2PropertiesEXT; + + //=== VK_QCOM_rotated_copy_commands === + using VULKAN_HPP_NAMESPACE::CopyCommandTransformInfoQCOM; + + //=== VK_KHR_workgroup_memory_explicit_layout === + using VULKAN_HPP_NAMESPACE::PhysicalDeviceWorkgroupMemoryExplicitLayoutFeaturesKHR; + + //=== VK_EXT_image_compression_control === + using VULKAN_HPP_NAMESPACE::ImageCompressionControlEXT; + using VULKAN_HPP_NAMESPACE::ImageCompressionPropertiesEXT; + using VULKAN_HPP_NAMESPACE::ImageSubresource2EXT; + using VULKAN_HPP_NAMESPACE::PhysicalDeviceImageCompressionControlFeaturesEXT; + using VULKAN_HPP_NAMESPACE::SubresourceLayout2EXT; + + //=== VK_EXT_attachment_feedback_loop_layout === + using VULKAN_HPP_NAMESPACE::PhysicalDeviceAttachmentFeedbackLoopLayoutFeaturesEXT; + + //=== VK_EXT_4444_formats === + using VULKAN_HPP_NAMESPACE::PhysicalDevice4444FormatsFeaturesEXT; + + //=== VK_EXT_device_fault === + using VULKAN_HPP_NAMESPACE::DeviceFaultAddressInfoEXT; + using VULKAN_HPP_NAMESPACE::DeviceFaultCountsEXT; + using VULKAN_HPP_NAMESPACE::DeviceFaultInfoEXT; + using VULKAN_HPP_NAMESPACE::DeviceFaultVendorBinaryHeaderVersionOneEXT; + using VULKAN_HPP_NAMESPACE::DeviceFaultVendorInfoEXT; + using VULKAN_HPP_NAMESPACE::PhysicalDeviceFaultFeaturesEXT; + + //=== VK_EXT_rgba10x6_formats === + using VULKAN_HPP_NAMESPACE::PhysicalDeviceRGBA10X6FormatsFeaturesEXT; + +#if defined( VK_USE_PLATFORM_DIRECTFB_EXT ) + //=== VK_EXT_directfb_surface === + using VULKAN_HPP_NAMESPACE::DirectFBSurfaceCreateInfoEXT; +#endif /*VK_USE_PLATFORM_DIRECTFB_EXT*/ + + //=== VK_EXT_vertex_input_dynamic_state === + using VULKAN_HPP_NAMESPACE::PhysicalDeviceVertexInputDynamicStateFeaturesEXT; + using VULKAN_HPP_NAMESPACE::VertexInputAttributeDescription2EXT; + using VULKAN_HPP_NAMESPACE::VertexInputBindingDescription2EXT; + + //=== VK_EXT_physical_device_drm === + using VULKAN_HPP_NAMESPACE::PhysicalDeviceDrmPropertiesEXT; + + //=== VK_EXT_device_address_binding_report === + using VULKAN_HPP_NAMESPACE::DeviceAddressBindingCallbackDataEXT; + using VULKAN_HPP_NAMESPACE::PhysicalDeviceAddressBindingReportFeaturesEXT; + + //=== VK_EXT_depth_clip_control === + using VULKAN_HPP_NAMESPACE::PhysicalDeviceDepthClipControlFeaturesEXT; + using VULKAN_HPP_NAMESPACE::PipelineViewportDepthClipControlCreateInfoEXT; + + //=== VK_EXT_primitive_topology_list_restart === + using VULKAN_HPP_NAMESPACE::PhysicalDevicePrimitiveTopologyListRestartFeaturesEXT; + +#if defined( VK_USE_PLATFORM_FUCHSIA ) + //=== VK_FUCHSIA_external_memory === + using VULKAN_HPP_NAMESPACE::ImportMemoryZirconHandleInfoFUCHSIA; + using VULKAN_HPP_NAMESPACE::MemoryGetZirconHandleInfoFUCHSIA; + using VULKAN_HPP_NAMESPACE::MemoryZirconHandlePropertiesFUCHSIA; +#endif /*VK_USE_PLATFORM_FUCHSIA*/ + +#if defined( VK_USE_PLATFORM_FUCHSIA ) + //=== VK_FUCHSIA_external_semaphore === + using VULKAN_HPP_NAMESPACE::ImportSemaphoreZirconHandleInfoFUCHSIA; + using VULKAN_HPP_NAMESPACE::SemaphoreGetZirconHandleInfoFUCHSIA; +#endif /*VK_USE_PLATFORM_FUCHSIA*/ + +#if defined( VK_USE_PLATFORM_FUCHSIA ) + //=== VK_FUCHSIA_buffer_collection === + using VULKAN_HPP_NAMESPACE::BufferCollectionBufferCreateInfoFUCHSIA; + using VULKAN_HPP_NAMESPACE::BufferCollectionConstraintsInfoFUCHSIA; + using VULKAN_HPP_NAMESPACE::BufferCollectionCreateInfoFUCHSIA; + using VULKAN_HPP_NAMESPACE::BufferCollectionImageCreateInfoFUCHSIA; + using VULKAN_HPP_NAMESPACE::BufferCollectionPropertiesFUCHSIA; + using VULKAN_HPP_NAMESPACE::BufferConstraintsInfoFUCHSIA; + using VULKAN_HPP_NAMESPACE::ImageConstraintsInfoFUCHSIA; + using VULKAN_HPP_NAMESPACE::ImageFormatConstraintsInfoFUCHSIA; + using VULKAN_HPP_NAMESPACE::ImportMemoryBufferCollectionFUCHSIA; + using VULKAN_HPP_NAMESPACE::SysmemColorSpaceFUCHSIA; +#endif /*VK_USE_PLATFORM_FUCHSIA*/ + + //=== VK_HUAWEI_subpass_shading === + using VULKAN_HPP_NAMESPACE::PhysicalDeviceSubpassShadingFeaturesHUAWEI; + using VULKAN_HPP_NAMESPACE::PhysicalDeviceSubpassShadingPropertiesHUAWEI; + using VULKAN_HPP_NAMESPACE::SubpassShadingPipelineCreateInfoHUAWEI; + + //=== VK_HUAWEI_invocation_mask === + using VULKAN_HPP_NAMESPACE::PhysicalDeviceInvocationMaskFeaturesHUAWEI; + + //=== VK_NV_external_memory_rdma === + using VULKAN_HPP_NAMESPACE::MemoryGetRemoteAddressInfoNV; + using VULKAN_HPP_NAMESPACE::PhysicalDeviceExternalMemoryRDMAFeaturesNV; + + //=== VK_EXT_pipeline_properties === + using VULKAN_HPP_NAMESPACE::PhysicalDevicePipelinePropertiesFeaturesEXT; + using VULKAN_HPP_NAMESPACE::PipelinePropertiesIdentifierEXT; + + //=== VK_EXT_multisampled_render_to_single_sampled === + using VULKAN_HPP_NAMESPACE::MultisampledRenderToSingleSampledInfoEXT; + using VULKAN_HPP_NAMESPACE::PhysicalDeviceMultisampledRenderToSingleSampledFeaturesEXT; + using VULKAN_HPP_NAMESPACE::SubpassResolvePerformanceQueryEXT; + + //=== VK_EXT_extended_dynamic_state2 === + using VULKAN_HPP_NAMESPACE::PhysicalDeviceExtendedDynamicState2FeaturesEXT; + +#if defined( VK_USE_PLATFORM_SCREEN_QNX ) + //=== VK_QNX_screen_surface === + using VULKAN_HPP_NAMESPACE::ScreenSurfaceCreateInfoQNX; +#endif /*VK_USE_PLATFORM_SCREEN_QNX*/ + + //=== VK_EXT_color_write_enable === + using VULKAN_HPP_NAMESPACE::PhysicalDeviceColorWriteEnableFeaturesEXT; + using VULKAN_HPP_NAMESPACE::PipelineColorWriteCreateInfoEXT; + + //=== VK_EXT_primitives_generated_query === + using VULKAN_HPP_NAMESPACE::PhysicalDevicePrimitivesGeneratedQueryFeaturesEXT; + + //=== VK_KHR_ray_tracing_maintenance1 === + using VULKAN_HPP_NAMESPACE::PhysicalDeviceRayTracingMaintenance1FeaturesKHR; + using VULKAN_HPP_NAMESPACE::TraceRaysIndirectCommand2KHR; + + //=== VK_EXT_image_view_min_lod === + using VULKAN_HPP_NAMESPACE::ImageViewMinLodCreateInfoEXT; + using VULKAN_HPP_NAMESPACE::PhysicalDeviceImageViewMinLodFeaturesEXT; + + //=== VK_EXT_multi_draw === + using VULKAN_HPP_NAMESPACE::MultiDrawIndexedInfoEXT; + using VULKAN_HPP_NAMESPACE::MultiDrawInfoEXT; + using VULKAN_HPP_NAMESPACE::PhysicalDeviceMultiDrawFeaturesEXT; + using VULKAN_HPP_NAMESPACE::PhysicalDeviceMultiDrawPropertiesEXT; + + //=== VK_EXT_image_2d_view_of_3d === + using VULKAN_HPP_NAMESPACE::PhysicalDeviceImage2DViewOf3DFeaturesEXT; + + //=== VK_EXT_shader_tile_image === + using VULKAN_HPP_NAMESPACE::PhysicalDeviceShaderTileImageFeaturesEXT; + using VULKAN_HPP_NAMESPACE::PhysicalDeviceShaderTileImagePropertiesEXT; + + //=== VK_EXT_opacity_micromap === + using VULKAN_HPP_NAMESPACE::AccelerationStructureTrianglesOpacityMicromapEXT; + using VULKAN_HPP_NAMESPACE::CopyMemoryToMicromapInfoEXT; + using VULKAN_HPP_NAMESPACE::CopyMicromapInfoEXT; + using VULKAN_HPP_NAMESPACE::CopyMicromapToMemoryInfoEXT; + using VULKAN_HPP_NAMESPACE::MicromapBuildInfoEXT; + using VULKAN_HPP_NAMESPACE::MicromapBuildSizesInfoEXT; + using VULKAN_HPP_NAMESPACE::MicromapCreateInfoEXT; + using VULKAN_HPP_NAMESPACE::MicromapTriangleEXT; + using VULKAN_HPP_NAMESPACE::MicromapUsageEXT; + using VULKAN_HPP_NAMESPACE::MicromapVersionInfoEXT; + using VULKAN_HPP_NAMESPACE::PhysicalDeviceOpacityMicromapFeaturesEXT; + using VULKAN_HPP_NAMESPACE::PhysicalDeviceOpacityMicromapPropertiesEXT; + +#if defined( VK_ENABLE_BETA_EXTENSIONS ) + //=== VK_NV_displacement_micromap === + using VULKAN_HPP_NAMESPACE::AccelerationStructureTrianglesDisplacementMicromapNV; + using VULKAN_HPP_NAMESPACE::PhysicalDeviceDisplacementMicromapFeaturesNV; + using VULKAN_HPP_NAMESPACE::PhysicalDeviceDisplacementMicromapPropertiesNV; +#endif /*VK_ENABLE_BETA_EXTENSIONS*/ + + //=== VK_HUAWEI_cluster_culling_shader === + using VULKAN_HPP_NAMESPACE::PhysicalDeviceClusterCullingShaderFeaturesHUAWEI; + using VULKAN_HPP_NAMESPACE::PhysicalDeviceClusterCullingShaderPropertiesHUAWEI; + + //=== VK_EXT_border_color_swizzle === + using VULKAN_HPP_NAMESPACE::PhysicalDeviceBorderColorSwizzleFeaturesEXT; + using VULKAN_HPP_NAMESPACE::SamplerBorderColorComponentMappingCreateInfoEXT; + + //=== VK_EXT_pageable_device_local_memory === + using VULKAN_HPP_NAMESPACE::PhysicalDevicePageableDeviceLocalMemoryFeaturesEXT; + + //=== VK_ARM_shader_core_properties === + using VULKAN_HPP_NAMESPACE::PhysicalDeviceShaderCorePropertiesARM; + + //=== VK_EXT_image_sliced_view_of_3d === + using VULKAN_HPP_NAMESPACE::ImageViewSlicedCreateInfoEXT; + using VULKAN_HPP_NAMESPACE::PhysicalDeviceImageSlicedViewOf3DFeaturesEXT; + + //=== VK_VALVE_descriptor_set_host_mapping === + using VULKAN_HPP_NAMESPACE::DescriptorSetBindingReferenceVALVE; + using VULKAN_HPP_NAMESPACE::DescriptorSetLayoutHostMappingInfoVALVE; + using VULKAN_HPP_NAMESPACE::PhysicalDeviceDescriptorSetHostMappingFeaturesVALVE; + + //=== VK_EXT_depth_clamp_zero_one === + using VULKAN_HPP_NAMESPACE::PhysicalDeviceDepthClampZeroOneFeaturesEXT; + + //=== VK_EXT_non_seamless_cube_map === + using VULKAN_HPP_NAMESPACE::PhysicalDeviceNonSeamlessCubeMapFeaturesEXT; + + //=== VK_QCOM_fragment_density_map_offset === + using VULKAN_HPP_NAMESPACE::PhysicalDeviceFragmentDensityMapOffsetFeaturesQCOM; + using VULKAN_HPP_NAMESPACE::PhysicalDeviceFragmentDensityMapOffsetPropertiesQCOM; + using VULKAN_HPP_NAMESPACE::SubpassFragmentDensityMapOffsetEndInfoQCOM; + + //=== VK_NV_copy_memory_indirect === + using VULKAN_HPP_NAMESPACE::CopyMemoryIndirectCommandNV; + using VULKAN_HPP_NAMESPACE::CopyMemoryToImageIndirectCommandNV; + using VULKAN_HPP_NAMESPACE::PhysicalDeviceCopyMemoryIndirectFeaturesNV; + using VULKAN_HPP_NAMESPACE::PhysicalDeviceCopyMemoryIndirectPropertiesNV; + + //=== VK_NV_memory_decompression === + using VULKAN_HPP_NAMESPACE::DecompressMemoryRegionNV; + using VULKAN_HPP_NAMESPACE::PhysicalDeviceMemoryDecompressionFeaturesNV; + using VULKAN_HPP_NAMESPACE::PhysicalDeviceMemoryDecompressionPropertiesNV; + + //=== VK_NV_linear_color_attachment === + using VULKAN_HPP_NAMESPACE::PhysicalDeviceLinearColorAttachmentFeaturesNV; + + //=== VK_EXT_image_compression_control_swapchain === + using VULKAN_HPP_NAMESPACE::PhysicalDeviceImageCompressionControlSwapchainFeaturesEXT; + + //=== VK_QCOM_image_processing === + using VULKAN_HPP_NAMESPACE::ImageViewSampleWeightCreateInfoQCOM; + using VULKAN_HPP_NAMESPACE::PhysicalDeviceImageProcessingFeaturesQCOM; + using VULKAN_HPP_NAMESPACE::PhysicalDeviceImageProcessingPropertiesQCOM; + + //=== VK_EXT_external_memory_acquire_unmodified === + using VULKAN_HPP_NAMESPACE::ExternalMemoryAcquireUnmodifiedEXT; + + //=== VK_EXT_extended_dynamic_state3 === + using VULKAN_HPP_NAMESPACE::ColorBlendAdvancedEXT; + using VULKAN_HPP_NAMESPACE::ColorBlendEquationEXT; + using VULKAN_HPP_NAMESPACE::PhysicalDeviceExtendedDynamicState3FeaturesEXT; + using VULKAN_HPP_NAMESPACE::PhysicalDeviceExtendedDynamicState3PropertiesEXT; + + //=== VK_EXT_subpass_merge_feedback === + using VULKAN_HPP_NAMESPACE::PhysicalDeviceSubpassMergeFeedbackFeaturesEXT; + using VULKAN_HPP_NAMESPACE::RenderPassCreationControlEXT; + using VULKAN_HPP_NAMESPACE::RenderPassCreationFeedbackCreateInfoEXT; + using VULKAN_HPP_NAMESPACE::RenderPassCreationFeedbackInfoEXT; + using VULKAN_HPP_NAMESPACE::RenderPassSubpassFeedbackCreateInfoEXT; + using VULKAN_HPP_NAMESPACE::RenderPassSubpassFeedbackInfoEXT; + + //=== VK_LUNARG_direct_driver_loading === + using VULKAN_HPP_NAMESPACE::DirectDriverLoadingInfoLUNARG; + using VULKAN_HPP_NAMESPACE::DirectDriverLoadingListLUNARG; + + //=== VK_EXT_shader_module_identifier === + using VULKAN_HPP_NAMESPACE::PhysicalDeviceShaderModuleIdentifierFeaturesEXT; + using VULKAN_HPP_NAMESPACE::PhysicalDeviceShaderModuleIdentifierPropertiesEXT; + using VULKAN_HPP_NAMESPACE::PipelineShaderStageModuleIdentifierCreateInfoEXT; + using VULKAN_HPP_NAMESPACE::ShaderModuleIdentifierEXT; + + //=== VK_EXT_rasterization_order_attachment_access === + using VULKAN_HPP_NAMESPACE::PhysicalDeviceRasterizationOrderAttachmentAccessFeaturesARM; + using VULKAN_HPP_NAMESPACE::PhysicalDeviceRasterizationOrderAttachmentAccessFeaturesEXT; + + //=== VK_NV_optical_flow === + using VULKAN_HPP_NAMESPACE::OpticalFlowExecuteInfoNV; + using VULKAN_HPP_NAMESPACE::OpticalFlowImageFormatInfoNV; + using VULKAN_HPP_NAMESPACE::OpticalFlowImageFormatPropertiesNV; + using VULKAN_HPP_NAMESPACE::OpticalFlowSessionCreateInfoNV; + using VULKAN_HPP_NAMESPACE::OpticalFlowSessionCreatePrivateDataInfoNV; + using VULKAN_HPP_NAMESPACE::PhysicalDeviceOpticalFlowFeaturesNV; + using VULKAN_HPP_NAMESPACE::PhysicalDeviceOpticalFlowPropertiesNV; + + //=== VK_EXT_legacy_dithering === + using VULKAN_HPP_NAMESPACE::PhysicalDeviceLegacyDitheringFeaturesEXT; + + //=== VK_EXT_pipeline_protected_access === + using VULKAN_HPP_NAMESPACE::PhysicalDevicePipelineProtectedAccessFeaturesEXT; + + //=== VK_KHR_ray_tracing_position_fetch === + using VULKAN_HPP_NAMESPACE::PhysicalDeviceRayTracingPositionFetchFeaturesKHR; + + //=== VK_EXT_shader_object === + using VULKAN_HPP_NAMESPACE::PhysicalDeviceShaderObjectFeaturesEXT; + using VULKAN_HPP_NAMESPACE::PhysicalDeviceShaderObjectPropertiesEXT; + using VULKAN_HPP_NAMESPACE::ShaderCreateInfoEXT; + + //=== VK_QCOM_tile_properties === + using VULKAN_HPP_NAMESPACE::PhysicalDeviceTilePropertiesFeaturesQCOM; + using VULKAN_HPP_NAMESPACE::TilePropertiesQCOM; + + //=== VK_SEC_amigo_profiling === + using VULKAN_HPP_NAMESPACE::AmigoProfilingSubmitInfoSEC; + using VULKAN_HPP_NAMESPACE::PhysicalDeviceAmigoProfilingFeaturesSEC; + + //=== VK_QCOM_multiview_per_view_viewports === + using VULKAN_HPP_NAMESPACE::PhysicalDeviceMultiviewPerViewViewportsFeaturesQCOM; + + //=== VK_NV_ray_tracing_invocation_reorder === + using VULKAN_HPP_NAMESPACE::PhysicalDeviceRayTracingInvocationReorderFeaturesNV; + using VULKAN_HPP_NAMESPACE::PhysicalDeviceRayTracingInvocationReorderPropertiesNV; + + //=== VK_EXT_mutable_descriptor_type === + using VULKAN_HPP_NAMESPACE::MutableDescriptorTypeCreateInfoEXT; + using VULKAN_HPP_NAMESPACE::MutableDescriptorTypeCreateInfoVALVE; + using VULKAN_HPP_NAMESPACE::MutableDescriptorTypeListEXT; + using VULKAN_HPP_NAMESPACE::MutableDescriptorTypeListVALVE; + using VULKAN_HPP_NAMESPACE::PhysicalDeviceMutableDescriptorTypeFeaturesEXT; + using VULKAN_HPP_NAMESPACE::PhysicalDeviceMutableDescriptorTypeFeaturesVALVE; + + //=== VK_ARM_shader_core_builtins === + using VULKAN_HPP_NAMESPACE::PhysicalDeviceShaderCoreBuiltinsFeaturesARM; + using VULKAN_HPP_NAMESPACE::PhysicalDeviceShaderCoreBuiltinsPropertiesARM; + + //=== VK_EXT_pipeline_library_group_handles === + using VULKAN_HPP_NAMESPACE::PhysicalDevicePipelineLibraryGroupHandlesFeaturesEXT; + + //=== VK_EXT_dynamic_rendering_unused_attachments === + using VULKAN_HPP_NAMESPACE::PhysicalDeviceDynamicRenderingUnusedAttachmentsFeaturesEXT; + + //=== VK_KHR_cooperative_matrix === + using VULKAN_HPP_NAMESPACE::CooperativeMatrixPropertiesKHR; + using VULKAN_HPP_NAMESPACE::PhysicalDeviceCooperativeMatrixFeaturesKHR; + using VULKAN_HPP_NAMESPACE::PhysicalDeviceCooperativeMatrixPropertiesKHR; + + //=== VK_QCOM_multiview_per_view_render_areas === + using VULKAN_HPP_NAMESPACE::MultiviewPerViewRenderAreasRenderPassBeginInfoQCOM; + using VULKAN_HPP_NAMESPACE::PhysicalDeviceMultiviewPerViewRenderAreasFeaturesQCOM; + + //=== VK_EXT_attachment_feedback_loop_dynamic_state === + using VULKAN_HPP_NAMESPACE::PhysicalDeviceAttachmentFeedbackLoopDynamicStateFeaturesEXT; + +#if defined( VK_USE_PLATFORM_SCREEN_QNX ) + //=== VK_QNX_external_memory_screen_buffer === + using VULKAN_HPP_NAMESPACE::ExternalFormatQNX; + using VULKAN_HPP_NAMESPACE::ImportScreenBufferInfoQNX; + using VULKAN_HPP_NAMESPACE::PhysicalDeviceExternalMemoryScreenBufferFeaturesQNX; + using VULKAN_HPP_NAMESPACE::ScreenBufferFormatPropertiesQNX; + using VULKAN_HPP_NAMESPACE::ScreenBufferPropertiesQNX; +#endif /*VK_USE_PLATFORM_SCREEN_QNX*/ + + //=============== + //=== HANDLEs === + //=============== + + using VULKAN_HPP_NAMESPACE::isVulkanHandleType; + + //=== VK_VERSION_1_0 === + using VULKAN_HPP_NAMESPACE::Buffer; + using VULKAN_HPP_NAMESPACE::BufferView; + using VULKAN_HPP_NAMESPACE::CommandBuffer; + using VULKAN_HPP_NAMESPACE::CommandPool; + using VULKAN_HPP_NAMESPACE::DescriptorPool; + using VULKAN_HPP_NAMESPACE::DescriptorSet; + using VULKAN_HPP_NAMESPACE::DescriptorSetLayout; + using VULKAN_HPP_NAMESPACE::Device; + using VULKAN_HPP_NAMESPACE::DeviceMemory; + using VULKAN_HPP_NAMESPACE::Event; + using VULKAN_HPP_NAMESPACE::Fence; + using VULKAN_HPP_NAMESPACE::Framebuffer; + using VULKAN_HPP_NAMESPACE::Image; + using VULKAN_HPP_NAMESPACE::ImageView; + using VULKAN_HPP_NAMESPACE::Instance; + using VULKAN_HPP_NAMESPACE::PhysicalDevice; + using VULKAN_HPP_NAMESPACE::Pipeline; + using VULKAN_HPP_NAMESPACE::PipelineCache; + using VULKAN_HPP_NAMESPACE::PipelineLayout; + using VULKAN_HPP_NAMESPACE::QueryPool; + using VULKAN_HPP_NAMESPACE::Queue; + using VULKAN_HPP_NAMESPACE::RenderPass; + using VULKAN_HPP_NAMESPACE::Sampler; + using VULKAN_HPP_NAMESPACE::Semaphore; + using VULKAN_HPP_NAMESPACE::ShaderModule; + + //=== VK_VERSION_1_1 === + using VULKAN_HPP_NAMESPACE::DescriptorUpdateTemplate; + using VULKAN_HPP_NAMESPACE::SamplerYcbcrConversion; + + //=== VK_VERSION_1_3 === + using VULKAN_HPP_NAMESPACE::PrivateDataSlot; + + //=== VK_KHR_surface === + using VULKAN_HPP_NAMESPACE::SurfaceKHR; + + //=== VK_KHR_swapchain === + using VULKAN_HPP_NAMESPACE::SwapchainKHR; + + //=== VK_KHR_display === + using VULKAN_HPP_NAMESPACE::DisplayKHR; + using VULKAN_HPP_NAMESPACE::DisplayModeKHR; + + //=== VK_EXT_debug_report === + using VULKAN_HPP_NAMESPACE::DebugReportCallbackEXT; + + //=== VK_KHR_video_queue === + using VULKAN_HPP_NAMESPACE::VideoSessionKHR; + using VULKAN_HPP_NAMESPACE::VideoSessionParametersKHR; + + //=== VK_NVX_binary_import === + using VULKAN_HPP_NAMESPACE::CuFunctionNVX; + using VULKAN_HPP_NAMESPACE::CuModuleNVX; + + //=== VK_EXT_debug_utils === + using VULKAN_HPP_NAMESPACE::DebugUtilsMessengerEXT; + + //=== VK_KHR_acceleration_structure === + using VULKAN_HPP_NAMESPACE::AccelerationStructureKHR; + + //=== VK_EXT_validation_cache === + using VULKAN_HPP_NAMESPACE::ValidationCacheEXT; + + //=== VK_NV_ray_tracing === + using VULKAN_HPP_NAMESPACE::AccelerationStructureNV; + + //=== VK_INTEL_performance_query === + using VULKAN_HPP_NAMESPACE::PerformanceConfigurationINTEL; + + //=== VK_KHR_deferred_host_operations === + using VULKAN_HPP_NAMESPACE::DeferredOperationKHR; + + //=== VK_NV_device_generated_commands === + using VULKAN_HPP_NAMESPACE::IndirectCommandsLayoutNV; + +#if defined( VK_USE_PLATFORM_FUCHSIA ) + //=== VK_FUCHSIA_buffer_collection === + using VULKAN_HPP_NAMESPACE::BufferCollectionFUCHSIA; +#endif /*VK_USE_PLATFORM_FUCHSIA*/ + + //=== VK_EXT_opacity_micromap === + using VULKAN_HPP_NAMESPACE::MicromapEXT; + + //=== VK_NV_optical_flow === + using VULKAN_HPP_NAMESPACE::OpticalFlowSessionNV; + + //=== VK_EXT_shader_object === + using VULKAN_HPP_NAMESPACE::ShaderEXT; + + //====================== + //=== UNIQUE HANDLEs === + //====================== + +#if !defined( VULKAN_HPP_NO_SMART_HANDLE ) + + //=== VK_VERSION_1_0 === + using VULKAN_HPP_NAMESPACE::UniqueBuffer; + using VULKAN_HPP_NAMESPACE::UniqueBufferView; + using VULKAN_HPP_NAMESPACE::UniqueCommandBuffer; + using VULKAN_HPP_NAMESPACE::UniqueCommandPool; + using VULKAN_HPP_NAMESPACE::UniqueDescriptorPool; + using VULKAN_HPP_NAMESPACE::UniqueDescriptorSet; + using VULKAN_HPP_NAMESPACE::UniqueDescriptorSetLayout; + using VULKAN_HPP_NAMESPACE::UniqueDevice; + using VULKAN_HPP_NAMESPACE::UniqueDeviceMemory; + using VULKAN_HPP_NAMESPACE::UniqueEvent; + using VULKAN_HPP_NAMESPACE::UniqueFence; + using VULKAN_HPP_NAMESPACE::UniqueFramebuffer; + using VULKAN_HPP_NAMESPACE::UniqueImage; + using VULKAN_HPP_NAMESPACE::UniqueImageView; + using VULKAN_HPP_NAMESPACE::UniqueInstance; + using VULKAN_HPP_NAMESPACE::UniquePipeline; + using VULKAN_HPP_NAMESPACE::UniquePipelineCache; + using VULKAN_HPP_NAMESPACE::UniquePipelineLayout; + using VULKAN_HPP_NAMESPACE::UniqueQueryPool; + using VULKAN_HPP_NAMESPACE::UniqueRenderPass; + using VULKAN_HPP_NAMESPACE::UniqueSampler; + using VULKAN_HPP_NAMESPACE::UniqueSemaphore; + using VULKAN_HPP_NAMESPACE::UniqueShaderModule; + + //=== VK_VERSION_1_1 === + using VULKAN_HPP_NAMESPACE::UniqueDescriptorUpdateTemplate; + using VULKAN_HPP_NAMESPACE::UniqueSamplerYcbcrConversion; + + //=== VK_VERSION_1_3 === + using VULKAN_HPP_NAMESPACE::UniquePrivateDataSlot; + + //=== VK_KHR_surface === + using VULKAN_HPP_NAMESPACE::UniqueSurfaceKHR; + + //=== VK_KHR_swapchain === + using VULKAN_HPP_NAMESPACE::UniqueSwapchainKHR; + + //=== VK_EXT_debug_report === + using VULKAN_HPP_NAMESPACE::UniqueDebugReportCallbackEXT; + + //=== VK_KHR_video_queue === + using VULKAN_HPP_NAMESPACE::UniqueVideoSessionKHR; + using VULKAN_HPP_NAMESPACE::UniqueVideoSessionParametersKHR; + + //=== VK_NVX_binary_import === + using VULKAN_HPP_NAMESPACE::UniqueCuFunctionNVX; + using VULKAN_HPP_NAMESPACE::UniqueCuModuleNVX; + + //=== VK_EXT_debug_utils === + using VULKAN_HPP_NAMESPACE::UniqueDebugUtilsMessengerEXT; + + //=== VK_KHR_acceleration_structure === + using VULKAN_HPP_NAMESPACE::UniqueAccelerationStructureKHR; + + //=== VK_EXT_validation_cache === + using VULKAN_HPP_NAMESPACE::UniqueValidationCacheEXT; + + //=== VK_NV_ray_tracing === + using VULKAN_HPP_NAMESPACE::UniqueAccelerationStructureNV; + + //=== VK_KHR_deferred_host_operations === + using VULKAN_HPP_NAMESPACE::UniqueDeferredOperationKHR; + + //=== VK_NV_device_generated_commands === + using VULKAN_HPP_NAMESPACE::UniqueIndirectCommandsLayoutNV; + +# if defined( VK_USE_PLATFORM_FUCHSIA ) + //=== VK_FUCHSIA_buffer_collection === + using VULKAN_HPP_NAMESPACE::UniqueBufferCollectionFUCHSIA; +# endif /*VK_USE_PLATFORM_FUCHSIA*/ + + //=== VK_EXT_opacity_micromap === + using VULKAN_HPP_NAMESPACE::UniqueMicromapEXT; + + //=== VK_NV_optical_flow === + using VULKAN_HPP_NAMESPACE::UniqueOpticalFlowSessionNV; + + //=== VK_EXT_shader_object === + using VULKAN_HPP_NAMESPACE::UniqueHandleTraits; + using VULKAN_HPP_NAMESPACE::UniqueShaderEXT; +#endif /*VULKAN_HPP_NO_SMART_HANDLE*/ + + //=========================== + //=== COMMAND Definitions === + //=========================== + using VULKAN_HPP_NAMESPACE::createInstance; + using VULKAN_HPP_NAMESPACE::enumerateInstanceExtensionProperties; + using VULKAN_HPP_NAMESPACE::enumerateInstanceLayerProperties; + using VULKAN_HPP_NAMESPACE::enumerateInstanceVersion; + +#if !defined( VULKAN_HPP_NO_SMART_HANDLE ) + using VULKAN_HPP_NAMESPACE::createInstanceUnique; +#endif /*VULKAN_HPP_NO_SMART_HANDLE*/ + +#if !defined( VULKAN_HPP_DISABLE_ENHANCED_MODE ) + using VULKAN_HPP_NAMESPACE::StructExtends; +#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ + +#if defined( VULKAN_HPP_DYNAMIC_LOADER_TOOL ) + using VULKAN_HPP_NAMESPACE::DynamicLoader; +#endif /*VULKAN_HPP_DYNAMIC_LOADER_TOOL*/ + + using VULKAN_HPP_NAMESPACE::DispatchLoaderDynamic; + + //===================== + //=== Format Traits === + //===================== + using VULKAN_HPP_NAMESPACE::blockExtent; + using VULKAN_HPP_NAMESPACE::blockSize; + using VULKAN_HPP_NAMESPACE::compatibilityClass; + using VULKAN_HPP_NAMESPACE::componentBits; + using VULKAN_HPP_NAMESPACE::componentCount; + using VULKAN_HPP_NAMESPACE::componentName; + using VULKAN_HPP_NAMESPACE::componentNumericFormat; + using VULKAN_HPP_NAMESPACE::componentPlaneIndex; + using VULKAN_HPP_NAMESPACE::componentsAreCompressed; + using VULKAN_HPP_NAMESPACE::compressionScheme; + using VULKAN_HPP_NAMESPACE::isCompressed; + using VULKAN_HPP_NAMESPACE::packed; + using VULKAN_HPP_NAMESPACE::planeCompatibleFormat; + using VULKAN_HPP_NAMESPACE::planeCount; + using VULKAN_HPP_NAMESPACE::planeHeightDivisor; + using VULKAN_HPP_NAMESPACE::planeWidthDivisor; + using VULKAN_HPP_NAMESPACE::texelsPerBlock; + + //====================================== + //=== Extension inspection functions === + //====================================== + using VULKAN_HPP_NAMESPACE::getDeprecatedExtensions; + using VULKAN_HPP_NAMESPACE::getDeviceExtensions; + using VULKAN_HPP_NAMESPACE::getExtensionDepends; + using VULKAN_HPP_NAMESPACE::getExtensionDeprecatedBy; + using VULKAN_HPP_NAMESPACE::getExtensionObsoletedBy; + using VULKAN_HPP_NAMESPACE::getExtensionPromotedTo; + using VULKAN_HPP_NAMESPACE::getInstanceExtensions; + using VULKAN_HPP_NAMESPACE::getObsoletedExtensions; + using VULKAN_HPP_NAMESPACE::getPromotedExtensions; + using VULKAN_HPP_NAMESPACE::isDeprecatedExtension; + using VULKAN_HPP_NAMESPACE::isDeviceExtension; + using VULKAN_HPP_NAMESPACE::isInstanceExtension; + using VULKAN_HPP_NAMESPACE::isObsoletedExtension; + using VULKAN_HPP_NAMESPACE::isPromotedExtension; + + export namespace VULKAN_HPP_RAII_NAMESPACE + { + //====================== + //=== RAII HARDCODED === + //====================== + + using VULKAN_HPP_RAII_NAMESPACE::Context; + using VULKAN_HPP_RAII_NAMESPACE::ContextDispatcher; + using VULKAN_HPP_RAII_NAMESPACE::DeviceDispatcher; + using VULKAN_HPP_RAII_NAMESPACE::exchange; + using VULKAN_HPP_RAII_NAMESPACE::InstanceDispatcher; + + //==================== + //=== RAII HANDLEs === + //==================== + + //=== VK_VERSION_1_0 === + using VULKAN_HPP_RAII_NAMESPACE::Buffer; + using VULKAN_HPP_RAII_NAMESPACE::BufferView; + using VULKAN_HPP_RAII_NAMESPACE::CommandBuffer; + using VULKAN_HPP_RAII_NAMESPACE::CommandBuffers; + using VULKAN_HPP_RAII_NAMESPACE::CommandPool; + using VULKAN_HPP_RAII_NAMESPACE::DescriptorPool; + using VULKAN_HPP_RAII_NAMESPACE::DescriptorSet; + using VULKAN_HPP_RAII_NAMESPACE::DescriptorSetLayout; + using VULKAN_HPP_RAII_NAMESPACE::DescriptorSets; + using VULKAN_HPP_RAII_NAMESPACE::Device; + using VULKAN_HPP_RAII_NAMESPACE::DeviceMemory; + using VULKAN_HPP_RAII_NAMESPACE::Event; + using VULKAN_HPP_RAII_NAMESPACE::Fence; + using VULKAN_HPP_RAII_NAMESPACE::Framebuffer; + using VULKAN_HPP_RAII_NAMESPACE::Image; + using VULKAN_HPP_RAII_NAMESPACE::ImageView; + using VULKAN_HPP_RAII_NAMESPACE::Instance; + using VULKAN_HPP_RAII_NAMESPACE::PhysicalDevice; + using VULKAN_HPP_RAII_NAMESPACE::PhysicalDevices; + using VULKAN_HPP_RAII_NAMESPACE::Pipeline; + using VULKAN_HPP_RAII_NAMESPACE::PipelineCache; + using VULKAN_HPP_RAII_NAMESPACE::PipelineLayout; + using VULKAN_HPP_RAII_NAMESPACE::Pipelines; + using VULKAN_HPP_RAII_NAMESPACE::QueryPool; + using VULKAN_HPP_RAII_NAMESPACE::Queue; + using VULKAN_HPP_RAII_NAMESPACE::RenderPass; + using VULKAN_HPP_RAII_NAMESPACE::Sampler; + using VULKAN_HPP_RAII_NAMESPACE::Semaphore; + using VULKAN_HPP_RAII_NAMESPACE::ShaderModule; + + //=== VK_VERSION_1_1 === + using VULKAN_HPP_RAII_NAMESPACE::DescriptorUpdateTemplate; + using VULKAN_HPP_RAII_NAMESPACE::SamplerYcbcrConversion; + + //=== VK_VERSION_1_3 === + using VULKAN_HPP_RAII_NAMESPACE::PrivateDataSlot; + + //=== VK_KHR_surface === + using VULKAN_HPP_RAII_NAMESPACE::SurfaceKHR; + + //=== VK_KHR_swapchain === + using VULKAN_HPP_RAII_NAMESPACE::SwapchainKHR; + using VULKAN_HPP_RAII_NAMESPACE::SwapchainKHRs; + + //=== VK_KHR_display === + using VULKAN_HPP_RAII_NAMESPACE::DisplayKHR; + using VULKAN_HPP_RAII_NAMESPACE::DisplayKHRs; + using VULKAN_HPP_RAII_NAMESPACE::DisplayModeKHR; + + //=== VK_EXT_debug_report === + using VULKAN_HPP_RAII_NAMESPACE::DebugReportCallbackEXT; + + //=== VK_KHR_video_queue === + using VULKAN_HPP_RAII_NAMESPACE::VideoSessionKHR; + using VULKAN_HPP_RAII_NAMESPACE::VideoSessionParametersKHR; + + //=== VK_NVX_binary_import === + using VULKAN_HPP_RAII_NAMESPACE::CuFunctionNVX; + using VULKAN_HPP_RAII_NAMESPACE::CuModuleNVX; + + //=== VK_EXT_debug_utils === + using VULKAN_HPP_RAII_NAMESPACE::DebugUtilsMessengerEXT; + + //=== VK_KHR_acceleration_structure === + using VULKAN_HPP_RAII_NAMESPACE::AccelerationStructureKHR; + + //=== VK_EXT_validation_cache === + using VULKAN_HPP_RAII_NAMESPACE::ValidationCacheEXT; + + //=== VK_NV_ray_tracing === + using VULKAN_HPP_RAII_NAMESPACE::AccelerationStructureNV; + + //=== VK_INTEL_performance_query === + using VULKAN_HPP_RAII_NAMESPACE::PerformanceConfigurationINTEL; + + //=== VK_KHR_deferred_host_operations === + using VULKAN_HPP_RAII_NAMESPACE::DeferredOperationKHR; + + //=== VK_NV_device_generated_commands === + using VULKAN_HPP_RAII_NAMESPACE::IndirectCommandsLayoutNV; + +#if defined( VK_USE_PLATFORM_FUCHSIA ) + //=== VK_FUCHSIA_buffer_collection === + using VULKAN_HPP_RAII_NAMESPACE::BufferCollectionFUCHSIA; +#endif /*VK_USE_PLATFORM_FUCHSIA*/ + + //=== VK_EXT_opacity_micromap === + using VULKAN_HPP_RAII_NAMESPACE::MicromapEXT; + + //=== VK_NV_optical_flow === + using VULKAN_HPP_RAII_NAMESPACE::OpticalFlowSessionNV; + + //=== VK_EXT_shader_object === + using VULKAN_HPP_RAII_NAMESPACE::ShaderEXT; + using VULKAN_HPP_RAII_NAMESPACE::ShaderEXTs; + + } // namespace VULKAN_HPP_RAII_NAMESPACE +} // namespace VULKAN_HPP_NAMESPACE diff --git a/vulkan/vulkan.hpp b/vulkan/vulkan.hpp index 82adb52..482c34e 100644 --- a/vulkan/vulkan.hpp +++ b/vulkan/vulkan.hpp @@ -6027,7 +6027,7 @@ namespace VULKAN_HPP_NAMESPACE } extern VULKAN_HPP_STORAGE_API DispatchLoaderDynamic defaultDispatchLoaderDynamic; # else - static inline ::VULKAN_HPP_NAMESPACE::DispatchLoaderStatic & getDispatchLoaderStatic() + inline ::VULKAN_HPP_NAMESPACE::DispatchLoaderStatic & getDispatchLoaderStatic() { static ::VULKAN_HPP_NAMESPACE::DispatchLoaderStatic dls; return dls; @@ -6688,9 +6688,9 @@ namespace VULKAN_HPP_NAMESPACE IncompatibleShaderBinaryEXTError( char const * message ) : SystemError( make_error_code( Result::eErrorIncompatibleShaderBinaryEXT ), message ) {} }; - namespace + namespace detail { - [[noreturn]] void throwResultException( Result result, char const * message ) + [[noreturn]] VULKAN_HPP_INLINE void throwResultException( Result result, char const * message ) { switch ( result ) { @@ -6736,7 +6736,7 @@ namespace VULKAN_HPP_NAMESPACE default: throw SystemError( make_error_code( result ), message ); } } - } // namespace + } // namespace detail #endif template @@ -6896,7 +6896,7 @@ namespace VULKAN_HPP_NAMESPACE #else if ( result != Result::eSuccess ) { - throwResultException( result, message ); + detail::throwResultException( result, message ); } #endif } @@ -6911,10 +6911,106 @@ namespace VULKAN_HPP_NAMESPACE #else if ( std::find( successCodes.begin(), successCodes.end(), result ) == successCodes.end() ) { - throwResultException( result, message ); + detail::throwResultException( result, message ); } #endif } + + //========================================= + //=== CONSTEXPR CONSTANTs AND FUNCTIONs === + //========================================= + VULKAN_HPP_CONSTEXPR uint32_t AttachmentUnused = VK_ATTACHMENT_UNUSED; + VULKAN_HPP_CONSTEXPR uint32_t False = VK_FALSE; + VULKAN_HPP_CONSTEXPR float LodClampNone = VK_LOD_CLAMP_NONE; + VULKAN_HPP_CONSTEXPR uint32_t LuidSize = VK_LUID_SIZE; + VULKAN_HPP_CONSTEXPR uint32_t MaxDescriptionSize = VK_MAX_DESCRIPTION_SIZE; + VULKAN_HPP_CONSTEXPR uint32_t MaxDeviceGroupSize = VK_MAX_DEVICE_GROUP_SIZE; + VULKAN_HPP_CONSTEXPR uint32_t MaxDriverInfoSize = VK_MAX_DRIVER_INFO_SIZE; + VULKAN_HPP_CONSTEXPR uint32_t MaxDriverNameSize = VK_MAX_DRIVER_NAME_SIZE; + VULKAN_HPP_CONSTEXPR uint32_t MaxExtensionNameSize = VK_MAX_EXTENSION_NAME_SIZE; + VULKAN_HPP_CONSTEXPR uint32_t MaxGlobalPrioritySizeKhr = VK_MAX_GLOBAL_PRIORITY_SIZE_KHR; + VULKAN_HPP_CONSTEXPR uint32_t MaxMemoryHeaps = VK_MAX_MEMORY_HEAPS; + VULKAN_HPP_CONSTEXPR uint32_t MaxMemoryTypes = VK_MAX_MEMORY_TYPES; + VULKAN_HPP_CONSTEXPR uint32_t MaxPhysicalDeviceNameSize = VK_MAX_PHYSICAL_DEVICE_NAME_SIZE; + VULKAN_HPP_CONSTEXPR uint32_t MaxShaderModuleIdentifierSizeExt = VK_MAX_SHADER_MODULE_IDENTIFIER_SIZE_EXT; + VULKAN_HPP_CONSTEXPR uint32_t QueueFamilyExternal = VK_QUEUE_FAMILY_EXTERNAL; + VULKAN_HPP_CONSTEXPR uint32_t QueueFamilyForeignExt = VK_QUEUE_FAMILY_FOREIGN_EXT; + VULKAN_HPP_CONSTEXPR uint32_t QueueFamilyIgnored = VK_QUEUE_FAMILY_IGNORED; + VULKAN_HPP_CONSTEXPR uint32_t Remaining3DSlicesExt = VK_REMAINING_3D_SLICES_EXT; + VULKAN_HPP_CONSTEXPR uint32_t RemainingArrayLayers = VK_REMAINING_ARRAY_LAYERS; + VULKAN_HPP_CONSTEXPR uint32_t RemainingMipLevels = VK_REMAINING_MIP_LEVELS; + VULKAN_HPP_CONSTEXPR uint32_t ShaderUnusedKhr = VK_SHADER_UNUSED_KHR; + VULKAN_HPP_CONSTEXPR uint32_t SubpassExternal = VK_SUBPASS_EXTERNAL; + VULKAN_HPP_CONSTEXPR uint32_t True = VK_TRUE; + VULKAN_HPP_CONSTEXPR uint32_t UuidSize = VK_UUID_SIZE; + VULKAN_HPP_CONSTEXPR uint64_t WholeSize = VK_WHOLE_SIZE; + VULKAN_HPP_CONSTEXPR uint32_t HeaderVersion = VK_HEADER_VERSION; + + template ::value>::type> + VULKAN_HPP_CONSTEXPR uint32_t apiVersionMajor( T const version ) + { + return ( ( (uint32_t)( version ) >> 22U ) & 0x7FU ); + } + + template ::value>::type> + VULKAN_HPP_CONSTEXPR uint32_t apiVersionMinor( T const version ) + { + return ( ( (uint32_t)( version ) >> 12U ) & 0x3FFU ); + } + + template ::value>::type> + VULKAN_HPP_CONSTEXPR uint32_t apiVersionPatch( T const version ) + { + return ( (uint32_t)(version)&0xFFFU ); + } + + template ::value>::type> + VULKAN_HPP_CONSTEXPR uint32_t apiVersionVariant( T const version ) + { + return ( (uint32_t)( version ) >> 29U ); + } + + template ::value>::type> + VULKAN_HPP_CONSTEXPR uint32_t makeApiVersion( T const variant, T const major, T const minor, T const patch ) + { + return ( ( ( (uint32_t)( variant ) ) << 29U ) | ( ( (uint32_t)( major ) ) << 22U ) | ( ( (uint32_t)( minor ) ) << 12U ) | ( (uint32_t)( patch ) ) ); + } + + template ::value>::type> + VULKAN_HPP_DEPRECATED( "This define is deprecated. VK_MAKE_API_VERSION should be used instead." ) + VULKAN_HPP_CONSTEXPR uint32_t makeVersion( T const major, T const minor, T const patch ) + { + return ( ( ( (uint32_t)( major ) ) << 22U ) | ( ( (uint32_t)( minor ) ) << 12U ) | ( (uint32_t)( patch ) ) ); + } + + template ::value>::type> + VULKAN_HPP_DEPRECATED( "This define is deprecated. VK_API_VERSION_MAJOR should be used instead." ) + VULKAN_HPP_CONSTEXPR uint32_t versionMajor( T const version ) + { + return ( (uint32_t)( version ) >> 22U ); + } + + template ::value>::type> + VULKAN_HPP_DEPRECATED( "This define is deprecated. VK_API_VERSION_MINOR should be used instead." ) + VULKAN_HPP_CONSTEXPR uint32_t versionMinor( T const version ) + { + return ( ( (uint32_t)( version ) >> 12U ) & 0x3FFU ); + } + + template ::value>::type> + VULKAN_HPP_DEPRECATED( "This define is deprecated. VK_API_VERSION_PATCH should be used instead." ) + VULKAN_HPP_CONSTEXPR uint32_t versionPatch( T const version ) + { + return ( (uint32_t)(version)&0xFFFU ); + } + + VULKAN_HPP_CONSTEXPR auto ApiVersion = makeApiVersion( 0, 1, 0, 0 ); + VULKAN_HPP_CONSTEXPR auto ApiVersion10 = makeApiVersion( 0, 1, 0, 0 ); + VULKAN_HPP_CONSTEXPR auto ApiVersion11 = makeApiVersion( 0, 1, 1, 0 ); + VULKAN_HPP_CONSTEXPR auto ApiVersion12 = makeApiVersion( 0, 1, 2, 0 ); + VULKAN_HPP_CONSTEXPR auto ApiVersion13 = makeApiVersion( 0, 1, 3, 0 ); + VULKAN_HPP_CONSTEXPR auto HeaderVersionComplete = makeApiVersion( 0, 1, 3, VK_HEADER_VERSION ); + } // namespace VULKAN_HPP_NAMESPACE // clang-format off diff --git a/vulkan/vulkan_raii.hpp b/vulkan/vulkan_raii.hpp index 8f41720..2e7f425 100644 --- a/vulkan/vulkan_raii.hpp +++ b/vulkan/vulkan_raii.hpp @@ -2645,7 +2645,7 @@ namespace VULKAN_HPP_NAMESPACE reinterpret_cast( &m_instance ) ) ); if ( result != VULKAN_HPP_NAMESPACE::Result::eSuccess ) { - throwResultException( result, "vkCreateInstance" ); + detail::throwResultException( result, "vkCreateInstance" ); } m_dispatcher.reset( new VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::InstanceDispatcher( context.getDispatcher()->vkGetInstanceProcAddr, static_cast( m_instance ) ) ); @@ -3336,7 +3336,7 @@ namespace VULKAN_HPP_NAMESPACE } else { - throwResultException( result, "vkEnumeratePhysicalDevices" ); + detail::throwResultException( result, "vkEnumeratePhysicalDevices" ); } } @@ -3371,7 +3371,7 @@ namespace VULKAN_HPP_NAMESPACE reinterpret_cast( &m_device ) ) ); if ( result != VULKAN_HPP_NAMESPACE::Result::eSuccess ) { - throwResultException( result, "vkCreateDevice" ); + detail::throwResultException( result, "vkCreateDevice" ); } m_dispatcher.reset( new VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::DeviceDispatcher( physicalDevice.getDispatcher()->vkGetDeviceProcAddr, static_cast( m_device ) ) ); @@ -4287,7 +4287,7 @@ namespace VULKAN_HPP_NAMESPACE reinterpret_cast( &m_accelerationStructure ) ) ); if ( result != VULKAN_HPP_NAMESPACE::Result::eSuccess ) { - throwResultException( result, "vkCreateAccelerationStructureKHR" ); + detail::throwResultException( result, "vkCreateAccelerationStructureKHR" ); } } @@ -4411,7 +4411,7 @@ namespace VULKAN_HPP_NAMESPACE reinterpret_cast( &m_accelerationStructure ) ) ); if ( result != VULKAN_HPP_NAMESPACE::Result::eSuccess ) { - throwResultException( result, "vkCreateAccelerationStructureNV" ); + detail::throwResultException( result, "vkCreateAccelerationStructureNV" ); } } @@ -4543,7 +4543,7 @@ namespace VULKAN_HPP_NAMESPACE reinterpret_cast( &m_buffer ) ) ); if ( result != VULKAN_HPP_NAMESPACE::Result::eSuccess ) { - throwResultException( result, "vkCreateBuffer" ); + detail::throwResultException( result, "vkCreateBuffer" ); } } @@ -4673,7 +4673,7 @@ namespace VULKAN_HPP_NAMESPACE reinterpret_cast( &m_collection ) ) ); if ( result != VULKAN_HPP_NAMESPACE::Result::eSuccess ) { - throwResultException( result, "vkCreateBufferCollectionFUCHSIA" ); + detail::throwResultException( result, "vkCreateBufferCollectionFUCHSIA" ); } } @@ -4806,7 +4806,7 @@ namespace VULKAN_HPP_NAMESPACE reinterpret_cast( &m_bufferView ) ) ); if ( result != VULKAN_HPP_NAMESPACE::Result::eSuccess ) { - throwResultException( result, "vkCreateBufferView" ); + detail::throwResultException( result, "vkCreateBufferView" ); } } @@ -4929,7 +4929,7 @@ namespace VULKAN_HPP_NAMESPACE reinterpret_cast( &m_commandPool ) ) ); if ( result != VULKAN_HPP_NAMESPACE::Result::eSuccess ) { - throwResultException( result, "vkCreateCommandPool" ); + detail::throwResultException( result, "vkCreateCommandPool" ); } } @@ -6041,7 +6041,7 @@ namespace VULKAN_HPP_NAMESPACE } else { - throwResultException( result, "vkAllocateCommandBuffers" ); + detail::throwResultException( result, "vkAllocateCommandBuffers" ); } } @@ -6078,7 +6078,7 @@ namespace VULKAN_HPP_NAMESPACE reinterpret_cast( &m_function ) ) ); if ( result != VULKAN_HPP_NAMESPACE::Result::eSuccess ) { - throwResultException( result, "vkCreateCuFunctionNVX" ); + detail::throwResultException( result, "vkCreateCuFunctionNVX" ); } } @@ -6201,7 +6201,7 @@ namespace VULKAN_HPP_NAMESPACE reinterpret_cast( &m_module ) ) ); if ( result != VULKAN_HPP_NAMESPACE::Result::eSuccess ) { - throwResultException( result, "vkCreateCuModuleNVX" ); + detail::throwResultException( result, "vkCreateCuModuleNVX" ); } } @@ -6324,7 +6324,7 @@ namespace VULKAN_HPP_NAMESPACE reinterpret_cast( &m_callback ) ) ); if ( result != VULKAN_HPP_NAMESPACE::Result::eSuccess ) { - throwResultException( result, "vkCreateDebugReportCallbackEXT" ); + detail::throwResultException( result, "vkCreateDebugReportCallbackEXT" ); } } @@ -6448,7 +6448,7 @@ namespace VULKAN_HPP_NAMESPACE reinterpret_cast( &m_messenger ) ) ); if ( result != VULKAN_HPP_NAMESPACE::Result::eSuccess ) { - throwResultException( result, "vkCreateDebugUtilsMessengerEXT" ); + detail::throwResultException( result, "vkCreateDebugUtilsMessengerEXT" ); } } @@ -6570,7 +6570,7 @@ namespace VULKAN_HPP_NAMESPACE reinterpret_cast( &m_operation ) ) ); if ( result != VULKAN_HPP_NAMESPACE::Result::eSuccess ) { - throwResultException( result, "vkCreateDeferredOperationKHR" ); + detail::throwResultException( result, "vkCreateDeferredOperationKHR" ); } } @@ -6702,7 +6702,7 @@ namespace VULKAN_HPP_NAMESPACE reinterpret_cast( &m_descriptorPool ) ) ); if ( result != VULKAN_HPP_NAMESPACE::Result::eSuccess ) { - throwResultException( result, "vkCreateDescriptorPool" ); + detail::throwResultException( result, "vkCreateDescriptorPool" ); } } @@ -6942,7 +6942,7 @@ namespace VULKAN_HPP_NAMESPACE } else { - throwResultException( result, "vkAllocateDescriptorSets" ); + detail::throwResultException( result, "vkAllocateDescriptorSets" ); } } @@ -6979,7 +6979,7 @@ namespace VULKAN_HPP_NAMESPACE reinterpret_cast( &m_descriptorSetLayout ) ) ); if ( result != VULKAN_HPP_NAMESPACE::Result::eSuccess ) { - throwResultException( result, "vkCreateDescriptorSetLayout" ); + detail::throwResultException( result, "vkCreateDescriptorSetLayout" ); } } @@ -7109,7 +7109,7 @@ namespace VULKAN_HPP_NAMESPACE reinterpret_cast( &m_descriptorUpdateTemplate ) ) ); if ( result != VULKAN_HPP_NAMESPACE::Result::eSuccess ) { - throwResultException( result, "vkCreateDescriptorUpdateTemplate" ); + detail::throwResultException( result, "vkCreateDescriptorUpdateTemplate" ); } } @@ -7233,7 +7233,7 @@ namespace VULKAN_HPP_NAMESPACE reinterpret_cast( &m_memory ) ) ); if ( result != VULKAN_HPP_NAMESPACE::Result::eSuccess ) { - throwResultException( result, "vkAllocateMemory" ); + detail::throwResultException( result, "vkAllocateMemory" ); } } @@ -7369,7 +7369,7 @@ namespace VULKAN_HPP_NAMESPACE static_cast( *physicalDevice ), drmFd, connectorId, reinterpret_cast( &m_display ) ) ); if ( result != VULKAN_HPP_NAMESPACE::Result::eSuccess ) { - throwResultException( result, "vkGetDrmDisplayEXT" ); + detail::throwResultException( result, "vkGetDrmDisplayEXT" ); } } @@ -7381,7 +7381,7 @@ namespace VULKAN_HPP_NAMESPACE static_cast( *physicalDevice ), &dpy, rrOutput, reinterpret_cast( &m_display ) ) ); if ( result != VULKAN_HPP_NAMESPACE::Result::eSuccess ) { - throwResultException( result, "vkGetRandROutputDisplayEXT" ); + detail::throwResultException( result, "vkGetRandROutputDisplayEXT" ); } } # endif /*VK_USE_PLATFORM_XLIB_XRANDR_EXT*/ @@ -7394,7 +7394,7 @@ namespace VULKAN_HPP_NAMESPACE static_cast( *physicalDevice ), deviceRelativeId, reinterpret_cast( &m_display ) ) ); if ( result != VULKAN_HPP_NAMESPACE::Result::eSuccess ) { - throwResultException( result, "vkGetWinrtDisplayNV" ); + detail::throwResultException( result, "vkGetWinrtDisplayNV" ); } } # endif /*VK_USE_PLATFORM_WIN32_KHR*/ @@ -7531,7 +7531,7 @@ namespace VULKAN_HPP_NAMESPACE } else { - throwResultException( result, "vkGetDisplayPlaneSupportedDisplaysKHR" ); + detail::throwResultException( result, "vkGetDisplayPlaneSupportedDisplaysKHR" ); } } @@ -7567,7 +7567,7 @@ namespace VULKAN_HPP_NAMESPACE reinterpret_cast( &m_displayModeKHR ) ) ); if ( result != VULKAN_HPP_NAMESPACE::Result::eSuccess ) { - throwResultException( result, "vkCreateDisplayModeKHR" ); + detail::throwResultException( result, "vkCreateDisplayModeKHR" ); } } @@ -7678,7 +7678,7 @@ namespace VULKAN_HPP_NAMESPACE reinterpret_cast( &m_event ) ) ); if ( result != VULKAN_HPP_NAMESPACE::Result::eSuccess ) { - throwResultException( result, "vkCreateEvent" ); + detail::throwResultException( result, "vkCreateEvent" ); } } @@ -7809,7 +7809,7 @@ namespace VULKAN_HPP_NAMESPACE reinterpret_cast( &m_fence ) ) ); if ( result != VULKAN_HPP_NAMESPACE::Result::eSuccess ) { - throwResultException( result, "vkCreateFence" ); + detail::throwResultException( result, "vkCreateFence" ); } } @@ -7827,7 +7827,7 @@ namespace VULKAN_HPP_NAMESPACE reinterpret_cast( &m_fence ) ) ); if ( result != VULKAN_HPP_NAMESPACE::Result::eSuccess ) { - throwResultException( result, "vkRegisterDeviceEventEXT" ); + detail::throwResultException( result, "vkRegisterDeviceEventEXT" ); } } @@ -7847,7 +7847,7 @@ namespace VULKAN_HPP_NAMESPACE reinterpret_cast( &m_fence ) ) ); if ( result != VULKAN_HPP_NAMESPACE::Result::eSuccess ) { - throwResultException( result, "vkRegisterDisplayEventEXT" ); + detail::throwResultException( result, "vkRegisterDisplayEventEXT" ); } } @@ -7974,7 +7974,7 @@ namespace VULKAN_HPP_NAMESPACE reinterpret_cast( &m_framebuffer ) ) ); if ( result != VULKAN_HPP_NAMESPACE::Result::eSuccess ) { - throwResultException( result, "vkCreateFramebuffer" ); + detail::throwResultException( result, "vkCreateFramebuffer" ); } } @@ -8101,7 +8101,7 @@ namespace VULKAN_HPP_NAMESPACE reinterpret_cast( &m_image ) ) ); if ( result != VULKAN_HPP_NAMESPACE::Result::eSuccess ) { - throwResultException( result, "vkCreateImage" ); + detail::throwResultException( result, "vkCreateImage" ); } } @@ -8248,7 +8248,7 @@ namespace VULKAN_HPP_NAMESPACE reinterpret_cast( &m_imageView ) ) ); if ( result != VULKAN_HPP_NAMESPACE::Result::eSuccess ) { - throwResultException( result, "vkCreateImageView" ); + detail::throwResultException( result, "vkCreateImageView" ); } } @@ -8375,7 +8375,7 @@ namespace VULKAN_HPP_NAMESPACE reinterpret_cast( &m_indirectCommandsLayout ) ) ); if ( result != VULKAN_HPP_NAMESPACE::Result::eSuccess ) { - throwResultException( result, "vkCreateIndirectCommandsLayoutNV" ); + detail::throwResultException( result, "vkCreateIndirectCommandsLayoutNV" ); } } @@ -8499,7 +8499,7 @@ namespace VULKAN_HPP_NAMESPACE reinterpret_cast( &m_micromap ) ) ); if ( result != VULKAN_HPP_NAMESPACE::Result::eSuccess ) { - throwResultException( result, "vkCreateMicromapEXT" ); + detail::throwResultException( result, "vkCreateMicromapEXT" ); } } @@ -8622,7 +8622,7 @@ namespace VULKAN_HPP_NAMESPACE reinterpret_cast( &m_session ) ) ); if ( result != VULKAN_HPP_NAMESPACE::Result::eSuccess ) { - throwResultException( result, "vkCreateOpticalFlowSessionNV" ); + detail::throwResultException( result, "vkCreateOpticalFlowSessionNV" ); } } @@ -8748,7 +8748,7 @@ namespace VULKAN_HPP_NAMESPACE reinterpret_cast( &m_configuration ) ) ); if ( result != VULKAN_HPP_NAMESPACE::Result::eSuccess ) { - throwResultException( result, "vkAcquirePerformanceConfigurationINTEL" ); + detail::throwResultException( result, "vkAcquirePerformanceConfigurationINTEL" ); } } @@ -8860,7 +8860,7 @@ namespace VULKAN_HPP_NAMESPACE reinterpret_cast( &m_pipelineCache ) ) ); if ( result != VULKAN_HPP_NAMESPACE::Result::eSuccess ) { - throwResultException( result, "vkCreatePipelineCache" ); + detail::throwResultException( result, "vkCreatePipelineCache" ); } } @@ -8994,7 +8994,7 @@ namespace VULKAN_HPP_NAMESPACE if ( ( m_constructorSuccessCode != VULKAN_HPP_NAMESPACE::Result::eSuccess ) && ( m_constructorSuccessCode != VULKAN_HPP_NAMESPACE::Result::ePipelineCompileRequiredEXT ) ) { - throwResultException( m_constructorSuccessCode, "vkCreateComputePipelines" ); + detail::throwResultException( m_constructorSuccessCode, "vkCreateComputePipelines" ); } } @@ -9016,7 +9016,7 @@ namespace VULKAN_HPP_NAMESPACE if ( ( m_constructorSuccessCode != VULKAN_HPP_NAMESPACE::Result::eSuccess ) && ( m_constructorSuccessCode != VULKAN_HPP_NAMESPACE::Result::ePipelineCompileRequiredEXT ) ) { - throwResultException( m_constructorSuccessCode, "vkCreateGraphicsPipelines" ); + detail::throwResultException( m_constructorSuccessCode, "vkCreateGraphicsPipelines" ); } } @@ -9042,7 +9042,7 @@ namespace VULKAN_HPP_NAMESPACE ( m_constructorSuccessCode != VULKAN_HPP_NAMESPACE::Result::eOperationNotDeferredKHR ) && ( m_constructorSuccessCode != VULKAN_HPP_NAMESPACE::Result::ePipelineCompileRequiredEXT ) ) { - throwResultException( m_constructorSuccessCode, "vkCreateRayTracingPipelinesKHR" ); + detail::throwResultException( m_constructorSuccessCode, "vkCreateRayTracingPipelinesKHR" ); } } @@ -9064,7 +9064,7 @@ namespace VULKAN_HPP_NAMESPACE if ( ( m_constructorSuccessCode != VULKAN_HPP_NAMESPACE::Result::eSuccess ) && ( m_constructorSuccessCode != VULKAN_HPP_NAMESPACE::Result::ePipelineCompileRequiredEXT ) ) { - throwResultException( m_constructorSuccessCode, "vkCreateRayTracingPipelinesNV" ); + detail::throwResultException( m_constructorSuccessCode, "vkCreateRayTracingPipelinesNV" ); } } @@ -9236,7 +9236,7 @@ namespace VULKAN_HPP_NAMESPACE } else { - throwResultException( result, "vkCreateComputePipelines" ); + detail::throwResultException( result, "vkCreateComputePipelines" ); } } @@ -9264,7 +9264,7 @@ namespace VULKAN_HPP_NAMESPACE } else { - throwResultException( result, "vkCreateGraphicsPipelines" ); + detail::throwResultException( result, "vkCreateGraphicsPipelines" ); } } @@ -9295,7 +9295,7 @@ namespace VULKAN_HPP_NAMESPACE } else { - throwResultException( result, "vkCreateRayTracingPipelinesKHR" ); + detail::throwResultException( result, "vkCreateRayTracingPipelinesKHR" ); } } @@ -9323,7 +9323,7 @@ namespace VULKAN_HPP_NAMESPACE } else { - throwResultException( result, "vkCreateRayTracingPipelinesNV" ); + detail::throwResultException( result, "vkCreateRayTracingPipelinesNV" ); } } @@ -9360,7 +9360,7 @@ namespace VULKAN_HPP_NAMESPACE reinterpret_cast( &m_pipelineLayout ) ) ); if ( result != VULKAN_HPP_NAMESPACE::Result::eSuccess ) { - throwResultException( result, "vkCreatePipelineLayout" ); + detail::throwResultException( result, "vkCreatePipelineLayout" ); } } @@ -9484,7 +9484,7 @@ namespace VULKAN_HPP_NAMESPACE reinterpret_cast( &m_privateDataSlot ) ) ); if ( result != VULKAN_HPP_NAMESPACE::Result::eSuccess ) { - throwResultException( result, "vkCreatePrivateDataSlot" ); + detail::throwResultException( result, "vkCreatePrivateDataSlot" ); } } @@ -9608,7 +9608,7 @@ namespace VULKAN_HPP_NAMESPACE reinterpret_cast( &m_queryPool ) ) ); if ( result != VULKAN_HPP_NAMESPACE::Result::eSuccess ) { - throwResultException( result, "vkCreateQueryPool" ); + detail::throwResultException( result, "vkCreateQueryPool" ); } } @@ -9893,7 +9893,7 @@ namespace VULKAN_HPP_NAMESPACE reinterpret_cast( &m_renderPass ) ) ); if ( result != VULKAN_HPP_NAMESPACE::Result::eSuccess ) { - throwResultException( result, "vkCreateRenderPass" ); + detail::throwResultException( result, "vkCreateRenderPass" ); } } @@ -9911,7 +9911,7 @@ namespace VULKAN_HPP_NAMESPACE reinterpret_cast( &m_renderPass ) ) ); if ( result != VULKAN_HPP_NAMESPACE::Result::eSuccess ) { - throwResultException( result, "vkCreateRenderPass2" ); + detail::throwResultException( result, "vkCreateRenderPass2" ); } } @@ -10042,7 +10042,7 @@ namespace VULKAN_HPP_NAMESPACE reinterpret_cast( &m_sampler ) ) ); if ( result != VULKAN_HPP_NAMESPACE::Result::eSuccess ) { - throwResultException( result, "vkCreateSampler" ); + detail::throwResultException( result, "vkCreateSampler" ); } } @@ -10165,7 +10165,7 @@ namespace VULKAN_HPP_NAMESPACE reinterpret_cast( &m_ycbcrConversion ) ) ); if ( result != VULKAN_HPP_NAMESPACE::Result::eSuccess ) { - throwResultException( result, "vkCreateSamplerYcbcrConversion" ); + detail::throwResultException( result, "vkCreateSamplerYcbcrConversion" ); } } @@ -10289,7 +10289,7 @@ namespace VULKAN_HPP_NAMESPACE reinterpret_cast( &m_semaphore ) ) ); if ( result != VULKAN_HPP_NAMESPACE::Result::eSuccess ) { - throwResultException( result, "vkCreateSemaphore" ); + detail::throwResultException( result, "vkCreateSemaphore" ); } } @@ -10421,7 +10421,7 @@ namespace VULKAN_HPP_NAMESPACE reinterpret_cast( &m_shader ) ) ); if ( result != VULKAN_HPP_NAMESPACE::Result::eSuccess ) { - throwResultException( result, "vkCreateShadersEXT" ); + detail::throwResultException( result, "vkCreateShadersEXT" ); } } @@ -10549,7 +10549,7 @@ namespace VULKAN_HPP_NAMESPACE } else { - throwResultException( result, "vkCreateShadersEXT" ); + detail::throwResultException( result, "vkCreateShadersEXT" ); } } @@ -10586,7 +10586,7 @@ namespace VULKAN_HPP_NAMESPACE reinterpret_cast( &m_shaderModule ) ) ); if ( result != VULKAN_HPP_NAMESPACE::Result::eSuccess ) { - throwResultException( result, "vkCreateShaderModule" ); + detail::throwResultException( result, "vkCreateShaderModule" ); } } @@ -10714,7 +10714,7 @@ namespace VULKAN_HPP_NAMESPACE reinterpret_cast( &m_surface ) ) ); if ( result != VULKAN_HPP_NAMESPACE::Result::eSuccess ) { - throwResultException( result, "vkCreateAndroidSurfaceKHR" ); + detail::throwResultException( result, "vkCreateAndroidSurfaceKHR" ); } } # endif /*VK_USE_PLATFORM_ANDROID_KHR*/ @@ -10734,7 +10734,7 @@ namespace VULKAN_HPP_NAMESPACE reinterpret_cast( &m_surface ) ) ); if ( result != VULKAN_HPP_NAMESPACE::Result::eSuccess ) { - throwResultException( result, "vkCreateDirectFBSurfaceEXT" ); + detail::throwResultException( result, "vkCreateDirectFBSurfaceEXT" ); } } # endif /*VK_USE_PLATFORM_DIRECTFB_EXT*/ @@ -10753,7 +10753,7 @@ namespace VULKAN_HPP_NAMESPACE reinterpret_cast( &m_surface ) ) ); if ( result != VULKAN_HPP_NAMESPACE::Result::eSuccess ) { - throwResultException( result, "vkCreateDisplayPlaneSurfaceKHR" ); + detail::throwResultException( result, "vkCreateDisplayPlaneSurfaceKHR" ); } } @@ -10771,7 +10771,7 @@ namespace VULKAN_HPP_NAMESPACE reinterpret_cast( &m_surface ) ) ); if ( result != VULKAN_HPP_NAMESPACE::Result::eSuccess ) { - throwResultException( result, "vkCreateHeadlessSurfaceEXT" ); + detail::throwResultException( result, "vkCreateHeadlessSurfaceEXT" ); } } @@ -10790,7 +10790,7 @@ namespace VULKAN_HPP_NAMESPACE reinterpret_cast( &m_surface ) ) ); if ( result != VULKAN_HPP_NAMESPACE::Result::eSuccess ) { - throwResultException( result, "vkCreateIOSSurfaceMVK" ); + detail::throwResultException( result, "vkCreateIOSSurfaceMVK" ); } } # endif /*VK_USE_PLATFORM_IOS_MVK*/ @@ -10810,7 +10810,7 @@ namespace VULKAN_HPP_NAMESPACE reinterpret_cast( &m_surface ) ) ); if ( result != VULKAN_HPP_NAMESPACE::Result::eSuccess ) { - throwResultException( result, "vkCreateImagePipeSurfaceFUCHSIA" ); + detail::throwResultException( result, "vkCreateImagePipeSurfaceFUCHSIA" ); } } # endif /*VK_USE_PLATFORM_FUCHSIA*/ @@ -10830,7 +10830,7 @@ namespace VULKAN_HPP_NAMESPACE reinterpret_cast( &m_surface ) ) ); if ( result != VULKAN_HPP_NAMESPACE::Result::eSuccess ) { - throwResultException( result, "vkCreateMacOSSurfaceMVK" ); + detail::throwResultException( result, "vkCreateMacOSSurfaceMVK" ); } } # endif /*VK_USE_PLATFORM_MACOS_MVK*/ @@ -10850,7 +10850,7 @@ namespace VULKAN_HPP_NAMESPACE reinterpret_cast( &m_surface ) ) ); if ( result != VULKAN_HPP_NAMESPACE::Result::eSuccess ) { - throwResultException( result, "vkCreateMetalSurfaceEXT" ); + detail::throwResultException( result, "vkCreateMetalSurfaceEXT" ); } } # endif /*VK_USE_PLATFORM_METAL_EXT*/ @@ -10870,7 +10870,7 @@ namespace VULKAN_HPP_NAMESPACE reinterpret_cast( &m_surface ) ) ); if ( result != VULKAN_HPP_NAMESPACE::Result::eSuccess ) { - throwResultException( result, "vkCreateScreenSurfaceQNX" ); + detail::throwResultException( result, "vkCreateScreenSurfaceQNX" ); } } # endif /*VK_USE_PLATFORM_SCREEN_QNX*/ @@ -10890,7 +10890,7 @@ namespace VULKAN_HPP_NAMESPACE reinterpret_cast( &m_surface ) ) ); if ( result != VULKAN_HPP_NAMESPACE::Result::eSuccess ) { - throwResultException( result, "vkCreateStreamDescriptorSurfaceGGP" ); + detail::throwResultException( result, "vkCreateStreamDescriptorSurfaceGGP" ); } } # endif /*VK_USE_PLATFORM_GGP*/ @@ -10910,7 +10910,7 @@ namespace VULKAN_HPP_NAMESPACE reinterpret_cast( &m_surface ) ) ); if ( result != VULKAN_HPP_NAMESPACE::Result::eSuccess ) { - throwResultException( result, "vkCreateViSurfaceNN" ); + detail::throwResultException( result, "vkCreateViSurfaceNN" ); } } # endif /*VK_USE_PLATFORM_VI_NN*/ @@ -10930,7 +10930,7 @@ namespace VULKAN_HPP_NAMESPACE reinterpret_cast( &m_surface ) ) ); if ( result != VULKAN_HPP_NAMESPACE::Result::eSuccess ) { - throwResultException( result, "vkCreateWaylandSurfaceKHR" ); + detail::throwResultException( result, "vkCreateWaylandSurfaceKHR" ); } } # endif /*VK_USE_PLATFORM_WAYLAND_KHR*/ @@ -10950,7 +10950,7 @@ namespace VULKAN_HPP_NAMESPACE reinterpret_cast( &m_surface ) ) ); if ( result != VULKAN_HPP_NAMESPACE::Result::eSuccess ) { - throwResultException( result, "vkCreateWin32SurfaceKHR" ); + detail::throwResultException( result, "vkCreateWin32SurfaceKHR" ); } } # endif /*VK_USE_PLATFORM_WIN32_KHR*/ @@ -10970,7 +10970,7 @@ namespace VULKAN_HPP_NAMESPACE reinterpret_cast( &m_surface ) ) ); if ( result != VULKAN_HPP_NAMESPACE::Result::eSuccess ) { - throwResultException( result, "vkCreateXcbSurfaceKHR" ); + detail::throwResultException( result, "vkCreateXcbSurfaceKHR" ); } } # endif /*VK_USE_PLATFORM_XCB_KHR*/ @@ -10990,7 +10990,7 @@ namespace VULKAN_HPP_NAMESPACE reinterpret_cast( &m_surface ) ) ); if ( result != VULKAN_HPP_NAMESPACE::Result::eSuccess ) { - throwResultException( result, "vkCreateXlibSurfaceKHR" ); + detail::throwResultException( result, "vkCreateXlibSurfaceKHR" ); } } # endif /*VK_USE_PLATFORM_XLIB_KHR*/ @@ -11114,7 +11114,7 @@ namespace VULKAN_HPP_NAMESPACE reinterpret_cast( &m_swapchain ) ) ); if ( result != VULKAN_HPP_NAMESPACE::Result::eSuccess ) { - throwResultException( result, "vkCreateSwapchainKHR" ); + detail::throwResultException( result, "vkCreateSwapchainKHR" ); } } @@ -11277,7 +11277,7 @@ namespace VULKAN_HPP_NAMESPACE } else { - throwResultException( result, "vkCreateSharedSwapchainsKHR" ); + detail::throwResultException( result, "vkCreateSharedSwapchainsKHR" ); } } @@ -11314,7 +11314,7 @@ namespace VULKAN_HPP_NAMESPACE reinterpret_cast( &m_validationCache ) ) ); if ( result != VULKAN_HPP_NAMESPACE::Result::eSuccess ) { - throwResultException( result, "vkCreateValidationCacheEXT" ); + detail::throwResultException( result, "vkCreateValidationCacheEXT" ); } } @@ -11444,7 +11444,7 @@ namespace VULKAN_HPP_NAMESPACE reinterpret_cast( &m_videoSession ) ) ); if ( result != VULKAN_HPP_NAMESPACE::Result::eSuccess ) { - throwResultException( result, "vkCreateVideoSessionKHR" ); + detail::throwResultException( result, "vkCreateVideoSessionKHR" ); } } @@ -11574,7 +11574,7 @@ namespace VULKAN_HPP_NAMESPACE reinterpret_cast( &m_videoSessionParameters ) ) ); if ( result != VULKAN_HPP_NAMESPACE::Result::eSuccess ) { - throwResultException( result, "vkCreateVideoSessionParametersKHR" ); + detail::throwResultException( result, "vkCreateVideoSessionParametersKHR" ); } }